继承

面向对象三大特征之继承：第一层含义简单来说可以表达为 “不劳而获” ： 子类可以通过继承机制，不写任何额外的代码就可以拥有父类的“所有”成员。
第二层含义是指类型之间 “ is a” 的关系（从属或者说继承关系），就是一种类型（类） 继承 另一种类型（类）
被继承的类称之为父类（基类或超类），继承其他类的类称之为子类（派生类）
**继承的语法：**class 子类名 extends 父类名｛｝

    public class Demo1 {

      public static void main(String[] args) {

        //类型之间 “is a” 的关系
        // 一个学生 是 一个人
        // 一个子类类型的对象 看作是  一个父类类型的对象
        Human human = new Student();

        //没有继承之前，创建什么类型的对象，就用什么类型的引用变量来接收这个对象
        Human human1 = new Human();

	//测试子类继承了父类中的私有成员
        Student student = new Student();
        student.study();

      }

    }

    // 父类， 基类，超类
    class Father {}

    // Son 子类 派生类 导出类
    class Son extends Father {}

	 class Human {

      //姓名属性
      String name;

      //父类中定义的私有成员
      private int fatherPrivate = 800;

      public void eat() {
        System.out.println(name + "eating");
      }

      public void sleep() {
        System.out.println(name + "sleeping");
      }

      public void testAccessPrivateValue() {
        System.out.println(fatherPrivate);
      }
    }
    //         is a
    // 一个学生 是 一个人
    class Student extends Human {

      //学号属性
      int sno;

      public void study() {
        //System.out.println(name + "learning");
        //子类中能否访问到父类的私有成员呢?
        //System.out.println(fatherPrivate);
        testAccessPrivateValue();
      }
    }

继承的优点： 1、代码复用（方法、类）
2、提高了代码的可维护性
不用重复定义类中成员，继承机制保证父类中的成员子类会继承下来，所在类中就不会出现冗余代码，代码只需要一份即可，子类复用。
3、弱化了Java中的类型约束《多态实现的前提》

    public class Demo1Benefit {

      public static void main(String[] args) {

        //在学习继承之前
        //Human human = new Human();
        //human = new Teacher();
        //
        但是在有了继承之后
        //human = new Student();
        //
         java语言的原有的类型约束
        Demo1Benefit benefit = new Student();
        //Demo1Benefit benefit = new Demo1Benefit();

        //如何理解，父类引用，指向子类实例，但是，我们却不能通过父类引用，访问到子类中自己定义的成员？
        // 1. 要想访问，堆上的数据，必须要通过一个"中间人"即引用变量
        // 2. 也就是说，总是通过引用变量，间接访问堆上的数据，做一个类比，就好像我们要操作电视机，
        //     我们人不可能直接给, 电视机发信号，我们都是通过遥控器，来间接的操作电视机
        // 3. 也就是说，遥控器提供什么功能，我们通过遥控器，就只能使用遥控器提供的功能，来操作电视机

        Human human = new Student();
        // 通过父类引用，可以访问到父类中定义的成员
        System.out.println(human.name);
        human.eat();
        human.sleep();

        //通过 父类引用访问不到，子类中自己定义的成员
        //System.out.println(human.sno);
        //human.study();

        Student student = new Student();

      }

    }

    class Human {

      //姓名属性
      String name;

      public void eat() {
        System.out.println(name + "eating");
      }

      public void sleep() {
        System.out.println(name + "sleeping");
      }
    }
    //         is a
    // 一个学生 是 一个人
    class Student extends Human {

      //学号属性
      int sno;

      public void study() {
        System.out.println(name + "learning");
      }
    }

    class Teacher extends Human {}





继承的缺点：父类的修改可能会出现在所有子类中（我们无法选择这些修改可以反映在那些子类中，不可以反映在那些子类中）



    public class Demo2Flaw {

    }

    class BaseDuck {

      // 鸭子呱呱叫的行为
      public void quack() {
        System.out.println("quack");
      }

      public void swim() {
        System.out.println("swim");
      }

      //飞行的方法
      public void fly() {
        System.out.println("fly");
      }
    }

    class FirstDuck extends BaseDuck {

    }

    class SecondDuck extends BaseDuck {

    }

    /*
        一种用橡皮材质模拟的鸭子，但我们的产品经理认为，模型鸭，不应该具有飞行的功能
     */
    class ModelDuck extends BaseDuck {

    }

Java继承的特点：在Java中只能实现单重继承，但一个类可以被多个类继承（儿子只可以有一个父亲，但父亲可以有多个儿子），反映出来就是一个extends关键字之后只能有一个类名

    public class Demo1 {

      public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.grandI);
        System.out.println(son.fatherI);
      }
    }

    class A {
      int i;
      public void a() {

      }
    }

    class C {

      double j;

      public void c() {

      }
    }
    // 一个类定义时，extends关键字之后，只能有一个类名
    //class B extends A, C {}

    class B extends A {}

    class GrandFather {

      int grandI;

      public void testGrand() {
        System.out.println("testGrand");
      }
    }

    class Father extends GrandFather {
      int fatherI;

      public void testFather() {
        System.out.println("testFather");
      }
    }

    class Son extends Father {

    }

继承的注意事项：1、子类只能访问父类中所有的非私有成员
2、子类不能继承父类的构造方法（父类中的构造方法不会被子类继承）