/**
* 继承:
* 1,成员变量
* 2,成员函数
*/
public class InheritDemo1 {
public static void main(String[] args) {
B_1 b_1 = new B_1();
B_2 b_2 = new B_2();
//成员变量
b_1.set();
//成员函数
b_2.show();
b_2.fonction_a();//子类直接调用父类方法
b_2.fonction_b();
//构造函数
new B_3();
new B_3(300);
}
}
//成员变量
class A_1{
int num1 = 6;
int age = 18;
}
class B_1 extends A_1{
int num2 = 16;
int age = 30;
void set(){
System.out.println("打印的是B_1:"+age+","+num1+""
+ "\n打印的是A_1:"+num2+","+super.age);
//子类中要访问父类中的成员的时候,要用super指向,本类中用this指向。
}
}
//下面是多重继承
class C_1 extends B_1{
}
//成员函数
class A_2{
void show(){
System.out.println("\n-----------------是A方法");
}
void fonction_a(){
System.out.println("\n显示:fonction_a");
}
}
class B_2 extends A_2{
void show(){
System.out.println("\n-----------------是B方法");
}
void fonction_b(){
System.out.println("显示:fonction_b");
}
}
//构造函数
class A_3{
A_3(){
System.out.println("\n显示:Class_A_3");
}
A_3(int x){
System.out.println("\n显示:Class_A_3,"+x);
}
}
class B_3 extends A_3{
B_3(){
//super();此时有个隐式super,调用父类中不带参数的构造函数
System.out.println("显示:Class_B_3");
}
B_3(int x){
super(300);//此时调用父类中带参数的构造函数
System.out.println("显示:Class_B_3,"+x);
}
}
/**
* Java中不能多继承但是可以多重继承--继承体现
* 此时会编译报错
* class C extends B,A{}
*/
运行结果:
打印的是B_1:30,6
打印的是A_1:16,18
-----------------是B方法
显示:fonction_a
显示:fonction_b
显示:Class_A_3
显示:Class_B_3
显示:Class_A_3,300
显示:Class_B_3,300
总结:
单继承:一个子类只有一个直接父类,
多继承:一个子类不能有多个直接父类(c支持),
多重继承,一个子类继承父类,父类继承另类--> a继承b,b继承c。这就出现了继承体系。
在Java中都是这种形式出现,一般查看基本方法看父类,使用方法是查看子类。
如果子父类中出现的函数是相同时,会运行子类中的函数与方法,也叫覆盖。
方法中时重写,类中是覆盖。
其中在构造函数中子类在new的时候要访问父类中的构造函数,所以在子类的构造函数之前必须访问父类的构造函数。所以在子类不带参数的构造函数中默认会用supper(),调用父类不带参数的构造函数(如果子类中指定,那就调用指定的)。并且super()必须要做构造函数的第一行指定,因为要继承父类中属性和成员变量。保证了前提。
以上权当个人看法,如有问题,请您联系。