java基础复习总结之static和final关键字

谁践踏了优雅 2022-05-29 04:09 197阅读 0赞

# 一、static关键字的用法和案例 #

##    1.静态变量  ##

静态变量通过类名或者实例访问，在内存中只有一份。在程序中当常量使用较多。

使用规则：类名.变量名、实例名.变量名

\*static只能修饰成员变量，不能修饰局部变量（编译错误），因为static修饰的是类的变量（静态变量生命周期和类一致），不是某个方法的变量，而方法里的局部变量，在实例调用方法结束后生命周期也结束。

案例：

public class Test {
    	// 定义一个静态变量
    	private static String name = "旺财";
    
    	public static void main(String[] args) {
    		//错误的写法
    		//static String name = "小红";   
    		
    		// 通过类名调用
    		System.out.println(Test.name);
    		
    		// 通过实例调用
    		Test test = new Test();
    		System.out.println(test.name);
    	}
    }

##    2.静态方法 ##

静态方法：有时我们想使用某个类的方法，在不创建该类的实例，就调用方法，则可以在该方法名前添加static。

使用规则：类名.变量名、实例名.变量名

\*在非静态方法中可以调用静态成员变量和非静态成员变量，在静态方法中只能调用静态成员变量，因为静态方法的生命周期和类一致，在静态方法中是无法调用没有实例的非静态变量。

案例：

public class Test {
    
    	// 定义一个静态变量
    	private static String name = "小红";
    
    	// 非静态变量
    	private int age = 9;
    
    	// 静态方法
    	public static void add(int a, int b) {
    		// 错误写法，在静态方法中无法调用非静态成员变量
    		// System.out.println(this.age+"岁");
    
    		// 在静态方法中的调用静态成员变量
    		System.out.println(Test.name + " 计算得到："+(a+b));
    	}
    
    	// 非静态方法
    	public void printInfo() {
    		// 调用静态方法
    		System.out.println("名字：" + Test.name);
    		// 调用非静态变量
    		System.out.println("年龄：" + this.age);
    	}
    
    	public static void main(String[] args) {
    		// 通过类名调用，推荐使用此方法
    		Test.add(1, 2);
    		
    		// 通过实例调用
    		Test test = new Test();
    		test.printInfo();
    		test.add(2, 2);
    	}
    }

输出结果 ：小红 计算得到：3  
                      名字：小红  
                      年龄：9  
                      小红 计算得到：4

##     3.静态代码块 ##

静态代码块：只有类第一次加载时，才会执行一次。非静态的代码块，类每一次加载都会执行。

案例：

public class Test {
    	// 静态变量
    	static int count = 0;
    
    	// 静态代码块
    	static {
    		Test.count++;
    		System.out.println("静态代码块!");
    	}
    
    	public static void main(String[] args) {
    		new Test();
    		System.out.println(Test.count);
    
    		new Test();
    		System.out.println(Test.count);
    
    		new Test();
    		System.out.println(Test.count);
    	}
    }

输出结果：静态代码块!  
     1  
     1  
     1

# 二、final关键字的用法和案例 #

##      1.final类 ##

被final修饰的类，无法派生子类。

案例：

//父类
    final class BaseTest{
    	//没有方法
    }
    
    //子类
    public class Test  extends BaseTest{
    	//没有方法
    }

输出结果：编译错误

##      2.final方法 ##

被final修饰的方法，无法重写（覆盖）

案例：

//父类
    class BaseTest {
    	
    	public final void log() {
    		// 没有方法体
    	}
    }
    
    // 子类
    public class Test extends BaseTest {
    	
    	@Override
    	public void log() {
    		// 没有方法体
    	}
    }

输出结果：编译错误

##     3.final变量（常量） ##

被final修饰的变量（成员变量和局部变量）是常量，只能赋值一次（初始化）

\*final修饰的变量，无法改变的是引用地址，不是引用指向对象里的数据。（基本数据类型的引用也是数据，所以无法修改）

案例：基本数据类型无法改变

public class Test {
    	// 成员常量
    	final String name = "小红";
    
    	public void setName() {
    		// 编译错误
    		this.name = "小白";
    	}
    
    	public int getAge() {
    		// 局部常量
    		final int age = 9;
    		// 编译错误
    		age = 10;
    		return age;
    	}
    }

案例：引用类型无法修改，但是引用类型对应的数据可以修改

public class Test {
    	public static void main(String[] args) {
    		// test存的是对象引用地址
    		final Test2 test2 = new Test2("小红");
    		
    		//引用地址重新赋值，所以编译错误
    		// test2 = new Test2("小白"); 
    		
    		//修改引用地址，指向对象的数据
    		test2.name = "小白";
    		System.out.println(test2.name);
    	}
    }
    
    class Test2 {
    	
    	public String name;
    
    	public Test2(String name) {
    		this.name = name;
    	}
    }

# 三、java中的常量分析 #

以下代码中，static表示这个变量在内存中只有一份，final表示这个数据无法改变。

案例：

public class Test {
    	//常量
    	public static final String NAME = "小白";
    }