Java——继承

为什么需要继承？

首先我们都知道我们可以创建一个对象或者是类，我们可以写入很多方法和属性，那么我们为什么需要继承呢？

我们来看下面这个问题：我们需要编写两个类一个是Pubil类（小学学生），一个是Graduate类（大学学生）：两个类当中我们需要赋予名字、年龄、考试成绩属性，同时要写入一个方法（考数学这个动作）。

pubil类：

public class Pubil {
	//模拟学生考试
	public String name;
	public int age;
	private double score;
	
	
	public void setScore(double score) {
		this.score = score;
	}
	
	public void testing() {
		System.out.println("小学生 "+name+"正在考小学数学...");
		
	}
	
	public void showInfo() {
		System.out.println("学生名："+name+"年龄："+age+"成绩："+score);
	}

}

graduate类：

public class Graduate {
	//模拟大学生考试情况
	public String name;
	public int age;
	private double score;
	
	public void setScore(double score) {
		this.score = score;
	}
	
	public void testing() {
		System.out.println("大学生 "+name+"正在考大学数学...");
		
	}
	
	public void showInfo() {
		System.out.println("学生名："+name+"年龄："+age+"成绩："+score);
	}

}

测试类：Extends01

public class Extends01 {

	public static void main(String[] args) {
		
		Pubil pubil1 = new Pubil();
		pubil1.name = "小明";
		pubil1.age = 12;
		pubil1.testing();
		pubil1.setScore(60);
		pubil1.showInfo();
		
		
		Graduate graduate1 = new Graduate();
		graduate1.name = "李明";
		graduate1.age = 20;
		graduate1.testing();
		graduate1.setScore(85);
		graduate1.showInfo();
    }

}

我们通过代码的编写，我们可以看出，在大学生和小学生类中，首先我们的属性都是一样的，而且两个类当中还有一些相同方法，所以如果我们要写很多这样的类，那么我们的代码就会很重复，因此我们就引出了——继承。

什么是继承？

继承可以解决代码复用的问题，让我们的编写更加靠近人的思维，当多个类存在相同的方法和属性的时候，可以从这些类当中抽象出父类，在父类当中定义这些相同的属性和方法，所有子类就不需要重新定义这些属性和方法，只需要通过extends来声明继承父类。

基本语法

class 子类名 extends 父类名{
			
		}

（1）子类会自动拥有父类当中定义的属性和方法。

（2）父类又称之为基类，超类。

（3）子类又称之为派生类。

案例演示：

我们通过开头的那个例子改造一下，写出父类和子类

父类：student

public class Student {

	//属性
	public String name;
	public int age;
	private double score;
	
	//方法
	public void setScore(double score) {
		this.score = score;
	}
	
	public void showInfo() {
		System.out.println("学生名："+name+"年龄："+age+"成绩："+score);
	}

}

子类：pubil

public class Pubil extends Student{
	
	//模拟学生考试
	public void testing() {
		System.out.println("小学生 "+name+"正在考小学数学...");
		
	}
	
}

子类：graduate

public class Graduate extends Student{
	//模拟大学生开始情况
	
	public void testing() {
		System.out.println("大学生 "+name+"正在考大学数学...");
		
	}
	
}

测试类：

public class Extends01 {

	public static void main(String[] args) {

        Pubil stu1 = new Pubil();
		stu1.age = 10;
		stu1.name = "xiaoming";
		stu1.setScore(89);
		stu1.testing();
		stu1.showInfo();

		System.out.println("==========================");

		Graduate stu2 = new Graduate();
		stu2.age = 20;
		stu2.name = "liming";
		stu2.setScore(60);
		stu2.testing();
		stu2.showInfo();

	}

}

测试结果：

小学生 xiaoming正在考小学数学...
学生名：xiaoming年龄：10成绩：89.0
==========================
大学生 liming正在考大学数学...
学生名：liming年龄：20成绩：60.0

继承注意事项

（1）子类继承了所有父类的属性和方法，但是私有的属性和方法不能在子类当中直接访问，需要通过公共的方法来进行访问。

例如：

父类base

public class Base{


    public int n1 = 100;
	protected int n2 = 200;
	int n3 = 300;
	private int n4 = 400;
    
    //无参构造器
	public Base() {
         System.out.println("Base()被调用...");
	}


    public void test100() {
		System.out.println("test100");
	}
	protected void test200() {
		System.out.println("test200");
	}
	void test300() {
		System.out.println("test300");
	}
	private void test400() {
		System.out.println("test400");
	}


    //调n4
	public int setN4() {
		System.out.println(n4);
		return n4;
	}

    //调test400
	public void callTest400() {
		test400();
	}


}

子类：sub

public class Sub extends Base {


       //无参构造器
	   public Sub() {
           System.out.println("Sub()被调用...");
	   }

     public void sayOk() {
		
		//报错The field Base.n4 is not visible
		//System.out.println(n1+n2+n3+n4);
		System.out.println(n1+" "+n2+" "+n3);
		test100();
		test200();
		test300();
		//报错：The method test400() from the type Base is not visible
		//test400();


        //如何调用n4 test400?
		//通过公共方法调用
		setN4();
		callTest400();

     }

}

输出结果：

base()构造器被调用...
sub()被调用...
100 200 300
test100
test200
test300
400
test400

（2）子类必须调用父类的构造器完成父类的初始化。

这里就是我们上述代码当中，我们在父类和子类创建的构造器，从输出结果来看，我们可以发现，先完成父类的调用，再完成子类的调用。

（3）当创建子类对象时，不管使用子类的哪一个构造器，默认情况下，总会调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪一个构造器来完成对父类的初始化工作，否则，编译不会通过。

（4）如果需要指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)。

//子类sub
public class Sub extends Base {
	
	//无参构造器
	public Sub() {
		//这里隐藏了
		//当父类没有无参构造器的时候，就必须使用super（）；否则会报错
		//报错：Implicit super constructor Base() is undefined. Must explicitly invoke another constructor
	    //如要调用父类的无参构造器可以什么都不写，也可以写super();
	//	super();
		
		System.out.println("sub()被调用...");
	}
	
	public Sub(String name) {
		//如果要调用父类的某一个有参构造器，那么super();括号里写入，传入的参数即可
		super("xiaoming",12);
		System.out.println("Sub(String name)构造器被调用...");
	}


}

//base为Sub的父类
public class Base{

    //无参构造器
	public Base() {
		System.out.println("base()构造器被调用...");
	}
	//有（一个）参构造器
	public Base(String name) {
		System.out.println("Base(String name)构造器被调用...");
	}
	//有（两个）参构造器
	public Base(String name,int age) {
		System.out.println("Base(String name,int age)构造器被调用...");
	}
}

（5）super在使用的时候，需要放在构造器的第一行。

（6）super（）和this（）都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器当中。

（7）Java所以得类都是Object类的子类，Object是所有类的基类。

（8）父类构造器的调用不限于直接父类，将一直向上追溯到Object类。

public class Test {

	public static void main(String[] args) {
		Sub sub = new Sub();

	}

}
class Topbase {

	public Topbase() {
		System.out.println("Topbase()构造器被调用");
	}

}

class Base extends Topbase{
    //无参构造器
	public Base() {
		System.out.println("base()构造器被调用...");
	}
}

class Sub extends Base {
	
	//无参构造器
	public Sub() {
        System.out.println("sub()被调用...");
	}
}

通过上述这段代码，程序的运行是我们先new一个对象，当我们找到Sub之后，会去找sub的父类base当我们进入base时，又会找base的父类，Topbase，然后不断地调用构造器依次进行。

Topbase()构造器被调用
base()构造器被调用...
sub()被调用...

（9）子类最多只能继承一个父类（指直接继承），即Java中是单继承机制。

如果需要继承多个如：A类要继承B类和C类，只能将B或者是C类当中的一个成为A的直接父类，然后将两者剩下的那一个成为另外一个的直接父类，这样A类便可以调用B和C的方法和属性。

（10）不能滥用继承，子类和父类之间必须满足is-a的逻辑关系。

例如：猫——动物、小学同学——学生等

继承在内存的分布

public class PracticeQuestion {

	public static void main(String[] args) {
		
		Son son = new Son();
		//查找顺序
		//当我们创建一个子类对象的时候
		//首先我们需要查看子类是否含有这个属性，并且可以直接访问，则直接返回信息
		//如果子类没有，那么就向上查找，查看其父类是否含有该属性，
		//如果有，并且可以直接访问，那么就返回该父类的这个信息
		//如果该父类没有该属性，那么就接着向上查找，该父类的父类是否有该属性，
		//如果有而且可以直接访问，那么就返回这个信息
		//如果没有，就接着向上，知道Object类
		System.out.println(son.name);
		System.out.println(son.hobby);
		System.out.println(son.age);
	}

}

class GrandPa {
	String name = "胡爷爷";
	String hobby = "旅游";
	int age = 60;
}

class Father extends GrandPa{
	String name = "小头爸爸";
	int age = 35;
}
class Son extends Father{
	String name = "大头儿子";
}

大头儿子
旅游
35

如有错误，还望指正。