内容回顾#

上一篇已经介绍过Java的基础语法和一些概念：

1. 对象：对象是类的一个实例，有状态和行为（例如：职工是一个对象，他有工号、岗位、姓名、性别等状态，有工作、吃饭、睡觉等行为）。
2. 类：类是一个模板，它描述一类对象的行为和状态。

类#

我们来举个例子。有一位职工，它具有工号，岗位，姓名，年龄的属性（状态），以及工作、吃饭、睡觉等行为。这段描述，我们可以用代码表示为：

1
/**
2
* 职工类
3
*/
4
public class Employee {
5
    int jobNo;      //工号
6
    String job;     //岗位
7
    String name;    //姓名
8
    int age;        //年龄
9

10
    /**
11
    * 工作行为
12
    */
13
    void work() {
14
    }
15

16
    /**
17
    * 吃行为
18
    */
19
    void eat() {
20
    }
21

22
    /**
23
    * 睡觉行为
24
    */
25
    void sleep(){
26
    }
27
}

构造方法#

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

1
public class Employee{
2
    public Employee(){
3
    }
4

5
    public Employee(String name){
6
        // 这个构造器仅有一个参数：name
7
    }
8
}

对象#

对象是根据类来创建的。可以理解成，类是创建对象所需的模板。 在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

1. 声明：声明一个对象，包括对象名称和对象类型。
2. 实例化：使用关键字 new 来创建一个对象。
3. 初始化：使用 new 创建对象时，会调用构造方法初始化对象。

我们使用一段代码来举例：

1
public class Employee{
2
   public Employee(String name){
3
      //这个构造器仅有一个参数：name
4
      System.out.println("* 职工姓名 : " + name + "。" );
5
   }
6
   public static void main(String[] args){
7
      // 创建一个Employee对象
8
      // 类名 对象名 = new 对象();
9
      Employee newEmployee = new Employee( "Asurin" );
10
   }
11
}

编译运行将会得到以下结果： * 职工姓名：Asurin。

访问实例中的变量和方法#

我们可以通过已创建的对象，来访问成员变量和成员方法。

1
public class Employee {
2
    int jobNo;      //工号
3
    String job;     //岗位
4
    int age;        //年龄
5

6
    /**
7
     * Employee类的构造方法
8
     * @param name 姓名
9
     */
10
    public Employee(String name) {
11
        System.out.println("* 职工姓名为：" + name);
12
    }
13

14
    /**
15
     * 方法：设置工号，以下同理
16
     * @param jobNo 工号
17
     */
18
    public void setJobNo(int jobNo) {
19
        this.jobNo = jobNo;
20
    }
21

22
    public void setJob(String job) {
23
        this.job = job;
24
    }
25

26
    public void setAge(int age) {
27
        this.age = age;
28
    }
29

30
    public void getInfo() {
31
        System.out.println("* 工号：" + jobNo + "，岗位：" + job + "，年龄：" + age + "岁。");
32
    }
33

34
    public static void main(String[] args) {
35
        Employee newEmployee = new Employee("Asurin"); //使用Employee类实例化一个对象newEmployee
36
        newEmployee.setJobNo(20200411); //调用成员方法setJobNo，设置工号，以下同理
37
        newEmployee.setAge(24);
38
        newEmployee.setJob("运维工程师");
39

40
        newEmployee.getInfo(); //调用成员方法getInfo，输出员工信息
41
    }
42
}

编译运行后将会得到以下结果：

1
* 职工姓名为：Asurin
2
* 工号：20200411，岗位：运维工程师，年龄：24岁。

Java包与import#

开发 Java 程序时，可能需要大量的类，为了解决这个问题，Java 引入了包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理等问题。 而为了让 Java 编译器能够使用某一个包内的成员，我们需要在 Java 程序中明确导入该包。使用 import 语句可完成此功能。

使用包和import时需要注意：

1. 如果一个类定义在某个包中，那么 package 语句应该在源文件的最开头；
2. 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件的最开头。
3. import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

同样地，我们使用上面的代码来进行举例。

1. 在项目src目录下中新建一个包，命名为test；
2. 在项目src目录下中新建一个类，命名为run，并在文件开头指定要导入的类；
3. 将Employee类中的main方法移入run类中；
4. 将修改后的Employee类移入test包内，并在文件开头声明所属的包名。

修改后的目录结构如下：

• Employee类：

  1
  //声明所属包名
  2
  package test;
  3
  
  4
  public class Employee {
  5
      int jobNo;      //工号
  6
      String job;     //岗位
  7
      int age;        //年龄
  8
  
  9
      /**
  10
      * Employee类的构造方法
  11
      * @param name 姓名
  12
      */
  13
      public Employee(String name) {
  14
          System.out.println("* 职工姓名为：" + name);
  15
      }
  16
  
  17
      /**
  18
      * 设置工号
  19
      * @param jobNo 工号
  20
      */
  21
      public void setJobNo(int jobNo) {
  22
          this.jobNo = jobNo;
  23
      }
  24
  
  25
      public void setJob(String job) {
  26
          this.job = job;
  27
      }
  28
  
  29
      public void setAge(int age) {
  30
          this.age = age;
  31
      }
  32
  
  33
      public void getInfo() {
  34
          System.out.println("* 工号：" + jobNo + "，岗位：" + job + "，年龄：" + age + "岁。");
  35
      }
  36
  }

  显示更多显示更少

• run类：

  1
  //导入test包中的Employee类
  2
  import test.Employee;
  3
  
  4
  public class run {
  5
      public static void main(String[] args) {
  6
          Employee newEmployee = new Employee("Asurin"); //实例化一个对象newEmployee
  7
          newEmployee.setJobNo(20200411); //调用成员方法setJobNo，设置工号，以下同理
  8
          newEmployee.setAge(24);
  9
          newEmployee.setJob("运维工程师");
  10
  
  11
          newEmployee.getInfo(); //调用成员方法getInfo，输出员工信息
  12
      }
  13
  }

修改后的main方法位于run类中，所以run类自然成了主类，程序必须从run类开始执行。编译运行后将会得到以下结果：

1
* 职工姓名为：Asurin
2
* 工号：20200411，岗位：运维工程师，年龄：24岁。

可见，运行结果是一样的。