Java基础之多态

最新推荐文章于 2024-10-10 09:56:47 发布

山海自有归期

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量71

点赞数 1

文章标签： java eclipse

本文链接：https://blog.csdn.net/weixin_50691399/article/details/120794315

版权

一：概念

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

举例：猫可以是猫的类型。

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

动物 d = new 猫(); 在举一个例子：水在不同时刻的状态

简而言之就是反读可以，正读不行就是多态

二：多态前提和体现

1：有继承关系

例如：动物和猫，猫继承动物类

2：有方法重写

例如：猫具有所有动物的共有的动作，吃饭，喝水。

3：有父类引用指向子类对象

例如：Animals c=new Cat();

三：成员访问特点

1：成员变量

编译看左边，运行看左边

package Proctice2;
/*编译看左边，运行看左边*/
class Fu2{
    int a;//父类的成员变量

}
class Zi2 extends Fu2{
    int a=10;//子类的成员变量
    int b=20;//子类的成员变量

}
public class Text7 {
    public static void main(String[] args) {
       Fu2 zi=new Zi2();//父类的引用指向子类的对象
        System.out.println(zi.a);//调用成员变量，由于父类有所以可以通过编译，结果是0
        System.out.println(zi.b);//调用成员变量，
// 由于父类没有这个成员变量所以编译就会出错
// Error:(16, 30) java: 找不到符号
//  符号:   变量 b
//  位置: 类型为Proctice2.Fu2的变量 zi

    }
}

2：成员方法

编译看左边，运行看右边

package Proctice2;
/*成员方法
编译看左边，运行看右边
*/
class Fu3{
    public void show(){
        System.out.println("这是父类的成员方法");
    }
}
class  Zi3 extends Fu3{
    public void show(){
        System.out.println("这是子类重写父类的成员方法");
    }
    public void show2(){
        System.out.println("这是子类特有的成员方法");
    }
}
public class Text8 {
    public static void main(String[] args) {
        Fu3 zi=new Zi3();//父类引用指向子类对象
        zi.show();//结果是：这是子类重写父类的成员方法
        zi.show2();//Error:(22, 11) java: 找不到符号
                    //符号:   方法 show2()
                   // 位置: 类型为Proctice2.Fu3的变量 zi


    }
}

3：静态方法

编译看左边，运行看左边所以前面我说静态方法不能算方法的重写

package Proctice2;
/*静态方法
编译看左边，运行看左边
*/
class Fu4{
    public static void show(){
        System.out.println("这是父类的静态方法");
    }
}
class Zi4 extends Fu4{
    public static void show(){
        System.out.println("这是子类重写的静态方法");
    }
    public static void show1(){
        System.out.println("这是子类的静态方法");
    }

}
public class Text9 {
    public static void main(String[] args) {
        Fu4 zi=new Zi4();//有父类引用指向子类对象
        zi.show();//结果是这是父类的静态方法
        zi.show1();//Error:(23, 11) java: 找不到符号
                  //符号:   方法 show1()
                  // 位置: 类型为Proctice2.Fu4的变量 zi

    }
}

四：多态的好处和弊端

1：好处

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

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

2：弊端

不能访问子类特有功能（向下转型）

访问父类特有的可以用super

那么我们如何才能访问子类的特有功能呢?

向下转型

五：多态中的转型。

1：向上转型

从子到父父类引用指向子类对象（可以调用super关键字）

2：向下转型

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

子 zi=（子）变量

3：例子

package Proctice2;
class Fu5{
    int a=10;
    int b=20;
    public void show(){
        System.out.println("这是父类的成员方法");
    }
    public void show1(){
        System.out.println("这是父类特有的成员方法");
    }
    public static void show2(){
        System.out.println("这是父类的静态方法");
    }

}
class Zi5 extends  Fu5{
    int a=20;
    public void show(){
        System.out.println("这是子类的成员方法");
        System.out.println(super.b);//用super向上转型输出父类特有变量输出为20
    }
    public void show3(){
        System.out.println("这是子类特有的成员方法");
    }
    public static void show2(){
        System.out.println("这是子类的静态方法");
    }

}

public class Text10 {
    public static void main(String[] args) {
        Fu5 zi=new Zi5();//父类的引用指向子类的对象
        System.out.println(zi.a);//输出变量a,结果是10
        zi.show();//调用重写的show方法结果是：这是子类的成员方法，20
        zi.show1();//调用没有重写的show1方法结果是：这是父类特有的成员方法
        zi.show2();//调用静态方法结果是：这是父类的静态方法
        Zi5 zi1=(Zi5) zi;//向下转型
        System.out.println(zi1.a);//调用子类的成员变量结果是：20
        zi1.show2();//调用子类的静态方法结果是：这是子类的静态方法
        zi1.show3();//调用子类特有的成员方法结果是：这是子类特有的成员方法


    }
}