Java学习笔记之对象与类

发表于   |   分类于   |     |   阅读次数

Java是一种面向对象的语言，它具有面向对象语言的一些特征，支持以下基本概念：

  • 多态性（Polymorphism）
  • 继承（Inheritance）
  • 封装（Encapsulation）
  • 抽象（Abstraction）
  • 类（Classes）
  • 对象（Objects）
  • 实例化（Instance）
  • 方法（Method）
  • 消息解析（Message Parsing）

在这篇博客中，主要探究类和对象的概念。

对象（Object）：对象具有状态和行为。例如：一条狗具有颜色、名字、品种等属性，同时也具有摇摆、犬叫和吃等行为。对象是类的一个实例。

类（Class）：类可以被定义为一种描述行为或状态的模板或蓝图。

Java中的对象（Objects）

在现实生活中，我们能够轻易地找出很多对象，如车子、狗以及人类等等，这些对象都有对应的状态和行为。

相比现实生活中的对象，软件中的对象也有相似的特征。它们也有状态和行为。只不过软件中的状态是存储在字段（fields）中的，而行为是通过方法（methods）体现出来的。

Java中的类（Classes）

类是创建单个对象的蓝图。

类的创建如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Dog{
 String breed;
   int ageC
   String color;

   void barking(){
   }
   
   void hungry(){
   }
   
   void sleeping(){
   }
}

构造函数（Constructors）

每一个类都有一个构造函数。如果我们没有明确地为一个类写构造函数，那么Java编译器将为这个类创建一个默认的构造函数。

每当一个新对象被创建时，至少会有一个构造函数被调用。构造函数必须与类同名。一个类可以有多个构造函数。

1
2
3
4
5
6
7
8
public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // This constructor has one parameter, name.
   }
}

创建对象

正如前面提到，类为对象提供了蓝图。所以对象是从类创建而来。在Java中，需要用new关键字创建新对象。

创建对象步骤：

  • 声明（Declaration）
  • 实例化（Instantiation）：new关键字
  • 初始化（Initialization）：new关键字之后是对构造函数的调用，并初始化。

如：

1
2
3
4
5
6
7
8
9
10
11
12
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" );
   }
}

运行结果：

1
Passed Name is :tommy

访问实例变量和方法

访问实例变量和方法是通过创建对象实现的。如：

1
2
3
4
5
6
7
8
/* 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();

完整的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Puppy{
   
   int puppyAge;

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Name chosen 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 ); 
   }
}

运行结果：

1
2
3
Name chosen is :tommy
Puppy's age is :2
Variable Value :2

源文件的声明规则

在源文件中类声明、import语句、package语句时必须遵循以下规则：

  • 每个源文件中只能有一个public类；
  • 一个源文件中可以有多个非public类；
  • public类名应该与源文件名一致，且源文件名需以后缀.java结尾；
  • 如果一个类定义在某个包中，那么package语句应该在源文件的首行；
  • 如果源文件中存在import语句，那么它必须放在package语句和类声明之间；如果源文件中没有package语句，那么它应该放在源文件的首行；
  • import语句和package语句对源文件中所有的类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有几种不同的访问级别，而且类也分不同类型；如abstract 类、final类等。除了这几种类，Java还有一些特别的类，Inner 类和Anonymous类；

Java包

它为类和接口的分类提供了简便的方法。我们知道，在Java开发应用中，经常会有几百个类和接口写入，那么把这些进行分类将会简便我们的工作。

Import语句

在Java中，如果提供一个完全合格的名称，其包含包名和类名，那么编译器将很容易定位到源代码或类。Import语句 就是这样一种给编译器提供恰当位置的方法。

例如，下面这行代码就是告诉编译器载入java_installation/java/io目录下所有的类：

1
import java.io.*;

一个简单的案例研究

Employee.java文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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);
   }
}

EmployeeTest.java文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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();
   }
}

编译：

1
2
3
4
5
6
7
8
9
10
11
C:\> javac Employee.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