JAVA 多态、抽象类、接口

多态是OOP面向对象编程的第三个特点。表现为：对象多态、行为多态。

多态性是允许你将父类引用设置成为一个或更多的他的子对象相等的技术，赋值之后，父类引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。

简单来说就是：父类对象根据赋值的子类对象，而表现出不同的行为。子类需要将父类中的方法重写。

父类的引入可以指向多个子类的对象。这种现象就是多态。必须存在继承关系

1.2 多态的表示形式

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

第二种: 接口多态接口名对象名=new 接口的实现类();// 接口下方会讲

//创建一个Animal类
public class Animal {

    public void eat(){
        System.out.println("动物吃东西");
    }
}
//创建Cat类并继承Animal类
public class Cat extends Animal {

    @Override//重写符号，可以不用在意
    //重写eat（）方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//创建Dog类并继承Animal类
public class Dog extends Animal{
    @Override
    //重写eat（）方法
    public void eat() {
        System.out.println("狗吃肉");
    }
}

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

1.3.为什么使用多态？

在软件开发过程中，需求常常会发生变化。通过多态，可以在不修改现有代码的基础上，轻松地添加新的功能或行为。多态能够将不同的实现细节隔离开来，使得代码的不同部分相对独立地发展和变化。

例：

动物园召开全作动物大会，需要一个管理员中途给动物喂食物，请完成以下功能

饲养员:喂养动物功能函数

A 有一个猫咪需要被喂养

B 有一个狗儿需要被喂养

C 有一个猪猪需要被喂养

你发现问题了吗?

如果这是动物园里引进了新物种---猫咪。要求饲养员也可以喂养猫咪。

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();
    }

}
//Dog类
class Dog{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
//Cat类
class Cat{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

思考: 每次引进一个新物种，都需要修改饲养员的代码。饲养员类与新增的物种产生高耦合。我们如果要解决这种耦合度。可以使用多态。

public class Test04 {
    //测试
    public static void main(String[] args) {
        Feeder f= new Feeder();//饲养员类
        Dog d=new Dog();//Dog类
        Cat c=new Cat();//Cat类

        f.feed(d);//Dog类继承了Animal类，此时调用feed方法，参数是d，输出d.eat()方法结果
        f.feed(c);//Cat类继承了Animal类，此时调用feed方法，参数是c，输出c.eat()方法结果
    }
}

class Feeder{
    //feed方法
    public void feed(Animal a){
        a.eat();
    }
}

class Animal{
    //Animal类的eat（）方法
    public void eat(){
        System.out.println("动物吃东西");
    }
}

class Dog extends Animal{
    //Dog类的eat（）方法
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

class Cat extends Animal{
    //Cat类的eat（）方法
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

使用多态的前提: 必须有继承关系。必须子类重写父类的方法。

1.4对象向上转型

对象的向上转型: 子类对象会自动转换为父类的对象。

向上转型：⽗类引⽤⼦类对象（⾃动成⽴，缺点是失去调⽤⼦类独有⽅法的能⼒）

父类对象名=new 子类(); //子类会自动向上转型

父类对象名=new 子类(); //子类会自动向上转型

转型后：

能调用哪些方法看等号的左边。 2. 执行哪些方法看等号的右边。

调用父类中的方法，但是按照子类中相同名字的方法中的代码执行（如果子类中没有该方法则按照父类中方法执行，子类继承了父类）。

Dog类代码：

public class Dog extends Animal {
    // eat
    @Override
    public void eat(){
        System.out.println("我是一只狗，我喜欢吃骨头！！！");
    }
    // 看家 watchDoor()
    public  void watchDoor(){
        System.out.println("狗会看门！！！");
    }
}

test类：

Animal animal = new Dog();// 向上转型  注意：1.能调用哪些方法看等号的左边。 2. 执行哪些方法看等号的右边。
 // dog 赋值给Animal
animal.eat();//向上转型后animal当作Animal类型来用，不能调用子类中的方法
animal.watchDoor(); // 报错

向上转型后该对象只能当成父类对象来用，原来子类中定义的属性和方法就被屏蔽掉不能被调用了。比如狗里有一个【看门】的方法，如果向上转型后作为【动物】类就不能调用dog类独有的【看门】的方法。

总结: 向上转型从小的转向大的缺点：不能调用子类里面的特有的方法 .

1.5向下转型

向下转型：⼦类引⽤⽗类对象（强制转换，慎重）（大转小，且需强制转换）

public static void main(String[] args) {
// Dog
Animal a = new Dog();
// ⼦类引⽤⽗类对象
Dog dog1 = (Dog) a;//强制转换
// 向下转型可以调用子类里面方法属性
dog1.watchDoor();
Cat cat = (Cat) a;

}

转换后，此时可以调用子类对象中的方法和属性。

注意事项：

对象向下转型时，容易出现类型转换异常. 转换时使用instanceof判断一下，若无报错可以转换，否则不可以。

语法: 对象名 instanceof 数据类型

向上转型--自动发生---目的就是实现多态特点----缺点:无法调用子类特有的方法。

向下转型--强制转换---目的想调用子类特有的功能---缺点: 出现异常。

下面返回一个Boolean值：true（表示可以转换）。

2.抽象类

看上方图可知，抽象类就是指从众多相同对象中抽象出一个类。就像‘图形’，它只是一个泛指，囊括了所有图形（长方形、正方形、圆形.....），而图形只是一个总称。

例：

People类：中国人、英国人、美国人.....

Animal类：狗、猫、牛、羊......

java中如何定义抽象类。关键字：abstract

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

public class Test02 {
    public static void main(String[] args) {
        //向上转型为Instrument类的对象
        Instrument i=new Piano();
        i.play();
        Instrument i1=new violin();
        i1.play();

    }
}
//创建抽象类：乐器类
public abstract class Instrument{
    //私有化name
    private String name;
    //无参构造方法
    public Instrument() {
    }
    //有参构造方法
    public Instrument(String name) {
        this.name = name;
    }
    //方法play（），不用写详细，只是笼统地有个名字就行，具体执行时，用的时被继承的子类中的代码
    public abstract void play();

}
//继承乐器类Instrument
public class Piano extends Instrument{
    //重写方法play（）
    public void play(){
        System.out.println("手脚并用演奏钢琴");
        }
}
//继承乐器类Instrument
public class violin extends Instrument{
    //重写方法play（）
    public void play(){
        System.out.println("用手演奏");
        }
}

2.2 抽象类特点

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

3.接口---理解为父辈

3.1 接口的概述

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

静态（static）常量（final）

3.2 java为什么使用接口

弥补java中单继承的问题。类只允许单继承，单继承存在缺陷。发明了接口。 java中类可以实现多个接口。

3.3 java中定义接口的语法

public interface 接口名{
//成员--jdk的老版本
静态常量;
抽象方法;
}

public interface Usb {
    public static final String WIDTH="2cm";

    public abstract void usb(); // 接口方法
}

这些成员都有默认的修饰符。以后编写接口成员时可以省略这些修饰符。

public interface Usb {
//    public static final String WIDTH="2cm";
    String WIDTH="2cm";

//    public abstract void usb(); // 接口方法
     void usb(); // 接口方法 通用的修饰符可以省略
}