java里面的put java里面的final的作用

什么是不变性

如果对象在被创建以后，状态就不能被修改，那么它就是不可变的

创建Person类，设置age和name属性，并且用final修饰

public class Person {
    final int age = 18;
    final String name ="Alice";
}

测试显示：

如果Person类中有一个属性可变，意味着该对象不具备不可变性

具有不变性的对象一定是线程安全的，我们不需要对其采取任何额外的安全措施，也能保证线程安全（final修饰的属性不能改但是可并发读取）

final的作用

1.早期的java版本中，会将final方法转为内嵌调用

2.现在：

① 类防止被继承、方法防止被重写、变量防止被修改

② 天生是线程安全的，而不需要额外的同步开销

final 3种用法

1.final修饰变量

被final修饰的变量，意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化

Person类

public class Person {
    String bag = "computer";
}

测试类TestFinal

public class TestFinal {
    public static void main(String[] args) {
       final Person person = new Person();
       person.bag ="book";
    }
}

赋值时机

为什么要规定赋值时机，如果初始化不赋值，后续赋值，就是从null变成你的赋值，这违反了final不变的原则

属性被声明为final后，该变量只能被赋值一次。且一旦被赋值，final的变量就不能再改变，无论如何也不会变

① final instance variable(类中的 final 属性)

• 第一种是在声明变量的等号右边直接赋值
• 第二种就是构造函数中赋值
• 第三种就是在类的初始代码块中赋值（不常用）
• 如果不采用第一种赋值方法，那么就必须在第二、三种挑一种来赋值，而不能不赋值，这是final语法所规定的

public class FinalVariableDemo {
//  private final int a =6;
    private final int a;

//    public FinalVariableDemo(int a) {
//        this.a = a;
//    }
    {
        a = 6;
    }
}

② final static variable(类中的 static final 属性)

• 两个赋值时机:除了在声明变量的等号右边直接赋值外，static final变量还可以用static初始代码块赋值，但是不能用普通的初始代码块赋值

public class FinalVariableDemo {
//    private static final int a = 6;
    private static final int a;
    static {
        a=6;
    }
}

③ final local variable(方法中的 final 变量)

• 和前面两种不同，由于这里的变量是在方法里的，所以没有构造函数，也不存在初始代码块
• final local variable不规定赋值时机，只要求在使用前必须赋值，这和方法中的非final变量的要求也是一样的

public class FinalVariableDemo {
    public void testFinal() {
        //final int a =7;
        final int a;
        a = 6;
        int b = a;
    }
}

2.final修饰方法

• 构造方法不允许用final修饰

• 不可被重写，即不能被override,即便是子类有同样名字的方法，那也不是override，这个和static是一个道理

• 引申：static方法不能被重写（子类可以写与父类同命的静态方法属于子类方法，与父类没有绑定关系）

3.final修饰类

• 不可被继承
• 例如典型的String类就是final修饰的，我们从未见过哪个类是继承String类的

不变性和final的关系

1.不变性并不意味着，简单的用final修饰就是不可变

① 对于基本数据类型，确实被final修饰后就具有不变性

② 但是对于对象类型，需要该对象保证自身被创建后，状态永远不会变才可以

2.如何利用final实现对象不可变

• 当把所有属性都声明为final修饰时，如果存在对象类型里面包含属性是可变的，则对象依然不具备不可变性

Person类

public class Person {
    final int age = 18;
    final String name = "Alice";
    final TestFinal testFinal = new TestFinal();
}

TestFinal类

public class TestFinal {
    String test; 
    public static void main(String[] args) {
        final Person person = new Person();
        person.testFinal.test = "12g";
        System.out.println(person.testFinal.test);
        person.testFinal.test = "15g";
        System.out.println(person.testFinal.test);
    }
}

结果显示：

• 属性是对象类型的做到不可变的实例

/**
 * 一个属性是对象，但是整体不可变，其他类无法修改set里面的数据
 * 不可变在于不局限是基本数据类型还是对象，取决于内容永远不会被修改
 * 只要ImmutableDemo完成初始化后，内部的students就再也不会更改了，ImmutableDemo所有属性就不可更改
 */
public class ImmutableDemo {
    private final Set<String> students = new HashSet<>();//private 属性外面的类访问不到

    public ImmutableDemo() { //在构造函数添加后，没有机会对students数值进行修改了
        students.add("张三");
        students.add("李四");
        students.add("王五");
    }

    public boolean isStudent(String name){ //所有方法都是对students读取
        return students.contains(name);
    }
}

3.对象不可变需要满足的条件

① 对象创建后，其状态就不能修改

② 所有属性都是final修饰的

③ 对象创建过程中，没有发生逸出

4.栈封闭，把变量写在线程内部

在方法里面新建的局部变量，实际上是存储在每个线程私有的栈空间，而每个栈的栈空间是不能被其他线程所访问的，所以不会有线程安全问题。这就是著名的"栈封闭"技术，是"线程封闭"技术的一种情况

/**
 * 演示栈封闭的两种情况，基本变量和对象
 * 先演示线程争抢带来错误结果，然后把变量放到方法类，情况就变了
 */
public class StackConfinement implements Runnable {
    int index = 0;

    public void inThread() {
        int neverGoOut = 0;
        for (int i = 0; i < 10000; i++) {
            neverGoOut++;
        }
        System.out.println("栈内保护的数字是线程安全的" + neverGoOut);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            index++;
        }
        inThread();
    }

    public static void main(String[] args) throws InterruptedException {
        StackConfinement r = new StackConfinement();
        Thread thread1 = new Thread(r);
        Thread thread2 = new Thread(r);
        Thread thread3 = new Thread(r);
        thread1.start();
        thread2.start();
        thread3.start();
        thread1.join();
        thread2.join();
        thread3.join();
        System.out.println(r.index);
    }
}

5.练习

案例①：

public class FinalPractice {
    public static void main(String[] args) {
        String a = "wukong2";
        final String b = "wukong";
        String d = "wukong";
        String c = b + 2;
        String e = d + 2;
        System.out.println(a == c);
        System.out.println(a == e);
    }
}

案例②：

public class FinalPractice2 {
    public static void main(String[] args) {
        String a = "wukong2";
        final String b = getValue();
        String c = b + 2;
        System.out.println(a == c);
    }

    public static String getValue() {
        return "wukong";
    }
}