Java基础--继承案例（一）

/**
 * 继承：
 * 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()必须要做构造函数的第一行指定，因为要继承父类中属性和成员变量。保证了前提。
以上权当个人看法，如有问题，请您联系。