Maîtrisez le polymorphisme orienté objet JAVA en un seul article

Cet article vous apporte des connaissances pertinentes sur java, qui introduit principalement des problèmes liés au polymorphisme. Le polymorphisme est une caractéristique importante de la programmation orientée objet, pointant vers la même entité et ayant plusieurs formes en même temps. formes d'objets. Examinons-les ensemble, j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

1. Concept

Le polymorphisme est une caractéristique importante de la programmation orientée objet (POO), ce qui signifie qu'une même entité a plusieurs formes en même temps, c'est-à-dire que les mêmes objets d'entité représentent différents objets à des moments différents, ce qui fait référence à diverses formes d'objets.

Vous pouvez traiter différents objets de sous-classe comme classes parentes, protégeant ainsi les différences entre les différents objets de sous-classe, écrivant du code commun, créant une programmation commune et unifiant les normes d'appel.

Par exemple, votre petite amie vous demande d'acheter des fruits. Peu importe ce que vous achetez, c'est une pomme ou une pastèque, tant que ce sont des fruits, c'est une manifestation de la diversité de la vie.

Un autre exemple est celui des chatons, des chiots. , et les porcelets. Nous pouvons tous les classer en petits animaux. Chaque petit animal a besoin de manger, nous pouvons donc définir de manière uniforme qu'ils doivent tous manger. Cependant, chaque petit animal a des habitudes différentes, cela peut donc être défini pour être unique. petit animal. Fonctions, les objets polymorphes ne peuvent appeler que les fonctions réécrites dans la sous-classe définie dans la classe parent, et ne peuvent pas appeler les fonctions uniques de la sous-classe. Cela réalise l'unification du code

Caractéristiques

1. Prémisse 1 de. polymorphisme : c'est la prémisse de l'héritage
2. polymorphisme 2 : il doit y avoir une réécriture de méthode
3. La référence de la classe parent pointe vers l'objet de la sous-classe, tel que : Animal a = new Cat();
4. Dans le polymorphisme, regardez à gauche lors de la compilation et le droit lors de l'exécution
   

3. Exercice : Cas d'entrée du polymorphisme

Créer un package : cn.tedu.oop
Créer une classe : 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. ne pas se soucier d'un certain En fonction du type spécifique de l'objet, vous pouvez utiliser certaines méthodes de l'objet

Améliore l'évolutivité et la maintenabilité du programme
2. 5 Utilisation du polymorphisme

Prémisse : Les objets polymorphes se considèrent comme Type de classe parent

variables membres : utilisez la méthode membre

de la classe parent : en raison de l'écrasement, utilisez les
1. membres statiques de la sous-classe : sont chargés au fur et à mesure que la classe est chargée, et celui qui l'appelle retournera Whose
3. 6. Exercice : Utiliser des membres polymorphes pour tester

Créer un package : cn.tedu.oop

Créer une classe : TestDemo2.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 Développer

7.1 Concevoir un boîtier de voiture complet

Créer un package : cn. tedu.oopexec Créer une classe : DesignCar.java

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("没想到吧，我还是个潜水艇");
    }}

7.2 Polymorphisme afin d'unifier le standard d'appel

package cn.tedu.oop2;public class TestFruit {
    public static void main(String[] args) {
        Fruit f = new Fruit();
        Apple a = new Apple();
        Orange o = new Orange();
        get(f);
        get(a);
        get(o);
    }
    //只需要创建一个方法，就可以执行截然不同的效果
    //忽略子类对象的差异统一看作父类类型
    public static void get(Fruit f){
        f.clean();
    }}class Fruit{
    public void clean(){
        System.out.println("水果要洗洗再吃");
    }}class Apple extends Fruit{
    @Override
    public void clean(){
        System.out.println("苹果需要削皮");
    }}class Orange extends Fruit{
    @Override
    public void clean(){
        System.out.println("橙子需要剥皮");
    }}

7.3 La différence entre les variables statiques et les variables d'instance

La différence dans la définition de la syntaxe : les variables statiques doivent être précédé Ajoutez le mot-clé static, mais ne l'ajoutez pas avant la variable d'instance. La différence lorsque le programme est en cours d'exécution : les variables d'instance appartiennent aux attributs d'un objet. Un objet d'instance doit être créé avant que la variable d'instance qu'il contient se voit allouer de l'espace, et cette variable d'instance peut ensuite être utilisée. Les variables statiques n'appartiennent pas à un objet instance, mais à une classe, elles sont donc également appelées variables de classe. Tant que le programme charge le bytecode de la classe sans créer d'objet instance, les variables statiques se verront allouer de l'espace, et le des variables statiques peuvent être utilisées. En bref, les variables d'instance doivent créer un objet avant de pouvoir être utilisées via cet objet, tandis que les variables statiques peuvent être référencées directement à l'aide du nom de classe.

7.4 Transformation vers le haut et transformation vers le bas

En JAVA, l'héritage est une fonctionnalité importante. Grâce au mot-clé extends, une sous-classe peut réutiliser les fonctions de la classe parent si la classe parent ne peut pas répondre aux besoins de la sous-classe actuelle. Ensuite, la sous-classe peut remplacer les méthodes de la classe parent pour l'étendre. Ensuite, il existe des applications polymorphes dans ce processus. Il existe deux voies de transformation : la transformation vers le haut et la transformation vers le bas.

Transformation vers le haut : vous pouvez traiter différents objets de sous-classe comme classes parentes, masquant ainsi les différences entre les différents objets de sous-classe, écrivant du code universel, créant une programmation universelle et unifiant les normes d'appel.

Par exemple : classe parent Parent, sous-classe Enfant
La référence de la classe parent pointe vers l'objet de la sous-classe : Parent p=new Child();
Remarque : Lors de la transformation ascendante, l'objet de la sous-classe est considéré comme l'objet de la classe parent, et seules les fonctions de la classe parent peuvent être appelées, si la sous-classe remplace une méthode déclarée dans la classe parent, le corps de la méthode exécute la fonction remplacée de la sous-classe. Mais à ce stade, l'objet se considère comme le type parent, donc d'autres ressources utilisent toujours le type parent.
Par exemple : Hua Mulan rejoint l'armée pour son père. Tout le monde considère Hua Mulan comme son père, mais c'est Hua Mulan qui rejoint l'armée. De plus, Hua Mulan ne peut faire que ce que son père peut faire, et elle n'est pas autorisée. se maquiller dans le camp militaire.

Transformation vers le bas (moins) : la référence de la sous-classe pointe vers l'objet de la sous-classe, et une transformation forcée doit être adoptée dans le processus. Il s'agit d'un objet de sous-classe qui a déjà été transformé vers le haut et qui souhaite toujours remplir les fonctions uniques de la sous-classe, il doit donc être restauré en un objet de sous-classe
Parent p = new Child();//Transformation vers le haut, en ce moment , p est le type Parent
Child c = (Child)p;//À ce stade, convertissez le type Parent p en petit type Child
En fait, cela équivaut à créer un objet de sous-classe. Vous pouvez utiliser la classe parent. ou le vôtre
Remarque : lors du downcasting, il s'agit de faciliter l'utilisation de méthodes spéciales de la sous-classe, c'est-à-dire que lorsque la fonction de la méthode de la sous-classe est développée, la fonction de la sous-classe peut être utilisée directement.
Par exemple : Une fois la guerre terminée, Hua Mulan n'a plus besoin d'être considérée comme son père et peut "regarder le miroir jaune"

Apprentissage recommandé : "Tutoriel vidéo Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!