java学习中，多态，抽象类，接口_java抽象类,接口,多态啥意思我是老奶奶-CSDN博客

一、多态

1.1 什么是多态

多态是OOP面向对象编程的第三个特点。表现为：对象多态、行为多态。多态性是允许你将父类引用设置成为一个或更多的他的子对象相等的技术，赋值之后，父类引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。

1.2多态的表示形式

多态的实现通常基于两个前提条件：

继承：子类继承父类，子类可以重写父类的方法。
方法重写：子类提供了父类方法的具体实现。

多态类分两种

第一种: 继承多态. 父类对象名=new 子类();

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }
}

class Cat extends Animal {

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

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

class Test {
    public static void main(String[] args) {
        Animal d = new Dog();
        Animal c = new Cat(); //父类的引入可以指向多个子类的对象。这种现象就是多态。
        d.eat(); //狗吃肉
        c.eat(); //猫吃鱼
    }//父类对象根据赋值的子类对象，而表现出不同的行为。

}

尽管类型为父类Animal但是打印仍然使用子类的方法。

1.3多态的使用

动物园中有一个猫咪需要被喂养，有一个狗需要被喂养，需要一个管理员给动物喂食物。

如果直接在管理类员的方法中直接使用的话。

public class Test {
    public static void main(String[] args) {
        Feeder f=new Feeder();//创建一个饲养员对象
        Dog d=new Dog();
        f.feed(d); //后期:一个类依赖另一个类。

        Cat c=new Cat();
        f.feed(c);
    }
}
class Feeder{//饲养员类
    //喂养狗
    public void feed(Dog d){
        d.eat();
    }
    //喂养猫
    public void feed(Cat c){
        c.eat();
    }

}

每新增一个动物，都需要修改饲养员的代码。饲养员类与新增的物种产生高耦合。可以使用多态来解决这种耦合度。

/**
 * @author ：lyk
 * @date ：Created in 2024/11/22 20:36
 * @description：
 * @modified By：
 * @version:
 */
public class Zoon {
    int age;

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

    public void drink() {
        System.out.println("喝水");
    }
}


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

class Sheep extends Zoon {
    @Override
    public void eat() {
        System.out.println("羊吃草");
    }
}

class Frog extends Zoon {
    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }
}

class Breeder extends Zoon {
    public void breed(Zoon zoon) {
        zoon.eat();
        zoon.drink();
    }
}

class Text1 {
    public static void main(String[] args) {
        Zoon b = new Breeder();
        // 创建饲养员对象
        Breeder breeder = new Breeder();

        // 饲养狗
        Zoon dog = new Dog();
        breeder.breed(dog);

        // 饲养羊
        Zoon sheep = new Sheep();
        breeder.breed(sheep);
        // 饲养青蛙
        Zoon frog = new Frog();
        breeder.breed(frog);
    }
}

这段代码实现了一个简单的模拟饲养动物的系统，在新增一个动物时只需要将其类继承Zoon类，并重写其方法，可以使用Zoon 类型的对象作为Breeder参数，并调用该对象的 eat 和 drink 方法。

二、抽象类

2.1 抽象类的定义方法

public abstract class 类名{
//属性
//普通方法
//抽象方法
}

import zuor.lx11_20.instrument;

public abstract class Instrument {
    public abstract void testPlay();
}

class Piano extends Instrument {
    @Override
    public void testPlay() {
        System.out.println("钢琴演奏");
    }
}

class violin extends Instrument {
    @Override
    public void testPlay() {
        System.out.println("吉他演奏");
    }
}

class InstrumentTest {
    public void showEat(Instrument i) {
        i.testPlay();
    }

    public static void main(String[] args) {
        InstrumentTest it = new InstrumentTest();
        it.showEat(new Piano());
        it.showEat(new violin());

    }
}

2.2抽象类特点

1. 抽象类不能创建对象
2. 抽象类它也有构造方法
3. 抽象类可以有抽象方法和普通方法。
4. 抽象方法所在的类它一定是抽象类。
5. 抽象类要想使用必须被子类继承。子类继承后必须重写抽象类中的重新方法。

三、接口

3.1 接口的概述

接口它是一个特殊的抽象类，因为它里面的方法都是抽象方法属性都是静态static常量final。

接口可以弥补java中单继承的问题。类只允许单继承，单继承存在缺陷。而 java中类可以实现多个接口。可以理解为干爹。

3.2 java中定义接口

public interface 接口名{
静态常量;
抽象方法;
}

public interface fly {
    void fly();

}

3.3 类如何实现接口

public class 类名 implements 接口名,接口名....{

}

public class Aeroplane implements fly {

    @Override
    public void fly() {
        System.out.println("飞机会飞");
    }
}

该类必须把接口中所有的方法重写

3.4 接口和抽象类有什么区别？

相同点: [1]都无法实例化对象 [2]都必须被子类继承或实现

不同点: [1]一个类可以实现多个接口，但是只能继承一个抽象类 [2]抽象类中可以有普通方法，而接口中只能有抽象方法。 [3]抽象类中可以有普通属性，而接口中只有静态常量。 [4]接口没有构造器，而抽象类有构造器