继承

继承：

1，提高代码复用性，
2，类与类之间产生了关系，就产生多态特性。

注意：千万不要为了获取其他类的功能而代码继承。必须类与类之间所属关系才可以继承。

java类只能单继承不能多继承，防止隐患，但是接口可以实现多继承。
查阅父类功能，创建子类对象使用功能。

类中的成员：
变量、函数、构造函数。

1，变量：如果子类中出现私有的同名成员变量时，
子类要访问本类的变量，用this。
子类访问父类中的同名变量，用super。

super的使用和this使用几乎相同。
this代表的是本类对象的引用。
super代表父类的对象。

2，子父类中的函数。
覆盖（重写）：
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
静态只能覆盖静态，静态不能覆盖非静态。

重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。 保留原有功能在其进行功能的扩展。

3，子父类的构造函数

为何子类一定要访问父类中的构造函数呢？
 因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要看父类如何对数据进行初始化。
 所以子类在对象初始化时，要先访问一下父类的构造函数。
 如果要访问父类中指定的构造函数，通过手动定义super()语句方式来指定。
注意：super语句一定定义在子类构造函数第一行。

构造函数中要么有this(),要么有super();

子类的实例化过程。
结论：
子类所有的构造函数，默认都会访问父类空参数构造函数。
因为子类的构造函数默认第一行有一条隐式的语句 super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式指定访问父类中的构造函数。
子类的构造函数第一行 可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。

隐式构造函数执行结果
class Fu{
 Fu(){
  System.out.println("fu");
 }
 Fu(int x){ 
 }
}
class Zi extends Fu{
 Zi(){
  
  //super();父类隐式引用
  System.out.println("zi");
 }
 Zi(int x){
  //super();父类隐式引用
  System.out.println("zi..."+x);
 }
}
public class ZiFuExtends {
 public static void main(String[] args) {
  
  Zi z=new Zi();   //fu zi
  Zi z1=new Zi(1);  //fu  zi...4
 }
}
-----------------------------------
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式指定访问父类中的构造
class Fu{
 
 Fu(int x){
 }
}
class Zi extends Fu{
 
 Zi(){
  super(5);  //手动指定super(5);
  System.out.println("zi...");
 }
}
public class ZiFuExtends {
 public static void main(String[] args) {
  
  Zi z1=new Zi();   //zi....
 }
}
----------------------------------------------------
子类的构造函数第一行 可以手动指定this语句来访问本类中的构造函数:
class Fu{
 
 Fu(){
  System.out.println("fu....");
 }
 Fu(int x){
  System.out.println("fu.."+x);
 }
}
class Zi extends Fu{
 
 Zi(){
  
  this(4);//super();  //手动指定本类的构造函数this();
  System.out.println("zi...");
 }
 Zi(int x){
  //super();
  System.out.println("zi.....");
 }
}
public class ZiFuExtends {
 public static void main(String[] args) {
  
  Zi z1=new Zi();
  //fu.... zi... zi.....
 }
}