Java-17 面向对象 多态

1.多态概论：某一个事物，在不同时刻表现出来的不同状态，要想有多态，就必须要有继承，继承是多态的前提

　　举例：

　　　　猫可以是猫的类型。猫 m = new 猫(); 

　　　　猫也是动物的一种，也可以把猫称为动物。 动物 d = new 猫();

2.多态的前提：

　　1.   要有继承的关系

　　2、要有方法的重写，如果没有重写也是可以的，但是你不重写就没有意义

　　3、要有父类的引用指向子类的对象
　　　　格式：
　　　　　　父 f = new 子();

3.多态访问成员特点：

　　1、成员变量
　　　　编译看左边，运行看左边
　　2、构造方法
　　　　创建子类对象的时候，先访问父类的构造方法，先对父类的数据进行初始化
　　3、成员方法
　　　　编译看左边，运行看右边
　　　　因为子类的成员方法存在重写，所以运行访问的时候看右边
　　4、静态的成员方法：
　　　　编译看左边，运行看左边
　　　　静态的随着类的加载而加载
　　　　由于被static修饰的都是与类有关系的，所以它算不上重写
　　　　所以，编译的时候看左边，运行访问的时候也看左边

　　总结：只有访问成员方法的时候是编译看左边，运行看右边，其他的是编译看左边，运行看左边

package shujia.day1.day4;
class Fu{
    int num =20;
    public void sing(){
        System.out.println("父类唱歌");
    }
    public static void song(){
        System.out.println("fu song");
    }
}

class Zi extends Fu{
    int num=30;
    int num1=40;
    public void sing(){
        System.out.println("子类唱歌");
    }
    public static void song(){
        System.out.println("zi song");
    }
}

public class PolymorphicDemo {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);//20
//        System.out.println(f.num1);报错
        f.sing();//子类唱歌
        Fu.song();
        f.song();
    }
}

4.多态的好处：

　   1.提高了程序的维护性(由继承保证)

　   2.提高了程序的扩展性(由多态保证)

5.多态的弊端：

　　1.不能直接访问子类特有功能 　　解决方法：转型

　　2.不能通过多态去访问父类和子类同名的方法，解决方式：super

package shujia.day1.day4;

/*多态的弊端
        不能访问子类特有功能

        如果我就想访问父类的喝酒方法呢？
        那么我们如何才能访问子类的特有功能呢?
        多态中的转型*/
class Fu1 {
    public void drink() {
        System.out.println("白酒");
    }
}

class Zi1 extends Fu1{
    public void drink(){
        System.out.println("饮料");
        super.drink();//通过super关键字访问父类
    }
    
    public void song(){
        System.out.println("唱歌");
    }
}

public class PolyDemo2 {
    public static void main(String[] args) {
        Fu1 fu1 = new Zi1();
        fu1.drink();
//        fu1.song();不能直接访问子类特有方法
    }
}

6. 多态中的转型

　　1.向上转型（从子到父 父类引用指向子类对象）

　　　　格式   Fu5 f = new Zi5();

　　2.向下转型

　　　　格式   Zi5 z = (Zi5) f;

 

 

 

注意事项：

 

 

class Fu1 {
    public void drink() {
        System.out.println("白酒");
    }
}

class Zi1 extends Fu1{
    public void drink(){
        System.out.println("饮料");
        super.drink();//通过super关键字访问父类
    }

    public void song(){
        System.out.println("唱歌");
    }
}

public class PolyDemo2 {
    public static void main(String[] args) {
        Fu1 fu1 = new Zi1();//自下向上转
        fu1.drink();//饮料 白酒
//        fu1.song();不能直接访问子类特有方法
        Zi1 zi = (Zi1) fu1;//自上向下
        zi.drink();//饮料 白酒
        zi.song();//唱歌
    }
}

7.final关键字保留父类特色方法

package shujia.day1.day4;
//final关键字保留父类特色方法
class Fu2{
    public final void speak(){
        System.out.println("说英语");
    }
}

class Zi2 extends Fu2{
    //父类使用final关键字不能被子类覆盖
//    public void speak(){
//        System.out.println("说韩语");
//    }
}

public class PolyDemo {
    public static void main(String[] args) {
        //创建子类对象
        Zi2 z = new Zi2();
        Fu2 fu2 =new Zi2();
        z.speak();//说英语
        fu2.speak();//说英语
    }
}