花几千上万学习Java，真没必要！（二十二）

1、final关键字：

 

测试代码1：

package finaltest.com;

public class FinalBasicDemo {
	public static void main(String[] args) {
		// final修饰基本数据类型变量
		final int number = 5;

		// 尝试修改number的值，这将导致编译错误
		// number = 10; // 这行会报错

		System.out.println("number: " + number);
	}
}

测试代码2：

package finaltest.com;
 //final关键字
public class FinalDemo {  

 // final静态变量，在声明时初始化  
 private static final int MAX_SIZE = 100;  

 // final实例变量，通常在构造方法中初始化  
 private final String name;  

 // final局部变量，通常在声明时或初始化块中初始化  
 // 不直接在类中声明final局部变量，因为它需要被赋值  

 // 构造方法  
 public FinalDemo(String name) {  
     this.name = name; // 初始化final实例变量  
 }  

 // final方法，表示该方法不能被子类重写  
 public final void showDetails() {  
     System.out.println("Name: " + name);  
     System.out.println("Max Size: " + MAX_SIZE);  
 }  

 // 普通方法，在方法内部使用final局部变量  
 public void processData(int[] data) {  
     // final局部变量，在声明时初始化  
     final int threshold = 50;  

     for (int i = 0; i < data.length; i++) {  
         if (data[i] > threshold) {  
             System.out.println("Data[" + i + "]: " + data[i] + " is greater than threshold.");  
         }  
     }  
 }  

 // main方法，测试FinalDemo类  
 public static void main(String[] args) {  
     // 创建FinalDemo对象  
     FinalDemo demo = new FinalDemo("ExampleObject");  

     // 调用final方法  
     demo.showDetails();  

     // 调用普通方法，并传递一个整数数组  
     int[] data = {20, 60, 30, 80, 40};  
     demo.processData(data);  

     // 尝试修改final静态变量的值（编译错误）  
     //FinalDemo.MAX_SIZE = 200; // 这行会报错  

     // 尝试在构造方法之外修改final实例变量的值（编译错误）  
     // demo.name = "NewName"; // 这行也会报错  
 }   
}

运行结果如下：

 

测试代码3：

package finaltest.com;
public class FinalReferenceDemo {  
    static class MyObject {  
        int value;  
  
        public MyObject(int value) {  
            this.value = value;  
        }  
  
        public void setValue(int value) {  
            this.value = value;  
        }  
  
        @Override  
        public String toString() {  
            return "MyObject{" + "value=" + value + '}';  
        }  
    }  
  
    public static void main(String[] args) {  
        // final修饰引用数据类型变量  
        final MyObject obj = new MyObject(10);  
  
        // 尝试修改obj的引用（即对象的地址），将导致编译错误  
        // MyObject newObj = new MyObject(20);  
        // obj = newObj; // 这行会报错  
  
        // 可以改变obj引用对象内部的数据  
        obj.setValue(20);  
  
        System.out.println(obj); 
    }  
}

 测试代码4：

package finaltest.com;
//一个 final 实例变量 finalInstanceVar，它必须在构造方法中初始化。
//一个 static final 静态变量 STATIC_FINAL_VAR，它在声明时就被初始化了，并且可以通过类名直接访问。
//一个 final 方法 finalMethod，该方法不能被任何子类重写。
//一个普通方法 printInfo，用于打印实例变量和静态变量的值。
public class MyClass {  
  
    // final 实例变量，必须在构造方法中初始化  
    private final int finalInstanceVartest;  
  
    // final 静态变量，在声明时初始化  
    private static final int STATIC_FINAL_VAR = 42;  
  
    // 构造方法，用于初始化final实例变量  
    public MyClass(int finalInstanceVar) {  
        this.finalInstanceVartest = finalInstanceVar;  
    }  
  
    // final 方法，表示该方法不能被重写  
    public final void finalMethod() {  
        System.out.println("This is a final method.");  
    }  
  
    // 普通方法，可以访问final变量  
    public void printInfo() {  
        System.out.println("Final instance var: " + finalInstanceVartest);  
        System.out.println("Static final var: " + STATIC_FINAL_VAR);  
    }  
  
    // main 方法，测试这个类  
    public static void main(String[] args) {  
        MyClass obj = new MyClass(10);  
        obj.finalMethod(); // 调用final方法  
        obj.printInfo(); // 调用普通方法，打印信息  
  
        // 尝试访问静态final变量，可以直接通过类名访问  
        System.out.println("Direct access to static final var: " + MyClass.STATIC_FINAL_VAR);  
    }  
}

运行结果如下：

 

2、static关键字：

 

测试代码1：

package finaltest.com;
public class StaticDemo {  
    // 静态变量  
    static int counter = 0;  
  
    // 静态初始化块  
    static {  
        System.out.println("Static block initialized");  
    }  
  
    // 静态内部类  
    static class StaticInner {  
        public void display() {  
            System.out.println("Static inner class method");  
        }  
    }  
  
    // 构造方法，实现静态变量的增加  
    public StaticDemo() {  
        counter++;  
    }  
  
    // 静态方法  
    public static int add(int a, int b) {  
        return a + b;  
    }  
  
    // 主方法，说明静态变量、静态方法和静态内部类的使用  
    public static void main(String[] args) {  
        // 静态代码块会在类加载时自动执行  
  
        // 调用静态方法  
        System.out.println("Sum of 5 and 3 is: " + add(5, 3));  
  
        // 访问静态变量  
        System.out.println("Number of StaticDemo objects created: " + counter);  
  
        // 使用静态内部类  
        StaticInner inner = new StaticInner();  
        
        inner.display();  
    }

    public void displayInstanceCount() {  
        // 直接访问静态变量instanceCount并打印其值  
        System.out.println("Number of StaticDemo objects created: " + counter);  
    } 
}

运行结果如下：

 

测试代码2：

package finaltest.com;
public class StaticTest {
    // 静态变量
    private static int instanceCount = 0;

    // 静态代码块
    static {
        System.out.println("Static block initialized");
        // 实现静态变量的初始化代码
    }

    // 构造方法，实现静态变量的增加
    public StaticTest() {
        instanceCount++;
    }

    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }

    // 静态内部类
    static class DatabaseConnection {
        // 数据库连接
        private static String connectionString = "jdbc:mysql://localhost:3306/mydb";

        // 静态方法，模拟获取数据库连接
        public static String getConnectionString() {
            return connectionString;
        }

    }

    // 一个非静态方法
    public void displayInstanceCount() {
        System.out.println("Number of StaticDemo objects created: " + instanceCount);
    }

    // 主方法，说明静态和非静态成员的使用
    public static void main(String[] args) {
        // 静态代码块会在类加载时自动执行

        // 调用静态方法
        System.out.println("Sum of 5 and 3 is: " + add(5, 3));

        // 访问静态内部类的静态成员
        System.out.println("Database connection string: " + DatabaseConnection.getConnectionString());

        // 创建StaticDemo的实例
        StaticDemo obj1 = new StaticDemo();
        StaticDemo obj2 = new StaticDemo();

        // 调用非静态方法
        obj1.displayInstanceCount(); 

    }
}

运行结果如下：