Java笔记：final修饰符

本篇笔记主要是final修饰符修饰类、成员变量、方法的用法，不可变类，实例缓存的不可变类

final关键字可以用来修饰类、变量、方法。final变量不能重新赋值，子类不能覆盖父类的final方法，final类不能有子类。

1.final修饰的成员变量
（1）final修饰的成员变量一旦赋值后，不能被重新赋值。
（2）final修饰的实例Field，要么在定义该Field的时候指定初始值，要么在普通初始化块或构造器中指定初始值。但是如果在普通初始化块中为某个实例Field指定了初始值，则不能再在构造器中指定初始值。
（3）final修饰的类Field，要么在定义该Field的时候指定初始值，要么在静态代码块中定义初始值。
（4）如果在构造器或初始化块中对final成员变量进行初始化，则不要在初始化之前就访问该成员的值。

package cn.lsl;

public class FinalTest {
    final int a = 5;    //直接赋值
    
    final String str;        //普通代码块中赋值
    {
        str = "zhangsan";
    }
    
    final int b;            //构造器中赋值
    public FinalTest(){
        b = 7;
    }
    
    final static int c = 8;        //直接赋值
    
    final static int d;            //静态代码块中赋值
    static{
        d = 9;
    }
    
    
    
    //如果在构造器或初始化块中对final成员变量进行初始化，则不要在初始化之前就访问该成员的值。
    final int age;
    {
        //System.out.println(age);
        age = 22;
        System.out.println(22);
    }
}

2.final修饰的局部变量
（1）系统不会对局部变量进行初始化，布局变量必须要显示的初始化。所以使用final修饰的局部变量，既可以在定义的时候指定默认值，也可以不指定默认值。
（2）final修饰形参的时候，不能为该形参赋值。

3.final修饰基本数据类型变量和修饰引用类型变量的区别
使用final修饰基本类型的变量，一旦对该变量赋值之后，就不能重新赋值了。但是对于引用类型变量，他保存的只是引用，final只能保证引用类型变量所引用的地址不改变，但不保证这个对象不改变，这个对象完全可以发生改变。

eg:

final Person p = new Person();
p.setAge(23);        //改变了Person对象的age Field
//p=null            //编译出错

final修饰的引用类型变量不能被重新赋值，但是可以改变引用变量所引用对象的内容。

4.final的“宏变量”
（1）final修饰符的一个重要用途就是“宏变量”。当定义final变量时就该为该变量指定了初始值，而且该初始值可以在编译时就确定下来，那么这个final变量本质上就是一个“宏变量”，编译器会把程序中
所有用到该变量的地方直接替换成该变量的值。

package cn.lsl;

public class FinalTest {
    public static void main(String[] args){
        final String name = "小明" + 22.0;
        final String name1 = "小明" + String.valueOf(22.0);
        System.out.println(name == "小明22.0");
        System.out.println(name1 == "小明22.0");
    }
}

final String name1 = "小明" + String.valueOf(22.0);中调用了String类的方法，因此编译器无法再编译的时候确定name1的值，所以name1不会被当成“宏变量”。

package cn.lsl;

public class FinalTest {
    public static void main(String[] args){
        String s1 = "小明";
        String s2 = "小" + "明";
        System.out.println(s1 == s2);    //true
        
        String str1 = "小";
        String str2 = "明";
        String s3 = str1 + str2;
        System.out.println(s1 == s3);        //false
        
        //宏替换
        final String str3 = "小";
        final String str4 = "明";
        String s4 = str3 + str4;
        System.out.println(s1 == s4);        //true
    }
}

分析：1.java会使用常量池量管理曾经使用过的字符串直接量。String a = "hello";  那么字符串池中会缓存一个字符串"hello"，当执行String b = "hello";会让b直接指向字符串池中的"hello"字符串。所以a==b返回true。
2.String s3 = str1 + str2;编译时无法确定s3的值
3.String s4 = str3 + str4;因为执行了宏替换，所以在编译的时候就已经确定了s4的值

5.用final修饰的方法不能被重写。用final修饰的类不能有子类。

6.不可变类
不可变类是指创建该类的实例后，该实例的Field是不可改变的。
如果创建自定义的不可变类，应该遵循如下规则
（1）使用private和final修饰符来修饰该类的Field。
（2）提供带参数的构造器，用于传入参数来初始化类里的Field。
（3）仅为该类的Field提供getter方法，不要为该类的Field提供setter方法。
（4）如果有必要，重写Object类的hashCode和equals方法。

package cn.lsl;

public class Address {
    private final String detail;
    private final String postCode;
    
    public Address() {
        this.detail = "";
        this.postCode = "";
    }
    public Address(String detail, String postCode) {
        this.detail = detail;
        this.postCode = postCode;
    }
    public String getDetail() {
        return detail;
    }
    public String getPostCode() {
        return postCode;
    }
    
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj !=null && obj.getClass() == Address.class){
            Address ad = (Address)obj;
            if(this.getDetail().equals(ad.getDetail()) && this.getPostCode().equals(ad.getPostCode())){
                return true;
            }
        }
        return false;
    }
    
    public int hashCode(){
        return detail.hashCode() + postCode.hashCode() * 31;
    }
    
}

因为final修饰引用类型变量时，表示这个引用变量不可重新被赋值，但引用类型变量所指向的对象依然可被改变。所以在创建不可变类的时候，如果包含的Field类型是可变的，那么这个不可变类就创建失败了。

如下：

package cn.lsl;

class Name{
    private String firstName;
    private String lastName;
    
    public Name() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Name(String firstName, String lastName) {
        super();
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

public class Person {
    private final Name name;
    public Person(Name name){
        this.name = name;
    }
    public Name getName(){
        return name;
    }
    public static void main(String[] args) {
        Name n = new Name("明","小");
        Person p = new Person(n);
        System.out.println(p.getName().getFirstName());
        n.setFirstName("君");
        System.out.println(p.getName().getFirstName());
    }
}

通过n.setFirstName("君");改变了firstName。
为了保证对象的不可变性
可以修改为如下代码

package cn.lsl;

class Name{
    private String firstName;
    private String lastName;
    
    public Name() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Name(String firstName, String lastName) {
        super();
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

public class Person {
    private final Name name;
    public Person(Name name){
        //this.name = name;
        this.name = new Name(name.getFirstName(), name.getLastName());
    }
    public Name getName(){
        //return name;
        return new Name(name.getFirstName(), name.getLastName());
    }
    public static void main(String[] args) {
        Name n = new Name("明","小");
        Person p = new Person(n);
        System.out.println(p.getName().getFirstName());
        n.setFirstName("君");
        System.out.println(p.getName().getFirstName());
    }
}

7.实例缓存的不可变类
如果程序需要经常使用想用的不可变类实例，则应该考虑缓存这种不可变类的实例，因为重复创建相同的对象没有太大的意义，而且加大系统的开销。
可以使用一个数组来作为缓存池，实现不可变类。

package cn.lsl;

class CacheImmutale {
    private static int MAX_SIZE = 10;
    //使用数组来缓存实例
    private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
    private static int pos = 0;
    private final String name;
    private CacheImmutale(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    public static CacheImmutale valueOf(String name){
        for(int i=0; i < MAX_SIZE; i++){
            if(cache[i] != null && cache[i].getName().equals(name)){
                return cache[i];
            }
        }
        if(pos == MAX_SIZE){
            cache[0] = new CacheImmutale(name);
            pos = 1;
        }else{
            cache[pos++] = new CacheImmutale(name);
        }
        return cache[pos-1];
    }
    
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj != null && obj.getClass() == CacheImmutale.class){
            CacheImmutale ci = (CacheImmutale)obj;
            return name.equals(ci.getName());
        }
        return false;
    }
    public int hashCode(){
        return name.hashCode();
    }
}


public class CacheImmutaleTest{
    public static void main(String[] args) {
        CacheImmutale c1 = CacheImmutale.valueOf("hello");
        CacheImmutale c2 = CacheImmutale.valueOf("hello");
        System.out.println(c1 == c2);
    }
}

分析：以上程序缓存池采用“先进先出”规则来决定哪个对象被移除缓存池。
程序中还使用了private修饰来隐藏该类的构造器，通过提供该类的valueOf方法来获取实例。

Java提供的java.lang.Integer类也是采用类似的策略来处理的，但是只能Integer缓存-128~127之间的Integer对象。

package cn.lsl;

public class IntegerTest {
    public static void main(String[] args) {
        Integer a = new Integer(23);
        Integer b = Integer.valueOf(23);
        Integer c = Integer.valueOf(23);
        System.out.println(a == b);
        System.out.println(b == c);
        
        //Integer只能缓存-128~127之间的Integer对象
        Integer d = Integer.valueOf(230);
        Integer e = Integer.valueOf(230);
        System.out.println(d == e);
    }
}