多态

1.多态的概述

 

 2.多态的格式和使用

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


public class ZiTest extends FuTest1{
    @Override
    public void method(){
        System.out.println("子类特有方法");
    }
}


/*
代码中体现多态性，其实就是一句话:父类引用指向子类对象
格式：
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称
 */
public class Demo01Multi {
    public static void main(String[] args) {
//        ZiTest zi  = new ZiTest();
//        zi.method();
//        zi.methodFu();
        //多态的写法：左侧父类的引用，指向了右侧子类的对象。
          FuTest1 obj = new ZiTest();
          obj.method();
          obj.methodFu();
    }
}

 3.多态中成员变量的使用特点

public class FuTest2 /*extends Object*/ {
    int num = 10;
    public void showNum(){
        System.out.println(num);
    }



public class ZiTest2 extends FuTest2{
    int num = 20;
    int age = 15;

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


/*
访问成员变量的两种方式：
1.直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则想上找。
2.间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则想上找。
 */
public class Demo02Multi {
    public static void main(String[] args) {
        FuTest2 obj = new ZiTest2();
        System.out.println(obj.num); //父：10
        //System.out.println(obj.age);//错误写法：父类没有该变量，向上找不到
        System.out.println("=======================");
        //子类没有覆盖重写就是父：10
        //子类覆盖重写，就是访问子：20
        obj.showNum();
    }
}

4.多态中成员方法的使用特点

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


public class ZiTest3 extends FuTest3{
    public void method(){
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}


/*
在多态的代码中，成员方法的访问规则是：
    看new的是谁，就优先用谁，没有则向上找。
    口诀：编译看左边，运行看右边
对比一下：
成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边
 */
public class Domo02Multi {
    public static void main(String[] args) {
        FuTest3 obj = new ZiTest3(); //多态
        obj.method(); // 父子都有，优先用子
        obj.methodFu(); //子类没有，父类有，向上找到父类

    }
}

5.使用多态的好处

 

 6.对象的向上转型

 

 

public abstract class Animal {
    public abstract void eat();
}



public class Cat extends Animal{

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


public class Demo01Main {
    public static void main(String[] args) {
        //对象的向上转型：父类引用指向子类对象
        Anima anima= new Cat();
        anima.eat();
    }
}

7.对象的向下转型

public abstract class Anima {
    public abstract void eat();
}


public class Cat extends Anima{

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


public class Demo01Main {
    public static void main(String[] args) {
        //对象的向上转型：父类引用指向子类对象
        Anima anima= new Cat(); //本来创建的时候就是一只猫
        anima.eat();//猫吃鱼
        //anima.catchMouse();//错误写法

        //向下转型，进行“还原”动作
        Cat cat = (Cat) anima;
        cat.catchMouse();//猫抓老鼠

        //下面是错误的向下转型
        //本来new的时候是一只猫，现在非要当作狗
        //错误写法！编译不会报错，但是运行会出现异常
        //java.lang.ClassCastException
//        Dog dog = (Dog) animal;
    }
}

8.用instanceof关键字进行类型判断

/接上面6.7代码
public class Dog extends Anima{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}

//如何才能直到一个父类引用的对象，本来是什么子类：
格式：  对象  instatceof  类名称
这将会得到一个boolean值的结果，也就是判断前面的对象能不能当作后面类型的实例
public class Demo02Instanceof {
    public static void main(String[] args) {
        Anima anima = new Cat();
        anima.eat();
        giveMePet(new Dog());
    }

//如果希望调用子类特有的方法，需要向下转型
//判断一个父类引用animal本来是不是Dog
    public static void giveMePet(Anima anima){
        if (anima instanceof Dog){
            Dog dog = (Dog) anima;
            dog.eat();
        }
        if(anima instanceof Cat){
            Cat cat = (Cat) anima;
            cat.eat();
        }
    }
}