final 修饰的成员变量必须手动初始化

理解1：

final关键字我们并不陌生，但是final修饰的属性变量为什么必须在定义的时候或者构造函数中被初始化呢？

static final修饰的变量又为什么必须在定义的时候进行初始化呢？

首先要明白一点：

final修饰的变量表示赋值之后不能再进行更改，系统赋默认值也算赋值，因此系统也不会赋默认值。

如果不在定义的时候或者构造函数中对final变量进行赋值的话，则生成的对象中final变量的值是未知的（编译器也会直接报错），因此必须进行初始化。

如果用static final同时修饰变量的话，则变量必须在定义的时候进行初始化。因为static变量属于类，在调用构造函数之前就已经被系统赋予默认值了。

如果不在定义的时候初始化，那么既无法在构造函数中初始化，系统也不会赋默认值。则该变量被定义出来是毫无意义的。

 

理解2：

问题：

我在定义一个final int类型的成员变量时，没有赋初始值，eclipse直接提示错误，dos编译也能通过，但是String类里面却又大量的没有给final定义的变量赋值的写法，这是为什么呢？

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
    /** The value is used for character storage. */
    private final char value[];

    /** The offset is the first index of the storage that is used. */
    private final int offset;

    /** The count is the number of characters in the String. */
    private final int count;

String类中的被final修饰的offset变量貌似在源代码中几次被赋值，这又是为什么呢？还是我有什么没有理解的？

解答：

① 在构造函数里赋值

② final成员变量可以在构造函数里赋值的嘛

③ final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

④ 不一定要在声明时赋值，但只能赋值一次

⑤ 再补充点，final修饰的索引，对象不能改变，但是对象的内容可以改变。
例如：
final A a = new A();
a.value = 2;
这样是可以的，但是如果再从新赋值a就报错了：a = new A();

⑥ String这个类的定义的final对象都在他的构造函数里赋值了。

public String() {
	this.offset = 0;
	this.count = 0;
	this.value = new char[0];
    }

    /**
     * Initializes a newly created {@code String} object so that it represents
     * the same sequence of characters as the argument; in other words, the
     * newly created string is a copy of the argument string. Unless an
     * explicit copy of {@code original} is needed, use of this constructor is
     * unnecessary since Strings are immutable.
     *
     * @param  original
     *         A {@code String}
     */
    public String(String original) {
	int size = original.count;
	char[] originalValue = original.value;
	char[] v;
  	if (originalValue.length > size) {
 	    // The array representing the String is bigger than the new
 	    // String itself.  Perhaps this constructor is being called
 	    // in order to trim the baggage, so make a copy of the array.
            int off = original.offset;
            v = Arrays.copyOfRange(originalValue, off, off+size);
 	} else {
 	    // The array representing the String is the same
 	    // size as the String, so no point in making a copy.
	    v = originalValue;
 	}
	this.offset = 0;
	this.count = size;
	this.value = v;
    }

他的设计理念是先申明，而不赋初值，这中变量叫final空白，但是在使用空白final之前必须被初始化，在构造函数里赋值了。

⑦ 要么声明时赋值，要么在构造里赋值

⑧ java的String类中成员变量offset使用final进行修饰。但并没有进行赋值。
你也就可以理解为offset是一个空白的身份证，每个构造方法是对身份证进行打印的操作。

String类中有多个构造方法，每个方法中都对offset进行了赋值处理，一旦赋值一次就不能再进行修改了。
我们在创建一个对象时，只会调用类的一个构造方法去实例化，所以就不会出现final offset被赋值多遍的情况。
例如：
String str = new String(byte bytes[], int offset, int length);
String str1 = new String(byte bytes[], int offset, int length, Charset charset);

另外需要注意的是，图片中被圈起的两个offset是不一样的。
一个是方法参数offset，一个是类成员变量offset（就是你说的 final offset）

追问：

非常感谢各位的回答，原来是在构造方法中赋值。我测试了下，也可以在代码块中赋值。
但小弟还有个问题，我看到String类中有很多重载的构造方法，于是我也写了个重载的构造方法来给final变量赋值

public class Test25_final {
	private final int x;
	
	public Test25_final(){
		x = 5;
	}
	
	public Test25_final(int xx){
		this.x = xx;
	}
	
	public static void main(String[] args){
		Test25_final tf = new Test25_final();
		System.out.println(tf.x);
		
		Test25_final tf2 = new Test25_final(6);
		System.out.println(tf2.x);
		
		Test25_final tf3 = new Test25_final(7);
		System.out.println(tf3.x);
	}
}

当我打印时分别打印了5,6,7。这是为什么，我第一次调用构造方法时已经给x赋值了，后面的构造方法还是有效果，并且重新给x赋值了。。这又为什么，或者又是我哪里理解错了？  这个x加不加都没有影响，那final在这个类中到底起作用了么？

解答：

⑨ 这里你创建了3个Test25_final对象，每个对象都用重新初始化，也就是要重新调用构造方法，所以，所以你的final值会都不一样，因为他们彼此不相干。
用我上面的例子就是，你现在有3张空白的身份证，通过实例化构造方法去为身份证复制。
你new几次就决定你有几张身份证。
不知道你是否能明白。

画了个图，参考下吧。

⑩ 你把这里写死，private final int x=5;
试试应该就不行了吧 。

Test25_final tf = new Test25_final();
System.out.println(tf.x);
         
Test25_final tf2 = new Test25_final(6);
System.out.println(tf2.x);
         
Test25_final tf3 = new Test25_final(7);
System.out.println(tf3.x);

这里你每次都new一个对象，每次new一个对象的时候都会重新调用构造函数，重新赋值的

举例：

这样编译也没有报错

总结：当用final作用于类的成员变量时，成员变量必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。而作用于局部变量时，只需要保证在使用之前被初始化赋值即可。

注：其实这个和上面的问题是一样的。

 

理解3：

手动初始化的两种方式：

① 直接赋值

class A{
    final int  i = 100;
}

② 在构造方法中初始化赋值

class A{
    final int  i;
    A(){
        i = 100;
    }    
}

final 修改的成员变量一般和 static 联用

因为 final修改的成员变量是无法被修改的,没有必要在每个对象里保存一份相同的成员变量

final不能和 abstract 修改类

抽象是用来实现的,final 不能被继承

final可以用来修饰引用

final用来修改对象的引用,则引用的对象的地址不能发生变化 ,但是该对象的属性可以发生变化