final的功能：　根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

1. package com.exam;
   
2. 
   
3. public class test {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 final student stu1=new student("zhang",1);
    
11.                 System.out.println(stu1.getName()+"  "+stu1.getID());
    
12.                
    
13.                 stu1.setName("wang");
    
14.                 System.out.println(stu1.getName()+"  "+stu1.getID());//这样打印出来的stu1就发生改变了，感觉就辜负了final字的功能
    
15.                
    
16.        
    
17.                
    
18.                
    
19.                
    
20.         }
    
21. 
    
22. }
    
23. class student
    
24. {        String name;
    
25.         public String getName() {
    
26.         return name;
    
27. }
    
28. public void setName(String name) {
    
29.         this.name = name;
    
30. }
    
31. public int getID() {
    
32.         return ID;
    
33. }
    
34. public void setID(int iD) {
    
35.         ID = iD;
    
36. }
    
37.         int ID;
    
38.         student(String name,int ID){
    
39.                 this.name=name;
    
40.                 this.ID=ID;
    
41.         }
    
42. }
    

复制代码

final字的功能修饰对象,你只能改变此对象属性，而不能其指向其它对象
是这个意思,并不是修饰后,他的成员属性就不能改变了.
                final Test1 t=new Test1();
                t.s="mimi";
                System.out.println(t.s);
                Test1 m=new Test1();
                t=null/t=m;时错误

final修饰对于一个对象来说，这个对象的引用地址是不可变的，但是其值可以变化，即对象的属性可以通过方法的设置进行改变。

那说来说去，final定义的东西还是可以变啊。就像我的例子一样，stu1都虽然它的名字没有变，但是他的属性，或者它代表的人还是变了啊。
这还是违背了我开头贴出的一段话。
Java关键字final有“这是无法改变的”或者“终态的”含义，你可能出于两种理解而需要阻止改变：设计或效率。

我觉得我们不能只理解现象，还要知道这个现象对我们的有什么好处。

      final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。
可以一下方法验证

　　引用本身的不变：
　　final StringBuffer a=new StringBuffer("immutable");
　　final StringBuffer b=new StringBuffer("not immutable");
　　a=b;//编译期错误

　　引用指向的对象不变：
　　final StringBuffer a=new StringBuffer("immutable");
　　a.append(" broken!"); //编译通过

所以有此可见
final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，
改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

所以 final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。

你有个不好的习惯，你的类名没有大写，还有一些命名也不符合规则。
你给stu1加了final关键字，stu1是个引用，不是个对象，stu1这个引用的内容是个地址，所以只能保证stu1的内容不变，也就是地址不变。这个地址放了个对象，你通过引用来操作这个对象。名字只是对象的属性，stu1还是指向那个对象。final stu1让stu1永远指向了这个student，但是不代表这个student不能改名啊。
就好像一个人，改了名字，人也没变啊。你要想让学生不能改名的话，就该给成员变量name加上final，那样的话，你的所有构造函数都必须对name进行初始化。
你得分清楚什么是引用，什么是对象。

当final修饰基本数据类型时，表示值不可改变
修饰对象的引用时，final使引用恒定不变，一旦引用被初始化指向一个对象，就无法让它再指向另一个对象，但是对于对象本身是可以被修改的。

当final修饰基本数据类型时，表示值不可改变，修饰对象的引用时，final使引用恒定不变，一旦引用被初始化指向一个对象，就无法让它再指向另一个对象，但是对于对象本身是可以被修改的

final可以修饰类，方法，成员
修饰的类不可以被继承，修饰的方法不可以被复写，修饰的成员只能被赋值一次
final student stu1=new student("zhang",1);表示赋值后，stu1学生对象只能被赋值一次，所以stu1引用不能再指向另外一个对象，但是修改这个对象中的属性不影响影响修改。因为修改这个对象中的属性，不改变这个对象的地址值，在内存中还是原来的那个地址。stu1所指向的地址是没有变化的。