Java中的多态

原创已于 2024-08-24 23:35:34 修改 · 1.6k 阅读

37 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2024-08-24 22:23:16 首次发布

一、数据类型

数据类型：决定数据在内存当中是什么样的存储形式

比如：

int类型：1bit符号位，32bit数值位

byte类型：1bit符号位，7bit数值位

float类型：1bit符号位，8bit阶位，23bit数值位

创建一个父类A：

public class A {
    public String name;
    public int age;
    public void run(){
        System.out.println("A跑得很快");
    }
    public void eat(){
        System.out.println(name+"吃的很多...");
    }
}

子类B：

public class B extends A{
    public char sex;
    public double height;

    public void fly(){
        System.out.println("B飞得很高");
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        A a = new A();

        B b = new B();
        
        A ab = new B();
    }
}

对象a的内存存储形式：A类的变量和方法都有。

对象b的内存存储形式：因为创建子类对象的前提是创建父类对象，所以b可以调用到A类和B类的变量和方法。

当子类B重写父类A中的run方法后，父类当中的run方法会被覆盖

A ab = new B();

对象ab的内存存储形式：因为创建子类对象的前提是创建父类对象，所以A类和B类的变量和方法都在。但由于ab的数据类型是A，所以ab只能调用到A中的name,age,eat()和被覆盖的run方法，即B中的run方法。

二、多态定义及存在条件

2.1多态的定义

多态是什么？

多态是同一个行为具有不同的表现形式的能力
同一方法可以根据发送对象的不同而采用不同的行为方式

多态就是事物的多种形态，一个对象在不同条件下所表现的不同形式

2.2 多态的存在条件

多态存在的三个必要条件

继承：在多态中必须存在有继承关系的子类和父类
方法的重写：子类对父类中的某些方法进行重新定义
父类引用指向子类对象，父类类型：指子类对象继承的父类类型1.3 多态的格式

2.3 多态的格式

父类类型变量名 = new 子类类型（）；
然后通过 变量名.方法名（）调用在子类中重写的方法
多态体现为父类引用变量可以指向子类对象：定义了一个父类类型的引用，指向新建的子类类型的对象，由于子类是继承他的父类的，所以父类类型的引用是可以指向子类类型的对象的

2.4多态中的成员特点

此处举例Animal是父类，Dog是子类

Animal dog = new Dog(); //Animal是引用类型，Dog是实际类型
System.out.println(dog.age) //dog的引用类型是Animal,所以取到的是父类Animal中的值,说白了dog是属于Animal类，Animal中变量的值是多少就通过对象就取得多少

父类Animal:

//父类
public class Animal {
 
    public int age = 11;
    
}

子类Dog:

//子类
public class Dog extends Animal {
 
    public int age = 33;
    
}

测试：

public class Test {
 
    public static void main(String[] args) {
 
        //父类类型 对象 = new 子类类型（）
        Animal dog = new Dog();
        System.out.println(dog.age);
    }
}

控制台打印输出：父类中定义的age

此处举例Animal是父类，Dog是子类

Animal dog = new Dog（）； //Animal是引用类型，Dog是实际类型
dog.eat(); //变量dog的实际类型是Dog,即是由Dog 这个实际类型new出来的，因此dog.eat() 调用的应该是子类Dog中重写的方法

父类Animal：

//父类
public class Animal {
 
    public void eat() {
        System.out.println("午餐吃狗粮");
    }
 
}

子类Dog:

//子类
public class Dog extends Animal {
    
    @Override
    public void eat() {
        System.out.println("晚餐吃狗粮");
    }
}

测试：

public class DemoApplication {
 
    public static void main(String[] args) {
 
        //父类类型 对象 = new 子类类型（）
        Animal dog = new Dog();
 
        dog.eat();
    }
}

控制台打印输出：调用的是子类中重写的方法

晚餐吃狗粮

2.5 多态的特点

多态情况下，子类和父类存在同名的成员变量时，访问的时父类的成员变量
多态情况下，子父类存在同名的非静态成员方法时，访问的是子类中重写的方法
多态情况下，子父类存在同名的静态成员变量成员方法时，访问的是父类的成员函数
多态情况下，不能访问子类独有的方法

对于子类独有的方法，父类无法访问，

父类Animal保持不变：

//父类
public class Animal {
 
    public void eat() {
        System.out.println("午餐吃狗粮");
    }
 
}

子类Dog:增加子类独有的方法walk()

//子类
public class Dog extends Animal { 
    
    public void walk(){
        System.out.println("子类独有的方法");
    }
        
    @Override
    public void eat() {
        System.out.println("晚餐吃狗粮");
    }
}

测试：walk()方法报红，即编译报错

三、引用类型转换

3.1 向上转型（自动转换）

先了解什么是向上转型（儿子变父亲）

儿子向上转型，父亲是唯一的，因此是自动转换

3.2 向下转型（父亲变儿子，需要强制转换）

对于子类来说，他们的父类是唯一的，而对于父类来说。他拥有很多的子类 ，所以一旦父类要转换成子类，就必须指定要变成哪个子类，必须有指向性，所以向下转型才是强制转换

向上转型

父类类型变量名 = new 子类类型（）；

Animal dog = new Dog（）

向下转型

子类类型子类变量名 = （子类类型）父类变量名

Dog dog1 = (Dog) dog;

dog1.walk； //此时可以使用子类独有的方法了

测试：

public class Test {
 
    public static void main(String[] args) {
 
        //父类类型 对象 = new 子类类型（）
        Animal dog = new Dog();
        //向下转型
        //子类类型 子类变量名 = （子类类型） 父类变量名
        Dog dog1 = (Dog) dog;
 
        dog.eat();  //访问的是子类中重写的方法
 
        //通过向下转型的子类对象调用子类独有的方法
        dog1.walk();  
 
    }
}

控制台打印输出：