OOP篇（Java - this、super、static、final、finally、finilize）

目录

一、this & super

1. this

2. super

3. 总结

二、static

1. 作用

2. 访问问题

3. 总结

三、final、finally、finilize

1. final

2. finally

3. finillize

4. 总结

---

一、this & super

this 和 super 都是 Java 中的关键字，分别表示当前对象和父类对象。它们的作用如下：

1. this

调用当前类的属性和方法：当在类中访问当前类的成员时，可以使用 this 关键字，以便与同名的局部变

量进行区分。

调用本类的构造函数：使用 this() 可以调用本类的其他构造函数。但是，必须将 this() 作为构造函数中

的第一条语句，并且只能在构造函数中使用。

返回当前对象：使用 return this; 可以返回当前对象的引用。

例如下面的代码片段演示了如何使用 this 关键字：

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

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

    public void sayHello() {
        System.out.println("Hello, my name is " + this.name);
    }
}

在这个例子中，我们通过 this.name 引用了当前对象的 name 属性，在 sayHello() 方法中输出了该属性

的值。

2. super

调用父类的属性和方法：当想要在子类中访问父类中定义的同名变量或方法时，可以使用 super 关键字

加以区分。

调用父类的构造函数：使用 super() 可以显式调用父类的构造函数。与 this() 相同，super() 必须作为构

造函数中的第一条语句，并且只能在构造函数中使用。

返回父类对象：如果子类想要返回其直接父类的引用，可以使用 super 关键字。

例如下面的代码片段演示了如何使用 super 关键字：

public class Student extends Person {
    private int grade;

    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }

    public void study() {
        System.out.println("I'm studying in grade " + this.grade);
    }
}

在这个例子中，我们通过 super(name, age) 调用了父类 Person 的构造函数，并将参数传递给父类的 name 和 age 属性。这样，我

们可以在 Student 类中访问父类 Person 的属性和方法。

3. 总结

总之，this 和 super 都是 Java 中的关键字，分别表示当前对象和父类对象。使用 this 可以调用当前类

的属性和方法、调用本类的构造函数和返回当前对象。使用 super 可以调用父类的属性和方法、调用父

类的构造函数和返回父类对象。

二、static

1. 作用

static 是 Java 中的一个关键字，表示静态的、不可变的。在 Java 中，static 主要有以下几种作用：

• 声明静态方法或属性：使用 static 关键字可以将方法或属性声明为静态的，这意味着它们属于类而不是对象。
• 访问静态方法或属性：由于静态方法和属性属于类而不是对象，因此可以通过类名直接访问它们，而无需先创建对象。
• 静态代码块：可以使用 static 关键字来声明静态代码块，在类加载时执行一次，可以用来进行初始化操作。
• 声明静态内部类：静态内部类属于外部类，但不能访问其它非静态的成员，常用于辅助实现某些功能。

例如下面的代码片段演示了如何使用 static 声明静态方法和属性：

public class MyClass {

    private static int x;

    public static void setX(int newX) {
        x = newX;
    }

    public static int getX() {
        return x;
    }
}

在这个例子中，我们使用 static 关键字声明了一个静态属性 x 和两个静态方法 setX 和 getX。

由于 x 属于类而不是对象，因此可以通过 MyClass.setX(10) 来访问该属性，而不需要先创建 MyClass 对象。

总之，static 是 Java 中的一个关键字，表示静态的、不可变的。

在 Java 中，static 主要用于声明静态方法或属性、访问静态方法或属性、定义静态代码块和声明静态内

部类等操作。

2. 访问问题

在 Java 中，使用 static 可以声明静态方法和静态属性，可以通过类名直接访问它们，而不需要先创建对

象。但是，在实际开发中需要注意以下几个问题：

• 静态方法不能访问非静态方法和属性：由于静态方法属于类而不是对象，因此无法访问属于对象的非静态方法和属性。如果需要使用非静态方法和属性，必须先创建对象。
• 静态方法不能重写：static 方法是属于类本身的，不能被子类重写。因此，父类中的 static 方法在子类中也必须是 static 的。
• 静态属性共享性：静态属性属于类，所有对象共享同一个静态属性。因此，对于一个类的静态属性的修改，会影响到所有对象。
• 静态代码块执行时机：静态代码块在类加载时执行一次。如果静态代码块中的逻辑比较复杂或者有耗时操作，可能会造成程序启动缓慢的问题。

下面是一个简单的示例，说明了如何使用 static 访问静态方法和属性：

public class MyClass {
    private static int count = 0;

    public static void incrementCount() {
        count++;
    }

    public static int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass.incrementCount();
        MyClass.incrementCount();
        System.out.println(MyClass.getCount()); // Output: 2
    }
}

在这个例子中，我们声明了一个静态属性 count 和两个静态方法 incrementCount 和 getCount，并通

过 MyClass.incrementCount() 调用 incrementCount 方法，将 count 属性加一。最后，我们通过

MyClass.getCount() 访问 count 属性并输出结果。

3. 总结

总之，使用 static 可以方便地访问静态方法和属性，但需要注意静态方法不能访问非静态方法和属性、

不能被重写、共享静态属性等问题。

三、final、finally、finilize

final、finally 和 finalize 是 Java 中的三个关键字，它们分别表示不可变性、异常处理和垃圾回收。

它们的作用如下：

1. final

声明常量：使用 final 关键字可以将变量声明为常量，一旦被赋值就不能再次更改。

防止继承或重写：使用 final 关键字可以防止类被继承、方法被重写和变量被修改。

例如下面是一个简单的示例：

public class MyClass {
    public final int MAX_VALUE = 100; // 声明一个不可变的常量

    public void printMaxValue() {
        System.out.println("MAX_VALUE: " + MAX_VALUE);
    }
}

在这个例子中，我们使用 final 关键字将 MAX_VALUE 声明为常量，并在 MyClass 类中声明了一个

printMaxValue() 方法来输出该常量的值。

2. finally

finally 关键字通常与 try-catch 结构一起使用，无论是否出现异常都会执行相关代码。

例如下面是一个简单的示例：

public class FileTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("myfile.txt");
            int data = fis.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fis.read();
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
            System.out.println("finally block");
        }
    }
}

在这个例子中，我们使用 FileInputStream 读取文件 myfile.txt 中的内容，如果出现异常，则捕获并输

出相关信息。

无论是否出现异常，finally 块中的代码都会被执行。

3. finillize

finalize() 方法是 Object 类中的一个方法，用于垃圾回收。

当对象不再被引用或被 JVM 彻底回收时，finalize() 方法会被调用。

例如下面是一个简单的示例：

public class Person {
    private String name;

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

    @Override
    protected void finalize() throws Throwable {
       // 进行清理操作
    }
}

在这个例子中，我们重写了 Object 类中的 finalize() 方法，在该方法中可以进行一些对象释放和资源回收的操作。

4. 总结

总之，final、finally 和 finalize 都是 Java 中的关键字。final 主要用于声明常量和防止继承、重写等操

作；finally 通常与 try-catch 结构一起使用，用于处理一些必须执行的代码块；finalize() 方法用于垃圾

回收，当对象不再被引用或被 JVM 彻底回收时，该方法会被调用。