Java中final、static、transient关键字区别和运用

一、final关键字

1. 修饰类

• 含义：当 final 修饰一个类时，该类不能被继承，即它不能有子类。这通常用于设计一些不希望被扩展的类，保证类的安全性和稳定性。
• 示例代码

final class FinalClass {
    public void show() {
        System.out.println("This is a final class.");
    }
}

// 以下代码会编译报错，因为 FinalClass 不能被继承
// class SubFinalClass extends FinalClass {
// }

2. 修饰方法

• 含义：当 final 修饰一个方法时，该方法不能被重写。这可以防止子类修改父类中某些关键方法的实现，保证方法的行为一致性。
• 示例代码

class ParentClass {
    public final void finalMethod() {
        System.out.println("This is a final method.");
    }
}

class ChildClass extends ParentClass {
    // 以下代码会编译报错，因为 finalMethod 不能被重写
    // @Override
    // public void finalMethod() {
    //     System.out.println("Trying to override final method.");
    // }
}

3. 修饰变量

• 含义：当 final 修饰一个变量时，该变量一旦被赋值，就不能再被重新赋值，即它成为一个常量。对于基本数据类型，其值不能改变；对于引用数据类型，其引用不能改变，但对象的内容可以改变。
• 示例代码

public class FinalVariableExample {
    public static void main(String[] args) {
        final int num = 10;
        // 以下代码会编译报错，因为 num 是 final 变量，不能重新赋值
        // num = 20;

        final StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World"); // 可以修改对象内容
        // 以下代码会编译报错，因为 sb 引用不能改变
        // sb = new StringBuilder("New");
    }
}

二、static关键字

1. 修饰成员变量（静态变量）

• 含义：静态变量属于类，而不是类的某个实例。它在类加载时就被初始化，并且在内存中只有一份拷贝，被该类的所有实例共享。
• 示例代码

class StaticVariableExample {
    static int staticVar = 0;
    int instanceVar = 0;

    public StaticVariableExample() {
        staticVar++;
        instanceVar++;
    }

    public static void main(String[] args) {
        StaticVariableExample obj1 = new StaticVariableExample();
        StaticVariableExample obj2 = new StaticVariableExample();

        System.out.println("Static variable: " + StaticVariableExample.staticVar); // 输出 2
        System.out.println("Instance variable of obj1: " + obj1.instanceVar); // 输出 1
        System.out.println("Instance variable of obj2: " + obj2.instanceVar); // 输出 1
    }
}

2. 修饰成员方法（静态方法）

• 含义：静态方法属于类，而不是类的某个实例。可以通过类名直接调用，不需要创建类的实例。静态方法只能访问静态成员变量和其他静态方法，不能访问实例成员变量和实例方法，因为静态方法在类加载时就存在，此时可能还没有创建对象实例。
• 示例代码

class StaticMethodExample {
    static int staticVar = 10;
    int instanceVar = 20;

    public static void staticMethod() {
        System.out.println("Static variable: " + staticVar);
        // 以下代码会编译报错，因为静态方法不能访问实例变量
        // System.out.println("Instance variable: " + instanceVar); 
    }

    public static void main(String[] args) {
        StaticMethodExample.staticMethod();
    }
}

3. 静态代码块

• 含义：静态代码块在类加载时执行，并且只执行一次，通常用于对静态变量进行初始化操作。
• 示例代码

class StaticBlockExample {
    static int staticVar;

    static {
        staticVar = 30;
        System.out.println("Static block executed.");
    }

    public static void main(String[] args) {
        System.out.println("Static variable: " + staticVar);
    }
}

三、transient关键字

1. 含义

transient 关键字用于修饰类的成员变量，被 transient 修饰的变量在对象序列化时会被忽略，即不会被保存到序列化文件或通过网络传输。这在某些情况下很有用，比如一些敏感信息或者临时计算结果，不需要在序列化时保存。

2. 示例代码

import java.io.*;

class User implements Serializable {
    private String username;
    private transient String password; // 密码是敏感信息，使用 transient 修饰

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }
}

public class TransientExample {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("admin", "123456");

        // 序列化对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"));
        oos.writeObject(user);
        oos.close();

        // 反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"));
        User deserializedUser = (User) ois.readObject();
        ois.close();

        System.out.println("Username: " + deserializedUser.getUsername());
        System.out.println("Password: " + deserializedUser.getPassword()); // 输出 null
    }
}

在上述示例中，password 被 transient 修饰，在反序列化后其值为 null，说明该变量在序列化过程中被忽略了。