Java中的继承

1. 继承：

• 作用：代码复用

• 通过extends来实现继承

• 超类/父类：共有的属性和行为

  派生类/子类：特有的属性和行为

• 派生类可以访问派生类的+超类的，但超类不能访问派生类的

• 一个超类可以有多个派生类，但一个派生类只能继承一个超类（单一继承）

• 继承具有传递性

• java规定：构造派生类之前必须先构造超类

  • 在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

    public class SuperDemo {
        public static void main(String[] args) {
            Boo o = new Boo();
        }
    }
    
    class Aoo {
        Aoo() {
            System.out.println("超类构造方法");
        }
    }
    class Boo extends Aoo {
        Boo() {
            super(); // 默认的，调用超类的无参构造方法
            System.out.println("派生类构造方法");
        }
    }
    

  • 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

    注意：super()调用超类构造方法，必须位于派生类构造方法的第一行

    class Coo {
        Coo(int a) {
            System.out.println(a);
        }
    }
    class Doo extends Coo {
        Doo() {
            super(5); // 调用Coo的有参构造方法
            System.out.println("派生类构造方法");
        }
    }
    

2. super：指代当前对象的超类对象

super的用法：

• super.成员变量名-------------------------访问超类的成员变量
• super.方法名()-----------------------------调用超类的方法
• super()---------------------------------------调用超类的构造方法

3. 向上造型：--------------------------------------------代码复用

• 超类型的引用指向派生类的对象

• 能点出来什么，看引用的类型

  何时向上造型：

  • 多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用

    eg: 学生/老师/医生都是输出名字+问好------干的事都一样，

    ​ 就可以将学生/老师/医生统一造型到Person数组中，这样一个for即可-------代码复用

  public class UploadDemo {
      public static void main(String[] args) {
          Aoo o1 = new Aoo();
          o1.a = 1;
          o1.show();
          //o1.b = 2;  // 编译错误
          //o1.test(); // 编译错误，超类不能访问派生类的
  
          Boo o2 = new Boo();
          o2.b = 1;
          o2.test();
          o2.a = 2;  // 正确
          o2.show(); // 正确，派生类可以访问超类的
  
          Aoo o3 = new Boo(); // 向上造型
          o3.a = 1;
          o3.show();
          //o3.b = 2;  // 编译错误
          //o3.test(); // 编译错误，能点出来什么，看引用的类型
      }
  }
  
  class Aoo{
      int a;
      void show(){
      }
  }
  class Boo extends Aoo{
      int b;
      void test(){
      }
  }
  

4. 方法的重写(override/overriding)：重新写、覆盖

• 发生在父子类中，方法名相同，参数列表相同

• 重写方法被调用时，看对象的类型

  class 餐馆 {
      void 做餐() { 做中餐 }
  }
  //1)我还是想做中餐-----------------不需要重写
  class Aoo extends 餐馆 {
  }
  //2)我想改做西餐-------------------需要重写
  class Aoo extends 餐馆 {
      void 做餐() { 做西餐 }
  }
  //3)我想在中餐基础之上加入西餐--------需要重写(先super中餐，再加入西餐)
  class Aoo extends 餐馆 {
      void 做餐() {
          super.做餐();
          做西餐
      }
  }
  

• 重写需遵循"两同两小一大"原则：

  • 两同：

    • 方法名相同
    • 参数列表相同

  • 两小：

    • 派生类方法的返回值类型小于或等于超类方法的

      • void和基本类型时，必须相等

      • 引用类型时，小于或等于

        // 超类大，派生类小
        class Coo{
            void show(){}
            double test() { return 0.0; }
            Student say() { return null; }
            Person sayHi() { return null; }
        }
        class Doo extends Coo{
            //int show() { return 1; } // 编译错误，void时必须相等
            //int test() { return 0; } // 编译错误，基本类型时必须相等
            //Person say() { return null; } // 编译错误，引用类型时必须小于或等于
            Student sayHi() { return null; } // 正确，Student小于Person
        }
        

    • 派生类方法抛出的异常小于或等于超类方法的

  • 一大：

    • 派生类方法的访问权限大于或等于超类方法的

5. 重写与重载的区别：

• 重写：发生在父子类中，方法名相同，参数列表相同
• 重载：发生在同一类中，方法名相同，参数列表不同