Quelles sont les utilisations et les principes du polymorphisme Java et des classes abstraites

Nous connaissons les trois fonctionnalités majeures de Java : l'encapsulation, l'héritage et le polymorphisme. Les deux premiers ont déjà été mentionnés dans Introduction à Java (6). Parlons maintenant de la fonctionnalité du polymorphisme.

Qu'est-ce que le polymorphisme ?

Le polymorphisme, comme son nom l'indique, signifie plusieurs formes

La signification du polymorphisme en Java :

• Envoyez un message à un objet et laissez l'objet décider lui-même quel comportement répondre au message

• Sous-classe La référence de l'objet est affectée à la variable de référence de la classe parent pour implémenter les appels de méthode dynamiques

Le prérequis au polymorphisme en Java :

• Héritage

• Réécriture des méthodes de la classe parent

• Transformation ascendante

Mon explication du polymorphisme :

Par exemple, nous sommes des personnes, des étudiants et des jeunes. Je peux faire des choses en tant qu'être humain, acheter des billets étudiants en tant qu'étudiant, ou acheter des billets étudiants en tant que jeune. fait de la charité, afin que nous puissions faire différentes choses sous différentes formes. Est-ce mieux compris ?

Remarque :

Prérequis du polymorphisme : il doit y avoir une relation de classe enfant-parent.

Lors de l'appel d'une méthode à l'aide d'une variable de référence de classe parent polymorphe, la méthode remplacée de la sous-classe sera appelée.

La définition et le format d'utilisation du polymorphisme :

Nom de la variable de type de classe parent = nouveau type de sous-classe ();

Caractéristiques des membres dans le polymorphisme :

• Variables membres polymorphes : regardez le côté gauche lors de la compilation et de l'exécution

• Méthodes de membres polymorphes : regardez à gauche lors de la compilation, regardez à droite lors de l'exécution

Transformation polymorphe :

• La transformation polymorphe est divisée en deux types : la transformation vers le haut et la transformation vers le bas

• Transformation vers le haut : le polymorphisme lui-même C'est le processus de transformation vers le haut

• Format d'utilisation : nom de la variable de type de classe parent = nouveau type de sous-classe();

• Scénarios applicables : Lorsqu'il n'est pas nécessaire de faire face aux types de sous-classes, en améliorant l'évolutivité, ou en utilisant Les fonctions de la classe parent peuvent effectuer les opérations correspondantes.

• Transformation vers le bas : un objet de sous-classe qui a été transformé vers le haut peut utiliser le format de conversion de type forcé pour convertir le type de référence de classe parent en type de référence de sous-classe

• Utilisation du format : nom de variable de type de sous-classe = (Type de sous-classe) Variable de type de classe parent ;

• Scénario applicable : Lorsque vous souhaitez utiliser les fonctions uniques de la sous-classe.

Explication du code :

public class Person {     //人类，作为父类使用
    public void speak(){
        System.out.println("我们都是一个人");
    }
}



public class Student extends Person{    //继承父类，相当于我们是学生，有人的方法
    @Override
    public void speak(){
        System.out.println("我是人类中的学生");
    }
}



public class Child extends Person{   //继承父类，相当于我们是孩子，有孩子的行为
    @Override
    public void speak(){

        System.out.println("我是人类中的孩子");
    }
}




//测试类
public class TestMain {
    public static void main(String[] args) {

		//父类类型 变量名=new 子类类型();
        Person p = new Student();   //子类对象的引用赋值给父类 
        p.speak(); //多态 相当于这里使用的是Student的方法。输出我是人类中的学生
        //我作为人，我用学生的身份，说出：我是人类中的学生


		Person p = new Child(); 
		p.speak();  //输出：我是人类中的孩子
		//我作为人，用孩子的身份，说出我是人类中的孩子

    }
}

//这段代码，我们用到了 继承，重写，向上转型，因为多态本来就是向上转型的过程

Le rôle du polymorphisme :

Après avoir introduit le polymorphisme, à quoi sert le polymorphisme ? Pourquoi le polymorphisme peut être considéré comme les trois caractéristiques majeures de Java. Il doit y avoir une raison :

• Améliorer la réutilisabilité du code

• Réduire le couplage entre modules

Ici, je voudrais vous présenter quel est le mécanisme polymorphe ? Comment le langage Java implémente-t-il le polymorphisme ? (C'est peut-être un peu difficile à comprendre, et je ne comprends pas complètement le contenu, mais c'est aussi une question dans l'interview)

Le soi-disant polymorphisme fait référence au type spécifique pointé par la variable de référence définie dans le programme et la méthode émis via la variable de référence L'appel n'est pas déterminé lors de la programmation, mais est déterminé lors de l'exécution du programme. C'est-à-dire sur quel objet d'instance de classe une variable de référence pointera. doit être implémenté dans quelle classe. Cela peut être décidé pendant l’exécution du programme. Étant donné que la classe spécifique n'est déterminée que lorsque le programme est en cours d'exécution, la variable de référence peut être liée à diverses implémentations de classe sans modifier le code du programme source, ce qui entraîne la modification en conséquence de la méthode spécifique appelée par la référence, c'est-à-dire qu'elle n'a pas besoin de être modifié. Le code du programme peut changer le code spécifique lié au programme lors de son exécution, permettant au programme de sélectionner plusieurs états d'exécution. Il s'agit du polymorphisme. Le polymorphisme est divisé en polymorphisme au moment de la compilation et en polymorphisme au moment de l'exécution. Parmi eux, le polymorphisme au moment de l'édition est statique et fait principalement référence à la surcharge des méthodes. Il distingue différentes fonctions en fonction de différentes listes de paramètres. Après l'édition, il n'y aura pas de polymorphisme au moment de l'exécution. Le polymorphisme d'exécution est dynamique et est obtenu grâce à une liaison dynamique, ce que nous appelons le polymorphisme.

Pour comprendre le polymorphisme, vous pouvez également vous référer à un morceau de code :

class People{     //父类
    public void eat(){
        System.out.println("我们会吃饭");
    }
}


class Student extends People{  //继承父类
    @Override
    public void eat(){
        System.out.println("我会吃肉");
    }
    public void study(){
        System.out.println("我们要好好学习");
    }
}


class Teacher extends People{     //继承父类
    @Override
    public void eat(){
        System.out.println("老师会吃蔬菜");
    }
    public void teach(){
        System.out.println("老师要认真上课");
    }
}

//测试类：
public class TestMain {
    public static void main(String[] args) {
        People p=new Stu();      //子类对象的引用赋值给父类 
        p.eat();       //输出： 我会吃肉
    }
}

Classe abstraite :

Qu'est-ce qu'une classe abstraite ?

Une classe commune est une classe fonctionnelle complète qui peut générer directement des objets instanciés et peut inclure des constructeurs, des méthodes communes, des méthodes statiques, des constantes, des variables, etc. Les classes abstraites font référence à des composants qui ajoutent des méthodes abstraites à la structure des classes ordinaires.

Méthode abstraite :

Il y aura un "{}" sur toutes les méthodes ordinaires, qui représente le corps de la méthode. Les méthodes avec des corps de méthode peuvent certainement être utilisées directement par l'objet. Les méthodes abstraites font référence à des méthodes sans corps de méthode, et les méthodes abstraites doivent également être modifiées avec le mot-clé abstract. En d'autres termes, la méthode abstraite de la classe abstraite n'a pas besoin d'être écrite, puis réécrite après avoir été héritée.

Mclé de déclaration de classe abstraite : abstracat

Définir une classe abstraite :

public abstract class studnet{//定义一个抽象类
	
	public void study(){                         //普通方法
		System.out.println("我会学习");
	}
	
	public abstract void eat();         //抽象方法，没有方法体，有abstract关键字做修饰
	
}

//注意： 有抽象方法，这个类必须是抽象的！！！

Explication d'exemple :

La classe de forme Shape doit fournir des méthodes de calcul de l'aire et du périmètre, mais la forme elle-même n'a pas été déterminée, puis calculez le périmètre La méthode de somme et d'aire ne peut pas être déterminée pour le moment, nous devons utiliser des classes abstraites et des méthodes abstraites.

由于Shape类计算周长和面积的方法无法确定，那么就可以将这样的方法声明为抽象的，以便在具体的子类中进行实现。

//定义一个shape类，但是没有具体的形状，所以我们定义成抽象类
public abstract class Shape {
    
    private int a;
    public abstract void area(){}     //求面积的方法
    public abstract void perimeter();   //求周长的方法

    public Shape() {    //无参构造
    }

    public Shape(int a) {
        this.a = a;
    }
}

//计算圆形面积的子类

public  abstract class shape {    //有抽象方法的类，则一定是抽象类，需要关键字abstract修饰

        private int a;
        public abstract void area();     //求面积的方法，没有方法体的方法，需要关键字abstract修饰
        public abstract void perimeter();   //求周长的方法
}


//创建计算圆面积和周长的子类，并继承抽象类shape,并重写shape内的方法
public class Circle extends shape{

    public static double pi = 3.14;
    private double r;  //半径


    @Override
    public void area() {
        System.out.println("圆的面积："+Circle.pi*this.r*this.r);
    }

    @Override
    public void perimeter() {
        System.out.println("圆的周长为："+2*Circle.pi*this.r);
    }

    public Circle() {
    }

    public Circle(double r) {  //
        this.r = r;
    }

}


//测试类：
public class TestMain {
    public static void main(String[] args) {
        Circle c = new Circle(5);        //传入半径为：5
        c.area();
        c.perimeter();

    }

}

//输出结果： 圆的面积：78.5
// 圆的周长为：31.400000000000002

抽象方法和抽象类的注意事项：

• 抽象类中是可以有构造函数的，并且构造函数的写法和其它类没有区别，只不过它真正跑起来是因为子类构造函数的super调用，毕竟我们没办法new一个抽象类对象出来，只能把抽象类的构造函数交给子类的构造函数去使用。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

• 抽象类的子类，必须重写父类中所有的抽象方法，如果有一个抽象方法没有重写，都会出现编译错误不给过，这时也可以把子类也声明为抽象类，报错就会消失。

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!