Java类和对象_java对袋鼠写一个类要求有属性和行为

		* [2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法](#2__javalangClass__javalangreflectConstuctor__newlnstance__679)
		* [3. 调用对象的 clone() 方法](#3__clone__691)
		* [4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法](#4__javaioObjectlnputStream__readObject__699)
		* [例 1](#_1_701)
+ [隐含创建对象](#_761)

• Java new运算符深入剖析
• Java访问对象的属性和行为
• Java对象的销毁
• Java中的空对象（null）是怎么回事？
• Java注释：类、方法和字段注释
• • • • 1. 类注释
        * 2. 方法注释
        * 3. 字段注释
• Java static关键字（静态变量和静态方法）
• • 静态变量
    • • • 例 1
    • 静态方法
    • • • 例 2
    • 静态代码块
    • • • 例 3
• Java import static静态导入
• Java static的常见问题和使用误区
• • 使用误区
• Java final修饰符详解
• • final 修饰变量
    • • • final 修饰基本类型变量和引用类型变量的区别
    • final修饰方法
    • final修饰类
    • final 修饰符使用总结
    • • • 1. final 修饰类中的变量
          • 2. final 修饰类中的方法
          • 3. final 修饰类
• Java main()方法
• • • • 例 1
• [Java中main()方法的

必看视频！获取2024年最新Java开发全套学习资料 备注Java

格式为什么是固定不变的？](#Javamain_1743)

• Java方法的可变参数
• • • • 例 1
• Java构造方法
• • • • 例 1
        * 例 2
• Java包（package）详解
• • 包定义
    • 包导入
    • 系统包
• Java使用自定义包

转载于：http://c.biancheng.net/java/80/

最早的程序开发使用的是结构化程序设计语言，随着时间的流逝，软件的规模逐渐扩大，使用结构化语言会出现各种弊端，导致无休止地拖延开发周期，产品的质量也不尽如人意。这一切都体现了结构化语言不再适合当前的软件开发。现在程序设计者们将另一种开发思想引入程序中，那就是面向对象开发思想。

面向对象最关键的两个词汇是类与对象，实质上可以将类看作对象的抽象，它定义了对象所具有的属性和方法。学习 Java 语言必须掌握类与对象，这样可以从深层次理解 Java 这种面向对象语言的幵发理念。因此，掌握类与对象是学习 Java 语言的基础，可以使开发人员更好、更快地掌握 Java 编程思想与编程方式。

本章将详细介绍 Java 中类的定义和对象的使用。

本章学习要点

1. 掌握类的声明和类的成员
2. 熟悉类的构造方法及其使用
3. 掌握对象的创建、销毁和使用
4. 掌握 main() 方法、构造方法和析构方法的使用
5. 熟悉 this 关键字的使用
6. 了解系统提供的常用包
7. 掌握如何声明和使用包

Java面向对象：对象的概念及面向对象的三个基本特征

面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析（OOA）、 面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。

对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

对象的概念

Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。对象有以下特点：

• 对象具有属性和行为。
• 对象具有变化的状态。
• 对象具有唯一性。
• 对象都是某个类别的实例。
• 一切皆为对象，真实世界中的所有事物都可以视为对象。

例如，在真实世界的学校里，会有学生和老师等实体，学生有学号、姓名、所在班级等属性（数据），学生还有学习、提问、吃饭和走路等操作。学生只是抽象的描述，这个抽象的描述称为“类”。在学校里活动的是学生个体，即张同学、李同学等，这些具体的个体称为“对象”，“对象”也称为“实例”。

面向对象的三大核心特性

面向对象开发模式更有利于人们开拓思维，在具体的开发过程中便于程序的划分，方便程序员分工合作，提高开发效率。面向对象程序设计有以下优点。

1. 可重用性：代码重复使用，减少代码量，提高开发效率。下面介绍的面向对象的三大核心特性（继承、封装和多态）都围绕这个核心。
2. 可扩展性：指新的功能可以很容易地加入到系统中来，便于软件的修改。
3. 可管理性：能够将功能与数据结合，方便管理。

该开发模式之所以使程序设计更加完善和强大，主要是因为面向对象具有继承、封装和多态 3 个核心特性。

继承性

如同生活中的子女继承父母拥有的所有财产，程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java 只支持单继承。

例如定义一个语文老师类和数学老师类，如果不采用继承方式，那么两个类中需要定义的属性和方法如图 1 所示。

图 1 语文老师类和数学老师类中的属性和方法

从图 1 能够看出，语文老师类和数学老师类中的许多属性和方法相同，这些相同的属性和方法可以提取出来放在一个父类中，这个父类用于被语文老师类和数学老师类继承。当然父类还可以继承别的类，如图 2 所示。

图 2 父类继承示例图

总结图 2 的继承关系，可以用概括的树形关系来表示，如图 3 所示。

图 3 类继承示例图

从图 3 中可以看出，学校主要人员是一个大的类别，老师和学生是学校主要人员的两个子类，而老师又可以分为语文老师和数学老师两个子类，学生也可以分为班长和组长两个子类。

使用这种层次形的分类方式，是为了将多个类的通用属性和方法提取出来，放在它们的父类中，然后只需要在子类中各自定义自己独有的属性和方法，并以继承的形式在父类中获取它们的通用属性和方法即可。

提示：C++ 支持多继承，多继承就是一个子类可有多个父类。例如，客轮是轮船也是交通工具，客轮的父类是轮船和交通工具。多继承会引起很多冲突问题，因此现在很多面向对象的语言都不支持多继承。Java 语言是单继承的，即只能有一个父类，但 Java 可以实现多个接口（接口类似于类，但接口的成员没有执行体。详细了解可参考《Java接口》一节），可以防止多继承所引起的冲突问题。

封装性

封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。封装的目的在于保护信息，使用它的主要优点如下。

• 保护类中的信息，它可以阻止在外部定义的代码随意访问内部代码和数据。
• 隐藏细节信息，一些不需要程序员修改和使用的信息，比如取款机中的键盘，用户只需要知道按哪个键实现什么操作就可以，至于它内部是如何运行的，用户不需要知道。
• 有助于建立各个系统之间的松耦合关系，提高系统的独立性。当一个系统的实现方式发生变化时，只要它的接口不变，就不会影响其他系统的使用。例如 U 盘，不管里面的存储方式怎么改变，只要 U 盘上的 USB 接口不变，就不会影响用户的正常操作。
• 提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用。例如，一个 U 盘可以在多台电脑上使用。

Java 语言的基本封装单位是类。由于类的用途是封装复杂性，所以类的内部有隐藏实现复杂性的机制。Java 提供了私有和公有的访问模式，类的公有接口代表外部的用户应该知道或可以知道的每件东西，私有的方法数据只能通过该类的成员代码来访问，这就可以确保不会发生不希望的事情。

多态性

面向对象的多态性，即“一个接口，多个方法”。多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。多态性允许一个接口被多个同类使用，弥补了单继承的不足。多态概念可以用树形关系来表示，如图 4 所示。

图 4 多态示例图

从图 4 中可以看出，老师类中的许多属性和方法可以被语文老师类和数学老师类同时使用，这样也不易出错。

Java认识类和对象

在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。

让我们来看看人类所具有的一些特征，这些特征包括属性（一些参数、数值）以及方法（一些行为，他能干什么）。

每个人都有身高、体重、年龄、血型等属性，人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人”这个群体的属性与方法。

“人类”只是一个抽象的概念，它仅仅是一个概念，是不存在的实体！但是所有具备“人类”这个群体的属性与方法的对象都叫人！这个对象“人” 是实际存在的实体！每个人都是“人”这个群体的一个对象。

老虎为什么不是人？因为它不具备“人”这个群体的属性与方法，老虎不会直立行走，不会使用工具等，所以说老虎不是人！也就是说，类是概念模型，定义对象的所有特性和所需的操作，对象是真实的模型，是一个具体的实体。

由此可见，类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

对象或实体所拥有的特征在类中表示时称为类的属性。例如，每个人都具有姓名、年龄和体重，这是所有人共有的特征。但是每一个对象的属性值又各不相同，例如，小明和小红都具有体重这个属性，但是他们的体重值是不同的。

对象执行的操作称为类的方法。比如，“人”这个对象都具有的行为是“吃饭”，因此，吃饭就是“人”类的一个方法。

综上所述，类是描述实体的“模板”和“原型”，它定义了属于这个类的对象所应该具有的状态和行为。比如一名学生在上课。一名正在上课的学生是类，它定义的信息有：姓名、上课。

使用该类定义的不同姓名的人在上课是对象，他们可能是小明、小红、小丽、张会等。在 Java 面向对象编程中，用自定义的类模型可以创建该类的一个实例，也就是对象。

类是实体对象的概念模型，因此通常是笼统的、不具体的。关于类和对象，初学者在理解上是存在一定难度的。表 1 给出了类和对象的更多示例。

类	对象
人	正在清洁的环卫工人小刘
教室里的学生张丽
汽车	一辆黄色的宝马跑车
一辆白色的林肯轿车
动物	一只叫“猫咪”的小花猫
一只叫“欢欢”的贵宾犬

类是构造面向对象程序的基本单位，是抽取了同类对象的共同属性和方法所形成的对象或实体的“模板”。而对象是现实世界中实体的描述，对象要创建才存在，有了对象才能对对象进行操作。类是对象的模板，对象是类的实例。

Java类的定义及定义类时可用的关键字

类是 Java 中的一种重要的引用数据类型，也是组成 Java 程序的基本要素，因为所有的 Java 程序都是基于类的。本节介绍如何定义类。

在 Java 中定义一个类，需要使用 class 关键字、一个自定义的类名和一对表示程序体的大括号。完整语法如下：

[public][abstract|final]class<class\_name>[extends<class\_name>][implements<interface\_name>] {
    // 定义属性部分
    <property\_type><property1>;
    <property\_type><property2>;
    <property\_type><property3>;
    …
    // 定义方法部分
    function1();
    function2();
    function3();
    …
}

提示：上述语法中，中括号“[]”中的部分表示可以省略，竖线“|”表示“或关系”，例如 abstract|final，说明可以使用 abstract 或 final 关键字，但是两个关键字不能同时出现。

上述语法中各关键字的描述如下。

• public：表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
• abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
• final：如果类被 final 修饰，则不允许被继承。
• class：声明类的关键字。
• class_name：类的名称。
• extends：表示继承其他类。
• implements：表示实现某些接口。
• property_type：表示成员变量的类型。
• property：表示成员变量名称。
• function()：表示成员方法名称。

Java 类名的命名规则：

1. 类名应该以下划线（_）或字母开头，最好以字母开头。
2. 第一个字母最好大写，如果类名由多个单词组成，则每个单词的首字母最好都大写。
3. 类名不能为 Java 中的关键字，例如 boolean、this、int 等。
4. 类名不能包含任何嵌入的空格或点号以及除了下划线（_）和美元符号（$）字符之外的特殊字符。

例 1

创建一个新的类，就是创建一个新的数据类型。实例化一个类，就是得到类的一个对象。因此，对象就是一组变量和相关方法的集合，其中变量表明对象的状态和属性，方法表明对象所具有的行为。定义一个类的步骤如下所述。

(1) 声明类。编写类的最外层框架，声明一个名称为 Person 的类。

public class Person {
    // 类的主体
}

(2) 编写类的属性。类中的数据和方法统称为类成员。其中，类的属性就是类的数据成员。通过在类的主体中定义变量来描述类所具有的特征（属性），这里声明的变量称为类的成员变量。

(3) 编写类的方法。类的方法描述了类所具有的行为，是类的方法成员。可以简单地把方法理解为独立完成某个功能的单元模块。

下面来定义一个简单的 Person 类。

public class Person {
    private String name;    // 姓名
    private int age;    // 年龄
    public void tell() {   
        // 定义说话的方法
        System.out.println(name+"今年"+age+"岁！");
    }
}

如上述代码，在 Person 类中首先定义了两个属性，分别为 name 和 age，然后定义了一个名称为 tell() 的方法。

Java类的属性：成员变量的定义和声明

在 Java 中类的成员变量定义了类的属性。例如，一个学生类中一般需要有姓名、性别和年龄等属性，这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下：

[public|protected|private][static][final]<type><variable_name>

各参数的含义如下。

• public、protected、private：用于表示成员变量的访问权限。
• static：表示该成员变量为类变量，也称为静态变量。
• final：表示将该成员变量声明为常量，其值无法更改。
• type：表示变量的类型。
• variable_name：表示变量名称。

可以在声明成员变量的同时对其进行初始化，如果声明成员变量时没有对其初始化，则系统会使用默认值初始化成员变量。

初始化的默认值如下：

• 整数型（byte、short、int 和 long）的基本类型变量的默认值为 0。
• 单精度浮点型（float）的基本类型变量的默认值为 0.0f。
• 双精度浮点型（double）的基本类型变量的默认值为 0.0d。
• 字符型（char）的基本类型变量的默认值为 “\u0000”。
• 布尔型的基本类型变量的默认值为 false。
• 数组引用类型的变量的默认值为 null。如果创建了数组变量的实例，但没有显式地为每个元素赋值，则数组中的元素初始化值采用数组数据类型对应的默认值。

定义类的成员变量的示例如下：

public class Student {
    public String name;    // 姓名
    final int sex = 0;    // 性别：0表示女孩，1表示男孩
    private int age;    // 年龄
}

上述示例的 Student 类中定义了 3 个成员变量：String 类型的 name、int 类型的 sex 和 int 类型的 age。其中，name 的访问修饰符为 public，初始化值为 null；sex 的访问修饰符为 friendly（默认），初始化值为 0，表示性别为女，且其值无法更改；age 的访问修饰符为 private，初始化值为 0。

例 1

下面以一个简单的例子来介绍成员变量的初始值，代码如下所示。

public class Counter {
    static int sum;
    public static void main(String[] args) {
        System.out.println(sum);
    }
}

在这里用静态的方法来修饰变量 sum，输出结果是 int 类型的初始值，即：0。

Java创建一个学生类

创建一个表示学生的实体类 Student，其中有学生姓名、性别和年龄信息。要求使用属性来表示学生信息，最终编写测试代码。

首先定义一个名为 Student 的类，代码如下：

public class Student {
    // 学生类
}

在类中通过属性定义学生、性别和年龄，代码如下：

public class Student {
    public String Name;    // 学生姓名
    public int Age;    // 学生年龄
    private boolean Sex;    // 学生性别
}

在上述代码中将学生性别属性 Sex 设置为 private 作用域。为了对该属性进行获取和设置，还需要编写 isSex 和 setSex 方法。代码如下：

public boolean isSex() {
    return Sex;
}
public void setSex(boolean sex) {
    this.Sex = sex;
}

在 Student 类中添加 main() 方法，然后创建两个学生类的实例，并输出学生信息。最终代码如下：

public static void main(String[] args) {
    Student zhang = new Student(); // 创建第一个实例
    zhang.Name = "张子同";
    String isMan = zhang.isSex() ? "女" : "男";
    System.out.println("姓名：" + zhang.Name + "性别：" + isMan + "年龄：" + zhang.Age);
    Student li = new Student(); // 创建第二个实例
    li.Name = "李子文";
    li.Sex = true;
    li.Age = 15;
    String isWoman = li.isSex() ? "女" : "男";
    System.out.println("姓名：" + li.Name + "性别：" + isWoman + "年龄：" + li.Age);
}

输出结果如下：

姓名：张子同性别：男年龄：0
姓名：李子文性别：女年龄：15

由输出结果可以看到，在第一个实例 zhang 中由于仅设置了 Name 属性的值，所以 boolean 类型的 Sex 默认使用值 false，int 类型的 Age 默认使用值 0。第二个实例 li 同时设置了这三个属性的值。

Java成员方法的声明和调用

声明成员方法可以定义类的行为，行为表示一个对象能够做的事情或者能够从一个对象取得的信息。类的各种功能操作都是用方法来实现的，属性只不过提供了相应的数据。一个完整的方法通常包括方法名称、方法主体、方法参数和方法返回值类型，其结构如图 1 所示。

图 1 方法组成元素

成员方法一旦被定义，便可以在程序中多次调用，提高了编程效率。声明成员方法的语法格式如下：

public class Test {
    [public|private|protected][static]<void|return_type><method\_name>([paramList]) {
        // 方法体
    }
}

注意：上述语法中，中括号“[]”中的部分表示可以省略，竖线“|”表示“或”，例如 public|private，说明可以使用 public 或 private 关键字，但是两个关键字不能同时出现。

上述代码中一个方法包含 4 部分：方法的返回值、方法名称、方法的参数和方法体。其中 retum_type 是方法返回值的数据类型，数据类型可以是原始的数据类型，即常用的 8 种数据类型，也可以是一个引用数据类型，如一个类、接口和数组等。

除了这些，一个方法还可以没有返回值，即返回类型为 void，像 main() 方法。method_name 表示自定义的方法名称，方法的名称首先要遵循标识符的命名约定，除此之外，方法的名称第一个单词的第一个字母是小写，第二单词的第一个字母是大写，依此类推。

paramList 表示参数列表，这些变量都要有自己的数据类型，可以是原始数据类型，也可以是复杂数据类型，一个方法主要依靠参数来传递消息。方法主体是方法中执行功能操作的语句。其他各修饰符的含义如下。

• public、private、protected：表示成员方法的访问权限。
• static：表示限定该成员方法为静态方法。
• final：表示限定该成员方法不能被重写或重载。
• abstract：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类。

注意：上面所提到的重写、重载和抽象类，由于篇幅有限，我们会在教程《Java方法重载》《Java方法重写》和《Java抽象类》中讲解，这里大致了解就可以。

例 1

为上一节创建的学生类 Student 添加一个可以返回学生信息字符串的方法。代码如下：

public class Student {
    public StringBuffer printInfo(Student st) {
        StringBuffer sb = new StringBuffer();
        sb.append("学生姓名："+st.Name+"\n 学生年龄："+st.Age+"\n 学生性别："+st.isSex());
        return sb;
    }
}

上述代码创建了一个名称为 printInfo 的方法，其返回值类型为 StringBuffer（引用数据类型）。该方法需要传递一个 Student 类型的参数，最后需要将一个 StringBuffer 类型的数据返回。

1. 成员方法的返回值

若方法有返回值，则在方法体中用 return 语句指明要返回的值，其格式如下所示。

return 表达式

或者

return (表达式)

其中，表达式可以是常量、变量、对象等。表达式的数据类型必须与声明成员方法时给出的返回值类型一致。

2. 形参、实参及成员方法的调用

一般来说，可以通过以下方式来调用成员方法：

methodName({paramList})

关于方法的参数，经常会提到形参与实参，形参是定义方法时参数列表中出现的参数，实参是调用方法时为方法传递的参数。

例 2

下面 retumMin() 方法中的 m 和 n 是形参，调用 retumMin() 方法时的 x 和 y 是实参。

public int returnMin(int m,int n) {
    return Math.min(m,n);    // m和n是形参
}
public static void main(String[] args) {
    int x = 50;
    int y = 100;
    Test t = new Test();
    int i = t.returnMin(x,y);    // x和y是实参
    System.out.println(i);
}

方法的形参和实参具有以下特点：

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在方法内部有效，方法调用结束返回主调方法后则不能再使用该形参变量。
• 实参可以是常量、变量、表达式、方法等，无论实参是何种类型的量，在进行方法调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值、输入等办法使实参获得确定值。
• 实参和形参在数量、类型和顺序上应严格一致，否则会发生“类型不匹配” 的错误。
• 方法调用中发生的数据传送是单向的，即只能把实参的值传送绐形参，而不能把形参的值反向地传送给实参。因此在方法调用过程中，形参的值发生改变，而实参中的值不会变化。

例 3

下面的示例演示了调用 add() 方法前后形参 x 的变化。

public int add(int x) {
    x += 30;
    System.out.println("形参 x 的值："+x);
    return x;
}
public static void main(String[] args) {
    int x = 150;
    System.out.println("调用 add() 方法之前 x 的值："+x);
    Test t = new Test();
    int i = t.add(x);
    System.out.println("实参 x 的值："+x);
    System.out.println("调用 add() 方法的返回值："+i);
}

运行上述程序，输出结果如下：

调用 add() 方法之前 x 的值：150
形参 x 的值：180
实参 x 的值：150
调用 add() 方法的返回值：180

从输出结果可以看出，形参 x 值的改变，并没有影响实参 x。

在调用成员方法时应注意以下 4 点：

1. 对无参成员方法来说，是没有实际参数列表的（即没有 paramList），但方法名后的括号不能省略。
2. 对带参数的成员方法来说，实参的个数、顺序以及它们的数据类型必须与形式参数的个数、顺序以及它们的数据类型保持一致，各个实参间用逗号分隔。实参名与形参名可以相同，也可以不同。
3. 实参也可以是表达式，此时一定要注意使表达式的数据类型与形参的数据类型相同，或者使表达式的类型按 Java 类型转换规则达到形参指明的数据类型。
4. 实参变量对形参变量的数据传递是“值传递”，即只能由实参传递给形参，而不能由形参传递给实参。程序中执行到调用成员方法时，Java 把实参值复制到一个临时的存储区（栈）中，形参的任何修改都在栈中进行，当退出该成员方法时，Java 自动清除栈中的内容。

3. 方法体中的局部变量

在方法体内可以定义本方法所使用的变量，这种变量是局部变量。它的生存期与作用域是在本方法内，也就是说，局部变量只能在本方法内有效或可见，离开本方法则这些变量将被自动释放。

在方法体内定义变量时，变量前不能加修饰符。局部变量在使用前必须明确赋值，否则编译时会出错。另外，在一个方法内部，可以在复合语句（把多个语句用括号{}括起来组成的一个语句称复合语句）中定义变量，这些变量只在复合语句中有效。

Java this关键字详解（3种用法）

this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

下面我们根据示例分别讲解 this 关键字的作用。

this.属性名

大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。

例 1

假设有一个教师类 Teacher 的定义如下：

public class Teacher {
    private String name;    // 教师名称
    private double salary;    // 工资
    private int age;    // 年龄
}

在上述代码中 name、salary 和 age 的作用域是 private，因此在类外部无法对它们的值进行设置。为了解决这个问题，可以为 Teacher 类添加一个构造方法，然后在构造方法中传递参数进行修改。代码如下：

// 创建构造方法，为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {
    this.name = name;    // 设置教师名称
    this.salary = salary;    // 设置教师工资
    this.age = age;    // 设置教师年龄
}

在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值，this 表示当前对象。this.name=name语句表示一个赋值语句，等号左边的 this.name 是指当前对象具有的变量 name，等号右边的 name 表示参数传递过来的数值。

创建一个 main() 方法对 Teacher 类进行测试，代码如下：

public static void main(String[] args) {
    Teacher teacher = new Teacher("王刚",5000.0,45);
    System.out.println("教师信息如下：");
    System.out.println("教师名称："+teacher.name+"\n教师工资："+teacher.salary+"\n教师年龄："+teacher.age);
}

运行该程序，输出的结果如下所示。

教师信息如下：
教师名称：王刚
教师工资：5000.0
教师年龄：45

提示：当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用 this 关键字来访问类中的属性，以区分类的属性和方法中的参数。

this.方法名

this 关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。

例 2

假设定义了一个 Dog 类，这个 Dog 对象的 run( ) 方法需要调用它的 jump( ) 方法，Dog 类的代码如下所示：

/\*\*
 \* 第一种定义Dog类方法
 \*\*/
public class Dog {
    // 定义一个jump()方法
    public void jump() {
        System.out.println("正在执行jump方法");
    }
    // 定义一个run()方法，run()方法需要借助jump()方法
    public void run() {
        Dog d = new Dog();
        d.jump();
        System.out.println("正在执行 run 方法");
    }
}

使用这种方式来定义这个 Dog 类，确实可以实现在 run( ) 方法中调用 jump( ) 方法。下面再提供一个程序来创建 Dog 对象，并调用该对象的 run( ) 方法。

public class DogTest {
    public static void main(String[] args) {
        // 创建Dog对象
        Dog dog = new Dog();
        // 调用Dog对象的run()方法
        dog.run();
    }
}

在上面的程序中，一共产生了两个 Dog 对象，在 Dog 类的 run( ) 方法中，程序创建了一个 Dog 对象，并使用名为 d 的引用变量来指向该 Dog 对象。在 DogTest 的 main() 方法中，程序再次创建了一个 Dog 对象，并使用名为 dog 的引用变量来指向该 Dog 对象。

下面我们思考两个问题。

1）在 run( ) 方法中调用 jump( ) 方法时是否一定需要一个 Dog 对象？

答案是肯定的，因为没有使用 static 修饰的成员变量和方法都必须使用对象来调用。

2）是否一定需要重新创建一个 Dog 对象？

不一定，因为当程序调用 run( ) 方法时，一定会提供一个 Dog 对象，这样就可以直接使用这个已经存在的 Dog 对象，而无须重新创建新的 Dog 对象了。因此需要在 run() 方法中获得调用该方法的对象，通过 this 关键字就可以满足这个要求。

this 可以代表任何对象，当 this 出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的只能是当前类的实例。只有当这个方法被调用时，它所代表的对象才被确定下来，谁在调用这个方法，this 就代表谁。

将前面的 Dog 类的 run( ) 方法改为如下形式会更加合适，run( ) 方法代码修改如下，其它代码不变。

/\*\*
 \* 第二种定义Dog类方法
 \*\*/
// 定义一个run()方法，run()方法需要借助jump()方法
public void run() {
    // 使用this引用调用run()方法的对象
    this.jump();
    System.out.println("正在执行run方法");
}

从第一种 Dog 类定义来看，在 Dog 对象的 run( ) 方法内重新创建了一个新的 Dog 对象，并调用它的 jump( ) 方法，这意味着一个 Dog 对象的 run( ) 方法需要依赖于另一个 Dog 对象的 jump( ) 方法，这不符合逻辑。

第二种 Dog 类定义是当一个 Dog 对象调用 run( ) 方法时，run( ) 方法需要依赖它自己的 jump( ) 方法，与第一种定义类的方法相比，更符合实际情形。

在现实世界里，对象的一个方法依赖于另一个方法的情形很常见，例如，吃饭方法依赖于拿筷子方法，写程序方法依赖于敲键盘方法。这种依赖都是同一个对象两个方法之间的依赖。因此，Java 允许对象的一个成员直接调用另一个成员，可以省略 this 前缀。也就是说，将上面的 run( ) 方法改为如下形式也完全正确。

public void run() {
    jump();
    System.out.println("正在执行run方法");
}

大部分时候，一个方法访问该类中定义的其他方法、成员变量时加不加 this 前缀的效果是完全一样的。

注意：对于 static 修饰的方法而言，可以使用类来直接调用该方法，如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象。所以，static 修饰的方法中不能使用 this 引用。并且 Java 语法规定，静态成员不能直接访问非静态成员。

省略 this 前缀只是一种假象，虽然程序员省略了调用 jump() 方法之前的 this，但实际上这个 this 依然是存在的。

this( )访问构造方法

this( ) 用来访问本类的构造方法（构造方法是类的一种特殊方法，方法名称和类名相同，没有返回值。详细了解可参考《Java构造方法》一节），括号中可以有参数，如果有参数就是调用指定的有参构造方法。

例 3

下面定义一个 Student 类，使用 this( ) 调用构造方法给 name 赋值，Student 类的代码如下所示：

public class Student {
    String name;
    // 无参构造方法（没有参数的构造方法）
    public Student() {
        this("张三");
    }
    // 有参构造方法
    public Student(String name) {
        this.name = name;
    }
    // 输出name和age
    public void print() {
        System.out.println("姓名：" + name);
    }
    public static void main(String[] args) {
        Student stu = new Student();
        stu.print();
    }
}

输出结果为：

姓名：张三

注意：

• this( ) 不能在普通方法中使用，只能写在构造方法中。
• 在构造方法中使用时，必须是第一条语句。

Java创建对象详解（显式创建和隐含创建）

对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除，本文详细介绍对象的创建，在 Java 语言中创建对象分显式创建与隐含创建两种情况。

显式创建对象

对象的显式创建方式有 4 种。

1. 使用 new 关键字创建对象

这是常用的创建对象的方法，语法格式如下：

类名 对象名 = new 类名()；

2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法

在 Java 中，可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象，代码格式如下：

java.lang.Class Class 类对象名称 = java.lang.Class.forName(要实例化的类全称);
类名 对象名 = (类名)Class类对象名称.newInstance();

调用 java.lang.Class 类中的 forName() 方法时，需要将要实例化的类的全称（比如 com.mxl.package.Student）作为参数传递过去，然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。

3. 调用对象的 clone() 方法

该方法不常用，使用该方法创建对象时，要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下：

类名对象名 = (类名)已创建好的类对象名.clone();

4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法

例 1

下面创建一个示例演示常用的前三种对象创建方法。示例代码如下：

public class Student implements Cloneable {   
    // 实现 Cloneable 接口
    private String Name;    // 学生名字
    private int age;    // 学生年龄
    public Student(String name,int age) {    
        // 构造方法
        this.Name = name;
        this.age = age;
    }
    public Student() {
        this.Name = "name";
        this.age = 0;
    }
    public String toString() {
        return"学生名字："+Name+"，年龄："+age;
    }
    public static void main(String[] args)throws Exception {
        System.out.println("---------使用 new 关键字创建对象---------");
       
        // 使用new关键字创建对象
        Student student1 = new Student("小刘",22);
        System.out.println(student1);
        System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
       
        // 调用 java.lang.Class 的 newInstance() 方法创建对象
        Class c1 = Class.forName("Student");
        Student student2 = (Student)c1.newInstance();
        System.out.println(student2);
        System.out.println("-------------------调用对象的 clone() 方法创建对象----------");
        // 调用对象的 clone() 方法创建对象
        Student student3 = (Student)student2.clone();
        System.out.println(student3);
    }
}

对上述示例的说明如下：

• 使用 new 关键字或 Class 对象的 newInstance() 方法创建对象时，都会调用类的构造方法。
• 使用 Class 类的 newInstance() 方法创建对象时，会调用类的默认构造方法，即无参构造方法。
• 使用 Object 类的 clone() 方法创建对象时，不会调用类的构造方法，它会创建一个复制的对象，这个对象和原来的对象具有不同的内存地址，但它们的属性值相同。
• 如果类没有实现 Cloneable 接口，则 clone。方法会抛出 java.lang.CloneNotSupportedException 异常，所以应该让类实现 Cloneable 接口。

程序执行结果如下：

---------使用 new 关键字创建对象---------
学生名字：小刘，年龄：22
-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------
学生名字：name，年龄：0
-------------------调用对象的done()方法创建对象----------
学生名字：name，年龄：0

隐含创建对象

除了显式创建对象以外，在 Java 程序中还可以隐含地创建对象，例如下面几种情况。

1）String strName = “strValue”，其中的“strValue”就是一个 String 对象，由 Java 虚拟机隐含地创建。

2）字符串的“+”运算符运算的结果为一个新的 String 对象，示例如下：

String str1 = "Hello";
String str2 = "Java";
String str3 = str1+str2;    // str3引用一个新的String对象

3）当 Java 虚拟机加载一个类时，会隐含地创建描述这个类的 Class 实例。

提示：类的加载是指把类的 .class 文件中的二进制数据读入内存中，把它存放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class 对象，用来封装类在方法区内的数据结构。

无论釆用哪种方式创建对象，Java 虚拟机在创建一个对象时都包含以下步骤：

• 给对象分配内存。
• 将对象的实例变量自动初始化为其变量类型的默认值。
• 初始化对象，给实例变量赋予正确的初始值。

注意：每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由 Java 虚拟机自带的垃圾回收机制处理。

Java new运算符深入剖析

”new“在 Java 中意思是”新的“，可以说是 Java 开发者最常用的关键字。在 Java 中 new 的操作往往意味着在内存中开辟新的空间，这个内存空间分配在内存的堆区。

堆是用来存放由 new 创建的对象和数组，即动态申请的内存都存放在堆区。栈是用来存放在方法中定义的一些基本类型的变量和对象的引用变量。

Java 中一般使用 new 来创建对象，它可以动态地为一个对象分配地址。它的通用格式如下：

classname obj = new classname( );

其中，obj 是创建的对象，classname 是类的名字，类名后边的( )指明了类的构造方法。构造方法定义了当创建一个对象时要进行的操作。

下面我们通过 String 这个类举例说明。

public class Test {
    public static void main(String[] args) {
        String a = "C语言中文网";
        String b = new String("C语言中文网");
        String c = "C语言中文网";
        String d = new String("C语言中文网");
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(d == b);
        System.out.println(a);
        a = "Java";
        System.out.println(a);
    }
}

输出结果为：

false
true
false
C语言中文网
Java

不同方式定义字符串时堆和栈的变化：

1. String a; 只是在栈中创建了一个 String 类的对象引用变量 a。
2. String a = "C语言中文网";在栈中创建一个 String 类的对象引用变量 a，然后查找栈中有没有存放“C语言中文网”，如果有则直接指向“C语言中文网"，如果没有，则将”C语言中文网“存放进栈，再指向。
3. String a = new String("C语言中文网");不仅在栈中创建一个 String 类的对象引用变量 a，同时也在堆中开辟一块空间存放新建的 String 对象“C语言中文网”，变量 a 指向堆中的新建的 String 对象”C语言中文网“。

==用来比较两个对象在堆区存放的地址是否相同。根据上面的输出结果，我们可以看出：

• 使用 new 运算符创建的 String 对象进行==操作时，两个地址是不同的。这就说明，每次对象进行 new 操作后，系统都为我们开辟堆区空间，虽然值是一样，但是地址却是不一样的。
• 当我们没有使用 new 运算符的时候，系统会默认将这个变量保存在内存的栈区。如果变量的值存放在栈中，使用==比较时，比较的是具体的值。如果变量的值存放在堆中，使用==比较时，比较的是值所在的地址。因此在变量 a 与变量 c 进行==操作的时候，返回 true，因为变量 a 和变量 c 比较的是具体的值，即“C语言中文网”。
• 在改变变量 a 的值后（如 a = “Java”），再次输出时，我们发现输出的结果是”Java“。事实上原来的那个“C语言中文网”在内存中并没有清除掉，而是在栈区的地址发生了改变，这次指向的是”Java“所在的地址。

注意：如果需要比较两个使用 new 创建的对象具体的值，则需要通过“equal()”方法去实现，这样才是比较引用类型变量具体值的正确方式。

这时，你可能想知道为什么对整数或字符这样的简单变量不使用 new 运算符。答案是 Java 的简单类型不是作为对象实现的。出于效率的考虑，它们是作为“常规”变量实现的。

对象有许多属性和方法，这使得 Java 对对象的处理不同于简单类型。Java 在处理对象和处理简单类型时开销不同，Java 能更高效地实现简单类型。当然，如果你希望完全使用对象类型，那么 Java 也提供了简单类型的对象版本，也就是包装类。

大家一定要明白，new 运算符是在运行期间为对象分配内存的，这使得内存的分配更加灵活和高效，你的程序在运行期间可以根据实际情况来合理地分配内存。但是，内存是有限的，因此 new 有可能由于内存不足而无法给一个对象分配内存。如果出现这种情况，就会发生运行时异常。

对于本教程中的示例程序，你不必担心内存不足的情况，但是在实际的编程中你必须考虑这种可能性。

Java访问对象的属性和行为

每个对象都有自己的属性和行为，这些属性和行为在类中体现为成员变量和成员方法，其中成员变量对应对象的属性，成员方法对应对象的行为。

在 Java 中，要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。语法格式如下：

对象名.属性(成员变量)    // 访问对象的属性
对象名.成员方法名()    // 访问对象的方法

例如，定义一个 Student 类，创建该类的对象 stu，再对该对象的属性赋值，代码如下：

Student stu = new Student();    // 创建 Student 类的对象 stu
stu.Name = "李子文";    // 调用stu对象的Name属性并赋值
stu.Sex = true;    // 调用stu对象的Sex属性并赋值
stu.Age = 15;    // 调用stu对象的Age属性并赋值

如果一个对象要被使用，则对象必须被实例化，如果一个对象没有被实例化而直接调用了对象中的属性或方法，如下代码所示：

Student stu = null;
stu.Name = "李子文";
stu.Sex = true;
stu.Age = 15;

则程序运行时会出现以下异常：

Exception in thread “main” java.lang.NullPointerException

此异常是开发中最常见的异常，也会始终伴随着每位开发人员，使用了未实例化的对象则肯定会出现此异常。

Java对象的销毁

对象使用完之后需要对其进行清除。对象的清除是指释放对象占用的内存。在创建对象时，用户必须使用 new 操作符为对象分配内存。不过，在清除对象时，由系统自动进行内存回收，不需要用户额外处理。这也是 Java 语言的一大特色，某种程度上方便了程序员对内存的管理。

Java 语言的内存自动回收称为垃圾回收（Garbage Collection）机制，简称 GC。垃圾回收机制是指 JVM 用于释放那些不再使用的对象所占用的内存。

Java 语言并不要求 JVM 有 GC，也没有规定 GC 如何工作。不过常用的 JVM 都有 GC，而且大多数 GC 都使用类似的算法管理内存和执行回收操作。具体的垃圾回收实现策略有好多种，在此不再赘述。

注意：C++语言对象是通过 delete 语句手动释放。如果回收内存的任务由程序负责，也就是说必须在程序中显式地进行内存回收，这无疑会增加程序员的负担，而且存在很多弊端。Java 语言对象是由垃圾回收器收集然后释放，程序员不用关系释放的细节。自动内存管理是现代计算机语言发展趋势，例如：C# 语言的垃圾回收，Objective-C 和 Swift 语言的 ARC（内存自动引用计数管理）。

一个对象被当作垃圾回收的情况主要如下两种。

1）对象的引用超过其作用范围。

{
    Object o = new Object();    // 对象o的作用范围，超过这个范围对象将被视为垃圾
}

2）对象被赋值为 null。

{
    Object o = new Object();
    o = null;    // 对象被赋值为null将被视为垃圾
}

在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。

在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。

1）可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。

2）可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。

3）不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。

注意：调用 System.gc() 或者 Runtime.gc() 方法也不能保证回收操作一定执行，它只是提高了 Java 垃圾回收器尽快回收垃圾的可能性。

Java中的空对象（null）是怎么回事？

Java 语言支持两种数据类型，分别是基本数据类型和引用数据类型，而 null 是一种特殊的引用数据类型。本节主要介绍 Java 空对象是什么及如何判断对象是否为空。

经过《Java new运算符深入剖析》一节的学习，我们知道了对象的实例化就是为对象开辟内存空间。

例如以下 3 条语句（如果理解下面内容有点困难，建议先学习《Java new运算符深入剖析》一节）：

Student stu = new Student(); // 语句1
Student stu2; // 语句2
stu2 = new Student(); // 语句3

• 语句 1 先声明一个 Student 类型的变量 stu，然后利用 new 关键字为其创建实例。一步到位，定义了一个实例变量并同时赋值。
• 语句 2 是声明一个 Student 类型的变量 stu2，虽然从表述习惯上讲 stu2 是实例变量，但实际上此时 stu2 并未成为一个真正的实例，它仅仅只是一个变量名字。
• 语句 3 中的 stu2 才成为了一个 Student 实例，它指向了内存中的某块地址空间。

为了明确表示那些仅有名字而没有内存空间的变量的具体内容，Java 引入了关键字 null。 null 表示“空”的意思，是绝对意义上的空，这个空指的是不存在。

一个引用变量（当变量指向一个对象时，这个变量就被称为引用变量）没有通过 new 分配内存空间，这个对象就是空对象，Java 使用关键字 null 表示空对象。示例代码如下：

String str1= null;
str1 = “C语言中文网”;

注意：null 是关键字，是大小写敏感的，不能将 null 写成 Null 或 NULL。

引用变量的默认值是 null。当试图调用一个空对象的属性或方法时，会抛出空指针异常（NullPointerException），如下代码所示：

String str1;    // 相当于 String str1= null;
// 输出null字符串
System.out.println(str1);
// 调用length()方法
int len = str1.length();

第 5 行代码不会发生编译错误，但是当代码运行到第 5 行时，系统会抛出空指针异常。这是因为调用 length() 方法时，str1 是空对象。程序员应该避免调用空对象的属性和方法。

判断一个对象是否为 null，可以用if (obj == null) { }来判断。代码如下：

// 判断对象是否为null
if (str1 != null) {
    int len = str1.length();
}

如果把上面代码改成如下代码：

String str2 = "";
int num = str2.length();
System.out.println(num);    // 输出结果为0

运行以上代码时没有抛出异常，因为 str2 是一个值为""的字符串对象。""表示的是一个长度为 0 的空字符串，它在内存中会被分配一个空间，str2 是直接指向""内存空间的实例化对象。

产生空对象主要有以下两种可能性：

1. 程序员自己忘记了实例化，所以程序员必须防止这种情况发生，应该仔细检查自己的代码，为自己创建的所有对象进行实例化并初始化。
2. 空对象是其它地方传递过来的，需要通过判断对象是否为 null 进行避免。

Java注释：类、方法和字段注释

一个程序的可读性，关键取决于注释。如果一个程序想二次开发，要读懂前面的程序代码，就必须在程序中有大量的注释文档，所以对于一个优秀的程序员来说，学会在程序中适当地添加注释是非常重要的。

注释除了帮助别人了解编写的程序之外，还对程序的调试、校对等有相当大的帮助。当程序具体运行时，计算机会自动忽略注释符号之后所有的内容。教程第二章中曾经提到过注释，读者也许印象不太深，在这里复习一遍。

本节将简单地介绍类、方法、字段等地方的注释方法，这些地方的注释虽然简单但是在开发工作中却是非常重要的。

注意：本节注释使用文档注释。多行注释的内容不能用于生成一个开发者文档（文档提供类、方法和变量的解释，也可称为帮助文档），而文档注释可以。

1. 类注释

类注释一般必须放在所有的“import”语句之后，类定义之前，主要声明该类可以做什么，以及创建者、创建日期、版本和包名等一些信息。以下是一个类注释的模板。

/\*\*
 \* @projectName（项目名称）: project\_name
 \* @package（包）: package\_name.file\_name
 \* @className（类名称）: type\_name
 \* @description（类描述）: 一句话描述该类的功能
 \* @author（创建人）: user 
 \* @createDate（创建时间）: datetime 
 \* @updateUser（修改人）: user 
 \* @updateDate（修改时间）: datetime
 \* @updateRemark（修改备注）: 说明本次修改内容
 \* @version（版本）: v1.0
 \*/

提示：以上以@开头的标签为 Javadoc 标记，由@和标记类型组成，缺一不可。@和标记类型之间有时可以用空格符分隔，但是不推荐用空格符分隔，这样容易出错。

一个类注释的创建人、创建时间和描述是不可缺少的。下面是一个类注释的例子。

/\*\*
 \* @author: zhangsan
 \* @createDate: 2018/10/28
 \* @description: this is the student class.
 \*/
public class student{
    .................
}

注意：没有必要在每一行的开始用*。例如，以下注释同样是合法的：

/\*\*
 @author: zhangsan
 @createDate: 2018/10/28
 @description: this is the student class.
 \*/
public class student{
    .................
}

2. 方法注释

方法注释必须紧靠在方法定义的前面，主要声明方法参数、返回值、异常等信息。除了可以使用通用标签外，还可以使用下列的以@开始的标签。

• @param 变量描述：对当前方法的参数部分添加一个说明，可以占据多行。一个方法的所有 @param 标记必须放在一起。
• @return 返回类型描述：对当前方法添加返回值部分，可以跨越多行。
• @throws 异常类描述：表示这个方法有可能抛出异常。有关异常的详细内容将在第 10 章中讨论。

下面是一个方法注释的例子。

/\*\*
 \* @param num1: 加数1
 \* @param num2: 加数2
 \* @return: 两个加数的和
 \*/
public int add(int num1,int num2) {
    int value = num1 + num2;
    return value;
}

以上代码的 add() 方法中声明了两个形参，并将它们两个的和作为返回值返回。

为类的构造方法添加注释时，一般声明该方法的参数信息，代码如下。

public class Student {
   String name;
   int age;
   /\*\*
 \* @description: 构造方法
 \* @param name: 学生姓名
 \* @param age: 学生年龄
 \*/
   public Student(String name,int age) {
    this.name = name;
    this.age = age;
   }
}

3. 字段注释

字段注释在定义字段的前面，用来描述字段的含义。下面是一个字段注释的例子。

/**
 * 用户名
 */
public String name;

也可以使用如下格式：

/**用户名*/
public String name;

在 Java 的编写过程中我们需要对一些程序进行注释，除了自己方便阅读，更为别人更好理解自己的程序。注释对于程序的可读性来说是非常重要的，希望读者不要忽视它。

Java static关键字（静态变量和静态方法）

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。

静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。

调用静态成员的语法形式如下：

类名.静态成员

注意：

• static 修饰的成员变量和方法，从属于类。
• 普通变量和方法从属于对象。
• 静态方法不能调用非静态成员，编译会报错。

静态变量

类的成员变量可以分为以下两种：

1. 静态变量（或称为类变量），指被 static 修饰的成员变量。
2. 实例变量，指没有被 static 修饰的成员变量。

静态变量与实例变量的区别如下：

1）静态变量

• 运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
• 在类的内部，可以在任何方法内直接访问静态变量。
• 在其他类中，可以通过类名访问该类中的静态变量。

2）实例变量

• 每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
• 在类的内部，可以在非静态方法中直接访问实例变量。
• 在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

静态变量在类中的作用如下：

• 静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
• 如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。

public static double PI = 3.14159256;

例 1

创建一个带静态变量的类，然后在 main() 方法中访问该变量并输出结果。

public class StaticVar {
    public static String str1 = "Hello";
    public static void main(String[] args) {
        String str2 = "World!";
        // 直接访问str1
        String accessVar1 = str1+str2;
        System.out.println("第 1 次访问静态变量，结果为："+accessVar1);
        // 通过类名访问str1
        String accessVar2 = StaticVar.str1+str2;
        System.out.println("第 2 次访问静态变量，结果为："+accessVar2);
        // 通过对象svt1访问str1
        StaticVar svt1 = new StaticVar();
        svt1.str1 = svt1.str1+str2;
        String accessVar3 = svt1.str1;
        System.out.println("第3次访向静态变量，结果为："+accessVar3);
        // 通过对象svt2访问str1
        StaticVar svt2 = new StaticVar();
        String accessVar4 = svt2.str1+str2;
        System.out.println("第 4 次访问静态变量，结果为："+accessVar4);
    }
}

运行该程序后的结果如下所示。

第 1 次访问静态变量，结果为：HelloWorld!
第 2 次访问静态变量，结果为：HelloWorld!
第 3 次访向静态变量，结果为：HelloWorld!
第 4 次访问静态变量，结果为：HelloWorld!World!

从运行结果可以看出，在类中定义静态的属性（成员变量），在 main() 方法中可以直接访问，也可以通过类名访问，还可以通过类的实例对象来访问。

注意：静态变量是被多个实例所共享的。

静态方法

与成员变量类似，成员方法也可以分为以下两种：

1. 静态方法（或称为类方法），指被 static 修饰的成员方法。
2. 实例方法，指没有被 static 修饰的成员方法。

静态方法与实例方法的区别如下：

• 静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。
• 在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

例 2

创建一个带静态变量的类，添加几个静态方法对静态变量的值进行修改，然后在 main( ) 方法中调用静态方法并输出结果。

public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法，打印 count
        StaticMethod.PrintCount();
    }
}

运行该程序后的结果如下所示。

在静态方法 method1()中的 count=2
method1() 方法返回值 intro1=2
在静态方法 method2()中的 count=4
method2() 方法返回值 intro1=4
在静态方法 PrintCount()中的 count=6

在该程序中，静态变量 count 作为实例之间的共享数据，因此在不同的方法中调用 count，值是不一样的。从该程序中可以看出，在静态方法 method1() 和 PrintCount() 中是不可以调用非静态方法 method1() 的，而在 method1() 方法中可以调用静态方法 method2() 和 PrintCount()。

在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问。

静态代码块

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

静态代码块的特点如下：

• 静态代码块类似于一个方法，但它不可以存在于任何方法体中。
• 静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。
• Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。
• 如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
• 静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。

例 3

编写一个 Java 类，在类中定义一个静态变量，然后使用静态代码块修改静态变量的值。最后在 main() 方法中进行测试和输出。

public class StaticCode {
    public static int count = 0;
    {
        count++;
        System.out.println("非静态代码块 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);
    }
    public static void main(String[] args) {
        System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* StaticCode1 执行 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
        StaticCode sct1 = new StaticCode();
        System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* StaticCode2 执行 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
        StaticCode sct2 = new StaticCode();
    }
}

如上述示例，为了说明静态代码块只被执行一次，特地添加了非静态代码块作为对比，并在主方法中创建了两个类的实例对象。上述示例的执行结果为：

静态代码块1 count=1
静态代码块2 count=2
*************** StaticCode1 执行 ***************
非静态代码块 count=3
*************** StaticCode2 执行 ***************
非静态代码块 count=4

上述代码中 { } 代码块为非静态代码块，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。代码域中定义的变量都是局部的，只有域中的代码可以调用。

Java import static静态导入

在 JDK 1.5 之后增加了一种静态导入的语法，用于导入指定类的某个静态成员变量、方法或全部的静态成员变量、方法。如果一个类中的方法全部是使用 static 声明的静态方法，则在导入时就可以直接使用 import static 的方式导入。

静态导入使用 import static 语句，静态导入也有两种语法，分别用于导入指定类的单个静态成员变量、方法和全部静态成员变量、方法，其中导入指定类的单个静态成员变量、方法的语法格式如下：

import static package.ClassName.fieldName|methodName;

上面语法导入 package.ClassName 类中名为 fieldName 的静态成员变量或者名为 methodName 的静态方法。例如，可以使用import static java.lang.System.out;语句来导入 java.lang.System 类的 out 静态成员变量。

导入指定类的全部静态成员变量、方法的语法格式如下：

import static package.ClassName.*;

上面语法中的星号只能代表静态成员变量或方法名。

import static 语句也放在 Java 源文件的 package 语句（如果有的话）之后、类定义之前，即放在与普通 import 语句相同的位置，而且 import 语句和 import static 语句之间没有任何顺序要求。

所谓静态成员变量、静态方法其实就是前面介绍的类变量、类方法，它们都需要使用 static 修饰，而 static 在很多地方都被翻译为静态，因此 import static 也就被翻译成了 “静态导入”。其实完全可以抛开这个翻译，用一句话来归纳 import 和 import static 的作用，使用 import 可以省略写包名，而使用 import static 可以省略类名。

下面程序使用 import static 语句来导入 java.lang.System 类下的全部静态成员变量，从而可以将程序简化成如下形式。

import static java.lang.System.*;
import static java.lang.Math.*;
public class StaticImportTest {
    public static void main(String[] args) {
        // out是java.lang.System类的静态成员变量，代表标准输出
        // PI是java.lang.Math类的静态成员变量，表示π常量
        out.println(PI);
        // 直接调用Math类的sqrt静态方法，返回256的正平方根
        out.println(sqrt(256));
    }
}

从上面程序不难看出，import 和 import static 的功能非常相似，只是它们导入的对象不一样而已。import 语句和 import static 语句都是用于减少程序中代码编写量的。

Java static的常见问题和使用误区

学完《Java static关键字》一节我们可能会产生很多疑问，所以本节主要讲解学习 Java 中关于 static 常见的几个问题。

1）为什么要用”static“关键字？

通常来说，用 new 创建类的对象时，数据存储空间才被分配，方法才供外界调用。有时候我们只想为特定域分配单一存储空间，不考虑要创建多少对象或者说根本就不创建任何对象，有时候我们想在没有创建对象的情况下也想调用方法。在这两种情况下，static 关键字，满足了我们的需求。

2）”static“关键字是什么意思？Java 中是否可以覆盖（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）一个 private 或者是 static 的方法？

“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。

Java 中 static 方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用。

3）是否可以在 static 环境中访问非 static 变量？

static 变量在 Java 中是属于类的，它在所有的实例中的值是一样的。当类被 Java 虚拟机载入的时候，会对 static 变量进行初始化。如果你的代码尝试不用实例来访问非 static 的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。

4）static 静态方法能不能引用非静态资源？

不能，new 的时候才会产生的东西，对于初始化后就存在的静态资源来说，不能引用它。

5）static 静态方法里面能不能引用静态资源？

可以，因为都是类初始化的时候加载的。

6）非静态方法里面能不能引用静态资源？

可以，非静态方法就是实例方法，那是 new 之后才产生的，那么属于类的内容它都认识。

使用误区

1）static 关键字会改变类中成员的访问权限吗？

有些初学者会将 Java 中的 static 与 C/C++ 中的 static 关键字的功能混淆了。在这里只需要记住一点，与 C/C++ 中的 static 不同，Java 中的 static 关键字不会影响到变量或者方法的作用域。在 Java 中能够影响到访问权限的只有 private、public、protected、friendly 这几个关键字。看下面的例子就明白了：

定义一个 Student 类，代码如下：

public class Student {
    public static String name = "张三";
    private static int age = 10;
}

定义 Main 类调用 Student 类的 age 属性，代码如下：

public class Main {
    public static void main(String[] args) {
        System.out.println(Student.name);
        System.out.println(Student.age);
    }
}

代码第 4 行会提示错误“Student.age 不可视（The field Student.age is not visible）”，这说明 static 关键字并不会改变变量和方法的访问权限。

2）能通过 this 访问静态成员变量吗？

虽然对于静态方法来说没有 this，那么在非静态方法中能够通过 this 访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？

public class Main {
    static int value = 33;
    public static void main(String[] args) throws Exception {
        new Main().printValue();
    }
    private void printValue() {
        int value = 3;
        System.out.println(this.value);    // 输出 33
    }
}

这里面主要考察 this 和 static 的理解。this 代表什么？this 代表当前对象，那么通过 new Main() 来调用 printValue 的话，当前对象就是通过 new Main() 生成的对象。而 static 变量是被对象所享有的，因此在 printValue 中的 this.value 的值毫无疑问是 33。在 printValue 方法内部的 value 是局部变量，根本不可能与 this 关联，所以输出结果是 33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

3）static 能作用于局部变量么？

在 C/C++ 中 static 是可以作用域局部变量的，但是在 Java 中切记，Java 语法规定 static 是不允许用来修饰局部变量。

Java final修饰符详解

final 在 Java 中的意思是最终，也可以称为完结器，表示对象是最终形态的，不可改变的意思。final 应用于类、方法和变量时意义是不同的，但本质是一样的，都表示不可改变，类似 C# 里的 sealed 关键字。

使用 final 关键字声明类、变量和方法需要注意以下几点：

• final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。
• final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。
• final 用在类的前面表示该类不能有子类，即该类不可以被继承。

final 修饰变量

final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。

1. final 修饰的局部变量必须使用之前被赋值一次才能使用。
2. final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。

注意：final 修饰的变量不能被赋值这种说法是错误的，严格的说法是，final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值。

public class FinalDemo {
    void doSomething() {
        // 没有在声明的同时赋值
        final int e;
        // 只能赋值一次
        e = 100;
        System.out.print(e);
        // 声明的同时赋值
        final int f = 200;
    }
    // 实例常量
    final int a = 5; // 直接赋值
    final int b; // 空白final变量
    // 静态常量
    final static int c = 12;// 直接赋值
    final static int d; // 空白final变量


### 最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友

![image.png](https://img-blog.csdnimg.cn/img_convert/16c3b165ea25b6877008a90523aca000.webp?x-oss-process=image/format,png)



）能通过 this 访问静态成员变量吗？


虽然对于静态方法来说没有 this，那么在非静态方法中能够通过 this 访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？

public class Main {
static int value = 33;
public static void main(String[] args) throws Exception {
new Main().printValue();
}
private void printValue() {
int value = 3;
System.out.println(this.value); // 输出 33
}
}

这里面主要考察 this 和 static 的理解。this 代表什么？this 代表当前对象，那么通过 new Main() 来调用 printValue 的话，当前对象就是通过 new Main() 生成的对象。而 static 变量是被对象所享有的，因此在 printValue 中的 this.value 的值毫无疑问是 33。在 printValue 方法内部的 value 是局部变量，根本不可能与 this 关联，所以输出结果是 33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。


3）static 能作用于局部变量么？


在 C/C++ 中 static 是可以作用域局部变量的，但是在 Java 中切记，Java 语法规定 static 是不允许用来修饰局部变量。


## Java final修饰符详解


final 在 [Java]( ) 中的意思是最终，也可以称为完结器，表示对象是最终形态的，不可改变的意思。final 应用于类、方法和变量时意义是不同的，但本质是一样的，都表示不可改变，类似 [C#]( ) 里的 sealed 关键字。


使用 final 关键字声明类、变量和方法需要注意以下几点：


* final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。
* final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。
* final 用在类的前面表示该类不能有子类，即该类不可以被继承。


### final 修饰变量


final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。


1. final 修饰的局部变量必须使用之前被赋值一次才能使用。
2. final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。


注意：final 修饰的变量不能被赋值这种说法是错误的，严格的说法是，final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值。

public class FinalDemo {
void doSomething() {
// 没有在声明的同时赋值
final int e;
// 只能赋值一次
e = 100;
System.out.print(e);
// 声明的同时赋值
final int f = 200;
}
// 实例常量
final int a = 5; // 直接赋值
final int b; // 空白final变量
// 静态常量
final static int c = 12;// 直接赋值
final static int d; // 空白final变量

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友

[外链图片转存中…(img-x5z05TXU-1716464857446)]