final关键字解析&匿名内部类形参用final

谈到final关键字，想必很多人都不陌生，在使用匿名内部类的时候可能会经常用到final关键字，另外，Java中的String类就是一个final类。
一、final关键字的基本用法
在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。
1.修饰类
当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让它被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
2.修饰方法
下面这段话摘自《Java编程思想》第四版第143页：
“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“
final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写。此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。（注：类的private方法会隐式地被指定为final方法。）
3.修饰变量
修饰变量是final用得最多的地方，也是本文接下来要重点阐述的内容。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其它对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
final修饰一个成员变量（属性），必须要显式初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。
当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

二、深入理解final关键字
1.类的final变量和普通变量有什么区别？
当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
那么final变量和普通变量到底有何区别呢？下面请看一个例子：
public class Test {
    public static void main(String[] args)  {
        String a = "hello2";   
        final String b = "hello";
        String d = "hello";
        String c = b + 2;   
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }
}
输出：
true
false
这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说，在用到该final变量的地方，相当于直接访问的是这个常量，不需要在运行时确定。因此在上面的一段代码中，由于变量b被final修饰，因此会被当作编译期常量，所以在使用到b的地方会直接将变量b替换为它的值。而对于变量d的访问却需要在运行时通过链接来进行。不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代码就不会进行优化：
public class Test {
    public static void main(String[] args)  {
        String a = "hello2";   
        final String b = getHello();
        String c = b + 2;   
        System.out.println((a == c));
 
    }
      
    public static String getHello() {
        return "hello";
    }
}
这段代码的输出结果为false。这里要注意一点就是：不要以为某些数据是final就可以在编译期知道其值，通过变量b我们就知道了，在这里是使用getHello()方法对其进行初始化，它要在运行期才能知道其值。
2.被final修饰的引用变量指向的对象内容可变吗？
public class Test {
    public static void main(String[] args)  {
        final MyClass myClass = new MyClass();
        System.out.println(++myClass.i);
 
    }
}
 
class MyClass {
    public int i = 0;
}
这段代码可以顺利编译通过并且有输出结果，输出结果为1。这说明引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。
3.final参数的问题
在实际应用中，我们除了可以用final修饰成员变量、成员方法、类，还可以修饰参数、若某个参数被final修饰了，则代表了该参数是不可改变的。如果在方法中我们修改了该参数，则编译器会提示你：The final local variable i cannot be assigned. It must be blank and not using a compound assignment：
public class TestFinal {
    
    public static void main(String[] args){
        TestFinal testFinal = new TestFinal();
        int i = 0;
        testFinal.changeValue(i);
        System.out.println(i);
        
    }
    
    public void changeValue(final int i){
        //final参数不可改变
        //i++;
        System.out.println(i);
    }
}
上面这段代码changeValue方法中的参数i用final修饰之后，就不能在方法中更改变量i的值了。值得注意的一点是，方法changeValue和main方法中的变量i根本就不是一个变量，因为Java参数传递采用的是值传递，对于基本类型的变量，相当于直接将变量进行了拷贝（对于引用类型的变量，则拷贝了地址值，依然指向同一个对象），所以即使没有final修饰的情况下，在方法内部改变了变量i的值也不会影响到方法外的i。
请看下面这段代码：
public class TestFinal {
    
    public static void main(String[] args){
        TestFinal testFinal = new TestFinal();
        StringBuffer buffer = new StringBuffer("hello");
        testFinal.changeValue(buffer);
        System.out.println(buffer);
        
    }
    
    public void changeValue(final StringBuffer buffer){
        //final修饰引用类型的参数，不能再让其指向其他对象，但是对其所指向的内容是可以更改的。
        //buffer = new StringBuffer("hi");
        buffer.append("world");
    }
}
运行这段代码就会发现输出结果为 helloworld。很显然，用final进行修饰虽不能再让buffer指向其他对象，但对于buffer指向的对象的内容是可以改变的。现在假设一种情况，如果把final去掉，结果又会怎样？看下面的代码：
public class TestFinal {
    
    public static void main(String[] args){
        TestFinal testFinal = new TestFinal();
        StringBuffer buffer = new StringBuffer("hello");
        testFinal.changeValue(buffer);
        System.out.println(buffer);
        
    }
    
    public void changeValue(StringBuffer buffer){
        //buffer重新指向另一个对象
        buffer = new StringBuffer("hi");
        buffer.append("world");
        System.out.println(buffer);
    }
}
输出：
hiword
hello
从运行结果可以看出，将final去掉后，同时在changeValue中让buffer指向了其他对象，并不会影响到main方法中的buffer，原因在于java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。
--------------匿名内部类，形参为何用final
一、使用匿名内部类
匿名内部类没有名字，其创建格式如下：
new 父类构造器（参数列表）|    实现接口（）
    {
        // 匿名内部类的实体部分
    }
在这里我们看到使用匿名内部类必须要继承一个父类或者实现一个接口，当然也仅能继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。
举例：
public class Test2 {

    public static void main(String[] args) {
        Test2 test = new Test2();
        test.test(new Bird() {

            @Override
            public int fly() {
                return 10000;
            }

            @Override
            public String getName() {
                return "大雁";
            }
        });

    }

    public void test(Bird bird) {
        System.out.println(bird.getName() + "能够飞" + bird.fly() + "米.");
    }

}

abstract class Bird {
    private String name;

    public String getName() {
        return name;
    }

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

    public abstract int fly();
}
在Test2类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。
对于匿名内部类的使用它是存在一个缺陷的，就是它只能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类不能够被重复使用。

二、注意事项
1.使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是二者不可兼得，同时也只能继承一个类或者实现一个接口；
2.匿名内部类中是不能定义构造函数的；
3.匿名内部类中不能有任何的静态成员或静态方法；
4.匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效；
5.匿名内部类不是抽象的，它必须要实现继承的类或实现的接口的所有抽象方法。

三、使用的形参为何要为final
我们给匿名内部类传递参数的时候，若该形参在内部类中需要被使用，那么该形参必须要为final。也就是说，当所在的方法的形参需要被内部类里面使用时，该形参必须为final。
为什么必须要为final呢？
首先我们知道在内部类编译成功后，它会产生一个class文件，该class文件与外部类并不是同一个class文件，仅仅只保留对外部类的引用。当外部类传入的参数需要被内部类调用时，从Java程序的角度来看是直接被调用：
public class OuterClass {

    public void display(final String name, String age) {// 此处必须加final
        class InnerClass {
            void display() {
                System.out.println(name);
            }
        }
    }
}
从上面代码中看好像name参数应该是被内部类直接调用了，其实不然，在Java编译后实际操作如下：
public class OuterClass$InnerClass {
    public InnerClass(String name,String age){
        this.InnerClass$name = name;
        this.InnerClass$age = age;
    }
    
    
    public void display(){
        System.out.println(this.InnerClass$name);
    }
}
所以从上面的代码来看，内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际上是自己的属性而不是外部方法传递进来的参数。
内部类中的属性和外部方法的参数，两者从外表上看是同一个东西，但实际上却不是，也就是说在内部类中我对属性的改变并不会影响到外部的形参，但这从程序员的角度来看是不可行的，毕竟站在程序的角度来看这两个根本就是同一个，所以为了保证参数的一致性，就规定使用final来避免形参的改变。
简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。
故如定义了一个匿名内部类，并且希望它使用一个其外部定义的参数，那么编译器会要求该参数引用是final的。