JAVA面向对象中的多态以及抽象类和接口-CSDN博客

本文链接：https://blog.csdn.net/hbb3050263247/article/details/120310168

多态

理解：同一个对象拥有多种形态

作用：把不同的数据类型进行统一，让程序拥有超强的可拓展性

实现多态的前提是必须要有继承关系

一、类的多态性

多态性的作用：把不同的数据类型进行统一，让程序具有超强的可拓展性

假设一个人养了猪和鱼

创建相应的类

鱼：

public class Fash {
    public void move(){
        System.out.println("如鱼得水");
    }
}

猪：

public class Ping {
    public void move(){
        System.out.println("人怕出名，猪怕壮");
    }
}

人：

public class Person {
    public void ping(Ping p){
        p.move();
    }
    public void fash(Fash f){
        f.move();
    }
}

测试类：

public class Test1 {
    public static void main(String[] args) {
        Fash f = new Fash();
        Ping p = new Ping();


        Person person = new Person();
        person.fash(f);
        person.ping(p);
    }
}

执行结果：

如鱼得水
人怕出名，猪怕壮

Process finished with exit code 0

我们可以发现，人养了多少种动物，那么对应的person类中就要有相应的方法

而写方法的方法体都是执行move方法，这样开发效率太低，代码量太多。

解决办法：我们可以把鱼和猪归类为动物，则动物也有move方法，我们只需要在person类中声明一个方法调用move方法，让猪和鱼去继承动物这个类即可。

代码实现：

这里我们使用猫和狗作比

public class Cat extends Animal {
    public void eat(){
        System.out.println("猫爱抓老鼠！");
    }
  public void findeat(){
        System.out.println("猫爱睡懒觉");
    }

}

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

public class Person {
    public void feed1(Animal animal){
        animal.eat();
    }

}

public class Test {
    public static void main(String[] args) {
        //把子类的对象赋值给父类型的引用，或者说，父类型的引用指向子类型的对象
        //向上转型:会屏蔽掉子类中特有的方法

        Animal a1 = new Cat();//理解：把猫看成动物
        Animal a2 = new Dog();
        Person p = new Person();
        p.feed1(a1);
        p.feed1(a2);


        //向下转型
        //向下转型可能有风险：java要求必须写强制类型转换
        Cat c = (Cat)a1;
        c.findeat();

结果：

猫爱抓老鼠！
狗喜欢吃骨头
猫爱睡懒觉

这就是类的多态性

二、抽象类

抽象：不存在的

java中的抽象：只声名，不实现

特点：
* 1.抽象类不可以创建对象
* 2.如果类中有抽象方法，那么这个类必须是一个抽象类
* 3.抽象类中可以有抽象方法，也可以有普通的方法
* 4.抽象类的子类必须重写父类的抽象方法,否则子类必须也是抽象类

作用：通过抽象类可以强制的要求子类中必须有哪些方法，起到规范方法的作用。

abstract

实现：abstract修饰的方法是一个抽象方法,抽象方法没有方法体，直接结束

public abstract class Animal {
    //abstract修饰的方法是一个抽象方法,抽象方法没有方法体，直接结束、
    public abstract void eat();
    public abstract void move();

}

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

    @Override
    public void move() {
        System.out.println("猫一般懒得动");
    }
}

package com.study.demo.dt.cx;

public class Test {
    public static void main(String[] args) {

        /**
         * 此时抽象类起到一个规范性的作用
         * 抽象类中定义的抽象方法，子类必须重写这些方法
         */
        Animal a = new Cat();//这里是多态性
        a.eat();
        a.move();


    }
}

结果：

如鱼得水
人怕出名，猪怕壮

三、接口

* 接口：接口实际上是一种特殊的抽象类，接口中所有的方法都是抽象方法，不可以有普通方法
* 接口使用interface声明
* 接口的继承：
* 接口只能由接口继承
* 接口和类只能是实现关系  implements
* 接口同样具有多态性
*
* 接口的优点：
* 类只能单继承，接口可以多实现。
* 通过接口可以把很多不相关的内容进行整合
*
* 接口特点：
* 1.接口中所有的方法都是抽象方法，都是公开的
* 2.接口中所有的变量都是全局静态常量

创建Animal接口和接口的实现类AnimalAImpl

public interface Animal {
    //接口中所有的方法都是抽象方法，所以可以省略abstract
    //接口中所有的内容都是公开的，公共的。

     void getCat();
}

public class AnimalImpl implements Animal {
    @Override
    public void getCat() {
        System.out.println("我想要一只猫！");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        //接口可以多实现
        AnimalImpl animal = new AnimalImpl();
        AnimalImpl2 animalImpl2 = new AnimalImpl2();
        AnimalImpl3 animalImpl3 = new AnimalImpl3();
        animal.getCat();
        animalImpl2.getCat();
        animalImpl3.getCat();

        System.out.println("---------------------------------");
      
        Cat cat = new Cat();
        cat.getCat();
        cat.move();
        cat.eat();
    }
}

结果：

我想要一只猫！
因为猫好可爱
可是猫好懒
---------------------------------
我想要一只猫
猫很懒
动物吃东西很快