在 Java 中，声明类、变量和方法时，可使用关键字 final 来修饰。final 所修饰的数据具有“终态”的特征，表示“最终的”意思。具体规定如下：
final 修饰的类不能被继承。
final 修饰的方法不能被子类重写。
final 修饰的变量(成员变量或局部变量)即成为常量，只能赋值一次。
final 修饰的成员变量必须在声明的同时赋值，如果在声明的时候没有赋值，那么只有 一次赋值的机会，而且只能在构造方法中显式赋值，然后才能使用。
final 修饰的局部变量可以只声明不赋值，然后再进行一次性的赋值。
final 一般用于修饰那些通用性的功能、实现方式或取值不能随意被改变的数据，以避免被误用，例如实现数学三角方法、幂运算等功能的方法，以及数学常量π=3.141593、e=2.71828 等。
事实上，为确保终态性，提供了上述方法和常量的 java.lang.Math 类也已被定义为final 的。
需要注意的是，如果将引用类型(任何类的类型)的变量标记为 final，那么该变量不能指向任何其它对象。但可以改变对象的内容，因为只有引用本身是 final 的。
如果变量被标记为 final，其结果是使它成为常数。想改变 final 变量的值会导致一个编译错误。下面是一个正确定义 final 变量的例子：
public final int MAX_ARRAY_SIZE = 25; // 常量名一般大写
常量因为有 final 修饰，所以不能被继承。
请看下面的代码：
final 也可以用来修饰类(放在 class 关键字前面)，阻止该类再派生出子类，例如 Java.lang.String 就是一个 final 类。这样做是出于安全原因，因为要保证一旦有字符串的引用，就必须是类 String 的字符串，而不是某个其它类的字符串(String 类可能被恶意继承并篡改)。
方法也可以被 final 修饰，被 final 修饰的方法不能被覆盖；变量也可以被 final 修饰，被 final 修饰的变量在创建对象以后就不允许改变它们的值了。一旦将一个类声明为 final，那么该类包含的方法也将被隐式地声明为 final，但是变量不是。
被 final 修饰的方法为静态绑定，不会产生多态(动态绑定)，程序在运行时不需要再检索方法表，能够提高代码的执行效率。在Java中，被 static 或 private 修饰的方法会被隐式的声明为 final，因为动态绑定没有意义。
由于动态绑定会消耗资源并且很多时候没有必要，所以有一些程序员认为：除非有足够的理由使用多态性，否则应该将所有的方法都用 final 修饰。
这样的认识未免有些偏激，因为 JVM 中的即时编译器能够实时监控程序的运行信息，可以准确的知道类之间的继承关系。如果一个方法没有被覆盖并且很短，编译器就能够对它进行优化处理，这个过程为称为内联(inlining)。例如，内联调用 e.getName() 将被替换为访问 e.name 变量。这是一项很有意义的改进，这是由于CPU在处理调用方法的指令时，使用的分支转移会扰乱预取指令的策略，所以，这被视为不受欢迎的。然而，如果 getName() 在另外一个类中被覆盖，那么编译器就无法知道覆盖的代码将会做什么操作，因此也就不能对它进行内联处理了。
最后，我自己是一名从事了多年开发的JAVA老程序员，今年年初我花了一个月整理了一份最适合零基础学习的java学习干货，可以送给每一位喜欢java的小伙伴，想要获取的可以关注我的头条号并在后台私信我：交流，即可免费获取。

不可以
在Java中，只要是被定义为final的类，也可以说是被final修饰的类，就是不能被继承的。

final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。

final可以用来修饰数据、方法、类。
final数据
1、final修饰变量

final修饰基本数据类型的变量时，必须赋予初始值且不能被改变。

static final修饰的是常量，常量分为编译时常量与运行时常量，定义为static，强调只有一份。

比如static final int a = 10;就是编译时常量，只要是该常量带入的语句，在编译过后都会替换。

这段代码



在反编译后变成



而且只要这种常量在的算式，在编译时期就会被计算。（只有基本数据类型和String）



反编译后



很明显了。

关于运行时常量：static final int a = “123”.length();就是一个运行时常量，它的赋值会引起类的初始化。

编译器常量有一个风险。就比如A类定义了常量，B类使用了常量。但现在需要修改A类源码的常量值，对A类重新编译，但没对B类重新编译，这就导致A类与B类的常量值不一样。

2、final修饰引用

对于对象引用，final使引用恒定不变。就是一旦引用指向一个对象，就无法把他再指向另一个对象，但对象是可以修改的。数组也一样，毕竟数组也是对象。

3、空白final

所谓空白final就是被声明为final但未赋初值的域，但在使用前，必须保证赋初值，这样就可以灵活的为其进行赋值，但是又保持了其不可更改的特性 。

必须在域定义处（final修饰局部变量）或每个构造器里（final修饰成员变量）用表达式对final进行赋值。
public class Tests {
	private final int j;
	public Tests(){
		j = 0;
	}
	public Tests(int x){
		j = x;
	}
	public static void main(String[] args) {
		new Tests(12);
		final int k;
		k = 2;
		System.out.println(k);
    }
}

3、final参数

被final修饰的参数称位final参数。意思是你无法更改参数引用所指向的变量，可以读参数，但不可修改参数。主要用于向内部类传递数据。

4、final方法

被final修饰的方法，只能被继承，不能被覆盖

final与private关键字：类中所有private方法都被隐式指定是final的，但如果在子类定义一个与父类方法名、参数列表、返回值都相同的private方法也可以，但调用的时候，还是按照private的法则，private方法只在本类中使用，而且用@Override也会报错，也就是说父类与子类的相同的private方法没有任何关系。

5、final类

当类被final修饰时，表示类是不可被继承的。final类中的所有方法都是隐式的指定为final的，无法被覆盖。但成员变量不是final，你可以人为指定某个成员变量是final。


继承与初始化
如下代码：
public class Battle extends Insect {
	private int k = printInit("Battle.k initialized");
	public Battle(){
		System.out.println("k = " + k);
		System.out.println("j = " + j);
	}
	private static int x2 = printInit("static Battle.x2 initialized");
	public static void main(String[] args) {
		System.out.println("Battle constructor");
		Battle t = new Battle();
    }
}
class Insect{
	private int i = 9;
	protected int j;
	Insect(){
		System.out.println("i = " + i + ", j = " + j);
		j = 39;
	}
	private static int x1 = printInit("static Insect.x1 initialized");
	static int printInit(String s){
		System.out.println(s);
		return 47;
	}
}

输出



在Battle上运行Java时，程序想要访问Battle类的main方法，这时加载器就要找出Battle的.class文件，对它进行加载。加载过程中，发现它有一个父类，于是就要对父类进行加载，如果发现父类还有父类，那就要加载“爷爷类”，不要认为加载父类是由于本类调用了父类的静态方法，实际上去掉调用父类的成员变量，父类还是先加载。

父类的static初始化完后，就轮到自己的static执行，执行完后，也就输出了前两行。

执行到这，说明必要的类已经加载完毕了。进入main方法，输出Battle constructor。开始创建对象。先把对象内所有的基本类型设置为默认值，引用类型设置为null（通过将对象内存设为二进制零值一举生成的），然后，构造器开始调用，我们知道，子类构造器会默认在第一行添加super()，先调用父类构造器，输出i = 9， j = 0；，然后子类构造器执行。

首先我们先看下final在java中的作用
final在Java中可以用来修饰类、修饰方法和修饰变量
 1. final修饰的类，为最终类，该类不能被继承。如String 类
    
 2. final修饰的方法可以被继承和重载，但不能被重写
        
 3. final修饰的变量不能被修改，是个常量

举例说明：
public class Person {

    private String name;
    private int age;
    private String sex;

    final public void work(){ //final 修饰的最终方法 可以被子类继承，但不能被重写
        System.out.println("a person can do work");
    }

    final public void work(int age){ //重载一个final类
        System.out.println("a person can do another work");
    }

    public void eat(){   //普通方法  可以被子类继承、重写
        System.out.println("a person need to eat");
    }

    public static void sleep(){  //静态方法  可以被继承
        System.out.println("a person need to sleep");
    }
}

子类继承了父类Person 重写了父类普通方法eat() ,但不能重写父类final修饰的方法和静态方法
public class Man extends Person{
    
    public void eat(){
        System.out.println("the man also need do eat");
    }

    public static void sleep(){
        System.out.println("the man also need to sleep");
    }

}

注意：

在Java中静态方法可以被继承，但是不能被覆盖，即不能重写。

如果子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。（比如子类Man 中的sleep方法）