1. public class Something {
   
2.     public int addOne(final int x) {
   
3.     return ++x;
   
4.     }
   
5. }
   

复制代码

1. public class Something {
   
2. 
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Other o = new Other();
   
6.                 new Something().addOne(o);
   
7.         }
   
8.         public void addOne(final Other o)
   
9.         {
   
10.                 o.i++;
    
11.         }
    
12. }
    
13. class Other
    
14. {
    
15.         public int i;
    
16. }
    

复制代码

这两段代码有错吗？为什么？

final int x和final Other o有错误，改下。被final修饰的变量为常量，值不能改变；被final修饰的类不能有之类；被final修饰的行数不能被覆写。现在已经给你说的这么清楚了，你看下知道错误的原因不。

要解决你这个问题:就要先了解了解final

final可以修饰类、方法、变量
final修饰的类不能被继承
final修饰的方法不能被子类覆盖
final修饰的变量(成员变量或局部变量)是一个常量，只能赋值一次
　　在描述事物的时候，一些数据的值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。而这个值不需要改变，所以加上final修饰（常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接）。
　　方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期，将一个形参定义成final也是可以的，这就限定了我们在方法中修改形式参数的值。
　　public static final共同标记常量时，这个常量就成了全局的常量，通过类名就可以调用。
少侠，你的第一段代码是错误的，第二段没什么问题

额~~上面回复下不小心点错了。。。
想知道上面的问题所在就要先了解了解final。final的英文解释是：最后。我用的是google在线翻译。final通用表示"这是无法改变的"，final类不能被继承，final类中的方法默认是final的。final方法不能被子类的方法覆盖，但可以被继承。final不能用于修饰构造成员。final成员当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里的不可改变是对基本类型来说，是其值不可改变（按值传递）；而对于对象变量来说是其引用不可再变【但引用的属性方法可以改变】（按引用传递）。

当用final来修饰基本数据类型的时候，那被修饰的基本数据类型的值不能改变。因为基本数据类型是按值传递的。如果修饰的是对象，只要对象的引用不变就可以，对象是按应用传递的。
代码演示final修饰基本数据类型：
                /**
                 * 未用final修饰的基本类型
                 */
                int i = 0 ;
                i +=1;
                int ii ;
                ii = 1;
                ii = 3;
                /**
                 * 使用final修饰的基本类型（只能赋一次值）
                 */
                final int i1 = 0;
                i1 = 1;//i1已经赋过一次值了，不能再次更改其值，编译失败
                final int i2;//能给i2赋一次值，赋过之后就不能再更改值
                i2 = 34;//第一次赋值，编译通过
                i2 = 45;//第二次赋值，编译报错
代码演示final修饰对象类型：
public class Something {
        public static void main(String[] args)
        {
                Other o = new Other();//-------------位置1和位置2的引用
                                                    //地址不一样
                new Something().addOne(o);
        }
        public void addOne(final Other o)
        {
                o.i++;
                o = new Other();//此时对象的引用改变了所以报错----------位置2
                o.a = new A();    //本以为这个也会报错，结果没错--！，但是把
                                          //位置3改成：final A a = new A();
                                          //就会报错
        }
}
class Other
{          
            A a = new A();//---------位置3
            public int i;    //----------位置4
}
class A{}
final class B{}
class C extends B{} //final类不能被继承
class D extends A{} //不是final修饰的类

Finle修饰符的总结
A. 可以修饰具备变量
   只能赋值一次，变量终身不变，其实就是常量

B. 可以修饰成员变量
   final锁住的不是内存默认值
   final修饰的成员变量，可以在构造方法中赋值
   但是不可以在普通方法中赋值
   成员变量属于对象的，构造方法运行是在建立对象过程中的事情
   普通方法运行，是对象已经建立完成了

C. 可以修饰成员方法
   修饰后，这个方法变成最终方法，不能被子类重写

D. 可以修饰类
   类变成最终类，没有子类了

你知道为什么错吗，final是用来修饰不可改变的值，比如final String a="aa";那么a永远都等于aa,不会再改变，而你（final int x）是不合法的参数，明白？

第一段代码不行，因为final int x 为基本数据类型，其中基本数据类型被final修饰后，不可以改变值。
而引用类型的不一样，如果一个引用类型的变量被final修饰，那么它的引用不可以被改变，而引用的对象的属性可以发生改变。