1、父类中staitic修饰的静态方法，不能覆盖、不能继承。

2、父类中staitic修饰的变量或常量，能覆盖、不能继承。

static修饰的变量和方法，只属于类本身，不属于对象；当声明一个对象时，并不产生static变量和方法的拷贝。也就是说，用static修饰的变量和方法在类加载的时候，会分配一块存储空间，所有此类的对象都可以操控此块存储空间；

注意：当子类没有与父类同名的static变量(或方法时)，子类的对象也可操控这块内存空间。但是，子类并没有继承父类中static修饰的变量和方法。这是因为static修饰的变量和方法是属于父类本身的。

3、父类中final修饰的方法，不能覆盖，但可继承。

代码示例：

package com.jdk;

/**

* Created by Liuxd on 2018-11-02.

*/

public class TestExtendsClass {

public static void main(String[] args) {

ParentClass parentClass = new ChildClass();

System.out.println();

int pFResult = ParentClass.plus(3,2);

int pResult = ParentClass.add(3,2);

int cResult = ChildClass.add(3,2);

int pMResult = parentClass.minus(2,3);

System.out.println("父类静final方法计算结果：" + pFResult);

System.out.println("父类静方法计算结果：" + pResult);

System.out.println("子类静方法计算结果：" + cResult);

System.out.println("父类final方法计算结果：" + pMResult);

System.out.println("父类静态变量num：" + ParentClass.num);

System.out.println("子类静态变量num：" + ChildClass.num);

}

}

class ParentClass {

public static final int num = 1;

ParentClass() {

System.out.println("执行父类无参数构造方法");

}

static int add(int i, int j) {

return i + j;

}

static final int plus(int i, int j) {

return i + j;

}

final int minus(int i, int j) {

return i - j;

}

}

class ChildClass extends ParentClass {

public static final int num = 2;

ChildClass() {

System.out.println("执行子类无参数构造方法");

}

// @Override 无法继承，编译时出错

static int add(int i, int j) {

return i * j;

}

// 无法继承，编译时出错

// int plus(int i, int j) {

// return i + j;

// }

// 无法继承，编译时出错

// int minus(int i, int j) {

// return i - j;

// }

}

输出结果：

执行父类无参数构造方法

执行子类无参数构造方法

父类静final方法计算结果：5

父类静方法计算结果：5

子类静方法计算结果：6

父类final方法计算结果：-1

父类静态变量num：1

子类静态变量num：2

补充知识：java中static、final 和 static final之间的区别

static可以修饰：全局属性，方法，代码块，内部类(静态内部类或嵌套内部类)

由于静态属性和方法是属于该类的所有对象的，所以可以用类名.静态属性/方法名来访问。用static修饰的代码块表示静态代码块，当Java虚拟机(JVM)加载类时，就会执行该代码块。

1.被static修饰的变量，叫静态变量或类变量(不能是局部变量)，直接可以用类名调用；被static修饰的变量，叫实例变量，必须实例化对象以后调用;static修饰的变量可以被修改.

2.静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，也不能直接访问所属类的实例变量和实例方法(非static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。

3.父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。

常见的java中的main方法必须有static修饰，因为在类加载时无法创建对象，静态方法可以不通过对象调用，所以在类的main方法所在在类加载时就可以通过main方法入口来运行程序。

4.static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

final可以修饰：方法，类，局部变量

对于基本类型数据，final会将值变为一个常量，创建后不能被修改；但是对于对象句柄(亦可称作引用或者指针)，final会将句柄变为一个常数(进行声明时，必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。

但是，对象的本身是可以修改的。这一限制也适用于数组，数组也属于对象，数组本身也是可以修改的。

方法参数中的final句柄，意味着在该方法内部，我们不能改变参数句柄指向的实际东西，也就是说在方法内部不能给形参句柄再另外赋值)。

1.final修饰的变量就会变成常量，而且应当大写，一旦赋值不能改变，final的常量不会有默认初始值，对于直接在初始化赋值时final修饰符常和static修饰符一起使用。

2.final修饰的方法将不能被其子类覆盖重写。

3.final修饰的类类将不能被继承，且final类中的方法也都是final的， final不能用来修饰构造方法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。

static final和final static

没什么区别，一般static写在前面，既具有static属性又具有final属性的类/方法/变量。

以上这篇Java父类继承中的static和final用法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

1. 基本初始化过程：

对于一个简单类的初始化过程是：

static 修饰的模块(static变量和static 块)  ---> 按照代码顺序依次执行。

|

实例变量  及非static模块---> 按照代码顺序依次执行。

|

构造函数 ---> 执行对应的构造函数。

子类的初始化过程。

父类static修饰的模块

|

子类static修饰模块

|

父类实例变量和非static块

|

父类对应构造函数。当子类对应构造函数中没有显示调用时调用的是父类默认的构造函数。

|

子类实例变量和非static块

|

子类构造函数

Class的static模块是唯一的，所以只初始化一次。所有类的实例公用Class的static模块。

static模块的初始化条件： ( From： 引用1 )

(1)遇到new、getstatic、putstatic 或 invokestatic这4条字节码指令时，如果类还没初始化，则触发初始化。对应场景是：new实例化对象时、读或设置一个静态字段时(被final修饰，已在编译器把结果放入常量池的静态字段除外)，以及调用一个类的静态方法时

(2)对类进行反射调用时

(3)初始化子类。但父类还没有初始化时，先触发父类初始化

(4)当虚拟机启动时，需指定一个需要执行的主类(包含main方法)，虚拟机会先初始化该类

2. 关于覆盖和隐藏

覆盖：被覆盖的方法相当于被擦除了，不可恢复(即使类型强制转换也无法调用)。

隐藏：一直保存的某个位置，等需要的时候可以继续使用(类型强制转换后可以调用)。

关于父类子类之间的覆盖和隐藏关系： (From ：引用2)

1. 父类的实例变量和类变量能被子类的同名变量隐藏。

2. 父类的静态方法被子类的同名静态方法隐藏，父类的实例方法被子类的同名实例方法覆盖。

3. 不能用子类的静态方法隐藏父类的实例方法，也不能用子类的实例方法覆盖父类的静态方法，否则编译器会异常。

4. 用final关键字修饰的最终方法不能被覆盖。

5. 变量只能被隐藏不会被覆盖，子类的实例变量可以隐藏父类的类变量，子类的类变量也可以隐藏父类的实例变量。

涉及的典型情况：

前提：

-----------------------------------------

class B extends A{……}

-----------------------------------------

(1) B instanceB = new B();

instanceB的初始化过程如第一部分中：子类的初始化过程。

此时instanceB中实际上有一个super的全部信息(除了父类中被覆盖的实例方法)，但是当前的引用是子类的信息(如果子类中没有的变量和方法则是从父类继承来)。

(2)A instanceA = new B();

此时父类A的变量和静态方法会将子类的变量和静态方法隐藏。instanceA此时唯一可能调用的子类B的地方就是子类B中覆盖了父类A中的实例方法。

执行 B instanceB = (B) instanceA; 后

此时instanceB相当于 B instanceB = new B();

注意：

(1) 这里唯一的覆盖的情况：父类的实例方法被子类的同名实例方法覆盖。

这里方法调用变量时，实际上是带有一个默认的this的。也就是此实例方法中调用的是当前Class的值。涉及到继承的情况时，要十分注意super，this的情况。

(2) 在初始化的时候，有两个阶段。第一步是申请空间，第二步是赋值。

具体见：

static的值和final static值在初始化时的区别。(引用1)

子类覆盖父类实例方法时，调用子类的实例方法，而此时子类的实例方法调用了子类中的变量(此时static变量已经初始化，但是实例变量并没有初始化)。(引用2)

这段代码来自引用2，如何精炼，如此有趣。值得一看。

classParent{

int x=10;

publicParent(){

add(2);

}

voidadd(inty){

x+=y;

}

}

classChildextendsParent{

int x=9;

voidadd(inty){

x+=y;

}

publicstaticvoidmain(String[] args){

Parent p=new Child();

System.out.println(p.x);

}

}

引用 1. 类加载机制：

引用 2. 隐藏和覆盖，以及一个好例子：

引用 3. 隐藏和覆盖

引用 4. 基本的初始化过程