java 多态和接口

第七章 多态和接口

1、多态

同一个接口(方法)在不同的实例中会有不同的体现；

同一个消息，作用于不同的子类对象，会有不同的表现

在有继承关系的类中，同一个方法(父类中的方法)在不同的子类会有不同的体现

实现方式：通过方法重写

面向对象设计原则：

1、对扩展开放，对修改关闭

2、里氏替换原则：程序中的父类对象，可以用子类对象代替

改进

1、宠物类：

2、不同的子类的eat方法不同

public class Pet {
    private String name;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public Pet(String name) {
        this.name = name;
    }
​
    public void eat(){
    }
}

Cat类：

public class Cat extends Pet {
    public Cat(String name) {
      super(name);
    }
    @Override
    public void eat(){
        System.out.println("小猫咪:"+this.getName()+"吃:小鱼");
    }
}

Dog类：

public class Dog extends Pet {
    public Dog(String name) {
       super(name);
    }
    @Override
    public void eat(){
        System.out.println("小花狗:"+this.getName()+"吃：骨头");
    }
}

Master类：

public class Master {
    private String name;
​
    public Master(String name) {
        this.name = name;
    }
​
    //喂养猫
    public void feed(Pet pet){
        System.out.println("主任:"+name+"喂养：");
        pet.eat();
    }
​
  /*  public void feed(Dog dog){
        System.out.println("主任:"+name+"喂养：");
        dog.eat();
    }*/
}

测试：

    public static void main(String[] args) {
        Master master=new Master("骑士");
        //向上转型：
        Pet cat=new Cat("Tom");
        Pet dog=new Dog("Jack");
        Pet pig=new Pig("佩奇");
        master.feed(cat);
        master.feed(dog);
        master.feed(pig);
   }

2、多态的实现步骤

1、继承关系

2、父类引用指向子类对象(向上转型)

3、子类方法要重写父类方法

Pet pet=new Cat();
pet.eat();
​
Pet pet2=new Dog();
pet2.eat();

向上转型：父类引用指向子类对象，子类对象自动转换成父类对象

向下转型：

将父类对象强制转换成子类对象：

  public static void main(String[] args) {
        //父类引用  =子类（黑白）
        Printer printer1=new BlackWhitePrinter();
        Printer printer2=new ColorPrinter();
        //向下转型：父类--->子类
        BlackWhitePrinter printer= (BlackWhitePrinter) printer1;
        printer.print();
        //转换失败
        ColorPrinter colorPrinter= (ColorPrinter) printer1;
        colorPrinter.print();
}

3、抽象类和抽象方法

抽象类：对一类事物的描述。

抽象方法：无法直接实现的方法，没有方法体的方法；

关键字：abstract

特点：

1、抽象类不能被实例化

2、抽象方法所在的类必须是抽象类

3、抽象类中可以有具体方法、构造方法、静态方法

4、非抽象子类继承父类必须重写父类中的所有的抽象方法

5、抽象方法不能有方法体

6、单继承

实例：

1、重构宠物喂养

2、打印机打印(黑白打印，彩色打印)

打印机抽象类：

public abstract class Printer {
    public abstract void print(String content);
}

黑白打印机：

public class BlackWhitePrinter extends Printer {
    @Override
    public void print(String content) {
        System.out.println("黑白打印"+content);
    }
}

彩色打印：

public class ColorfulPrinter extends Printer {
    @Override
    public void print(String content) {
        System.out.println("彩色打印"+content);
    }
}

测试：

public class Test {
    public void print(Printer printer,String content){
        printer.print(content);
    }
​
    public static void main(String[] args) {
        Test test=new Test();
        Printer printer=new BlackWhitePrinter();
        test.print(printer,"黑白");
        Printer printer1=new ColorfulPrinter();
        test.print(printer1,"彩色");
​
    }
}

 

4、接口

接口：规定了一系列要实现的标准，要求(方法)

程序中的接口：对一系列方法的抽象，对要实现的方法的约束，规定，本身并没有实现方法。

关键字：interface

特点：

1、接口不能实例化、不能有构造方法

2、接口中的方法必须是抽象方法，默认：public abstract

3、接口中的成员默认都是：public static final

4、接口的实现类(子类)，要实现接口中的所有方法；实现：implements

5、子类可以实现多个接口，多实现

6、接口可以继承接口

先继承后实现

接口和抽象类的比较

	抽象类	接口
相同点:	都是作为顶层抽象存在	都是作为顶层抽象存在
	可以被继承	可以被实现
	不能被实例化	不能被实例化
不同点：	部分抽象	完全抽象
	对一类事物的描述	对一系列方法的抽象

instanceof

用来判断对象是否是某种类型得实例，或者对象是否兼容某种类型

对象 instanceof 类型