多态，抽象类，接口

多态的概述

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

public class MyTest {
    public static void main(String[] args) {
        //继承是多态的前提。
        //多态：指的是某个事物，在某个时刻，所表现出来的不同状态
        //多态的三个必要条件
        //1.要有继承
        //2.要有方法重写，可以没有，但是多态就没有意义
        //3.父类引用指向子类对象
        //Cat cat = new Cat();
        //cat.sleep();
        //cat.eat();
       // Animal anima=new Animal();
        //多态，父类引用指向的是子类对象
        Animal an=new Cat();
        an.sleep();
        an.eat();
        an.show();
    }
}

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

    public void sleep() {
        System.out.println("睡觉");
    }

    public void show() {
        System.out.println("父类中的show方法");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫爱吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫爱白天睡觉");
    }
}

多态中的成员访问特点

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

public class MyTest {
    public static void main(String[] args) {
        //以多态的形式来访问成员变量 使用的还是父类的变量
        //编译看左边，运行也看左边
        Fu fu = new Zi();
        System.out.println(fu.num);
        //多态的形式访问成员方法 编译看左边，运行看右边
        //
        fu.show();
        Fu.hehe();

    }
}

class Fu{

    int num = 100;
    public void show(){
        System.out.println("父类的show方法");
    }
    public static void hehe(){
        System.out.println("父类的静态方法");
    }
}
class Zi extends Fu{
    int num=10;

    @Override
    public void show() {
        System.out.println("子类重写过后的show方法");
    }

    public static void hehe() {
        System.out.println("子类的静态方法");
    }
}

多态的好处和弊端

• 多态的好处
  a:提高了代码的维护性(继承保证)
  b:提高了代码的扩展性(由多态保证)

public class MyTest {
    public static void main(String[] args) {
        //多态的好处，提高了代码的扩展性
        //多态的弊端，不能访问子类独有的功能和属性
        Fu fu = new Zi();
        System.out.println(fu.a);
        //System.out.println(fu.num);
        fu.show();
        //父类引用不能直接访问子类独有的方法
       // fu.test();
        //我们可以向下转型

        Zi zi= (Zi) fu; //向下转型
        System.out.println(zi.num);
        zi.test();

    }
}

class Fu{
    int a=10;
    public void show(){
        System.out.println("父类的show方法");
    }
}

class Zi extends Fu{
    int num=10;
    @Override
    public void show() {
        System.out.println("子类重写了父类的show方法");
    }
    public void test(){
        System.out.println("子类一个特有的方法");
    }
}

• 通过多态的弊端引出问题
  不能使用子类特有的功能
• 解决问题
  把父类的引用强制转换为子类的引用。(向下转型)

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal an=cat; //多态就是向上转型
        an.eat();
        //an.cacheMouse();
        Cat c= (Cat) an; //向下转型
        c.eat();
        c.cacheMouse();

        Dog dog = new Dog();
        an=dog;
        Dog d= (Dog) an; //向下转型
        d.lookDoor();
        an.eat();
       // an=new Tiger();
        Tiger t= (Tiger) an;
        //ClassCastException 类型转换异常
        t.goSwimming();

    }

}

class Animal{

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

class Cat extends Animal{

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

class Dog extends Animal{

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

class Tiger extends Animal{
    @Override
    public void eat() {
        System.out.println("老虎不吃素");
    }
    public void goSwimming(){
        System.out.println("老虎去游泳");
    }

}

抽象类的概述及特点

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

抽象类的成员特点

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

public class MyTest5 {
    public static void main(String[] args) {
        //假如我们在开发一个系统时需要对员工(Employee) 类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
        //经理(Manager) 也是员工，除了含有员工的属性外，另为还有一个奖金(bonus) 属性。
        //然后定义工作的方法.
        //        请使用继承的思想设计出员工类和经理类。
        Person p = new Employee();
        p.name="小张";
        p.num=1;
        p.salary=2000;
        System.out.println(p.name+"=="+p.num+"==="+p.salary);
        p.work();
        System.out.println("--------------------");
        p=new Manager();
        p.name = "老王";
        p.num = 2;
        p.salary = 4000;
        ((Manager) p).bonus=2000;
        System.out.println(p.name+"==="+((Manager) p).bonus+"==="+p.num);
        p.work();
    }
}
 abstract class Person {
    public String name;
    public int num;
    public double salary;
    public abstract void work();
}
class Manager extends Person {
    public double bonus;
    @Override
    public void work() {
        System.out.println("经理管理员工");
    }
}
class Employee extends Person{
    @Override
    public void work() {
        System.out.println("员工敲代码");
    }
}

接口的概述及特点

• 接口的概述：为了体现事物的功能的扩展性，java中就提供了接口来定义这些额外功能，并不给出具体实现，只需要将这些额外功能实现即可。

• 接口特点
  a:接口用关键字interface表示 格式: interface 接口名 {}
  b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
  c:接口不能实例化
  那么，接口如何实例化呢?
  按照多态的方式来实例化。
  d:接口的子类
  a:可以是抽象类。但是意义不大。
  b:可以是具体类。要重写接口中的所有抽象方法。

  接口的成员特点

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

抽象类和接口的区别

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