多态、抽象类、接口

一、多态

1. 多态概述：某一个事物，在不同时刻表现出来的不同状态。
2. 多态前提：要有继承关系、要有方法重写、要有父类引用指向子类对象。
3. 多态中的成员访问特点：
   (1)成员变量：编译看左边，运行看左边
   (2)构造方法：创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化
   (3)成员方法：编译看左边，运行看右边
   (4)静态方法：编译看左边，运行看左边
4. 多态的好处：提高了代码的维护性、扩展性
5. 多态的弊端：不能访问子类特有的功能，可以通过向下转型来解决

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

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

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

public class MyTest {
    public static void main(String[] args) {
        Animal an=new Cat();
        an.eat();
        ((Cat) an).CatchMouse();

        Animal bn=new Dog();
        bn.eat();
        ((Dog) bn).lookDoor();
    }
}

二、抽象类

1. 抽象类的概述：在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
2. 抽象类特点

• 抽象类和抽象方法必须用abstract关键字修饰
  抽象类格式: abstract class 类名 {}
  抽象方法格式: public abstract void eat();
• 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
• 抽象类中可以有构造方法,抽象类不能进行实例化
• 象类不能直接实例化，按照多态的方式，由具体的子类实例化

3. 抽象类的成员特点
   (1)成员变量：既可以是变量，也可以是常量
   (2)构造方法：有。用于子类访问父类数据的初始化
   (3)成员方法：既可以是抽象的，也可以是非抽象的

public abstract class Animal {
    public String name;
    public int age;
    public abstract void eat();
}
class Dog extends Animal{

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

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

public class MyTest {
    public static void main(String[] args) {
      Animal an=new Dog();
      an.name="小狗";
      an.age=3;
        System.out.println(an.name+"===="+an.age);
      an.eat();
        ((Dog) an).lookDoor();

      Animal bn=new Cat();
      bn.name="小猫";
      bn.age=1;
        System.out.println(bn.name+"==="+bn.age);
      bn.eat();
        ((Cat) bn).CatchMouse();
    }
}

三、接口

1. 接口概述：为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现
2. 接口特点：
   (1)接口用关键字interface表示
   (2)类实现接口用implements表示
   (3)接口通过多态的方式来实例化
3. 接口成员特点
   • 成员变量：只能是常量，并且是静态的
     默认修饰符public static final
   • 构造方法：接口没有构造方法
   • 成员方法：只能是抽象方法
     默认修饰符public abstract

public abstract class Animal {
    public String name;
    public int age;

    public abstract void eat();

    public abstract void sleep();
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

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

public interface JumpInterface {
    void jump();
}

public class BigDog extends Dog implements JumpInterface{

    @Override
    public void jump() {
        System.out.println("学会了跳高");
    }
}

public class MyTest {
    public static void main(String[] args) {
        Animal a=new Dog();
        a.name="小白";
        a.age=1;
        System.out.println(a.name+"==="+a.age);
        a.eat();
        a.sleep();

        Animal b=new BigDog();
        b.name="小黑";
        b.age=2;
        System.out.println(b.name+"==="+b.age);
        ((BigDog) b).jump();

    }
}

四、类与类,类与接口,接口与接口的关系

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

抽象类和接口的区别

• 抽象类：
  成员变量：可以变量，也可以常量
  构造方法：有
  成员方法：可以抽象，也可以非抽象
• 接口：
  成员变量：只可以常量
  成员方法：只可以抽象