转自：https://www.cnblogs.com/dotgua/p/6357951.html
 
 
 
在java的关键字中，static和final是两个我们必须掌握的关键字。不同于其他关键字，他们都有多种用法，而且在一定环境下使用，可以提高程序的运行性能，优化程序的结构。下面我们来了解一下final关键字及其用法。
 
 
final关键字
 
 
在java中，final的含义在不同的场景下有细微的差别，但总体上来说，它指的是“这是不可变的”。下面，我们来讲final的四种主要用法。
 
 
1.修饰数据
 
 
在编写程序时，我们经常需要说明一个数据是不可变的，我们成为常量。在java中，用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。更重要的是，final会告诉编译器，这个数据是不会修改的，那么编译器就可能会在编译时期就对该数据进行替换甚至执行计算，这样可以对我们的程序起到一点优化。不过在针对基本类型和引用类型时，final关键字的效果存在细微差别。我们来看下面的例子：
 
 
 
  

   
  
 
  
 1 class Value {
 2     int v;
 3     public Value(int v) {
 4         this.v = v;
 5     }
 6 }
 7 
 8 public class FinalTest {
 9     
10     final int f1 = 1;
11     final int f2;
12     public FinalTest() {
13         f2 = 2;
14     }
15 
16     public static void main(String[] args) {
17         final int value1 = 1;
18         // value1 = 4;
19         final double value2;
20         value2 = 2.0;
21         final Value value3 = new Value(1);
22         value3.v = 4;
23     }
24 }
 
  

   
  
 
 
 
 
上面的例子中，我们先来看一下main方法中的几个final修饰的数据，在给value1赋初始值之后，我们无法再对value1的值进行修改，final关键字起到了常量的作用。从value2我们可以看到，final修饰的变量可以不在声明时赋值，即可以先声明，后赋值。value3时一个引用变量，这里我们可以看到final修饰引用变量时，只是限定了引用变量的引用不可改变，即不能将value3再次引用另一个Value对象，但是引用的对象的值是可以改变的，从内存模型中我们看的更加清晰：
 
 
 
 
上图中，final修饰的值用粗线条的边框表示它的值是不可改变的，我们知道引用变量的值实际上是它所引用的对象的地址，也就是说该地址的值是不可改变的，从而说明了为什么引用变量不可以改变引用对象。而实际引用的对象实际上是不受final关键字的影响的，所以它的值是可以改变的。
 
 
另一方面，我们看到了用final修饰成员变量时的细微差别，因为final修饰的数据的值是不可改变的，所以我们必须确保在使用前就已经对成员变量赋值了。因此对于final修饰的成员变量，我们有且只有两个地方可以给它赋值，一个是声明该成员时赋值，另一个是在构造方法中赋值，在这两个地方我们必须给它们赋初始值。
 
 
最后我们需要注意的一点是，同时使用static和final修饰的成员在内存中只占据一段不能改变的存储空间。
 
 
2.修饰方法参数
 
 
前面我们可以看到，如果变量是我们自己创建的，那么使用final修饰表示我们只会给它赋值一次且不会改变变量的值。那么如果变量是作为参数传入的，我们怎么保证它的值不会改变呢？这就用到了final的第二种用法，即在我们编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，我们不会（实际上是不能）改变参数的值：
 
 
 
  

   
  
 
  
public class FinalTest {

    /* ... */

    public void finalFunc(final int i, final Value value) {
        // i = 5; 不能改变i的值
        // v = new Value(); 不能改变v的值
        value.v = 5; // 可以改变引用对象的值
    }
}
 
  

   
  
 
 
 
 
3.修饰方法
 
 
第三种方式，即用final关键字修饰方法，它表示该方法不能被覆盖。这种使用方式主要是从设计的角度考虑，即明确告诉其他可能会继承该类的程序员，不希望他们去覆盖这个方法。这种方式我们很容易理解，然而，关于private和final关键字还有一点联系，这就是类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法，所以也就无法覆盖它。
 
 
4.修饰类
 
 
了解了final关键字的其他用法，我们很容易可以想到使用final关键字修饰类的作用，那就是用final修饰的类是无法被继承的。
 
 
上面我们讲解了final的四种用法，然而，对于第三种和第四种用法，我们却甚少使用。这不是没有道理的，从final的设计来讲，这两种用法甚至可以说是鸡肋，因为对于开发人员来讲，如果我们写的类被继承的越多，就说明我们写的类越有价值，越成功。即使是从设计的角度来讲，也没有必要将一个类设计为不可继承的。Java标准库就是一个很好的反例，特别是Java 1.0/1.1中Vector类被如此广泛的运用，如果所有的方法均未被指定为final的话，它可能会更加有用。如此有用的类，我们很容易想到去继承和重写他们，然而，由于final的作用，导致我们对Vector类的扩展受到了一些阻碍，导致了Vector并没有完全发挥它应有的全部价值。
 
 
总结
 
 
final关键字是我们经常使用的关键字之一，它的用法有很多，但是并不是每一种用法都值得我们去广泛使用。它的主要用法有以下四种：
 
 
用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；
用来修饰方法参数，表示在变量的生存期中它的值不能被改变；
修饰方法，表示该方法无法被重写；
修饰类，表示该类无法被继承。
 
 
上面的四种方法中，第三种和第四种方法需要谨慎使用，因为在大多数情况下，如果是仅仅为了一点设计上的考虑，我们并不需要使用final来修饰方法和类。
 

一、修饰变量
 
final修饰的变量必须初始化，且一旦初始化后不能再被修改，下面是初始化时机的具体分析：
 
1、修饰成员变量
 
不管是类变量（有static）还是实例变量（无static），可以在声明的时候就初始化。对于类变量来说，可以在类中声明final类变量，在类代码块中初始化，如下图所示。这是因为在类中声明定义类变量，编译器会将该代码移入类代码块中的相应位置；对于实例变量也类似，不过将类代码块换成构造器而已，由此可见jvm不会对final修饰的变量赋初值。
 
 
那对于类变量来说，可不可以在类中声明为final，在构造器中在对其进行初始化呢？看下图可知是不行的。因为类变量和实例变量的分配空间的时机不同。类变量实在类初始化时就已经分配空间了，而实例变量在新建对象时调用构造器对其进行分配空间，并进行初始化。因此，在构造器被调用之前类变量就已经有了内存空间了，编译器发现此时final修饰的类变量没有初始化就会报错。按道理说，成员变量在没有显示初始化的情况下，系统会自动赋初值0或null，由此也可以推断出jvm并没有为final修饰的成员变量隐式初始化。
 
 
2、修饰局部变量
 
java中局部变量必须显示初始化，jvm不会给局部变量隐式初始化，原因可能是一个方法中可能会声明多次，且声明周期可能各不相同，如果每次都默认初始化的话开销会很大，而且带来的效益并没有明显提升。final修饰局部变量时，只要在使用该变量前对其初始化即可，如下图所示：
 
 
3、修饰引用变量
 
指的是不能改变引用的指向，即只能指向同一处地址，但是能够修改指向对象的内容。
 
二、修饰成员方法
 
final修饰的成员方法不能被子类重写，但可以重载和调用。
 
三、修饰类
 
final修饰的类方法不能被继承，但可以创建对象。
 
四、修饰范围
 
final不能用来修饰构造器，因为final修饰的成员方法不能被重写，而构造器既不能被继承，也不能被重写，用final修饰符多此一举

（1）修饰一个类，格式：
public final class 类名称{  }
含义：表示这个类不能有任何子类，即不能被继承。
注意：final类中的所有方法都不能被覆盖重写。

（2）修饰一个方法，格式：
修饰符 final 返回值类型 方法名称(参数列表){}
含义：该方法为最终方法，不能被覆盖重写。

注意事项：对于类、方法而言，abstract和final关键字不能同时使用，因为抽象方式是用来被重写的，但是final方法不能被重写。

（3）修饰一个局部变量，格式：
final 数据类型 变量名 = 初始化值;
含义：一旦被final修饰，这个变量初始化后值就不能发生改变。对于基本数据类型是【值不可变】；对于引用数据类型是【地址值不可变】，但是地址中的值可以发生改变。

（4）修饰一个成员变量，格式：
final 数据类型 变量名 = 初始值;
含义：一旦被final修饰，这个变量初始化后值就不能发生改变。

注意事项：
（1）对于成员变量，会有默认赋值，但是一旦被final修饰以后，该成员变量就不会默认赋值。
（2）对于final修饰的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
（3）必须保证类中所有重载的构造方法，都最后会对final修饰的成员变量完成赋值。
 
 

 
java final关键字使用及面试题重点
 
1. 在java中声明类、属性和方法时，可以使用关键字final来修饰，表示“最终的”。
2.java 面试题final关键字知识点，例题
 

 
1. 在java中声明类、属性和方法时，可以使用关键字final来修饰，表示“最终的”。
 
final修饰类:（俗称太监类不能有孩子）
 提高安全性，提高程序的可读性
 这个类就不能被继承。如：String类、StringBuffer类、System类
 
//class SubString extends String{
//	
//}
final class A{
	
}
//class B extends A{
//	
//} 
 
final修饰方法：（确定下功能，没有被子类重写的必要）
 不能被子类重写。如：Object的getClass();功能已经确定下来，就算子类重写了该方法后，也是实现一样的功能，所以没有必要被子类重写。
 
class C{
	public final void method1() {
		System.out.println("I am method1");
	}
}

class E extends C{
	public void method1() {
//		System.out.println("I am method1 for D");
//	}
}
 
final修饰属性：（已经是常量）
 此属性就是一个常量,一旦初始后，不可再被赋值。习惯上，重用大写字符表示。
 此常量在哪里赋值：①此常量不能使用默认初始②可以显示的赋值、代码块、构造器
 注：显示赋值和代码块赋值只能有其中的一个
 变量用static final修饰：全局常量，如Math类的PI
 
public class Test {
	public static void main(String[] args) {
		C c = new C();
		System.out.println(c.getClass());
		System.out.println(Math.PI);
	}
}
class D{
//	final  int I;//常量不能使用默认的赋值
	final  int I = 11;
	final  double PI;
	final String NAME;
	public void m1(){
		System.out.println(I);
//		I = 10;
	}
	{
		PI = 3.14;
	}

	public D() {
		NAME = "DD";
	}
	public D(String name) {
		this();
//		NAME = "DD";
	}
}
//c
 
付：后续需要知道final 与 finally finalize()区别
 
 
 
Object.finalize()//辣鸡回收的，显示把内存中对象清理掉
 
 
2.java 面试题final关键字知识点，例题
 
排除错误例题一
 
/*
 * 错误，调用方法的时候已经对x进行赋值，不能再对其进行++操作。
 */
public class Something { 
	public int addOne(final int x) { 
		return ++x; 
	}  
} 
 
排除错误例题一
 
/*
 * 正确，因为final修饰的类，但++的却是其对象，说明类属性改变，类不一定跟着改变
 */
public class Something { 
	public static void main(String[] args) { 
		Other o = new Other(); 
		new Something().addOne(o); 
	} 
	public void addOne(final Other o) { 
		o.i++; 
	}  
} 
class Other { 
	public int i;
}