实例代码：
class Outer{
        private String name = "helloworld" ;
         public void fun(final int x){     //如果不加final则会出错的
            class Inner{
                    public void print(){
                            System.out.println(name) ;
                            System.out.println(x) ;
                    }
        }
            new Inner().print() ;
        }
       
}
public class InnerclassDemo {
    public static void main(String args[]){
    new Outer().fun(10) ;       
    }
}

你这个x就是局部变量,局部内部类访问局部变量,局部变量必须被final修饰.
也就是说这个x在这个函数中,一被定义就不能修改

final:最终，作为一个修饰符
        1，可以修饰类，函数，变量
        2，被final修饰的类不可以被继承，为了避免被继承
        被子类复写功能
        3，被final修饰的方法不可以被复写
        4，被final修饰的变量是一个常量只能被赋值一次，既可以修饰成员变量
        也可以修饰局部变量
                当描述事物时，一些数据的出现值是固定的，那么为了增强阅读性，
                都给这些值起一个名字，方便阅读
                而这个值不需要改变，所以加上final修饰，
                作为常量：
                常量的书写规范所有的字母都大写，如果多个单词组成通过_连接
        5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量
示例中你所说的为第五种情况

1.final数据
许多程序设计语言都有自己的办法告诉编译器某个数据是“常数”。常数主要应用于下述两个方面：
(1) 编译期常数，它永远不会改变
(2) 在运行期初始化的一个值，我们不希望它发生变化
对于编译期的常数，编译器（程序）可将常数值“封装”到需要的计算过程里。也就是说，计算可在编译期间提前执行，从而节省运行时的一些开销。在Java中，这些形式的常数必须属于基本数据类型（Primitives），而且要用final关键字进行表达。在对这样的一个常数进行定义的时候，必须给出一个值。
无论static还是final字段，都只能存储一个数据，而且不得改变。
若随同对象句柄使用final，而不是基本数据类型，它的含义就稍微让人有点儿迷糊了。对于基本数据类型，final会将值变成一个常数；但对于对象句柄，final会将句柄变成一个常数。进行声明时，必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。然而，对象本身是可以修改的。Java对此未提供任何手段，可将一个对象直接变成一个常数（但是，我们可自己编写一个类，使其中的对象具有“常数”效果）。这一限制也适用于数组，它也属于对象。

额，被final修饰的类不可以被继承，不可以被复写；被final修饰的变量可以看做是一个只能赋值一次的常量；被final修饰的函数，不可以进行扩展

加final的话，java会吧函数参数复制一份到堆内存中，这样当函数执行结束后，内部类对象仍然可以持有有效的参数引用

final是最终修饰符，用于修饰类、方法、变量。被修饰的类不能被继承，方法不能被复写、变量只能一次赋值，也就是常量。而你的代码中的 Inner类是定义在成员函数里，想要打印x，x必须要被final修饰才能够传递

final
作用 1、最终类：用final修饰的类都最终类。
有两个特点：①隐含地声明了该类所有的方法为final方法。②不能被继承，即该类没有子类。用final修饰主要是出于安全和效率，有时候为了防止一个类被继承，将其定义为最终类。
作用 2、声明一个成员变量为常量。如果类中的一个成员变量不能被改变，则将其定义为常量，如圆周率π
代码如下:
public class FinalDemo
        {
                final double PI= 3.14;
                double radius;
                public double getarea()
                        {
                                return PI*radius*radius;
                        }
                FinalDemo (double radius)
                {
                        this.radius = radius;
                }
                public static void main(String[] args)
                        {
                                FinalDemo f = new FinalDemo(2);
                                double area = f.getarea();
                                // f.PI = 3.1415926; 非法操作，试图改变类中定义的常量
                                System.out.println(area);
                        }
        }
如果在程序中试图修改定义为final类型的成员变量，则编译会出错。
希望能帮到你。

1.         修饰基础数据成员的final

这是final的主要用途，其含义相当于C/C++的const，即该成员被修饰为常量，意味着不可修改。如java.lang.Math类中的PI和E是final成员，其值为3.141592653589793和2.718281828459045。

2.         修饰类或对象的引用的final

在Java中，我们无法让对象被修饰为final，而只能修饰对象的引用，这意味着即使你写public final A a = new A(); 事实上a指向的对象的数据依然可以被修改，不能修改的是a本身的引用值，即你不能再对a进行重赋值。同样的情况出现在数组中，比如public final int[] a = {1, 2, 3, 4, 5}，事实上a中的数值是可修改的，即可以写a[0] = 3。据目前了解，java中数组内的数据是无法修饰为不可修改的，而C/C++可以。

3.         修饰方法的final

修饰方法的final和C/C++中修饰成员对象的const大不相同。首先，修饰方法的final含义不是“不可修改”，而是指该方法不可被继承成员重新定义。（注意，这里所说的不能被重新定义，并不是指子类一定不能定义同名方法，如果父类的方法是私有类型，子类是允许定义该方法的，这里指的不能重新定义是指不能通过改写方法来使得方法重写的多态性得以实现，如不希望A a = new B(); a.f();这样的重写方法情况出现）