Java 每日一刊（第13期）：this super static

“优秀的代码不仅仅是给机器看的，更是给人看的。”

前言

这里是分享 Java 相关内容的专刊，每日一更。

本期将为大家带来以下内容：

1. this 关键字
2. super 关键字
3. static 关键字

this 关键字

this 关键字是 Java 中最常见的关键字之一，它用于表示“当前对象”的引用。它通常用于区分实例变量和方法参数，以及在对象的方法内部引用自身。在对象的内部方法中，this 可以用来调用成员变量、方法和构造方法。

访问当前对象的成员变量

当方法的参数名称与当前类的成员变量名称相同时，this 可以用来区分它们。下面是一个经典的例子：

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;  // 使用 this 关键字区分成员变量和参数
    }

    public void display() {
        System.out.println("Name: " + this.name);  // this 引用当前对象的 name 变量
    }
}

在上面的代码中，this.name 表示当前对象的 name 成员变量，而 name 表示方法参数。通过 this 关键字，我们可以清楚地表明要访问的是当前对象的成员变量。

调用当前类的构造方法

this() 还可以在构造方法中调用类的其他构造方法，避免重复代码。这种用法也称为 构造器链。在一个类中可以通过 this() 互相调用多个构造器：

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

    public Person(String name) {
        this(name, 0);  // 调用另一个构造方法
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

在这个例子中，this(name, 0) 调用了带两个参数的构造方法，这不仅减少了重复代码，还增强了代码的可维护性。

返回当前对象

this 关键字还可以用来返回当前对象，这在需要链式调用时非常有用。例如，很多流式 API（如 StringBuilder 或 Stream）使用这种模式：

public class Person {
    private String name;

    public Person setName(String name) {
        this.name = name;
        return this;  // 返回当前对象，支持链式调用
    }

    public void display() {
        System.out.println("Name: " + name);
    }

    public static void main(String[] args) {
        new Person().setName("John").display();  // 链式调用
    }
}

通过 this 返回当前对象，可以使方法链式调用，代码更加简洁、优雅。

super 关键字

super 关键字用于引用父类中的成员变量、方法以及构造方法。在子类和父类有继承关系时，super 可以帮助子类访问父类中的实现。它主要用于以下三种场景：

调用父类的构造方法

当子类继承父类时，如果父类有参数化的构造方法，子类通常需要通过 super() 来显式调用父类的构造方法。调用父类构造方法必须是子类构造方法的 第一行，否则编译器会报错。

public class Person {
    protected String name;

    public Person(String name) {
        this.name = name;
    }
}

public class Student extends Person {
    private int grade;

    public Student(String name, int grade) {
        super(name);  // 显式调用父类的构造方法
        this.grade = grade;
    }

    public void display() {
        System.out.println("Name: " + name + ", Grade: " + grade);
    }
}

在这个例子中，Student 类通过 super(name) 调用了父类 Person 的构造方法，确保在子类中初始化父类的成员变量。

访问父类的成员变量

当子类中的成员变量与父类中的成员变量同名时，可以使用 super 来明确访问父类的成员变量：

public class Person {
    protected String name = "Parent";
}

public class Student extends Person {
    protected String name = "Child";

    public void printName() {
        System.out.println(super.name);  // 访问父类的 name
        System.out.println(this.name);   // 访问子类的 name
    }
}

输出结果为：

Parent
Child

在这个例子中，通过 super.name 明确地访问了父类中的 name 成员变量。

调用父类的方法

如果子类重写了父类的方法，而你在子类中仍然想调用父类的方法，可以通过 super 关键字实现：

public class Person {
    public void display() {
        System.out.println("Person display");
    }
}

public class Student extends Person {
    @Override
    public void display() {
        super.display();  // 调用父类的 display() 方法
        System.out.println("Student display");
    }
}

输出结果为：

Person display
Student display

通过 super.display()，我们可以在子类中调用父类的 display 方法，保留父类方法的行为，同时扩展子类的功能。

static 关键字

static 关键字用于修饰类的静态成员（变量或方法），这些成员属于类本身，而不是类的实例。它主要用于实现共享数据或工具类的通用方法。

静态变量

静态变量（也称为类变量）是类的所有实例共享的变量。无论创建了多少个对象，静态变量只有一份内存空间，所有实例都可以访问和修改它：

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

    public Counter() {
        count++;  // 每创建一个实例，count 增加 1
    }

    public static void displayCount() {
        System.out.println("Count: " + count);  // 静态方法可以访问静态变量
    }
}

public class Main {
    public static void main(String[] args) {
        new Counter();
        new Counter();
        Counter.displayCount();  // 输出 2
    }
}

静态变量 count 是类的所有实例共享的，当创建了多个对象时，它们会共同维护同一个 count 变量。

静态方法

静态方法可以直接通过类名调用，而不需要实例化对象。静态方法通常用于实现不依赖实例的工具类方法或逻辑：

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);  // 输出 15
    }
}

静态方法只能访问静态变量或其他静态方法，不能直接访问非静态的成员变量或方法，因为它们不依赖于具体的实例。

静态代码块

静态代码块在类加载时执行一次，通常用于初始化类的静态成员或执行一些只需进行一次的操作：

public class Example {
    static {
        System.out.println("Static block executed");
    }

    public static void main(String[] args) {
        Example ex = new Example();  // 静态代码块在类加载时执行
    }
}

在上面的代码中，无论创建多少个 Example 对象，静态代码块只会在类加载时执行一次。

本期小知识

在 Java 构造方法中，this() 和 super() 是互斥的，不能在同一个构造方法中同时使用。它们都必须出现在构造方法的第一行，this() 用于调用当前类的其他构造方法，而 super() 用于调用父类的构造方法。