Java 类与对象初探：从定义到实例化

将洗衣机这一现实对象用 Java 描述后，经过 javac 编译生成 .class 文件，JVM 便能识别并使用这个类。

注意事项：

1. 类名应采用大驼峰命名法；
2. 成员前一般统一使用 public 修饰（后续会详细说明）；
3. 此处所写的方法均不带 static 关键字（后续会讲解其意义）。

小练习

定义一个狗类

class PetDog {
    public String name;   // 狗的名字
    public String color;  // 狗的颜色

    // 狗的属性描述
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }

    // 狗的行为描述
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

定义一个学生类

public class Student {
    public String name;
    public String gender;
    public short age;
    public double score;

    public void DoClass() {
        // 上课方法
    }

    public void DoHomework() {
        // 做作业方法
    }

    public void Exam() {
        // 考试方法
    }
}

在定义类时需注意以下几点：

1. 一般一个文件中只定义一个类；
2. 含有 main 方法的类通常应使用 public 修饰（例如 Eclipse 默认在 public 修饰的类中查找 main 方法）；
3. 用 public 修饰的类名必须与文件名相同；
4. 修改 public 类的名称需谨慎。

类的实例化

什么是实例化

当我们使用 class 关键字定义了一个类，就相当于在计算机中定义了一种新的类型（如同 int、double 等内置类型）。只不过 int 和 double 是 Java 语言自带的类型，而类是程序员自定义的类型。

有了这种新类型之后，就可以用它来创建对象（也称为类的实例）。用类类型创建对象的过程称为类的实例化，在 Java 中通过 new 关键字配合类名来完成。

public class Student {
    public String name;
    public String gender;
    public short age;
    public double score;

    public void DoClass() {}
    public void DoHomework() {}
    public void Exam() {}

    public static void main(String[] args) {
        // 通过 new 关键字实例化对象
        Student s1 = new Student();
        s1.name = "Li Lei";
        s1.gender = "男";
        s1.age = 18;
        s1.score = 3.8;

        Student s2 = new Student();
        s2.name = "Han Meimei";
        s2.gender = "女";
        s2.age = 19;
        s2.score = 4.0;

        Student s3 = new Student();
        s3.name = "Jim";
        s3.gender = "男";
        s3.age = 18;
        s3.score = 2.6;
    }
}

注意事项：

1. new 关键字用于创建对象的实例；
2. 使用 . 号来访问对象的属性和方法；
3. 同一个类可以创建多个对象，每个对象独立占用内存空间，存储各自的成员变量。

类和对象的说明

1. 类只是一个'模型'或'蓝图'，用来描述对象应该包含哪些成员变量和成员方法；它本身并不直接占用实际的存储空间。
2. 对象是类的实例化结果，才真正占用物理空间，可以用来存储数据，也能执行方法。
3. 同一个类可以实例化出多个对象，对象之间的成员变量互不影响。
4. 类比：类就像'建筑设计图'，对象就像'根据设计图建造出来的房子'。设计图只有一份，但可以建造出很多房子，每个房子都有自己的空间和家具。

示例代码：

public class PetDog {
    public String name;
    public String color;

    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }

    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }

    public static void main(String[] args) {
        PetDog dog1 = new PetDog();
        dog1.name = "阿黄";
        dog1.color = "黑黄";
        dog1.barks();
        dog1.wag();

        PetDog dog2 = new PetDog();
        dog2.name = "赛虎";
        dog2.color = "棕白";
        dog2.barks();
        dog2.wag();
    }
}

执行结果：

阿黄：旺旺旺~~~ 阿黄：摇尾巴~~~ 赛虎：旺旺旺~~~ 赛虎：摇尾巴~~~

this 引用

为什么要有 this 引用

先来看一个日期类的例子：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }

    public void printDate() {
        System.out.println(year + "/" + month + "/" + day);
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
        d1.printDate(); // 2020/9/15
        d2.printDate(); // 2020/9/16
        d3.printDate(); // 2020/9/17
    }
}

这段代码能正常运行，但仔细思考时，会有两个疑问：

1. 如果形参名和成员变量名相同，例如都叫 year，month，day，那在 setDay 方法里写 year = year; 究竟是谁给谁赋值？
2. d1, d2, d3 分别调用了 setDay 和 printDate 方法，而这两个方法中并没有任何'对象标识'的信息，它们是如何知道当前要修改或打印的是哪个对象的数据呢？

为解决这两个疑惑，Java 提供了 this 引用。

什么是 this 引用

this 引用指向'当前对象'，也就是'调用该成员方法的那个对象'。在成员方法中，对所有成员变量的访问，实际上都隐式地通过 this 引用完成，但对程序员是透明的。

示例：当我们写 year = y; 时，编译器底层会将其视作 this.year = y;，其中 this 就是那个正在调用 setDay 方法的对象。

public void setDay(int year, int month, int day) {
    // 此时如果写：year = year; 就会产生歧义。
    // 下面使用 this 来指明是给当前对象的 year 赋值
    this.year = year;
    this.month = month;
    this.day = day;
}

this 引用的特性

1. this 的类型：与所在类相同，哪个对象在调用方法，this 就指向哪个对象；
2. 只能在'成员方法'中使用：this 不存在于静态方法或其他语法结构中；
3. 只能引用当前对象：无法在一个对象的方法中让 this 指向另一个对象；
4. this 是成员方法中的第一个'隐藏'参数：当对象调用成员方法时，编译器会自动将调用者对象的引用作为实参传给方法，方法体内的 this 则用于接收该引用。

示例：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;   // this.year 表示'当前对象的 year'
        this.month = month; // this.month 表示'当前对象的 month'
        this.day = day;     // this.day 表示'当前对象的 day'
    }

    public void printDate() {
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }

    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2021, 6, 9);
        d.printDate(); // 2021/6/9
    }
}

总结与展望

总结

1. 面向对象思想：通过对现实事物的抽象，利用类来描述其属性和行为，并通过实例化对象进行具体操作。这种方法比面向过程更能体现人们对事物本质的认知，特别适合大型程序的设计和维护。
2. 类的定义与使用：使用 class 关键字创建类，并在类中定义成员变量（属性）和成员方法（行为），为后续实例化提供模板。
3. 对象的实例化：通过 new 关键字和类名生成对象，每个对象都拥有独立的内存空间，用于存储自身的成员变量和方法。
4. this 引用：在成员方法中用于指代'当前对象'，可以有效避免形参与成员变量重名带来的歧义，并在方法内部显式访问或修改当前对象的属性。

展望

• 对象的构造与初始化：了解构造方法、默认初始化、就地初始化等机制，掌握对象在创建时如何完成初始赋值。
• 封装与访问控制：通过访问限定符（如 public、private 等）保护对象内部数据，保证程序的安全性和可维护性。
• 静态成员与代码块：学习 static 修饰符的作用以及静态成员变量、静态方法的特点；同时深入理解普通代码块、构造代码块和静态代码块在初始化中的应用。
• 内部类：探索在类中定义类的高级用法，包括实例内部类、静态内部类、局部内部类和匿名内部类的语法和应用场景。

通过本篇的学习，我们已经打下了面向对象编程的基础。后续内容将进一步扩展和深入，让你在编写 Java 程序时更加得心应手。