面向对象4

---

一、多态

1.多态的概述

A:多态概述
  某一个事物，在不同时刻表现出来的不同状态。
  举例： Cat c=new Cat();
     Animal a=new Cat();
  猫可以是猫的类型。猫 m = new 猫();
  同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
  a:要有继承关系。
  b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
  c:要有父类引用指向子类对象。
  父 f = new 子();

2.多态的成员访问特点

a:成员变量
  编译看左边，运行看左边。
b:构造方法
  创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
  编译看左边，运行看右边。
d:静态方法
  编译看左边，运行看左边。
  (静态和类相关，算不上重写，所以，访问还是左边的)

3.多态的好处和弊端

多态的好处
  a:提高了代码的维护性(继承保证)
  b:提高了代码的扩展性(由多态保证)
多态的弊端
  a:不能使用子类特有的功能

4.向上转型和向下转型

  多态就是向上转型。
  多态的形式，不能直接调用子类特有的功能
  如果你要调用子类特有的方法，你可以向下转型，你可以把父类引用，转换成子类对象

public class MyTest {
    public static void main(String[] args) {
        Animal an = new Cat();  //多态就是向上转型。
        an.eat();
        System.out.println(an.num);//
        //多态的形式，不能直接调用子类特有的功能
        //an.catchMouse();
        //如果你要调用子类特有的方法，你可以向下转型，你可以把父类引用，转换成子类对象
        Cat cat = (Cat) an; //向下转型。
        cat.catchMouse();
        an = new Dog();
        Dog dog = (Dog) an;
        dog.lookDoor();
    }
}
class Animal {
    int num = 20;

    public void eat() {
        System.out.println("吃饭");
    }
}

class Cat extends Animal {
    int num = 500;
    int age = 2;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

class Dog extends Animal {
    int num = 900;
    int age = 800;

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }

}

5.多态内存图

二、抽象类

1.抽象类的概述

A:抽象类概述
  在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
  a:抽象类和抽象方法必须用abstract关键字修饰
  抽象类格式: abstract class 类名 {}
  抽象方法格式: public abstract void eat();
  b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
  c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
  用于子类访问父类数据时的初始化
  d:抽象类不能直接实例化那么，抽象类如何实例化呢?
  按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  e:抽象类的子类
  要么是抽象类
  要么重写抽象类中的所有抽象方法

2.抽象类的成员特点

A:抽象类的成员特点
  a:成员变量：既可以是变量，也可以是常量。
  b:构造方法：有。用于子类访问父类数据的初始化。
  c:成员方法：既可以是抽象的，也可以是非抽象的。
B:抽象类的成员方法特性：
  a:抽象方法 强制要求子类做的事情。
  b:非抽象方法 子类继承的事情，提高代码复用性。

三、接口

1.接口的概述特点

A:接口概述
  为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现
B:接口特点
  a:接口用关键字interface表示 格式: interface 接口名 {}
  b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
  c:接口不能实例化
  那么，接口如何实例化呢?
  按照多态的方式来实例化。
  d:接口的子类
    a:可以是抽象类。但是意义不大。
    b:可以是具体类。要重写接口中的所有抽象方法。

2.接口的成员特点

A:接口成员特点
  成员变量；只能是常量，并且是静态的。默认修饰符：public static final
  建议：自己手动给出。
  构造方法：接口没有构造方法。
  成员方法：只能是抽象方法。默认修饰符：public abstract
  建议：自己手动给出。

3.类与类,类与接口,接口与接口的关系

A:类与类,类与接口,接口与接口的关系
 a:类与类：
  继承关系,只能单继承,可以多层继承。
 b:类与接口：
  实现关系,可以单实现,也可以多实现。
  并且还可以在继承一个类的同时实现多个接口。
 c:接口与接口：
  继承关系,可以单继承,也可以多继承。

4.抽象类与接口的区别

A:成员区别
 抽象类：
  成员变量：可以变量，也可以常量
  构造方法：有
  成员方法：可以抽象，也可以非抽象
 接口：
  成员变量：只可以常量
  成员方法：只可以抽象
B:关系区别
 类与类
  继承，单继承
 类与接口
  实现，单实现，多实现
 接口与接口
  继承，单继承，多继承
C:设计理念区别
  抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
  接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。