09.面向对象多态的概述及其代码体现

09.面向对象多态的概述及其代码体现
09.01_面向对象(多态的概述及其代码体现)
- A:多态(polymorphic [,pɒlɪ'mɔːfɪk])概述
  - 事物存在的多种形态
- B:多态前提
  - a:要有继承关系。
  - b:要有方法重写。
  - c:要有父类引用指向子类对象。
- C:案例演示
  - 代码体现多态
    案例：
    class Demo1_Polymorphic {
    public static void main(String[] args) {
    Cat c = new Cat();//猫是一只猫
    c.eat();
    Animal a = new Cat(); //父类引用指向子类对象，猫是一只动物
    a.eat();
    }
    }
    class Animal {
    public void eat() {
    System.out.println("动物吃饭");
    }
    }
    class Cat extends Animal {
    public void eat() {
    System.out.println("猫吃鱼");
    }
    }
09.02_面向对象(多态中的成员访问特点之成员变量)
- 成员变量
  - 编译看左边(父类)，运行看左边(父类)。
    /*
    成员变量
    编译看左边(父类),运行看左边(父类)
    成员方法
    编译看左边(父类)，运行看右边(子类)。动态绑定
    静态方法
    编译看左边(父类)，运行看左边(父类)。
    (静态和类相关，算不上重写，所以，访问还是左边的)
    只有非静态的成员方法,编译看左边,运行看右边
    */
    案例：
    class Demo2_Polymorphic {
    public static void main(String[] args) {
    Father f = new Son(); //父类引用指向子类对象
    System.out.println(f.num); //相当于是Father.method()
    Son s = new Son();
    System.out.println(s.num);
    }
    }
    class Father {
    int num = 10;
    }
    class Son extends Father {
    int num = 20;
    }
09.03_面向对象(多态中的成员访问特点之成员方法)
- 成员方法
  - 编译看左边(父类)，运行看右边(子类)。
    案例：
    class Demo2_Polymorphic {
    public static void main(String[] args) {
    Father f = new Son();
    f.print(); //相当于是Father.method()
    }
    }
    class Father {
    int num = 10;
    public void print() {
    System.out.println("father");
    }
    }
    class Son extends Father {
    int num = 20;
    public void print() {
    System.out.println("son");
    }
    }
09.04_面向对象(多态中的成员访问特点之静态成员方法)
- 静态方法
  - 编译看左边(父类)，运行看左边(父类)。
  - (静态和类相关，算不上重写，所以，访问还是左边的)
  - 只有非静态的成员方法,编译看左边,运行看右边
    案例：
    class Demo2_Polymorphic {
    public static void main(String[] args) {
    Father f = new Son();
    f.method(); //相当于是Father.method()
    }
    }
    class Father {
    int num = 10;
    public static void method() {
    System.out.println("father static method");
    }
    }
    class Son extends Father {
    int num = 20;
    public static void method() {
    System.out.println("son static method");
    }
    }
09.05_面向对象(超人的故事)
- A:案例分析
  - 通过该案例帮助学生理解多态的现象（talkTrade:谈生意）
    案例：
    class Demo3_SuperMan {
    public static void main(String[] args) {
    Person p = new SuperMan(); //父类引用指向子类对象,超人提升为了人
    //父类引用指向子类对象就是向上转型
    System.out.println(p.name);
    p.talkTrade();
    }
    }
    class Person {
    String name = "John";
    public void talkTrade() {
    System.out.println("谈生意");
    }
    }
    class SuperMan extends Person {
    String name = "superMan";
    public void talkTrade() {
    System.out.println("谈几个亿的大单子");
    }
    public void fly() {
    System.out.println("飞出去救人");
    }
    }
09.06_面向对象(多态中向上转型和向下转型)
- A:案例演示
  - 详细讲解多态中向上转型和向下转型
    Person p = new SuperMan();向上转型
    SuperMan sm = (SuperMan)p;向下转型
    案例：
    class Demo3_SuperMan {
    public static void main(String[] args) {
    Person p = new SuperMan(); //父类引用指向子类对象,超人提升为了人
    //父类引用指向子类对象就是向上转型
    System.out.println(p.name);
    p.talkTrade();
    SuperMan sm = (SuperMan)p; //向下转型
    sm.fly();
    /*
    基本数据类型自动类型提升和强制类型转换
    */
    int i = 10;
    byte b = 20;
    //i = b; //自动类型提升
    //b = (byte)i; //强制类型转换
    }
    }
    class Person {
    String name = "John";
    public void talkTrade() {
    System.out.println("谈生意");
    }
    }
    class SuperMan extends Person {
    String name = "superMan";
    public void talkTrade() {
    System.out.println("谈几个亿的大单子");
    }
    public void fly() {
    System.out.println("飞出去救人");
    }
    }
09.07_面向对象(多态的好处和弊端)
- A:多态的好处
  - a:提高了代码的维护性(继承保证)
  - b:提高了代码的扩展性(由多态保证)
- B:案例演示
  - 多态的好处
  - 可以当作形式参数,可以接收任意子类对象
- C:多态的弊端
  - 不能使用子类的特有属性和行为。
- D:案例演示
  案例：
  class Demo4_Animal {
  public static void main(String[] args) {
  //Cat c1 = new Cat();
  //c1.eat();
  method(new Cat());
  method(new Dog());
  //Animal a = new Cat(); 开发的是很少在创建对象的时候用父类引用指向子类对象,直接创建子类对象更方便,可以使用子类中的特有属性和行为
  }
  
  //Cat c = new Dog();狗是一只猫,这是错误的
  /public static void method(Cat c) {
  c.eat();
  }
  public static void method(Dog d) {
  d.eat();
  }/
  
  //如果把狗强转成猫就会出现类型转换异常,ClassCastException
  public static void method(Animal a) { //当作参数的时候用多态最好,因为扩展性强
  //关键字 instanceof 判断前边的引用是否是后边的数据类型
  if (a instanceof Cat) {
  Cat c = (Cat)a;
  c.eat();
  c.catchMouse();
  }else if (a instanceof Dog) {
  Dog d = (Dog)a;
  d.eat();
  d.lookHome();
  }else {
  a.eat();
  }
  }
  }
  class Animal {
  public void eat() {
  System.out.println("动物吃饭");
  }
  }
  class Cat extends Animal {
  public void eat() {
  System.out.println("猫吃鱼");
  }
  public void catchMouse() {
  System.out.println("抓老鼠");
  }
  }
  class Dog extends Animal {
  public void eat() {
  System.out.println("狗吃肉");
  }
  public void lookHome() {
  System.out.println("看家");
  }
  }
09.08_面向对象(多态中的题目分析题)
- A:看下面程序是否有问题，如果没有，说出结果
class Fu {
public void show() {
System.out.println("fu show");
}
}
```
    class Zi extends Fu {
        public void show() {
            System.out.println("zi show");
        }

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

    class Test1Demo {
        public static void main(String[] args) {
            Fu f = new Zi();
            f.method();//编译看左边,左边的父类中没有这个方法,所以编译都通不过
            f.show();
        }
    }
```
- B:看下面程序是否有问题，如果没有，说出结果
- ```
class A {
    public void show() {
        show2();
    }
    public void show2() {
        System.out.println("我");
    }
}
class B extends A {
    public void show2() {
        System.out.println("爱");
    }
}
class C extends B {
    public void show() {
        super.show();
    }
    public void show2() {
        System.out.println("你");
    }
}
public class Test2DuoTai {
    public static void main(String[] args) {
        A a = new B();
        a.show();//爱//父类引用指向子类,但是show方法没有重写,所以不构成多态,只是继承,所以调用父类的show方法,里面还有个
```
  show2方法,show2方法重写了,构成了重写,有了多态,所以要看右边的,所以调用子类的show2方法,而不是父类的show2,所以打印出子类的爱,下同
```
        B b = new C();
        b.show();//你//编译看右边,然后子类的show方法调用父类的show,它从它爷爷那里拿到show方法,里面又有show2方法,同样构成了多态,运行看右边子类,那就是C类中的打印你字
    }
}
```
09.09_面向对象(抽象类的概述及其特点)
- A:抽象类概述,定义一个类是,为了miso
  - 抽象就是看不懂的
- B:抽象类特点
  - a:抽象类和抽象方法必须用abstract关键字修饰
    
    abstract class 类名 {}
    
    public abstract void eat();//当不知道该方法具体是怎么实现的
    //比如动物吃，你知道它吃什么吗？怎么吃？都不知道
  - b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
  - c:抽象类不能实例化那么，抽象类如何实例化呢?
    
    按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  - d:抽象类的子类
    
    要么是抽象类
    
    要么重写抽象类中的所有抽象方法
- C:案例演示
  - 抽象类特点
    案例：
    class Demo1_Abstract {
    public static void main(String[] args) {
    //Animal a = new Animal(); //错误: Animal是抽象的; 无法实例化
    Animal a = new Cat(); //父类引用指向子类对象
    a.eat();
    }
    }
    abstract class Animal { //抽象类
    public abstract void eat(); //抽象方法
    public Animal() {
    System.out.println("父类空参构造");
    }
    }
    class Cat extends Animal {
    public Cat() {
    super();
    }
    public void eat() {
    System.out.println("猫吃鱼");
    }
    }
09.10_面向对象(抽象类的成员特点)
- A:抽象类的成员特点
  - a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
  - b:构造方法：有。
    
    用于子类访问父类数据的初始化。
  - c:成员方法：既可以是抽象的，也可以是非抽象的。
- B:案例演示
  - 抽象类的成员特点
- C:抽象类的成员方法特性：
  - a:抽象方法强制要求子类做的事情。
  - b:非抽象方法子类继承的事情，提高代码复用性。
    案例：
    class Demo2_Abstract {
    public static void main(String[] args) {
    System.out.println("Hello World!");
    }
    }
    abstract class Demo {
    int num1 = 10;//变量
    final int num2 = 20;//常量
    public Demo(){}//构造方法
    public void print() {//非抽象方法，子类可以直接使用
    System.out.println("111");
    }
    public abstract void method();//抽象方法，子类必须实现
    }
    class Test extends Demo {
    public void method() {
    System.out.println("111");
    }
    }
09.11_面向对象(葵花宝典)
- 案例演示
  - 抽象类的作用
    class Demo3_葵花宝典 {
    public static void main(String[] args) {
    岳不群小岳子 = new 岳不群();
    小岳子.自宫();
    }
    }
    abstract class 葵花宝典 {
    public abstract void 自宫();
    }
    class 岳不群 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用牙签");
    }
    }
    class 林平之 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用指甲刀");
    }
    }
    class 东方不败 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用锤子,不忍直视");
    }
    }
09.12_面向对象(抽象类练习猫狗案例)
- A:案例演示
  - 具体事物：猫，狗
  - 共性：姓名，年龄，吃饭
  - 猫的特性:抓老鼠
  - 狗的特性:看家
    案例：
    class Test1_Animal {
    public static void main(String[] args) {
    Cat c = new Cat("加菲",8);
    System.out.println(c.getName() + "…" + c.getAge());
    c.eat();
    c.catchMouse();
    Dog d = new Dog("八公",30);
    System.out.println(d.getName() + "…" + d.getAge());
    d.eat();
    d.lookHome();
    }
    }
    abstract class Animal {
    private String name; //姓名
    private int age; //年龄
    public Animal(){} //空参
    public Animal(String name,int age) {//有参
    this.name = name;
    this.age = age;
    }
    public void setName(String name) { //设置姓名
    this.name = name;
    }
    public String getName() { //获取姓名
    return name;
    }
    public void setAge(int age) { //设置年龄
    this.age = age;
    }
    public int getAge() { //获取年龄
    return age;
    }
    public abstract void eat(); //吃饭
    }
    class Cat extends Animal {
    public Cat(){} //空参
    public Cat(String name,int age) {//有参
    super(name,age);
    }
    public void eat() {
    System.out.println("猫吃鱼");
    }
    public void catchMouse() {
    System.out.println("抓老鼠");
    }
    }
    class Dog extends Animal {
    public Dog(){} //空参
    public Dog(String name,int age) {//有参
    super(name,age);
    }
    public void eat() {
    System.out.println("狗吃肉");
    }
    public void lookHome() {
    System.out.println("看家");
    }
    }
09.13_面向对象(抽象类练习老师案例)
- A:案例演示
  - 具体事物：基础班老师，就业班老师
  - 共性：姓名，年龄，讲课。
  - 具体事物:基础班学生,就业班学生
  - 共性:姓名,年龄,学习
    案例：
    class Test2_Teacher {
    public static void main(String[] args) {
    BaseTeacher bt = new BaseTeacher("冯佳",18);
    bt.teach();
    }
    }
    abstract class Teacher {
    private String name; //姓名
    private int age; //年龄
    public Teacher(){} //空参
    public Teacher(String name,int age) {//有参
    this.name = name;
    this.age = age;
    }
    public void setName(String name) { //设置姓名
    this.name = name;
    }
    public String getName() { //获取姓名
    return name;
    }
    public void setAge(int age) { //设置年龄
    this.age = age;
    }
    public int getAge() { //获取年龄
    return age;
    }
    public abstract void teach();
    }
    class BaseTeacher extends Teacher {
    public BaseTeacher(){} //空参
    public BaseTeacher(String name,int age) {//有参
    super(name,age);
    }
    public void teach() {
    System.out.println("我的姓名是:" + this.getName() + ",我的年龄是:" + this.getAge() + ",讲的内容是java基础");
    }
    }
    容易出错的地方:声明的方法名忘记修改,参数列表忘记修改,方法体中变量忘记修改,调用方法忘记加()
09.14_面向对象(抽象类练习员工案例)
- A:案例演示
  - 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
  - 经理，除了含有程序员的属性外，另为还有一个奖金属性。
  - 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。
    案例：
    class Test3_Employee {
    public static void main(String[] args) {
    Coder c = new Coder("德玛西亚","007",8000);
    c.work();
    Manager m = new Manager("苍老师","9527",3000,20000);
    m.work();
    }
    }
    abstract class Employee {
    private String name; //姓名
    private String id; //工号
    private double salary; //工资
    public Employee() {} //空参构造
    public Employee(String name,String id,double salary) {
    this.name = name;
    this.id = id;
    this.salary = salary;
    }
    public void setName(String name) { //设置姓名
    this.name = name;
    }
    public String getName() { //获取姓名
    return name;
    }
    public void setId(String id) { //设置id
    this.id = id;
    }
    public String getId() { //获取id
    return id;
    }
    public void setSalary(double salary) { //设置工资
    this.salary = salary;
    }
    public double getSalary() { //获取工资
    return salary;
    }
    public abstract void work();
    }
    //程序员
    class Coder extends Employee {
    public Coder() {} //空参构造
    public Coder(String name,String id,double salary) {
    super(name,id,salary);
    }
    public void work() {
    System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:"
    + this.getSalary() + ",我的工作内容是敲代码");
    }
    }
    //项目经理
    class Manager extends Employee {
    private int bonus; //奖金
    public Manager() {} //空参构造
    public Manager(String name,String id,double salary,int bonus) {
    super(name,id,salary);
    this.bonus = bonus;
    }
    public void work() {
    System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:"
    + this.getSalary() + ",我的奖金是:" + bonus + ",我的工作内容是管理");
    }
    }
09.15_面向对象(抽象类中的面试题)
- A:面试题1
  - 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
  - 可以
  - 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
- B:面试题2
  - abstract不能和哪些关键字共存
    案例：
    class Demo4_Abstract {
    public static void main(String[] args) {
    System.out.println("Hello World!");
    }
    }
/*
- A:面试题1
  - 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
  - 可以
  - 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
- B:面试题2
  - abstract不能和哪些关键字共存
    abstract和static
    被abstract修饰的方法没有方法体
    被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
    abstract和final
    被abstract修饰的方法强制子类重写
    被final修饰的不让子类重写,所以他俩是矛盾
    abstract和private
    被abstract修饰的是为了让子类看到并强制重写
    被private修饰不让子类访问,所以他俩是矛盾的
    */
abstract class Demo {
//public static abstract void print(); //错误: 非法的修饰符组合: abstract和static
//public final abstract void print(); //错误: 非法的修饰符组合: abstract和final
private abstract void print(); //错误: 非法的修饰符组合: abstract和private
}

09.16_面向对象(接口的概述及其特点)
- A:接口概述,
  - 从狭义的角度讲就是指java中的interface
  - 从广义的角度讲对外提供规则的都是接口
- B:接口特点
  - a:接口用关键字interface表示
    
    interface 接口名 {}
  - b:类实现接口用implements表示
    
    class 类名 implements 接口名 {}
  - c:接口不能实例化
    
    那么，接口如何实例化呢?
    
    按照多态的方式来实例化。
  - d:接口的子类
    
    a:可以是抽象类。但是意义不大。
    
    b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
- C:案例演示
  - 接口特点
    案例：
    class Demo1_Interface {
    public static void main(String[] args) {
    //Inter i = new Inter(); //接口不能被实例化,因为调用抽象方法没有意义
    Inter i = new Demo(); //父类引用指向子类对象,但是不可以再把i强制类型向下转换,但是在继承中是可以的;
    i.print();
    }
    }
    interface Inter {
    public abstract void print(); //接口中的方法都是抽象的,并且不加{},里面没有任何的代码块;
    }
    class Demo implements Inter {
    public void print() {
    System.out.println("print");
    }
    }
09.17_面向对象(接口的成员特点)
- A:接口成员特点
  - 成员变量只能是常量，(系统会自动改变成常量) 并且是静态的并公共的。
    * 默认修饰符：public static final他们三个没有顺序之分
    * 建议：自己手动给出。
  - 构造方法：接口没有构造方法。(默认继承object)
  - 成员方法：只能是抽象方法。
    * 默认修饰符：public abstract(所以他的子类中重写的方法必须是public)
    * 建议：自己手动给出。
- B:案例演示
  - 接口成员特点
    案例：
    class Demo2_Interface {
    public static void main(String[] args) {
    Demo d = new Demo();
    d.print();
    System.out.println(Inter.num);
    }
    }
    interface Inter {
    public static final int num = 10;
    //public Inter(){} 接口中没有构造方法
    /*public void print() { 接口中不能定义非抽象方法
  }/
  public abstract void print();
  }
  class Demo /extends Object*/ implements Inter { //一个类不写继承任何类,默认继承Object类
  public void print() {
  //num = 20;
  System.out.println(num);
  }
  public Demo() {
  super();
  }
  }
  补充: 错误: 接口方法不能带有主体,,抽象方法也是,错误: 抽象方法不能有主体,即不能有{},
  错误: Coder不是抽象的, 并且未覆盖Skill中的抽象方法skill(),,接口中的方法必须全部重写,
  抽象类中的抽象方法必须重写,其他方法可以不重写
09.18_面向对象(类与类,类与接口,接口与接口的关系)
- A:类与类,类与接口,接口与接口的关系
  - a:类与类：
    
    继承关系,只能单继承,可以多层继承。
  - b:类与接口：
    
    实现关系,可以单实现,也可以多实现。
    
    并且还可以在继承一个类的同时实现多个接口。
  - c:接口与接口：
    
    继承关系,可以单继承,也可以多继承。
- B:案例演示
  - 类与类,类与接口,接口与接口的关系
    案例：
    class Demo3_Interface {
    public static void main(String[] args) {
    System.out.println("Hello World!");
    }
    }
    interface InterA {
    public abstract void printA();
    }
    interface InterB {
    public abstract void printB();
    }
    interface InterC extends InterB,InterA {
    }
    //class Demo implements InterA,implements InterB { //这么做不允许是非法的
    class Demo extends Object implements InterA,InterB {
    public void printA() {
    System.out.println("printA");
    }
    public void printB() {
    System.out.println("printB");
    }
    }
09.19_面向对象(抽象类和接口的区别)
- A:成员区别
  - 抽象类：
    
    成员变量：可以变量，也可以常量
    
    构造方法：有
    
    成员方法：可以抽象，也可以非抽象
  - 接口：
    
    成员变量：只可以常量
    * 无构造方法
    
    成员方法：只可以抽象
- B:关系区别
  - 类与类
    
    继承，单继承,多层继承
  - 类与接口
    
    实现，单实现，多实现
  - 接口与接口
    
    继承，单继承，多继承,多层继承
- C:设计理念区别
  - 抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
  - 接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
    
    对事物本质的抽象用抽象类，对事物功能的扩展用接口
09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)
- A:案例演示
  - 动物类：姓名，年龄，吃饭，睡觉。
  - 猫和狗
  - 动物培训接口：跳高
    案例：
    class Test1_Animal {
    public static void main(String[] args) {
    Cat c = new Cat("加菲",8);
    c.eat();
    c.sleep();
    JumpCat jc = new JumpCat("跳高猫",3);
    jc.eat();
    jc.sleep();
    jc.jump();
    }
    }
    abstract class Animal {
    private String name; //姓名
    private int age; //年龄
    public Animal() {} //空参构造
    public Animal(String name,int age) {//有参构造
    this.name = name;
    this.age = age;
    }
    public void setName(String name) { //设置姓名
    this.name = name;
    }
    public String getName() { //获取姓名
    return name;
    }
    public void setAge(int age) { //设置年龄
    this.age = age;
    }
    public int getAge() { //获取年龄
    return age;
    }
    public abstract void eat(); //吃饭
    public abstract void sleep(); //睡觉
    }
    interface Jumping { //跳高的接口
    public void jump();
    }
    class Cat extends Animal {
    public Cat() {} //空参构造
    public Cat(String name,int age) {//有参构造
    super(name,age);
    }
    public void eat() {
    System.out.println("猫吃鱼");
    }
    public void sleep() {
    System.out.println("侧着睡");
    }
    }
    class JumpCat extends Cat implements Jumping {
    public JumpCat() {} //空参构造
    public JumpCat(String name,int age) {//有参构造
    super(name,age);
    }
    public void jump() {
    System.out.println("猫跳高");
    }
    }
相关阅读:
PAT A1023 Have Fun with Numbers (20) [⼤整数运算高精度]
算法笔记-数学问题-高精-大整数
 PAT A1130 Infix Expression (25) [中序遍历]
PAT A1130 Infix Expression (25分) [二叉树中序遍历中缀表达式]
PAT A1129 Recommendation System (25) [set的应⽤，运算符重载]
PAT A1118 Birds in Forest (25) [并查集]
PAT A1124 Raffle for Weibo Followers (20分) [map vector]
C++ STL
PAT A1121 Damn Single (25) [map set hash]
算法笔记-易错记录
原文地址：https://www.cnblogs.com/itlyh/p/6024676.html

09.面向对象多态的概述及其代码体现

09.01_面向对象(多态的概述及其代码体现)

09.02_面向对象(多态中的成员访问特点之成员变量)

09.03_面向对象(多态中的成员访问特点之成员方法)

09.04_面向对象(多态中的成员访问特点之静态成员方法)

09.05_面向对象(超人的故事)

09.06_面向对象(多态中向上转型和向下转型)

09.07_面向对象(多态的好处和弊端)

09.08_面向对象(多态中的题目分析题)

09.09_面向对象(抽象类的概述及其特点)

09.10_面向对象(抽象类的成员特点)

09.11_面向对象(葵花宝典)

09.12_面向对象(抽象类练习猫狗案例)

09.13_面向对象(抽象类练习老师案例)

09.14_面向对象(抽象类练习员工案例)

09.15_面向对象(抽象类中的面试题)

09.16_面向对象(接口的概述及其特点)

09.17_面向对象(接口的成员特点)

09.18_面向对象(类与类,类与接口,接口与接口的关系)

09.19_面向对象(抽象类和接口的区别)

09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)