Java中static与final关键字详解(简单易懂)

public class Student {
    // 非static变量（实例变量）：每个学生有独立的姓名
    private String name;
    // static变量（类变量）：所有学生共享同一个班级名称，只有1份
    public static String className = "高一(1)班";

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

    public static void main(String[] args) {
        Student s1 = new Student("张三");
        Student s2 = new Student("李四");

        // 访问static变量：推荐用类名访问
        System.out.println(Student.className); // 输出：高一(1)班
        // 修改static变量
        Student.className = "高一(2)班";
        // 所有实例的static变量都被修改
        System.out.println(s1.className); // 输出：高一(2)班
        System.out.println(s2.className); // 输出：高一(2)班
    }
}

public class Calculator {
    // static方法：无需创建Calculator对象即可调用
    public static int add(int a, int b) {
        // 可以访问static成员，不能访问非static成员
        return a + b;
    }

    // 非static方法：必须创建对象才能调用
    public int subtract(int a, int b) {
        return a - b;
    }

    public static void main(String[] args) {
        // 调用static方法：直接用类名
        int sum = Calculator.add(10, 20);
        System.out.println(sum); // 输出：30

        // 调用非static方法：必须创建对象
        Calculator cal = new Calculator();
        int diff = cal.subtract(20, 10);
        System.out.println(diff); // 输出：10
    }
}

public class Config {
    public static String DB_URL;

    // static代码块：类加载时执行，初始化静态变量
    static {
        System.out.println("static代码块执行");
        DB_URL = "jdbc:mysql://localhost:3306/test";
    }

    public static void main(String[] args) {
        // 首次访问类，触发类加载，执行static代码块
        System.out.println(Config.DB_URL); // 输出：static代码块执行 + jdbc:mysql://localhost:3306/test
        // 再次创建实例，static代码块不会重复执行
        Config c1 = new Config();
        Config c2 = new Config();
    }
}

public class OuterClass {
    private static String staticField = "静态字段";
    private String nonStaticField = "非静态字段";

    // static内部类
    public static class StaticInnerClass {
        public void print() {
            // 可以访问外部类的static成员
            System.out.println(staticField);
            // 错误：不能访问外部类的非static成员
            // System.out.println(nonStaticField);
        }
    }

    public static void main(String[] args) {
        // 创建static内部类：无需外部类实例
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.print(); // 输出：静态字段
    }
}

public class FinalDemo {
    // 1. 成员final变量：声明时直接赋值（推荐）
    private final String NAME = "张三";
    // 2. 成员final变量：构造方法中赋值
    private final int AGE;
    // 3. static final常量（类级常量，最常用）
    public static final double PI = 3.1415926;

    public FinalDemo(int age) {
        this.AGE = age; // 构造方法中初始化final变量
    }

    public static void main(String[] args) {
        FinalDemo demo = new FinalDemo(18);
        // 错误：final变量不可修改
        // demo.NAME = "李四";
        // demo.AGE = 20;

        // 引用类型final变量：引用不可变，但对象内容可变
        final StringBuilder sb = new StringBuilder("hello");
        sb.append(" world"); // 合法：修改对象内容
        System.out.println(sb); // 输出：hello world
        // 错误：引用不可变
        // sb = new StringBuilder("new");

        // static final常量：类名访问，不可修改
        System.out.println(FinalDemo.PI); // 输出：3.1415926
    }
}

public class Parent {
    // final方法：子类不能重写
    public final void sayHello() {
        System.out.println("Hello from Parent");
    }
}

public class Child extends Parent {
    // 错误：无法重写final方法
    // @Override
    // public void sayHello() {
    //     System.out.println("Hello from Child");
    // }

    public static void main(String[] args) {
        Child child = new Child();
        child.sayHello(); // 输出：Hello from Parent
    }
}

// final类：不能被继承
public final class FinalClass {
    public void print() {
        System.out.println("这是final类的方法");
    }
}

// 错误：无法继承final类
// public class SubClass extends FinalClass {
// }

public class Constants {
    // 数据库连接常量
    public static final String DB_URL = "jdbc:mysql://localhost:3306/test";
    public static final String DB_USER = "root";
    public static final String DB_PWD = "123456";

    // 工具类：私有化构造方法，避免创建实例
    private Constants() {}
}