public class Something //定义一个公有类
{
   public static void main(String[] args) {
       Other o = new Other();//新建Other类的实例对象
       new Something().addOne(o);//新建本类对象，并调用本类方法
   }
   public void addOne(final Other o) //定义本类方法，传递参数final Ohther o
{
       o.i++;
   }
}
class Other //定义一个Other类
{
   public int i;//定义公有成员变量
}


疑问：1、Something类里方法addOne中所传递的参数，加final与不加有何区别，请举例说明。
          2、调用new Something().addOne(o)后，这个类有何变化？怎样将结果打印？

Other o被修饰成final，意味着o不能在addOne方法中被修改。比如：
public void addOne(final Other o)
{
       o = new Other();
}
在上例中就是错误的。
但是上例中是o.i++，修改的是o的成员变量而不是o的reference。
反之，不加final的话就可以在addOne中对o本身的reference进行修改。

你可以加一些代码观察调用addOne方法后i值的打印结果。

1. public class Something //定义一个公有类
   
2. {
   
3.    public static void main(String[] args) {
   
4.        Other o = new Other();//新建Other类的实例对象
   
5.        new Something().addOne(o);//新建本类对象，并调用本类方法
   
6.        System.out.println(o.i);
   
7.    }
   
8.    public void addOne(final Other o) { //定义本类方法，传递参数final Ohther o
   
9.        o.i++;
   
10.    }
    
11. }
    
12. class Other //定义一个Other类
    
13. {
    
14.    public int i = 0;//定义公有成员变量
    
15. }
    
16. 
    

复制代码

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
懂了么？区别就在这里。

此问题已解决

addOne方法中的参数被final修饰之后，在这个函数中就无法改变这个参数的值，注意是这个参数的值，如果这个参数是引用类型，那么他的值就是对象的地址，这个地址不能被改变，但是对象中的内容是可以改变的

1. class   Other
   
2. {
   
3.         String i = "AAAA";
   
4. 
   
5.         void   print()
   
6.         {
   
7.                 System.out.println(i);
   
8.         }
   
9. }
   
10. 
    
11. public class Demo //定义一个公有类
    
12. {
    
13.    public static void main(String[] args)
    
14.    {
    
15.        Other a = new Other();//新建Other类的实例对象
    
16.        Other b = new Other();
    
17.        b.i = "BBBB";
    
18.        System.out.println(a.i);
    
19.        System.out.println(b.i);
    
20.        a = b;
    
21.        System.out.println(a.i);
    
22.        new Demo().addOne(a);//新建本类对象，并调用本类方法
    
23.    }
    
24.    public void addOne(final Other o) //定义本类方法，传递参数final Ohther o
    
25.    {
    
26.                 o.i = "aaaa";
    
27.                 System.out.println(o.i);
    
28.         }
    
29. }

复制代码

这样的输出结果是
AAAA
BBBB
BBBB
aaaa
如果把

public void addOne(final Other o) //定义本类方法，传递参数final Ohther o
{
        o.i = "aaaa";
        System.out.println(o.i);
}

改成中的o.i = "aaaa";改成o = new Other
就会在编译的时候报错
Exception in thread "main" java.lang.Error: 无法解析的编译问题：
        不能对终态局部变量 o 赋值。它必须为空白，并且不使用复合赋值

1.final 是最终的意思    表示这个变量在addOne（）不论执行什么样的程序他的值都不会改变