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();
}
}运行结果如下：
