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

一、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 = "小白";
}