Java基础3---多态

Y编程小白

已于 2024-08-24 20:14:22 修改

阅读量510

点赞数 14

分类专栏： java 文章标签： java 开发语言

于 2024-08-24 18:04:28 首次发布

本文链接：https://blog.csdn.net/2301_81453175/article/details/141502401

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

多态是什么？

父类的引用指向子类的对象

例1

测试类

package Work1;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    A ab=new B();//父类的引用指向子类的对象
    A a=new A();
    B b=new B();//创建子类对象的前提是创建父类的对象
}

父类

package Work1;

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


}

子类

package Work1;

public class B extends A{
  public char sex;
  public double height;
  public void fly(){
      System.out.println("B飞的很高");
  }
    public void run(){
        System.out.println("B跑的很快");
    }
}

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

int a=10;//1bit符号位 31bit数值位

byte b=10;//1bit符号位 7bit数值位

float f=10.0f; //1bit符号位 8bit阶位 2bit数值位

以下两种定义方式的堆栈内存图

A a=new A();

B b=new B();

创建B类对象之前，要先创建A类对象，

创建的对象b指向B类对象，

由于继承，B对象可以调用A对象的所有变量和方法。

B类重写了A类对象当中的run方法，所以调用子类当中重写的方法

例2

测试类

package Work1;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        A ab=new B();//A B对象都有，因为创建子类对象一定会创建父类对象
        ab.name="aaa";
        ab.age=20;//因为数据类型决定在内存当中的存储形式，所以只能调用创建的A类的对象
        ab.eat("mmm");
        ab.run();//A类的run方法被B类所重写，因此被重写覆盖
        
    }
}

子类

package Work1;

public class B extends A{
  public char sex;
  public double height;
  public void fly(){
      System.out.println("B飞的很高");
  }
    public void run(){
        System.out.println("B跑的很快");
    }
}

父类

package Work1;

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


}

执行结果

多态如何使用？

A ab=new B();

父类的引用指向子类的对象：

创建A和B类的对象，由于数据类型是A，所以在内存中指向的是A类的对象，可以调用的也是A类的对象

但是由于方法的重写，run方法被重写，因此可以调用的是重写后的方法

多态的堆栈内存图

多态的用法----向上转型

例3

测试类

package Work1;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
       B b=new B();
       C.aaa(b);
       //向上转型：子类的对象可以被父类的类型所接收------>父类的引用指向子类的对象
        //没有A类的对象，向C类的方法中传入B类的对象不报错，说明向上转型
    }
}

C类

package Work1;

public class C {
    public static void aaa(A a){
        System.out.println("c的输出");
    }
}

A类

package Work1;

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


}

B类

package Work1;

public class B extends A{
  public char sex;
  public double height;
  public void fly(){
      System.out.println("B飞的很高");
  }
    public void run(){
        System.out.println("B跑的很快");
    }
}

向上转型：

子类的对象可以被父类的类型所接收------>父类的引用指向子类的对象

因为没有A类的对象，向C类的方法中传入B类的对象不报错，并且可以正常调用输出，说明向上转型

例4

A类

public class A {
    public String show(D obj) {
        return ("A and D");
    }
    public String show(A obj) {
        return ("A and A");
    } 
}

B类

public class B extends A{
    public String show(Obj obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

C类

public class C extends B{
}

D类

public class D extends B{
}

测试类

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

程序分析

a1可以调用的方法