Beherrschen Sie den objektorientierten JAVA-Polymorphismus in einem Artikel

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, das hauptsächlich verwandte Themen zum Thema Polymorphismus einführt. Polymorphismus ist ein wichtiges Merkmal der objektorientierten Programmierung, das auf dieselbe Entität verweist und mehrere Formen gleichzeitig aufweist Schauen wir sie uns gemeinsam an. Ich hoffe, dass es für alle hilfreich ist.

Empfohlene Studie: „Java-Video-Tutorial“

1. Polymorphismus ist ein wichtiges Merkmal der objektorientierten Programmierung (OOP), was bedeutet, dass dieselbe Entität mehrere Formen gleichzeitig hat. Das heißt, dieselben Entitätsobjekte stellen unterschiedliche Objekte zu unterschiedlichen Zeiten dar, was sich auf verschiedene Formen von Objekten bezieht.

Sie können verschiedene Unterklassenobjekte als übergeordnete Klassen behandeln und so die Unterschiede zwischen verschiedenen Unterklassenobjekten abschirmen, gemeinsamen Code schreiben, gemeinsame Programmierungen durchführen und Aufrufstandards vereinheitlichen.

Deine Freundin bittet dich zum Beispiel, etwas Obst zu kaufen, egal, was du kaufst, ist ein Apfel oder eine Wassermelone, solange es Obst ist, ist dies ein Ausdruck der Vielfalt im Leben

Ein weiteres Beispiel sind Kätzchen, Welpen , und Ferkel. Wir können sie alle in kleine Tiere einteilen, die essen müssen, sodass wir einheitlich festlegen können, dass jedes kleine Tier unterschiedliche Gewohnheiten hat, sodass dies individuell festgelegt werden kann kleines Tier. Funktionen, polymorphe Objekte können nur die in der übergeordneten Klasse neu geschriebenen Funktionen aufrufen und nicht die eindeutigen Funktionen der Unterklasse aufrufen. Dies erreicht die Vereinheitlichung des Codes

Prämisse 1 Polymorphismus: Es ist die Prämisse der Vererbung

Polymorphismus 2: Es muss eine Methodenumschreibung erfolgen

1. Der Verweis der übergeordneten Klasse verweist auf das Unterklassenobjekt, wie zum Beispiel: Animal a = new Cat();
2. Schauen Sie sich beim Polymorphismus die linke Seite an beim Kompilieren und das Recht beim Ausführen
4. 
   3. Übung: Polymorphismus-Eingabefall
Erstellen Sie ein Paket: cn.tedu.oop

Erstellen Sie eine Klasse: TestDemo.java

package cn.tedu.oop2;/*本类用作多态的入门案例*/public class TestDemo {
    public static void main(String[] args) {
        //6.创建“纯纯的”对象用于测试
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();//小动物Animal吃啥都行~调用的是父类自己的功能
        c.eat();//小猫爱吃小鱼干~调用的是子类重写后的功能
        d.eat();//小狗爱吃肉骨头~调用的是子类重写后的功能
        /*2.父类对象不可以使用子类的特有功能*/
        //a.jump();//报错，Animal类里并没有这个方法
        //a.run();//报错，Animal类里并没有这个方法
        c.jump();//小猫Cat跳的老高啦~,子类可以调用自己的功能
        d.run();//小狗Dog跑的老快啦~,子类可以调用自己的功能

        //7.创建多态对象进行测试
        /*3.口诀1：父类引用指向子类对象
        * 解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存*/
        Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
        Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
        //8.测试多态对象
        /*4.口诀2：编译看左边，运行看右边
        * 解释：必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
        *      必须要在子类重写这个方法，才能满足多态，实际干活的是子类*/
        a2.eat();//小猫爱吃小鱼干~，多态对象使用的是父类的定义，子类的方法体
    }}/*1.多态的前提：继承+重写*///1.创建父类class Animal{
    //3.创建父类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }}//2.1创建子类1class Cat extends Animal{
    //4.1添加重写的方法
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //5.1添加子类的特有功能
    public void jump(){
        System.out.println("小猫Cat跳的老高啦~");
    }}//2.2创建子类2class Dog extends Animal{
    //4.2添加重写的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头~");
    }
    //5.2添加子类的特有功能
    public void run(){
        System.out.println("小狗Dog跑的老快啦~");
    }}

4. Vorteile des Polymorphismus

Polymorphismus ermöglicht Wir kümmern uns nicht um einen bestimmten Objekttyp. Sie können bestimmte Methoden des Objekts verwenden. Verbessert die Skalierbarkeit und Wartbarkeit des Programms. 5. Verwendung von Polymorphismus. Voraussetzung: Polymorphe Objekte betrachten sich selbst als Typ der übergeordneten Klasse

Mitgliedsvariablen: Verwenden Sie die
1. Mitgliedsmethode der übergeordneten Klasse: Verwenden Sie aufgrund des Überschreibens die
2. statischen Mitglieder der Unterklasse: werden geladen, während die Klasse geladen wird, und wer auch immer sie aufruft, gibt Whose zurück 6. Übung: Verwenden Sie polymorphe Mitglieder zum Testen .tedu.oopexec

Klasse erstellen: DesignCar.java

package cn.tedu.oop2;/*本类用于测试多态成员的使用情况*/public class TestDemo2 {
    public static void main(String[] args) {
        //7.创建纯纯的子类对象
        Dog2 d = new Dog2();
        System.out.println(d.sum);//20,子类自己的属性
        d.eat();//小狗爱吃肉包子,子类自己的方法

        //8.创建多态对象
        /*口诀1：父类引用指向子类对象*/
        /*口诀2：编译(保存)看左边，运行(效果)看右边*/
        Animal2 a = new Dog2();
        /*多态中，成员变量使用的是父类的*/
        System.out.println(a.sum);//10
        /*多态中，方法的声明使用的是父类的，方法体使用的是子类的*/
        a.eat();//小狗爱吃肉包子
        /*多态中，调用的静态方法是父类的，因为多态对象把自己看作是父类类型
        * 直接使用父类中的静态资源*/
        a.play();//没有提示，玩啥都行~
        Animal2.play();
    }}//1.创建父类class Animal2{
    //3.创建父类的成员变量
    int sum = 10;
    //4.创建父类的普通方法
    public void eat(){
        System.out.println("吃啥都行~");
    }
    //9.1定义父类的静态方法play
    public static void play(){
        System.out.println("玩啥都行~");
    }}//2.创建子类class Dog2 extends Animal2{
    //5.定义子类的成员变量
    int sum = 20;
    //6.重写父类的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉包子");
    }
    //9.2创建子类的静态方法play
    //@Override
    /*这不是一个重写的方法，只是恰巧在两个类中出现了一模一样的两个静态方法
    * 静态方法属于类资源，只有一份，不存在重写的现象
    * 在哪个类里定义，就作为哪个类的资源使用*/
    public static void play(){
        System.out.println("小狗喜欢玩皮球~");
    }}

7.2 Polymorphismus zur Vereinheitlichung des Aufrufstandards

package cn.tedu.oop2;/*本类用于完成汽车设计案例*/public class DesignCar {
    public static void main(String[] args) {
        //9.创建一个纯纯的父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null
        c.start();
        c.stop();
        //c.swim();//报错，父类对象不可以调用子类的特有功能

        //10.创建纯纯的子类对象做测试
        BMW b = new BMW();
        System.out.println(b.color);//五彩斑斓的黑
        System.out.println(b.getColor());//null
        b.start();//都让开，我的车要起飞啦~
        b.stop();//唉呀妈呀熄火了~

        //11.创建多态对象进行测试
        Car c2 = new TSL();
        //System.out.println(c2.color);
        System.out.println(c2.getColor());
        c2.stop();
        c2.start();
        //c2.swim();
    }}//1.通过分析，抽象形成一个汽车类class Car{
    //2.定义并封装汽车类的属性--成员变量
    private String brand;//品牌
    private String color;//颜色
    private int id;//编号
    private double price;//价格

    //3.定义功能
    public void start(){
        System.out.println("我的小车车启动啦~");
    }
    public void stop(){
        System.out.println("唉呀妈呀熄火了~");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }}//4.创建子类class BMW extends Car{
    String color = "五彩斑斓的黑";
    //5.重写父类的方法
    @Override
    public void start(){
        System.out.println("都让开，我的车要起飞啦~");
    }}//6.创建子类2class TSL extends Car{
    //7.重写父类的方法
    @Override
    public void stop(){
        System.out.println("唉呀妈，怎么停不下来呢");
    }
    //8.添加子类的特有功能
    public void swim(){
        System.out.println("没想到吧，我还是个潜水艇");
    }}

1. 7.3 Der Unterschied zwischen statischen Variablen und Instanzvariablen
3. Der Unterschied in der Syntaxdefinition: Statische Variablen müssen vorangestellt sein Fügen Sie das Schlüsselwort static hinzu, aber fügen Sie es nicht vor der Instanzvariablen hinzu.
Der Unterschied bei laufendem Programm: Instanzvariablen gehören zu den Attributen eines Objekts, bevor der darin enthaltenen Instanzvariablen Platz zugewiesen wird, und dann kann diese Instanzvariable verwendet werden. Statische Variablen gehören nicht zu einem Instanzobjekt, sondern zu einer Klasse und werden daher auch als Klassenvariablen bezeichnet. Solange das Programm den Bytecode der Klasse lädt, ohne Instanzobjekte zu erstellen, wird den statischen Variablen Speicherplatz zugewiesen Es können statische Variablen verwendet werden. Kurz gesagt, Instanzvariablen müssen ein Objekt erstellen, bevor sie über dieses Objekt verwendet werden können, während auf statische Variablen direkt über den Klassennamen verwiesen werden kann.

7.4 Aufwärtstransformation und Abwärtstransformation

In JAVA ist Vererbung eine wichtige Funktion. Durch das Schlüsselwort „extends“ kann eine Unterklasse die Funktionen der übergeordneten Klasse wiederverwenden. Dann kann die Unterklasse die Methoden in der übergeordneten Klasse überschreiben, um sie zu erweitern.

Dann gibt es in diesem Prozess polymorphe Anwendungen. Es gibt zwei Arten der Transformation: Transformation nach oben und Transformation nach unten.

Aufwärtstransformation: Sie können verschiedene Unterklassenobjekte als übergeordnete Klassen behandeln und so die Unterschiede zwischen verschiedenen Unterklassenobjekten abschirmen, universellen Code schreiben, universell programmieren und Aufrufstandards vereinheitlichen.

Zum Beispiel: Elternklasse Parent, Unterklasse Child Der Verweis der Elternklasse zeigt auf das Unterklassenobjekt: Parent p=new Child(); Hinweis: Bei der Aufwärtstransformation wird das Unterklassenobjekt als übergeordnetes Klassenobjekt betrachtet und Es können nur die Funktionen der übergeordneten Klasse aufgerufen werden. Wenn die Unterklasse eine in der übergeordneten Klasse deklarierte Methode überschreibt, führt der Methodenkörper die überschriebene Funktion der Unterklasse aus. Zu diesem Zeitpunkt betrachtet sich das Objekt jedoch als übergeordneter Typ, sodass andere Ressourcen weiterhin den übergeordneten Typ verwenden.

Zum Beispiel: Hua Mulan tritt für ihren Vater in die Armee ein. Jeder betrachtet Hua Mulan als ihren Vater, aber es ist Hua Mulan, die in Wirklichkeit in die Armee einsteigt. Darüber hinaus kann Hua Mulan nur das tun, was ihr Vater tun kann, und sie darf nicht im Militärlager Make-up tragen.

Abwärtstransformation (weniger): Der Verweis der Unterklasse zeigt auf das Unterklassenobjekt, und dabei muss eine erzwungene Transformation übernommen werden. Dies ist ein Unterklassenobjekt, das zuvor nach oben transformiert wurde und weiterhin die einzigartigen Funktionen der Unterklasse ausführen möchte. Daher muss es zu diesem Zeitpunkt in ein Unterklassenobjekt wiederhergestellt werden. Parent p = new Child(); // Aufwärtstransformation zu diesem Zeitpunkt , p ist der übergeordnete Typ
Child c = (Child)p;// Konvertieren Sie zu diesem Zeitpunkt den übergeordneten Typ p in den kleinen Typ Child
Tatsächlich entspricht dies dem Erstellen eines Unterklassenobjekts. Sie können die übergeordnete Klasse verwenden oder Ihr eigenes
Hinweis: Beim Downcasting soll die Verwendung spezieller Methoden der Unterklasse erleichtert werden. Das heißt, wenn die Funktion der Unterklassenmethode erweitert wird, kann die Unterklassenfunktion direkt verwendet werden.
Zum Beispiel: Nachdem Hua Mulans Krieg vorbei ist, muss sie nicht mehr als ihr Vater gesehen werden und kann „gelb in den Spiegel schauen“

Empfohlenes Lernen: „

Java-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonBeherrschen Sie den objektorientierten JAVA-Polymorphismus in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!