8.1面向对象继承性

8.1.1继承的引出

提高程序代码的可重用性

8.1.2类继承定义

继承性是指扩充一个已有的的功能，基本语法。

class 子类extends 父类{}

在继承结构中，很多情况下会把子类称为派生类，把父类称为超类（SupperClass）。
范例：继承基本实现

public class Person {
       private String name;
       private int age;
       public void setNane(String name) {
    	   this.name=name;
       }
       public String getName() {
    	   return name;
       }
       public void setAge(int age) {
    	   this.age=age;
       }
       public int getAge() {
    	   return age;
       }
       public Person(){}
       public Person(String name,int age) {
    	   this.name=name;
    	   this.age=age;
       }
}
----------------------------------------------------------
public class Student extends Person {
       //在子类中定义任何构造
}

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

public class JavaDemo01 {
       public static void main(String[] args) {
		Student stu=new Student();
		stu.setNane("张三");
		stu.setAge(22);
		System.out.println("姓名："+stu.getName()+"  年龄："+stu.getAge());
	}
}

姓名：张三  年龄：22

子类可以继续重用父类中定义的属性和方法，同时可以根据子类功能的需要进行结构扩充。所以子类往往要比父类描述的范围更小。
范例：在子类的中扩充父类的功能

public class Person {
       private String name;
       private int age;
       public void setNane(String name) {
    	   this.name=name;
       }
       public String getName() {
    	   return name;
       }
       public void setAge(int age) {
    	   this.age=age;
       }
       public int getAge() {
    	   return age;
       }
       public Person(){}
       public Person(String name,int age) {
    	   this.name=name;
    	   this.age=age;
       }
}

-------------------------------------------
public class Student extends Person {
       private String school;//扩充属性
       public void setSchool(String school) {  //扩充的方法
    	   this.school=school;
       }
       public String getSchool() {
    	   return this.school;
       }
       
}
-----------------------------------------------------------
public class JavaDemo01 {
       public static void main(String[] args) {
		Student stu=new Student();
		stu.setNane("张三");
		stu.setAge(22);
		stu.setSchool("西安文理学院");
		System.out.println("姓名："+stu.getName()+"  年龄："+stu.getAge()+"  学校："+stu.getSchool());
	}
}

姓名：张三  年龄：22  学校：西安文理学院

8.1.3子类对象实例化流程

进行子类对象实例化之前往往会默认调用父类中的无参构造方法，为父类对象实例化（属性初始化）而后再进行子类构造调用，为子类对象实例化（属性初始化）
范例：子类对象实例化，观察无参构造调用

public class Extends162a {
	  public Extends162a() {    //父类无参构造
		  System.out.println("【父类】调用父类构造实例化对象");
	  }
}

public class Extends162b extends Extends162a{
	public Extends162b() {
		System.out.println("【子类】调用子类构造实例化对象");
	}
}

public class Extends162c {
     public static void main(String[] args) {
    	 Extends162b a=new Extends162b();     //实例化子类对象
    	 
	}
}

【父类】调用父类构造实例化对象
【子类】调用子类构造实例化对象

本程序在实例化子类时只调用了子类构造，而通过执行结果可以发现，父类构造会被默认调用，执行完毕才会调用子类构造，结论：子类对象实例化前一定会实例化父类对象，实际上这个时候就相当于子类的构造方法里面隐含了一个super()的形式。
范例：观察子类构造
子类中的super（）作用表示在子类中明确调用父类的无参构造，如果不写也默认会调用父类构造，对于super（）构造调用的语句只能够在子类的构造方法中定义，并且放在子类构造的首行。
如果父类没有提供无参构造方法时，可以通过“ super（参数,…） ”的形式调用指定参数的构造方法。
范例：明确调用父类指定构造方法

public class Person {
       private String name;
       private int age;
       public void setNane(String name) {
    	   this.name=name;
       }
       public String getName() {
    	   return name;
       }
       public void setAge(int age) {
    	   this.age=age;
       }
       public int getAge() {
    	   return age;
       }
       public Person(){}
       public Person(String name,int age) {
    	   this.name=name;
    	   this.age=age;
       }
}

public class Student extends Person {
       private String school;//扩充属性
       public void setSchool(String school) {  //扩充的方法
    	   this.school=school;
       }
       public String getSchool() {
    	   return this.school;
       }
       public Student(String name,int age,String school){
    	   super(name,age);
    	   this.school=school;
       }
       
}

public class JavaDemo01 {
       public static void main(String[] args) {
		Student stu=new Student("李四",21,"北京大学");
		System.out.println(stu);
		}
		}

本程序父类不在明确提供无参构造方法，这样在子类构造方法中就必须通过super（）明确指明要调用的父类构造，并且该语句必须放在子类构造方法的首行。
提问：有没有不让子类去调用父类构造的可能性
回答：没有