Java的对象和类

以下内容引用自http://wiki.jikexueyuan.com/project/java/object-classes.html

一、概述

Java是一种面向对象的语言。作为一种具有面向对象特征的语言,Java包括以下几项基本概念:

  • 多态性
  • 继承性
  • 封装性
  • 抽象性
  • 对象
  • 实例
  • 消息解析

什么是类和对象:

  • 对象:对象具有状态和行为。比如现实世界的:小汽车,狗,人类等等。所有这些对象都具有状态和行为。
  • :类可以被定义为描述对象支持类型的行为、状态的的模板、蓝图。

二、Java中的对象

如果考虑一条狗,那么它的状态就是:名字,品种,颜色,它的行为就是汪汪,摇尾巴,跑。

如果将软件中的对象和现实世界中的对象对比,那么会发现他们有很多相似的特征。软件中的对象也具有状态和行为。软件的状态被储存在文件中,它的行为通过方法来表现。

因此,在软件发展过程中方法控制对象的内在状态并且对象和对象间的交流是通过方法来完成的。

三、Java中的类

类是有独立的对象创造出的蓝图。

下面给出了一个类的例子:

public class Dog{
   String breed;
   int age;
   String color;

   void barking(){
   }

   void hungry(){
   }

   void sleeping(){
   }
}

类可以包括以下的变量类型:

  • 局部变量:在方法,构造器或区域中定义的变量成为局部变量。变量将会在方法内产生和发展,然后当方法结束变量就会破坏。
  • 实例变量:实例变量是在类内,但是在方法外的变量。这些变量是当类被装载时被实体化的。实例变量可以是从特定类的任何方法,构造器,区域中存取。
  • 类变量:类变量是在类中声明的变量,它处在任何方法之外,有静态关键字。

类可以由任意数量的方法来存取不同种类方法的值。在上面的例子中,barking()hungry()sleeping()是方法。

四、构造器

每一个类都有一个构造器。如果不单独为一个类编写构造器那么Java的编译器将会给这个类建立一个默认的构造器。

每当一个新的对象被创建,至少一个构造器将会被调用。构造器的一个最主要的原则就是他们必须和类有同样的名字。一个类可以有不止一个构造器。并且没有返回值。

下面给出了一个构造器的例子:

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
   }
}

在需要只创建一个类的实例的时,Java也支持单例。

五、创造一个对象

如前所述,类为对象提供了蓝图。因此基本来说一个对象是从一个类中创造出来的。在Java中,新的关键词被用来创造新的对象。创建类的步骤如下:

  • 声明:变量声明可以声明其所代表的对象类型。
  • 实例化:“新的”关键词用来创造对象。
  • 初始化:“新的”关键词伴随着一个构造器的启用,这个将新的对象初始化。

下面给出了一个创造对象的例子:

public class Puppy{

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }
   public static void main(String []args){
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}
//如果编译并运行上述程序,那么将输出下列结果:
Passed Name is :tommy

六、访问实体变量和方法

实体变量和方法是通过创造对象来访问的。为了访问一个实体变量完全有效的路径应该如下所示:

/* First create an object */
ObjectReference = new Constructor();
/* Now call a variable as follows */
ObjectReference.variableName;
/* Now you can call a class method as follows */
ObjectReference.MethodName();

例子:

这个例子解释了如何存取类的实体变量和方法:

public class Puppy{

   int puppyAge;

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }
   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy‘s age is :" + puppyAge );
       return puppyAge;
   }
   public static void main(String []args){
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy‘s age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy‘s age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}
//如果编译运行上述程序,那么将会产生如下结果:
Passed Name is :tommy
Puppy‘s age is :2
Variable Value :2

七、源文件声明规则

当在源文件中声明类,输入和打包语法时,这些规则是十分重要的。

  • 每个源文件中只能有一个公共类。
  • 一个源文件可以有很多非公共类。
  • 公共类的名称必须是源文件的名称同时也要以.java为后缀。举例来说:类的名称是public class Employee{},那么源文件就应该是Employee.java
  • 如果类是在一个程序包中定义的,那么程序包的声明必须是源文件的第一个声明。
  • 如果输入声明出现那么他们必须被写在封装声明和类声明之间。如果没有封装声明那么输入声明必须在源文件的第一行。
  • 输入和打包声明会暗示所有源文件中的存在的类。在源文件中很难为不同的类区分输入和封装声明。
    类有不同的访问级别并且有很多不同的类;抽象的类,最终的类等等。
    除了以上提到的类的类型之外,Java也有像内部类和匿名类这样的特殊类。

八、Java程序包

简而言之,就是一种对类和接口进行分类的一种方法。当用Java开发程序时,数百个类和接口会被编写,因此对这些类进行分类是必须的,而且也会使问题变得容易。

九、Import语法

在Java中,如果给出包括封装和类的名称的全限定名,那么编译器很容易定位到源类和源代码。Import语法是给编译器寻找特定类的适当位置的一种方法。

举例来说,下面这行语句将会要求编译器去装载java_installation/java/io路径下的所有可用的类:

import java.io.*;

十、一个简单的案例

下面将创建两个类:Employee和EmployeeTest。

这个Employee类包括四个实体变量姓名(name),年龄(age),职位(designation)和薪水(salary)。这个类有一个确定的且需要参数的构造器。

import java.io.*;
public class Employee{
   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name){
      this.name = name;
   }
   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge){
      age =  empAge;
   }
   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* Assign the salary to the variable salary.*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* Print the Employee details */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

为了运行这个Employee类应当建立主函数和类实例化。下面分别为这些任务创建类。

下面所给的是EmployeeTest类,这个类创建了两个Employee类的实例,并且为每个对象调用方法从而给每个变量赋值。

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

编译两个类然后运行EmployeeTest,会看到如下结果:

C :> javac Employee.java
C :> vi EmployeeTest.java
C :> javac EmployeeTest.java
C :> java EmployeeTest

Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

测试工程:https://github.com/easonjim/5_java_example/tree/master/javabasicstest/test2

时间: 2024-10-05 05:21:31

Java的对象和类的相关文章

Java常见对象Object类中的个别方法

Java常见对象Object类 public int hashCode() : 返回该对象的哈希码值. 注意:哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关,但是不是实际地址值.你可以理解成地址值. package common_object; public class Demo extends Object{ } package common_object; public class DemoTest { public static void main(String[] args)

4.2-全栈Java笔记:对象和类的概念及定义

对象和类的概念 我们人认识世界,其实就是面向对象的.大家眼里都是一个个对象,要不怎么老说搞对象搞对象啊.比如现在让大家认识一下"天使"这个新事物,天使大家没见过吧,怎么样认识呢?最好的办法就是,给你们面前摆4个天使,带翅膀的美女,让大家看,看完以后,即使我不说,大家下一次是不是就都认识天使了. 但是,看完10个天使后,我们总要总结一下,什么样的东东才算天使?天使是无数的,总有没见过的!所以必须总结抽象,便于认识未知事物!总结的过程就是抽象的过程. 小时候,我们学自然数时怎么定义的?像1

Java面向对象-对象和类概述

java语言提供了定义类.成员变量.方法等基本功能. 类可以认为是一种自定义的数据类型,可以使用类来定义变量,所有使用类来定义的变量都是引用变量,它们都会引用到类的对象. java面向对象的三大特征:封装.继承.多态. 封装:提供了private.protected和public三个访问修饰符来实现 继承:extends关键字让子类继承父类 多态:父类引用指向子类对象,使用继承关系来实现复用时,子类对象可以直接赋给父类变量,这个变量具有多态性,编程更加灵活.(百度搜:花木兰替父从军引例) 类和对

Java 1-Java 对象和类

Java 对象和类 Java作为一种面向对象语言.支持以下基本概念: 多态 继承 封装 抽象 类 对象 实例 方法 消息解析 本节我们重点研究对象和类的概念. 对象:对象是类的一个实例,有状态和行为.例如,一条狗是一个对象,它的状态有:颜色.名字.品种:行为有:摇尾巴.叫.吃等. 类:类是一个模板,它描述一类对象的行为和状态. Java中的对象 现在让我们深入了解什么是对象.看看周围真实的世界,会发现身边有很多对象,车,狗,人等等.所有这些对象都有自己的状态和行为. 拿一条狗来举例,它的状态有:

Java学习——对象和类

1. 入门例子 package jihite; public class Dog{ int dogage; public Dog(String name){ System.out.println("Passed Name is:" + name); } public void setAge(int age){ dogage = age; } public int getAge(){ System.out.println("Dog's age is:" + dogag

一天一个Java基础——对象和类

1.在Java中你所做的全部工作就是定义类,产生那些类的对象,以及发送消息给这些对象 2.可以在类中设置两种类型的元素:字段(也被称作数据成员)和方法(也被称作成员函数) 3.字段可以是任何类型的对象,可以通过其引用与其进行通信:也可以是基本类型中的一种.如果字段是对某个对象的引用,那么必须初始化该引用,以便使其与一个实际的对象向关联(使用new来实现) 4.可以把两个类放在同一个文件中,但是文件中只能有一个类是公共的.此外,公共类必须与文件同名 1.1 构造方法构造对象 构造方法是一种特殊的方

【Java】对象与类

LocalData类 java.time.LocalDate; static LocalTime now(); 构造一个表示当前日期的对象. static LocalTime of(int year,int month,int day); 构造一个表示给定日期的对象. int getYear(); int getMonthValue(); int getDayOfMonth(); 得到当前日期的年.月和日. DayofWeek getDayOfWeek 得到当前日期是星期几,作为DayOfWee

JAVA基础--对象和类

一.类之间的关系 1.依赖:user-a 当一个类的方法操作另一个类的对象时,称为依赖: 2.聚合:has-a 类A对象包含类B对象: 3.继承:is-a 注:一个对象变量并没有实际包含一个对象,而是持有该对象的引用: 方法参数总结: 一个方法不能修改一个基本数据类型的参数: 一个方法可以改变一个对象参数的状态: 一个方法不能让对象参数引用到一个新的对象: 注:1)重载需要的参数列表和方法称为方法的签名. 2)Random.nextInt(int n);返回一个0~(n-1)之间的数 3)fin

java中对象和类的联系与区别

1.对象:客观事物的一个实体,由一组属性和方法构成. 属性:对象具有各种特征:方法:对象执行的操作. 2.类:对对象的概括,是对对象的分类:具有相同属性.相同方法的一组对象的集合. 3.类与对象的关系:类是对象的抽象,对象是类的具体:程序中先类产生对象. 4.面向对象的三个特征:封装.继承.多态. 5.面向对象的编程步骤:定义类:构造对象:使用对象. 构造对象的方法:类名 对象名 = new 类名();