java子类继承的规则

继承的基本概念：（1）Java不⽀持多继承，也就是说⼦类⾄多

只能有⼀个⽗类。（2）⼦类继承。。。

继承的基本概念：

（1）Java不⽀持多继承，也就是说⼦类⾄多只能有⼀个⽗类。

（2）⼦类继承了其⽗类中不是私有的成员变量和成员⽅法，作为⾃⼰的成员变量和⽅法。

（3）⼦类中定义的成员变量和⽗类中定义的成员变量相同时，则⽗类中的成员变量不能被继承。

（4）⼦类中定义的成员⽅法，并且这个⽅法的名字返回类型，以及参数个数和类型与⽗类的某个成员⽅法完全相同，则⽗类的成员⽅法不

能被继承。

分析以上程序⽰例，主要疑惑点是“⼦类继承⽗类的成员变量，⽗类对象是否会实例化？私有成员变量是否会被继承？被继承的成员变量在

哪⾥分配空间？”1：虚拟机加载ExtendsDemo类，提取类型信息到⽅法区。

2：通过保存在⽅法区的字节码，虚拟机开始执⾏main⽅法，main⽅法⼊栈。

3：执⾏main⽅法的第⼀条指令，new Student(); 这句话就是给Student实例对象分配堆空间。因为Student继承Person⽗类，所以，虚拟机

⾸先加载Person类到⽅法区，并在堆中为⽗类成员变量在⼦类空间中初始化。然后加载Student类到⽅法区，为Student类的成员变量分配空

间并初始化默认值。将Student类的实例对象地址赋值给引⽤变量s。4：接下来两条语句为成员变量赋值，由于name跟age是从⽗类继承⽽来，会被保存在⼦类⽗对象中(见图中堆中在⼦类实例对象中为⽗类成

员变量分配了空间并保存了⽗类的引⽤，并没有实例化⽗类。)，所以就根据引⽤变量s持有的引⽤找到堆中的对象(⼦类对象)，然后给name

跟age赋值。 4：调⽤say()⽅法，通过引⽤变量s持有的引⽤找到堆中的实例对象，通过实例对象持有的本类在⽅法区的引⽤，找到本类的类

型信息，定位到say()⽅法。say()⽅法⼊栈。开始执⾏say()⽅法中的字节码。5：say()⽅法执⾏完毕，say⽅法出栈，程序回到main⽅法，main⽅法执⾏完毕出栈，主线程消亡，虚拟机实例消亡，程序结束。

java⼦类与⽗类继承关系

People.java

public class People {

int age,leg = 2,hand = 2;

protected void showPeopleMess() {

System.out.printf("%d岁，%d只脚,%d只⼿\t",age,leg,hand);

}

}

Student.java

public class Student extends People {

int number;

void tellNumber() {

System.out.printf("学号:%d\t",number);

}

int add(int x,int y) {

return x+y;

}

}

UniverStudent.java

public class UniverStudent extends Student {

int multi(int x,int y) {

return x*y;

}

}

Example5_1.java

public class Example5_1 {

public static void main(String args[]) {

Student zhang = new Student();

zhang.age = 17; //访问继承的成员变量

zhang.number=100101;

zhang.showPeopleMess(); //调⽤继承的⽅法

zhang.tellNumber();

int x=9,y=29;

System.out.print("会做加法:");

int result=zhang.add(x,y);

System.out.printf("%d+%d=%d\n",x,y,result);

UniverStudent geng = new UniverStudent();

geng.age = 21; //访问继承的成员变量

java⼦类继承⽗类执⾏顺序⽬录

java new⼀个类对象，类中各部分执⾏顺序：

静态代码块--》⾮静态代码块--》有参构造--》⽆参构造（包含有参构造不执⾏）--》⼀般⽅法

创建⽗类测试执⾏顺序。

public class father {

static{

System.out.println("--⽗类的静态代码块--");

}

{

System.out.println("--⽗类的⾮静态代码块--");

}

father(String name){

=name;

System.out.println("--⽗类的有参构造函数--"+);

}

father(){

System.out.println("--⽗类的⽆参构造函数--");

}

private String name;

public void speak(){

System.out.println("--⽗类的⽅法--");

}

public static void main(String[] args) {

System.out.println("--⽗类主程序--");

father father=new father("⽗亲的名字");

father.speak();

}

}

执⾏结果：

--⽗类的静态代码块

--⽗类主程序

--⽗类的⾮静态代码块

--⽗类的有参构造函数--⽗亲的名字

--⽗类的⽅法

创建⼦类继承该⽗类测试执⾏顺序。

public class Son extends father{

private String name;

static{

System.out.println("--⼦类的静态代码块--");

}

{

System.out.println("--⼦类的⾮静态代码块--");

}

Son(){

System.out.println("--⼦类的⽆参构造函数--");

}

Son(String name){

浅析Java中的静态字段与实例字段、静态⽅法与⾮静态⽅法、

以及Java继承中⽗类⼦类构造⽅。。。

⼀、静态字段与实例字段

在⼀个class中定义的字段，我们称之为实例字段。实例字段的特点是，每个实例都有独⽴的字段，各个实例的同名字段互不影响。

还有⼀种字段，是⽤static修饰的字段，称为静态字段：static field。

实例字段在每个实例中都有⾃⼰的⼀个独⽴“空间”，但是静态字段只有⼀个共享“空间”，所有实例都会共享该字段。

public class Main {

public static void main(String[] args) {

Person ming = new Person("Xiao Ming", 12);

Person hong = new Person("Xiao Hong", 15);

ming.number = 88;

System.out.println(hong.number);

hong.number = 99;

System.out.println(ming.number);

}

}

class Person {

public String name;

public int age;

public static int number;

public Person(String name, int age) {

= name;

this.age = age;

}

}

上述代码运⾏结果为打印： 88 99。为什么？修改 ming.number 为 88 ，打印 hong.number 也是 88；修改 hong.number 为 99，打印ming.number 也为 99。 对于静态字段，⽆论修改哪个实例的静态字段，效果都是⼀样的：所有实例的静态字段都被修改了，原因是静态字段并不属于实例

虽然实例可以访问静态字段，但是它们指向的其实都是Person class的静态字段。所以，所有实例共享⼀个静态字段。