Luckylau's Blog

Java基础之final,static,finalize的区别

发表于 | 分类于 |
更新时间 更新内容
2017-04-27 原文初始化
2017-05-08 static方法初始化的过程

final关键字

​ Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

final的使用

定义变量，包括静态的和非静态的。

用final修饰的成员变量表示常量，值一旦给定就无法改变。

final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

定义方法的参数。

斯坦福教授说的好，方法可以比喻成一台机器(面包机)，没错，在我的机器（方法）里面，我要的参数加了final(要原料)，你给我传过来的参数，机器里面就无法改了，也就是说在机器里的这个参数，一直指向的都是你传进来的参数。

一句话概括是不允许将引用变量进行重定向。

1
2
3
4
5
6
7
8
9
10
11
public void setLength( int length) {
	if(length < 8) {
		length = 8;
	}
}
//下面就会出现编译错误
public void setLength( final int length) {
	if(length < 8) {
		length = 8;
	}
}

定义方法。

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。

使用final修饰，可以把方法锁定，防止任何继承类修改它的意义和实现；其次是高效，编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

1
2
3
4
5
6
7
8
9
10
11
class PersonalLoan{
	 public final String getName(){
	    return "personal loan";
	    }
	}
class CheapPersonalLoan extends PersonalLoan{
	  @Override
	  public final String getName(){
	    return "cheap personal loan"; //compilation error: overridden method is final
	    }
	}

定义类。

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

final与static的区别

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class staitcTest {		
		private static int B;
		private int b;
		static {
			B = 1;  
			System.out.println(" B : " +B);
			staitcTest t = new staitcTest(); 
			t.printTest();
			t.B=2;
			t.b=1;
			System.out.println(" B : " + B);
			System.out.println(" b : " +t.b);		
		}
		public void printTest(){
			System.out.println(".... test ....");
		}
		public static void main(String[] args) {		
		}	
		static { 
            B = 3; 
            System.out.println(" B : " + B);          
		} 		
}
//output
 B : 1
 B : 2
 b : 1
 B : 3

解释static代码块如何加载（static块到底在什么时候运行的）：

一个类的运行包括以下步骤：装载—-连接—-初始化

装载阶段又三个基本动作组成：

通过类型的完全限定名，产生一个代表该类型的二进制数据流；
解析这个二进制数据流为方法区内的内部数据结构；
创建一个表示该类型的java.lang.Class类的实例；
另外如果一个类装载器在预先装载的时遇到缺失或错误的class文件，它需要等到程序首次主动使用该类时才报告错误。

连接阶段又分为三部分：

验证，确认类型符合Java语言的语义，检查各个类之间的二进制兼容性(比如final的类不用拥有子类等)，另外还需要进行符号引用的验证。
准备，Java虚拟机为类变量分配内存，设置默认初始值。
解析(可选的) ，在类型的常量池中寻找类，接口，字段和方法的符号引用，把这些符号引用替换成直接引用的过程。

当一个类被主动使用时，Java虚拟就会对其初始化，如下六种情况为主动使用：

当创建某个类的新实例时（如通过new或者反射，克隆，反序列化等）
当调用某个类的静态方法时
当使用某个类或接口的静态字段时
当调用Java API中的某些反射方法时，比如类Class中的方法，或者java.lang.reflect中的类的方法时
当初始化某个子类时
当虚拟机启动某个被标明为启动类的类（即包含main方法的那个类）

Java编译器会收集所有的类变量初始化语句和类型的静态初始化器，将这些放到一个特殊的方法中：clinit。

实际上，static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。

执行static块的几种情况：

第一次new A()的过程会打印””；因为这个过程包括了初始化；

第一次Class.forName(“A”)的过程会打印；因为这个过程相当于Class.forName(“A”,true,this.getClass().getClassLoader())；

第一次Class.forName(“A”,false,this.getClass().getClassLoader())的过程则不会打印。因为false指明了装载类的过程中，不进行初始化。不初始化则不会执行static块。

重要的几点说明

1.被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

2.用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

3.static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用–废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

4.static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

​ 类名.静态方法名(参数列表…)
​ 类名.静态变量名

5.用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

static和final合纵连横

static 和final用来修饰成员变量和成员方法，可简单理解为“全局常量”！对于变量，表示一旦给值就不可修改，并且通过类名可以访问。对于方法，表示不可覆盖，并且可以通过类名直接访问。

特别要注意一个问题： 对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。

final与static的联合使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class FinalTest {
		public final int A = 10; // 在定义时初始化
		public final int B;
		{
			B = 20;  // 在初始化块中初始化
		}
		// 非静态final变量不能在静态初始化块中初始化
		// public final int C;
		// static {
		// 		C = 30;
		// }
		public static final int STATIC_D = 40; //静态常量，在定义时初始化
		public static final int STATIC_E;
		static {
			STATIC_E = 50; // 静态常量，在静态初始化块中初始化
		}
		// 静态变量不能在初始化块中初始化
		// public static final int STATIC_F;
		// {
		// STATIC_F = 60;
		// }
		public final int G;   
		// 静态final变量不可以在构造器中初始化
		// public static final int STATIC_H;
		// 在构造器中初始化
		public FinalTest() {
			G = 70;
		// 静态final变量不可以在构造器中初始化
		// STATIC_H = 80;
		// 给final的变量第二次赋值时，编译会报错
		// A = 99;
		// STATIC_D = 99;
		}
		// final变量未被初始化，编译时就会报错
		// public final int I;
		// 静态final变量未被初始化，编译时就会报错
		// public static final int STATIC_J;
}

final、finally和finalize的区别

finally

finally 它只能用在try/catch语句中，并且附带着一个语句块，表示这段语句最终总是被执行。

1
2
3
4
5
6
7
8
9
10
11
12
public class FinallyTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			throw new NullPointerException();
		} catch (NullPointerException e) {
			System.out.println("程序抛出了异常");
		} finally {
			System.out.println("执行了finally语句块");
		}
	}
}

那么，有没有一种情况使finally语句块得不到执行呢？我们测试一下return、continue、break，代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class FinallyTest {	
	// 测试return语句
	public ReturnClass testReturn() {
	try {
		return new ReturnClass();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println("执行了finally语句");
		}
		return null;
	}
	// 测试continue语句
	public void testContinue() {
		for (int i = 0; i < 3; i++) {
			try {
				System.out.println(i);
				if (i == 1) {
					continue;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				System.out.println("执行了finally语句");
			}
		}
	}
	// 测试break语句
	public void testBreak() {
		for (int i = 0; i < 3; i++) {
			try {
				System.out.println(i);
				if (i == 1) {
					break;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				System.out.println("执行了finally语句");
			}
		}
	}	
	class ReturnClass {
		public ReturnClass() {
			System.out.println("执行了return语句");
			}
		}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FinallyTest ft = new FinallyTest();
		// 测试return语句
		ft.testReturn();
		System.out.println("================");
		// 测试continue语句
		ft.testContinue();
		System.out.println("================");
		// 测试break语句
		ft.testBreak();
	}
}
//output
执行了return语句
执行了finally语句
================
0
执行了finally语句
1
执行了finally语句
2
执行了finally语句
================
0
执行了finally语句
1
执行了finally语句

从输出的结果来看，return语句似乎在finally语句块之前执行了，事实真的如此吗？

分析如下：

​ 我们来想想看，return语句的作用是什么呢？是退出当前的方法，并将值或对象返回。如果finally语句块是在return语句之后执行的，那么return语句被执行后就已经退出当前方法了，finally语句块又如何能被执行呢？因此，正确的执行顺序应该是这样的：编译器在编译return new ReturnClass();时，将它分成了两个步骤，new ReturnClass()和return，前一个创建对象的语句是在finally语句块之前被执行的，而后一个return语句是在finally语句块之后执行的，也就是说finally语句块是在程序退出方法之前被执行的。同样，finally语句块是在循环被跳过（continue）和中断（break）之前被执行的。

finalize

它是一个方法，属于java.lang.Object类，它的定义如下：
​ protected void finalize() throws Throwable { }
​ 众所周知，finalize()方法是GC(garbage collector)运行机制的一部分，finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常(uncaught exception)，GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。

以后在java垃圾回收详细分析。

参考

http://lavasoft.blog.51cto.com/62575/18771/

http://www.cnblogs.com/ivanfu/archive/2012/02/12/2347817.html

Luckylau wechat
如果对您有价值,看官可以打赏的！