Java中的几种关键字this、super、static和final介绍

在Java编程语言中，关键字是具有特殊含义的预定义标识符。关键字是Java编程语言中具有特殊用途的保留单词，用于表示语法结构和程序行为。关键字在语法上具有特定的用途，不能用作变量名、方法名或其他标识符。

this 关键字用于引用当前对象，可以在方法中使用它来访问实例变量和调用实例方法。在构造方法中，this 可以用来调用同一个类的其他重载构造方法。

super 关键字用于引用父类的成员，可以在子类中调用父类的方法或构造方法。

static 关键字用于声明类成员，这些成员由整个类共享，而不是每个实例单独拥有。可以直接使用类名加点号来访问静态成员，无需创建类的实例。

final 关键字用于表示终态性，可以用于声明不允许被继承的类、不允许被重写的方法，以及常量。一旦使用 final 进行声明，就不能再改变其状态或进行继承。换句话说，final 修饰的类不能被子类化，final 修饰的方法不能被重写，final 修饰的变量的初始值不能被修改。

下面进行解读。

this关键字

☆"this"关键字代表当前对象的引用。

☆它可以在类的方法内部使用，用于引用正在执行该方法的对象。

☆通过"this"关键字，可以访问当前对象的成员变量和方法。

"this"关键字在Java中用于引用当前对象，可以用于访问实例变量、调用方法和构造函数等场景。下面是一些示例来说明"this"关键字的用法：

1.访问实例变量：

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name; // 使用"this"关键字将参数值赋给实例变量
    }

    public String getName() {
        return this.name; // 使用"this"关键字返回实例变量的值
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        System.out.println(person.getName()); //输出：John
    }
}

2.调用当前对象的方法：

public class Car {
    private String color;

    public void setColor(String color) {
        this.color = color;
    }

    public void printColor() {
        System.out.println("Car color is: " + this.color); // 使用"this"关键字调用当前对象的成员变量
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.setColor("Blue");
        car.printColor(); //输出：Car color is: Blue
    }
}

3.在构造函数中调用其他构造函数：

public class Circle {
    private double radius;
    private String color;

    public Circle(double radius) {
        this.radius = radius;
        this.color = "red"; // 在构造函数中使用"this"关键字设置默认颜色
    }

    public Circle(double radius, String color) {
        this(radius); // 使用"this"关键字调用另一个构造函数
        this.color = color; // 设置指定的颜色
    }

    public static void main(String[] args) {
        Circle circle1 = new Circle(5.0);
        System.out.println("Circle color: " + circle1.color);

        Circle circle2 = new Circle(3.0, "blue");
        System.out.println("Circle color: " + circle2.color);
    }
}

运行输出：
Circle color: red
Circle color: blue

super关键字

☆"super"关键字表示父类的引用。

☆它可以在子类中使用，用于引用父类的成员变量和方法。

☆通过"super"关键字，可以调用父类的构造函数、访问父类的成员变量和调用父类的方法。

super关键字的使用情境：通过使用super关键字，可以用于访问父类的成员变量、调用父类的方法，以及在子类构造函数中调用父类的构造函数。

1.访问父类的成员变量：

public class Animal {
    protected String name;

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

//子类
public class Cat extends Animal {
    private int age;

    public Cat(String name, int age) {
        super(name); // 调用父类的构造函数
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + super.name); // 使用super关键字访问父类的成员变量
        System.out.println("Age: " + this.age);
    }

    public static void main(String[] args) {
        Cat cat = new Cat("Tom", 3);
        cat.display();
    }
}

2. 调用父类的方法：

public class Vehicle {
    public void start() {
        System.out.println("Vehicle started.");
    }
}

//子类
public class Car extends Vehicle {
    @Override
    public void start() {
        super.start(); // 调用父类的方法
        System.out.println("Car started.");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();
    }
}

3. 在子类构造函数中调用父类构造函数：

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 static void main(String[] args) {
        Student student = new Student("John", 10);
        System.out.println("Name: " + student.name);
        System.out.println("Grade: " + student.grade);
    }
}

 需要注意的是，super关键字必须作为子类构造方法中的第一行代码来调用父类的构造方法。这是因为子类构造方法在执行之前需要先初始化父类的成员变量和状态。

其次，super关键字可以多次使用，但只能在构造方法内部使用，并且每次使用都必须放在第一行。这样可以通过不同的构造方法选择性地调用父类的不同构造方法。

最后，如果子类没有显式调用父类的构造函数，Java 编译器会隐式地插入一个默认的父类构造函数的调用语句。这个默认的父类构造函数是没有参数的构造函数。但是，当父类中没有无参构造函数时，编译器将会报错，此时子类必须显式地调用父类的其他构造函数。

static关键字

☆"static"关键字表示静态的，属于类本身而不是实例化对象。

☆它可以修饰变量、方法、代码块和内部类。

☆静态变量由所有实例共享，静态方法可以直接通过类名调用。

☆静态代码块在类加载时执行，用于初始化静态成员。

静态变量（也称为类变量）使用static修饰符声明的变量，它们与类本身关联而不是与类对象关联。这意味着静态变量在所有类对象之间共享，并在整个程序执行期间保持相同的值。可以使用类名直接访问静态变量。

静态方法（也称为类方法）使用static修饰符声明的方法，它们与类本身相关联，而不与特定的类对象关联。静态方法通常用于执行与类本身相关的操作，并且无法直接访问实例变量。可以通过类名直接访问静态方法。

在Java中，static关键字用于声明静态成员。静态成员属于类，而不是对象实例。static关键字的使用情境：用于声明静态变量、定义静态方法和静态代码块，静态成员可以在没有创建对象实例的情况下直接访问和使用。以下是一些示例：

1.静态变量：

public class Circle {
    private static double pi = 3.14;
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double calculateArea() {
        return pi * radius * radius;
    }

    public static void main(String[] args) {
        Circle circle = new Circle(5);
        System.out.println("Area: " + circle.calculateArea()); //输出：Area: 78.5
    }
}

2.静态方法：

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int sum = MathUtils.add(5, 3);
        System.out.println("Sum: " + sum); // Sum: 8
    }
}

3.静态代码块：

public class AppConfig {
    private static String appName;

    static {
        initAppName();
    }

    private static void initAppName() {
        appName = "MyApp";
    }

    public static void main(String[] args) {
        System.out.println("App Name: " + appName);  // App Name: MyApp
    }
}

静态变量可以通过类名直接访问，无需创建对象实例。由于它们属于整个类，所以对一个静态变量的修改会影响到所有使用该变量的地方。此外，静态变量的生命周期与程序的执行周期相同，可以在任何地方访问。

静态变量或类变量：被static修饰的成员变量是与类相关联的变量，也称为静态变量或类变量。它们不是属于类的实例对象，而是属于整个类，在内存中只有一份拷贝。

静态变量存储在静态存储区，这是一块特殊的内存区域，用于存储静态变量和静态方法。它们在程序的整个执行期间都存在，不会随着对象的创建和销毁而改变。

初始化：静态变量如果没有显式地赋值，那么它们会被默认初始化。对于数值类型（如int、float等），默认值是0；对于引用类型（如String、Object等），默认值是null。例如：

public class Example {
    static int age;
    public static void main(String[] args){
        System.out.println(age);    //输出0
    }
}

被static修饰的方法称为静态方法或类方法，与实例方法不同，静态方法不依赖于特定的对象实例，而是与类本身相关联。

实例方法必须通过对象实例来调用。也就是说，我们需要先创建一个对象，然后使用该对象来调用实例方法。静态方法可以直接通过类名来调用，不需要先创建对象。我们可以使用类名直接调用静态方法。

静态方法中不能使用this和super关键字。在静态方法中，无法使用this关键字。因为this关键字指代当前对象实例，而静态方法并没有隐含的对象实例，所以无法引用它。静态方法中也不能使用super关键字。super关键字用于访问父类的成员和方法，但静态方法与任何特定的对象实例无关，所以无法使用super关键字来引用父类的成员。

在Java中，静态代码块是一个特殊的代码块，用于在类加载时执行一次。它使用关键字static和花括号{}来定义。

静态代码块在类加载过程中被执行，而不是在创建对象实例时执行。它主要用于初始化静态变量或执行一些只需在程序运行前执行一次的操作。以下是静态代码块的一些特点和用途：

1.执行顺序：静态代码块按照它们在类中的出现顺序进行执行。当类加载时，会首先执行所有的静态代码块，然后才会执行其他的静态成员（如静态变量、静态方法）。

2.只执行一次：静态代码块只在类加载时执行一次，之后不再执行。即使创建多个对象实例，静态代码块也只会执行一次。

3.初始化静态变量：静态代码块常用于初始化静态变量。它可以在类加载时为静态变量赋初值，确保它们在使用之前已经被正确初始化。

4.静态代码块可以执行其他需要在程序运行前执行一次的操作，比如读取配置文件、建立数据库连接等，这些操作可以在静态代码块中完成，以保证它们在程序运行时可用。

5. 静态代码块不能接收任何参数。

final关键字

☆"final"关键字表示最终的，用于限制变量、方法和类的特性。

☆用于修饰变量时，表示该变量的值不可修改。

☆用于修饰方法时，表示该方法不可被子类重写，即该方法是最终实现。

☆用于修饰类时，表示该类不可被继承，即该类不允许有子类。

在Java中，final关键字用于声明不可变的实体，包括变量、方法和类。final关键字的使用情境：用于声明不可变的常量、不可重写的方法和不可继承的类。以下是一些示例说明final关键字的使用：

1.不可变的常量：

public class MathConstants {
    public static final double PI = 3.14159;
    public static final int MAX_VALUE = 100;

    public static void main(String[] args) {
        System.out.println("PI: " + PI);
        System.out.println("Max Value: " + MAX_VALUE);
    }
}

2.不可重写的方法：

public class Shape {
    public final void draw() {
        System.out.println("Drawing shape...");
    }
}

//子类
public class Circle extends Shape {
    // 无法重写父类的final方法

    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();
    }
}

3.不可继承的类：

public final class StringUtil {
    public static String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }
}

//子类，无法继承自final类
public class StringUtils extends StringUtil {

    public static void main(String[] args) {
        String reversed = StringUtil.reverse("Hello");
        System.out.println("Reversed: " + reversed);
    }
}

在Java中，我们可以使用final关键字来声明常量。可以将final关键字用于变量、方法和类。当用于变量时，表示该变量为常量；当用于方法时，表示该方法不能被子类重写——表明该方法是最终实现；当用于类时，表示该类不能被继承——该类不允许有子类，也就防止了子类修改父类的行为。

在Java中被final修饰的变量称为常量，一旦赋值后不能再被修改。传统上推荐使用大写字母来表示常量名。如：

final int MAX_SIZE = 100;

需要注意的是，虽然常量的值不能被修改，但如果常量是引用类型的变量，它所引用的对象的状态仍然可以被修改。因此，被final修饰的引用类型常量只能保证其引用地址不变，而不是保证其所指向的对象不变。

附录、Java中修饰符

Java中的修饰符也属于关键字的一种。修饰符作为关键字，有特定的语法规则和语义含义。它们用于修改类、方法、变量和构造函数的属性和行为。通过使用不同的修饰符，可以控制成员的可见性、访问级别、继承性等。

在Java中，修饰符被用于声明或修饰其他关键字（如class、method、variable等）。通过将修饰符与这些关键字组合使用，可以实现对代码的更精确的控制和定义。

在Java中，修饰符用于限定类、方法、变量和构造函数的访问和行为。以下是Java中常用的修饰符：

1.访问修饰符：

• public：可以被任何类访问。
• private：只能在当前类内部访问。
• protected：可以在当前类、同一包内的其他类以及子类中访问。
• 默认（无修饰符）：只能在当前类、同一包内的其他类中访问。

2.非访问修饰符：

• static：用于声明静态成员，属于类本身而不是实例化对象。
• final：用于表示不可修改的常量、不能被继承的类或方法、以及禁止方法重写等。
• abstract：用于声明抽象类和抽象方法。
• synchronized：用于实现线程安全，多个线程对带有此修饰符的方法或代码块的访问将进行同步。
• volatile：用于保证被修饰变量的可见性，并禁止指令重排序优化。

以上是Java中常用的修饰符，它们可以根据需要来修饰类、方法、变量和构造函数。不同的修饰符具有不同的作用和使用场景，合理使用修饰符有助于控制代码的封装性、可访问性和行为特性。