JAVA中STRING为什么用FINAL修饰

STRING为什么要用final修饰?

    首先：我们先了解一下final关键字的作用

1. final修饰为基本数据类型：如果修饰的是基本数据类型，则该数据类型为常量，该值无法修改。如final int a = 1;
2. final修饰一个引用
1. 如果引用为引用数据类型，比如对象，数组，则该对象，数组本身可以修改，但指向该对象或者数组的地址的引用不能修改，final int[] a = {1,2}也是属于引用数据类型
2. 如果引用时类的成员变量，则必须当场赋值，否则编译会报错，如
1. class A{
2.       private final aa;//没赋值，会报错，private final aa = "12";应该这样；
3. }
3. 用来修斯一个方法
1. 当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承，如：
1. class Person {
2.     public final void say() {
3.         System.out.println("说....");
4.     }
5.     public void eat() {
6.         System.out.println("吃...");
7.     }
8. }
9. class Teacher extends Person {
10.     //1. final修饰的方法不能被重写，但此方法仍然被继承
11.     /*@Override
12.     public void say() {
13.         System.out.println("老师在一本正经的说...");
14.     }*/
15.     
16.     public void eat() {
17.         System.out.println("老师在大口大口的吃...");
18.     }
19. }
20. public class Demo02 {
21.     public static void main(String[] args) {
22.         Teacher t = new Teacher();
23.         t.say();
24.     }    
25. }
4. final修饰类，表示类不能被继承，用网上一句话，就是断子绝孙类

其次，为什么STRING要用FINAL修饰

1. FINAL在STRING中修饰了类和一个char型数组，如下：
1. public final class String
2. implements java.io.Serializable, Comparable<String>, CharSequence {
3. /** The value is used for character storage. */
4. private final char value[];
5.  
6. /** Cache the hash code for the string */
7. private int hash; // Default to 0
2. 根据定义可知STRING是不可变的，不可变有以下两点点组成
1. STRING类中的数据由一个private final char value[];，该数组由final修饰，表示该数组指向的地址不可变
2. value由private修饰，说明该值只能被该类所改变，不能被其他继承下去的类改变，所以STRING的不可变性就由此产生
3. 为了安全，用了FIANL修饰STRING，不可被继承
4. 不可变的好处
1. 可以实现字符串池，在变量池中，多个字符串对象的应用可以放心指向一个STRING实例，因为这个实例不可变，所以可以放心使用
2. ，因为字符串是不可变的，所以字符串是线程安全的
3. 字符串不可变，所以它在创建的时候，HASHCODE就被缓存了，这就使得字符串很适合坐MAP的KEY，因为MAP的KEY是要根据HASHCODE去找桶，根据桶再去equals对象。

STRING的面试题

1. STRING为什么用FINAL修饰，为了安全，本篇上半部分已经介绍
2. STRING用SUBSTRING为什么是新建的，这个也是因为STRING是不可变性，比如“aa”.subString(0,1)="a"，因为"aa"在常量池中已经存在，且不可变，所以就需要在新建一个对象"a"，subString源码为
1. public String substring(int beginIndex, int endIndex) {
2. if (beginIndex < 0) {
3. throw new StringIndexOutOfBoundsException(beginIndex);
4. }
5. if (endIndex > value.length) {
6. throw new StringIndexOutOfBoundsException(endIndex);
7. }
8. int subLen = endIndex - beginIndex;
9. if (subLen < 0) {
10. throw new StringIndexOutOfBoundsException(subLen);
11. }
12. return ((beginIndex == 0) && (endIndex == value.length)) ? this
13. : new String(value, beginIndex, subLen);
14. }