java-继承

继承

1. 类，超类，和子类

• 定义子类

  关键字extends表明正在构造的新类派生与一个已存在的类。这个已存在的类称为父类，基类或者超类。新类称为子类，派生类，或者孩子类。

  //父类
  public class People{
       
      public void read(){
       
          System.out.print("read...");
      }
  }
  //子类
  public class Student extends People{
       
      @override
      public void read(){
       
          System.out.print("read books...");
      }
  }
  

• 覆盖方法

  方法覆盖（override）
  在类继承中，子类可以修改从父类继承来的行为，也就是说子类能创建一个与父类方法有不同功能的方法，但具有相同的：名称、 返回类型、 参数列表。
  方法覆盖的原则

  1. 覆盖方法必须和父类中被覆盖方法具有相同的方法名称、输入参数和返回值类型。
  2. 覆盖方法不能使用比父类中被覆盖方法更严格的访问权限。
  3. 覆盖方法不能比父类中被覆盖方法抛出更多的异常

• 子类构造

  首先父类构造方法是绝对不能被子类继承的。子类构造方法调用父类的构造方法重点是：子类构造方法无论如何都要调用父类的构造方法。

  1. 子类构造方法要么调用父类无参构造方法（包括当父类没有构造方法时。系统默认给的无参构造方法），要么调用父类有参构造方法。
  2. 当子类构造方法调用父类无参构造方法，一般都是默认不写的，要写的话就是super（），且要放在构造方法的第一句。当子类构造方法要调用父类有参数的构造方法，那么子类的构造方法中必须要用super（参数）调用父类构造方法，且要放在构造方法的第一句。
  3. 当子类的构造方法是无参构造方法时，必须调用父类无参构造方法。因为系统会自动找父类有没有无参构造方法，如果没有的话系统会报错：说父类没有定义无参构造方法。

  package com.ming.demo1;
  
  public class Employer {
       
  	private String name;
  	private int id;
  	
  	public Employer(String name, int id) {
       
  		super();
  		this.name = name;
  		this.id = id;
  	}
  	
  }
  class Employee extends Employer{
       
  
  	public Employee(String name, int id) {
       
          //子类调用父类构造方法1.调用父类默认的无参构造2.调用父类的有参构造
          //调用无参构造时一般不显示的写出来，要写的话就是super（），且要放在构造方法的第一句。
          //当子类的构造方法是无参构造方法时，必须调用父类无参构造方法。因为系统会自动找父类有没有无参构造方法，如果没有的话系   //统会报错：
  		super(name, id);
  		// TODO Auto-generated constructor stub
  	}
  	
  }
  
  

  //报错信息
  /*
  Implicit super constructor Employer() is undefined for default constructor. Must define an explicit constructor
  */
  // 默认构造函数没有定义隐式的超级构造函数Employer()。必须定义显式构造函数
  

• 继承层次

  继承的层次：继承并不是仅限于一个层次。例如，可以由Manager类派生Executive类。一个公共超类派生出来的所有类的集合被称为继承层次。在继承层次中，从某个特定类到其祖先的路径被称为该类的继承链。如下图：

  

  一个祖先类可以拥有多个子孙继承链。

• 多态

  多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作.

  多态的优点

  1. 消除类型之间的耦合关系
  2. 可替换性
  3. 可扩充性
  4. 接口性
  5. 灵活性
  6. 简化性

  多态存在的三个必要条件

  1. 继承
  2. 重写
  3. 父类引用指向子类对象：Parent p = new Child();

  public class Test {
       
      public static void main(String[] args) {
       
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法
                  
        Animal a = new Cat();  // 向上转型  
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型  
        c.work();        // 调用的是 Cat 的 work
    }  
              
      public static void show(Animal a)  {
       
        a.eat();  
          // 类型判断
          if (a instanceof Cat)  {
         // 猫做的事情 
              Cat c = (Cat)a;  
              c.work();  
          } else if (a instanceof Dog) {
        // 狗做的事情 
              Dog c = (Dog)a;  
              c.work();  
          }  
      }  
  }
   
  abstract class Animal {
         
      abstract void eat();  
  }  
    
  class Cat extends Animal {
         
      public void eat() {
         
          System.out.println("吃鱼");  
      }  
      public void work() {
         
          System.out.println("抓老鼠");  
      }  
  }  
    
  class Dog extends Animal {
         
      public void eat() {
         
          System.out.println("吃骨头");  
      }  
      public void work() {
         
          System.out.println("看家");  
      }  
  }