Java 类的其他语法

在 Java 中，类是面向对象编程的核心概念之一。除了类的基本结构（类的定义、构造方法、成员变量和方法）外，Java 还提供了许多与类相关的语法特性，帮助开发者更灵活地定义和使用类。这些特性包括构造器、this 关键字、封装、静态变量与方法等。在本课中，我们将详细介绍这些概念，并通过代码示例帮助大家更好地理解。

1. 构造器

构造器是类的特殊方法，它在创建对象时被自动调用。构造器的作用是初始化新创建的对象，它的名称与类名相同，且没有返回类型。

构造器的基本使用：

public class Person {
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("大家好，我是 " + name + "，今年 " + age + " 岁。");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Person对象时调用构造器
        Person person = new Person("张三", 25);
        person.introduce();
    }
}

解释：

• 在上面的代码中，Person 类有一个构造器，它接受两个参数：name 和 age。构造器用于初始化新创建的 Person 对象。
• 在 main 方法中，我们通过 new Person("张三", 25) 创建了一个 Person 对象，并调用了构造器。

2. this 关键字

this 是 Java 中一个非常重要的关键字，它指向当前对象的引用。在构造器和方法中，this 用来访问当前对象的成员变量和方法。

this 关键字的使用：

public class Person {
    private String name;
    private int age;

    // 使用this区分成员变量和参数
    public Person(String name, int age) {
        this.name = name; // this.name 指的是成员变量，name 指的是构造器参数
        this.age = age;
    }

    public void introduce() {
        System.out.println("大家好，我是 " + this.name + "，今年 " + this.age + " 岁。");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("李四", 30);
        person.introduce();
    }
}

解释：

• 在构造器中，this.name 表示类中的成员变量，而 name 是构造器的参数。如果没有 this，Java 编译器无法区分成员变量和参数。
• this 关键字也可以用于方法中，指向当前对象。

3. 封装

封装是面向对象编程中的一个核心原则，它将对象的属性（数据）和行为（方法）封装在一起，并通过方法控制对属性的访问。通过封装，我们可以保护对象的内部数据不被随意修改，从而提高程序的安全性和可维护性。

封装的基本实现：

public class Person {
    // 私有成员变量
    private String name;
    private int age;

    // 公有的 getter 方法
    public String getName() {
        return name;
    }

    // 公有的 setter 方法
    public void setName(String name) {
        this.name = name;
    }

    // 公有的 getter 方法
    public int getAge() {
        return age;
    }

    // 公有的 setter 方法
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        } else {
            System.out.println("年龄不能为负！");
        }
    }

    public void introduce() {
        System.out.println("大家好，我是 " + name + "，今年 " + age + " 岁。");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("王五");
        person.setAge(28);
        person.introduce();
    }
}

解释：

• name 和 age 变量是私有的，外部无法直接访问。通过 getName、setName、getAge 和 setAge 方法来间接访问和修改这些私有成员。
• 通过封装，我们确保了数据的完整性，比如通过 setAge 方法可以控制年龄不能为负数。

4. 实体类

实体类通常用于表示数据对象，它是一个简单的类，通常只包含属性和对应的 getter、setter 方法。实体类不包含复杂的业务逻辑，它主要用于存储数据。

实体类示例：

public class Person {
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用构造器创建实体类对象
        Person person = new Person("赵六", 35);
        System.out.println("姓名: " + person.getName() + ", 年龄: " + person.getAge());
    }
}

解释：

• Person 类是一个实体类，包含了 name 和 age 属性，并通过构造器进行初始化。
• 在 main 方法中，我们创建了 Person 类的一个实例，并通过 getName 和 getAge 方法获取其属性。

5. static 修饰成员变量

static 关键字可以修饰类的成员变量，表示该变量是静态的，属于类而不是类的实例。静态变量在所有对象之间共享。

static 修饰成员变量：

public class Counter {
    // 静态成员变量
    static int count = 0;

    // 构造器
    public Counter() {
        count++;
    }

    public static void displayCount() {
        System.out.println("当前对象数量: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter.displayCount();  // 输出当前对象数量
    }
}

解释：

• count 变量是静态的，这意味着它属于 Counter 类，而不是某个特定的对象。因此，所有对象共享同一个 count 变量。
• 每创建一个 Counter 对象，count 的值就会增加。通过静态方法 displayCount 打印当前的 count 值。

static 修饰成员变量的场景：

静态变量通常用于表示类的全局状态，比如计数器、常量等。比如，表示类的所有实例共享的数据，或者记录某个特定类的状态。

6. static 修饰成员方法

static 关键字也可以修饰成员方法，表示该方法是静态的，可以通过类名直接调用，而不需要创建类的实例。

static 修饰成员方法示例：

public class MathUtil {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = MathUtil.add(5, 10);
        System.out.println("结果: " + result);
    }
}

解释：

• add 方法是静态的，可以通过 MathUtil.add() 直接调用，而不需要创建 MathUtil 的实例。

7. 静态方法的应用场景：工具类

静态方法常用于工具类中，工具类通常包含一些通用的静态方法，例如字符串处理、数学计算等。这些方法不需要依赖于类的实例，因此可以直接通过类名调用。

8. 静态方法的注意事项

• 静态方法无法访问实例变量和实例方法，它们只能访问静态变量和静态方法。
• 在静态方法中，this 关键字是不可用的，因为静态方法没有 this 引用。

总结

Java 中的类不仅仅是一个简单的结构体，它提供了丰富的语法特性，如构造器、this 关键字、封装、静态变量与方法等。这些特性使得我们能够灵活地组织和管理代码，提高代码的可维护性和复用性。通过合理地使用这些语法特性，我们能够写出更加高效、清晰的程序。