15.Java 面向对象多态性

1. 多态性
2. instanceof 关键字
3. 抽象类的应用
4. 接口的应用

多态

1. 多态性的体现
   • 方法的重载和重写
   • 对象的多态性
2. 对象的多态性
   • 向上转型 : 程序会自动完成
     • 父类 父类对象 = 子类实例
   • 向下转型 : 强制类型转换
     • 子类 子类对象 = （子类）父类实例

对象的多态性

向上转型

class A{
    public void tell1(){
        System.out.println("A--tell1");
    }
    public void tell2(){
        System.out.println("A--tell2");
    }
}
class B extends A{
    public void tell1(){
        System.out.println("B--tell1");
    }
    public void tell3(){
        System.out.println("B--tell3");
    }
}

public class PolDemo01{
    public static void mian(String[] args){
        //向上转型
        B b = new B();
        A a = b;
        //A a = new B();
        a.tell1();//重写的，调用的是 B 复写的方法
        a.tell2();
    }
}

实现效果：

B--tell1
A--tell2

向下转型

向下转型必须先发生想上转型，再发生向下转型

class A{
    public void tell1(){
        System.out.println("A--tell1");
    }
    public void tell2(){
        System.out.println("A--tell2");
    }
}
class B extends A{
    public void tell1(){
        System.out.println("B--tell1");
    }
    public void tell3(){
        System.out.println("B--tell3");
    }
}

public class PolDemo02{
    public static void mian(String[] args){
        A a = new B();//向上转型
        B b = (B)a;//向下转型
        b.tell1();
        b.tell2();
        b.tell3();
    }
}

实现效果：

B--tell1
A--tell2
B--tell3

多态性的应用

class A1{
    public void tell1(){
        System.out.println("A--tell1");
    }
}
class B1 extends A1{
    public void tell2(){
        System.out.println("B--tell2");
    }
}
class C1 extends A1{
    public void tell3(){
        System.out.println("C--tell3");
    }
}
public class PolDemo02{
    public static void mian(String[] args){
        //匿名对象调用
        say(new B1());
        say(new C1());
    }
    public static void say(B1 b){
        b.tell1();
    }
    public static void say(C1 c){
        c.tll1();
    }
}

实现效果：

A--tell1

多态性

class A1{
    public void tell1(){
        System.out.println("A--tell1");
    }
}
class B1 extends A1{
    public void tell2(){
        System.out.println("B--tell2");
    }
}
class C1 extends A1{
    public void tell3(){
        System.out.println("C--tell3");
    }
}
class D1 extends A1{

}
public class PolDemo02{
    public static void mian(String[] args){
        //匿名对象调用
        say(new B1());
        say(new C1());
        say(new D1());
    }
    public static void say(A1 a){
        a.tell1();
    }
}

实现效果：

A--tell1

instanceof 关键字

在 java 中可以使用instanceof关键字判断一个对象到底是不是一个类的实例

class A{
    public void tell1(){
        System.out.println("A--tell1");
    }
    public void tell2(){
        System.out.println("A--tell2");
    }
}
class B extends A{
    public void tell1(){
        System.out.println("B--tell1");
    }
    public void tell3(){
        System.out.println("B--tell3");
    }
}

public class PolDemo02{
    public static void mian(String[] args){
        A a = new A();
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);

        A a1 = new B();
        System.out.println(a1 instanceof A);
        System.out.println(a1 instanceof B);
    }
}

实现效果

true//a 是一个 A
false//a 不是一个 B
true//a1 是一个 A
true//a1 是一个 B

抽象类的应用

抽象类由abstract修饰

abstract class Person{
    private int age;
    private String name;
    //构造方法，和类名相同的方法，用于初始化
    public Person(int age,String name){
        this.age = age;
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public int setAge(){
        this.age = age;
    }
    public int getName(){
        return name;
    }
    public int setName(){
        this.name = name;
    }
    public abstract void want(); //一个未实现的方法，抽象方法
}

class Student extends Person{
    private int score;
    public int getScore(){
        return score;
    }
    public int setScore(){
        this.score = score;
    }
  
    //构造方法
    public Student(int age, String name, int score){
        super(age,name);
        this.score = score;
    }
  
    //需要复写父类中的抽象方法
    public void want(){
        System.out.println("姓名："+getName()+"年龄："+getAge()+"成绩："+getScore());
    }
}
class Worker extends Person{
    private int moneny;
    public int getScore(){
        return moneny;
    }
  
    public int setMoney(){
        this.money = money;
    }
  
    //构造方法
    public Student(int age, String name, int money){
        super(age,name);
        this.money = money;
    }
  
    //需要复写父类中的抽象方法
    public void want(){
        System.out.println("姓名："+getName()+"年龄："+getAge()+"工资："+getMoney());
    }
}
public class AbsDemo01{
    public static void mian(String[] args){
        Student stu = new Student(10, "小明", 99);
        stu.want();
        Worker wor = new Worker(35, "老王", 5000);
        wor.want();
    }
}

类用** class **修饰，后面没有括号
方法后面有括号

接口的使用

interface USB{
    void start();
    void stop();
}
class C{
    public static void work(USB u){
        u.start();
        System.out.println("工作中");
        u.stop();
    }
}
class USBDisk implements USB{
    public void start(){
        System.out.println("U 盘开始工作");
    }
    public void stop(){
        System.out.println("U 盘停止工作");
    }
}
class Printer implements USB{
    public void start(){
        System.out.println("打印机开始工作");
    }
    public void stop(){
        System.out.println("打印机停止工作");
    }
}
public class InterDemo01{
    public static void main(String[] args){
        C.work(new USBDisk());
        C.work(new Printer());
    }
}

实现效果：

U 盘开始工作
工作中
U 盘停止工作
打印机开始工作
工作中
打印机停止工作