大数据Java基础DAY10（面向对象——多态）

目录

多态

多态概述

多态前提和体现

成员访问特点

 多态的好处

多态的弊端

多态中的转型问题

向下转型

向上转型

---

多态

多态概述

某一个事物，在不同时刻表现出来的不同状态。

例：猫可以是猫的类型。猫 m = new 猫(); 同时猫也是动物的一种，也可以把猫称为动物。 动物 d = new 猫();

多态前提和体现

 a.有继承关系    

b.有方法重写

c.有父类引用指向子类对象

父类名 f = new 子类名（...)

例：

class Father{
    public void show(){
        System.out.println("这是父类中的show方法");
    }
}

class Son extends Father{
    @Override             //重写父类的show方法
    public void show() {
        System.out.println("这是子类中的show方法");
    }
    public void show2(){
        System.out.println("这是子类特有的show2方法");
    }
}
public class PolymorphicTest1 {
    public static void main(String[] args) {

        Father father=new Son();  //父类的引用指向子类对象
    }
}

成员访问特点

    a.成员变量

               编译看左边，运行看左边

    b.成员方法

                编译看左边，运行看右边

    c.静态方法

                编译看左边，运行看左边

例：

class Father{
    int a=10;  //父类中的成员变量
    public void show(){
        System.out.println("这是父类中的show方法");
    }

    public static void fun(){
        System.out.println("这是父类中的静态fun方法");
    }
}
class Son extends Father {

    int a=100;  //子类中的成员变量
    @Override             //重写父类的show方法
    public void show() {
        System.out.println("这是子类中的show方法");
    }
    public void show2(){
        System.out.println("这是子类特有的show2方法");
    }
    public static void fun(){
        System.out.println("这是子类中的静态方法");
    }

}
public class Test{
    public static void main(String[] args) {
       Father father=new Son();  //父类的引用指向子类对象

        System.out.println(father.a);    //成员变量，编译看左，运行看左
        father.show();      //成员方法，编译看左，运行看右（子类对象）
        father.fun();       //静态方法，编译看左，运行看左
    }
}

 多态的好处

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

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

多态的弊端

不能直接访问子类特有功能

多态中的转型问题

如果我们就想用多态去访问子类特有的方法，该怎么办？

我们把子类看作一个小的类型，把父类看作一个大的类型，现在想要使用小的类型里的方法，就应该将大的类型转换成小的类型。在继承关系中，可以使用向下转型。

向下转型

从父到子 父类引用转为子类对象

格式：

        子类类名 变量名 = （子类类名）父类的引用；

例：

class Father2{
    public void eat(){
        System.out.println("吃饭");  //父类中的eat方法
    }
}
class Son2 extends Father2 {
    @Override
    public void eat() {       //子类重写父类的eat方法
        System.out.println("子类重写父类的方法");
    }

    public void study(){
        System.out.println("这是子类特有的学习方法");
    }
}
public class Test2 {
    public static void main(String[] args) {

         Father2 f = new Son2(); //父类的引用指向子类对象（多态）
        //要想访问子类的特有方法，使用向下转型
              Son2 s =(Son2) f;
              s.study();   //现在就可以调用子类的特有方法了 ， ((Son2) f).study() 这样写也行就是把两个行代码合起来。

              s.eat();  //当然也可以调用本身的方法
              f.eat();  //编译看左 ，运行看右
    }
}

 注意：向下转型要求转型的类与父类引用存在继承关系，并且一开始创建多态的时候，使用的是该类。

向上转型

从子到父 父类引用指向子类对象

格式：

   父类类名 变量名 = new  子类类名（）    （就是我们经常使用的多态基本类型）

例：多态转型🐏和🐺的案例

class Animals{   //创建一个动物类作为父类
    public void eat(){
        System.out.println("吃东西");
    }
}

class Sheep extends Animals{    //创建🐏的类作为子类
   @Override
   public void eat(){
       System.out.println("羊吃草");    //重写父类的eat方法
   }
   public void run(){
       System.out.println("羊会跑");  //子类特有方法
   }
}
class Wolf extends Animals{   //创建🐺的类作为子类
    @Override
    public void eat(){
        System.out.println("狼吃肉");    //重写父类的eat方法
    }
    public void hunting(){
        System.out.println("狼会狩猎");   //子类特有方法
    }
}
public class Test3 {
    public static void main(String[] args) {
        //多态创建羊的对象
        Animals s1 = new Sheep();
           s1.eat();
           //向下转型,可以访问子类特有方法
        Sheep p = (Sheep) s1;
            p.eat();
            p.run();     // ((Sheep) s1).run()  这样写一样的
        
            //多态创建狼的对象
        Animals s2 =new Wolf();
             s2.eat();
             //向下转型
        Wolf f = (Wolf) s2;  
           f.eat();
           f.hunting();   //   ((Wolf) s2).hunting()   
    }
}

面向对象三大特征——封装https://blog.csdn.net/qq_52400447/article/details/122520149面向对象三大特征——继承https://blog.csdn.net/qq_52400447/article/details/122546522