Java 关键字 static 和final 理解

Static :

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就为static变量分配一块固定的内存地址。因此运行时可以直接指向这块固定的内存地址而无需实例化。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

1.    静态变量：

静态变量会在类被加载时初始化且只会被初始化一次。代表不论由哪个句柄指向的堆的内存地址只有一个。所有可以由类.变量名直接引用。该类所有实例的这个变量都指向同一个地址，因此称为静态变量。

2. 静态方法：

 静态方法可以直接通过类名调用，任何的实例也都可以调用，

因为静态方法代表对所有实例均一致的特性。因此静态方法中不能设计特定实例的个性。所以不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员方法)，只能访问所属类的静态成员变量和成员方法。

3. 静态代码块：

独立于类成员的代码块，用static修饰。只在jvm加载类时执行一次。

 

扩展：单例模式的使用。

public class SingletonStudentHungry {
	// 静态成员变量先初始化，且只初始化一次。因此类调用的静态变量都存在同一个内存空间。
	private static SingletonStudentHungry ssh = new SingletonStudentHungry();
	private String name;

	private SingletonStudentHungry() {
	}

	public void setName(String name) {
		this.name = name;
	}

	public static synchronized SingletonStudentHungry getSingletonStudentHungry(String name) {
		ssh.setName(name);
		return ssh;
	}

	public void printSs() {
		System.out.println(this);
	}

	@Override
	public String toString() {
		return "SingletonStudent [name=" + name + "]" + "\nhashcode:" + this.hashCode();
	}

	public static void main(String[] args) {
		SingletonStudentHungry s1 = getSingletonStudentHungry("n1");
		s1.printSs();
		SingletonStudentHungry s2 = getSingletonStudentHungry("n2");
		// 由于指向同一个堆内存地址，因此更改响应值后，所有指向哪个内存的句柄获取的name值均改变
		s1.printSs();
		s2.printSs();
	}
}

运行结果：

Final：

1. final类：

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2. final方法：

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
        使用final方法的原因有二：
        第一、把方法锁定，防止任何继承类修改它的意义和实现。
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3. final变量：

对于基础数据类型：用final定义后，如 final int a = 10;会为a在栈空间分配值，值为10.而final定义则是句柄指向的位置不能更改。因此不能对a的值进行更改。

    对于引用数据类型，即类，接口，数组。定义后，栈内存储堆的内存位置。而使用final定义后，句柄始终指向那个堆，堆内存储数据可以更改，但是句柄到堆内存的指向不能更改。

4. final 参数

 当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

public class Student {

	private String name;

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


	public void setName(String name) {
		this.name = name;
	}

	public  void printStudent(){
		System.out.println(this);
	}
	
	public void changeName(Student s1 , String newName){
		s1.setName(newName);
	}
	
	public void cannotChangeName(Student s2, String newName){
		s2 = new Student(newName);//由于声明的s2指向另一块内存地址，因此对传入的参数没有影响
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + "]"+"\n "
				+ "hashcode:"+this.hashCode();
	}
	
}

public class FinalTest {

	private final int a = 10;
	private final Student student = new Student("caiwuxin"+":"+Math.random());
	
	public FinalTest(){
		
	}
	public static void main(String []args){
		FinalTest f1 = new FinalTest();
		f1.student.printStudent();
		f1.student.changeName(f1.student, "newName");
		f1.student.printStudent();
		f1.student.cannotChangeName(f1.student, "annotherName");
		f1.student.printStudent();
		System.out.println("----------------------------------");
		
		FinalTest f2 = new FinalTest();
		f2.student.printStudent();
		f2.student.changeName(f2.student, "newName");
		f2.student.printStudent();
		f2.student.cannotChangeName(f2.student, "annotherName");
		f2.student.printStudent();
		//a++;无法更改
	}
}

输出结果：

参考文章：内存管理 http://liu1227787871.blog.163.com/blog/static/205363197201263103320466/