java学习笔记18（多态）

概述

extends继承或者implements实现，是多态性的前提
多态：一个对象拥有多种形态，就是对象的多态性

格式与使用

代码当中体现多态性，其实就是一句话，父类引用指向子类对象
格式：
父类名称 对象名=new 子类名称();
接口名称 对象名=new 实现类名称();

public class Fu
{
   public void method()
   {
     System.out.println("fu lei");
   }
}
public class Zi
{
   public void method()
   {
     System.out.println("zi lei");
   }
}
public class Demo01Multi
{
  public static void main(String[] args)
  {
    //左父右子
    Fu obj=new Zi();
    obj.method();
  }
}

成员变量的使用特点

访问对象的两种方式：
1 直接通过对象名称访问成员变量，看到等号左边是谁，优先用谁，没有则向上找
2 间接通过成员变量访问，看属于谁就用谁，没有则向上查找

public class Fu
{
   public void method()
   {
     System.out.println("fu lei");
   }
   int num=10;
}
public class Zi
{
   public void method()
   {
     System.out.println("zi lei");
   }
}
public class
public class Demo01MultiField
{
    public static void main(String[] args)
    {
       Fu obj=new Zi();
       System.out.println(obj.num);//成员变量不能覆盖重写
    }
}

成员方法的使用特点

package cn.itcast.day10.demo05;

/*
在多态的代码当中，成员方法的访问规则是：
    看new的是谁，就优先用谁，没有则向上找。

口诀：编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
 */
public class Demo02MultiMethod {

    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态

        obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
//        obj.methodZi(); // 错误写法！
    }

public class Fu /*extends Object*/ {

    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }

}
package cn.itcast.day10.demo05;

public class Zi extends Fu {

    int num = 20;

    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }

    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

使用多态的好处

对象的转型

对象的向上转型 其实就是多态写法
格式： 父类名称 对象名 =new 子类名称();
含义：右侧创建一个子类对象，把他当做父类来看待
注意事项：向上转型一定是安全的，从小范围转到大范围
弊端：对象一旦向上转型为父类，无法调用子类的特有方法

对象的向下转型 ：其实是一个还原的动作
格式 子类名称 对象名=（子类名称）父类对象
含义：将父类对象，【还原】成为本来的子类对象
注意;
1 必须·保证对象本身创建时就是猫，才能向下转型成为猫
2 否则会报错

用instanceof关键字进行类型判断

//格:对象.instanceof 类名称
//将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例
public class Demo02Instanceof {

    public static void main(String[] args) {
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃SHIT

        // 如果希望掉用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        // 判断一下animal本来是不是Cat
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        giveMeAPet(new Dog());
    }

    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }

}