Introduction aux trois caractéristiques de base du javascript orienté objet

Les étudiants qui ont appris l'orientation objet devraient tous savoir que les trois caractéristiques de base de l'orientation objet sont : l'encapsulation, l'héritage et le polymorphisme, mais ils ne savent peut-être pas grand-chose sur ces trois mots. Pour le front-end, les plus exposés peuvent être 封装 et 继承, mais le polymorphisme n'est peut-être pas aussi compris.

Emballage

Avant de parler d'emballage, comprenons d'abord ce qu'est l'emballage ?

Qu'est-ce que l'encapsulation

Encapsulation : Encapsuler les ressources nécessaires à l'exécution de l'objet dans l'objet programme - basique Ci-dessus, vous trouverez les méthodes et les données. Un objet "expose son interface". D'autres objets attachés à ces interfaces peuvent utiliser cet objet sans se soucier des méthodes implémentées par l'objet. Le concept est « ne me dites pas comment vous faites, faites-le ». Un objet peut être considéré comme un atome autonome. L'interface objet comprend des méthodes publiques et des données d'initialisation. (Extrait de l'Encyclopédie Baidu)

Ma compréhension de l'encapsulation, il peut y avoir une autre étape qui est 抽离Tout d'abord, vous devez être clair sur les méthodes d'attribut que vous devez séparer d'une paire de codes. Avec ceux-ci comme base Ce n'est qu'ainsi que l'emballage pourra être mieux réalisé.

L'encapsulation n'est rien d'autre que l'encapsulation de ses propriétés et méthodes.

1. Classe : encapsule les propriétés et le comportement des objets

2. Méthode : encapsule des fonctions logiques spécifiques

3. Encapsulation d'accès : L'encapsulation de modification d'accès n'est rien d'autre que d'encapsuler ses droits d'accès

class Employees {
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    getInfo(){
        let {name,age} = this;
        return {name,age};
    }
    static seyHi(){
        console.log("Hi");   
    }
}

let lisi = new Employees("Aaron",18);
lisi.seyHi();   // lisi.seyHi is not a function
lisi.getInfo();  // {name: "Aaron", age: 18}
Employees.seyHi();  // Hi

Les attributs publics extraits dans Employees sont name, age, et les méthodes publiques sont getInfo,seyHi, cependant, la différence entre getInfo et seyHi est que seyHi utilise le modificateur static, le changeant en méthode statique seyHi n'appartient qu'à la classe Employees. . Cependant, la méthode getInfo appartient aux instances.

Ici, static est utilisé pour encapsuler les droits d'accès de la méthode seyHi.

Donnez un autre exemple.

Promise.then()  //  Promise.then is not a function
let p1 = new Promise(() => {})
p1.then();  //  Promise {<pending>}
Promise.all([1]);   //  Promise {<resolved>: Array(1)}

Comme vous pouvez le voir dans le code ci-dessus, Promise utilise également static pour encapsuler les autorisations d'accès de ses méthodes.

Héritage

Héritage : Parler d'héritage n'est pas inconnu. L'héritage peut donner aux sous-classes diverses propriétés publiques de la classe parent属性 et. publique 方法. Sans avoir à réécrire le même code. Tout en laissant la sous-catégorie hériter de la catégorie parent, vous pouvez redéfinir certains attributs et remplacer certaines méthodes, c'est-à-dire écraser les attributs et méthodes d'origine de la catégorie parent afin qu'elle puisse obtenir différentes fonctions de la catégorie parent. (Extrait de l'Encyclopédie Baidu)

Une fois qu'une sous-classe hérite de la classe parent, la sous-classe possède les propriétés et les méthodes de la classe parent, mais elle possède également ses propres propriétés et méthodes uniques. la sous-classe doit être supérieure ou identique à la classe parent, pas inférieure à la classe parent.

class Employees {
    constructor(name){
        this.name = name;
    }
    getName(){
        console.log(this.name)
    }
    static seyHi(){
        console.log("Hi");   
    }
}
class Java extends Employees{
    constructor(name){
        super(name);
    }
    work(){
        console.log("做后台工作");
    }
}
let java = new Java("Aaron");
java.getName();
java.work();
// java.seyHi();    //  java.seyHi is not a function

À partir de l'exemple ci-dessus, nous pouvons voir que l'héritage n'héritera pas des méthodes statiques de la classe parent, mais uniquement des propriétés et méthodes publiques de la classe parent. Cela nécessite une attention particulière. Après l'héritage de la sous-classe

, elle possède non seulement la méthode getName, mais possède également sa propre méthode worker.

Polymorphisme

Polymorphisme : Signifie littéralement « plusieurs états », permettant d'attribuer des pointeurs de types de sous-classes au parent Pointeur vers le type de classe. (Extrait de l'Encyclopédie Baidu)

Pour parler franchement, le polymorphisme est la même chose, lorsque la même méthode est appelée et que les paramètres sont les mêmes, le comportement est différent. Le polymorphisme est divisé en deux types, l’un est le polymorphisme comportemental et le polymorphisme objet.

Réécriture et surcharge d'expressions polymorphes.

Qu'est-ce qui est prioritaire

Overriding : Les sous-classes peuvent hériter des méthodes de la classe parent sans réécrire la même méthode. Mais parfois, la sous-classe ne souhaite pas hériter des méthodes de la classe parent inchangées, mais souhaite apporter certaines modifications, ce qui nécessite une réécriture des méthodes. Le remplacement de méthode est également appelé remplacement de méthode. (Extrait de l'Encyclopédie Baidu)

class Employees {
    constructor(name){
        this.name = name;
    }
    seyHello(){
        console.log("Hello")
    }
    getName(){
        console.log(this.name);
    }
}
class Java extends Employees{
    constructor(name){
        super(name);
    }
    seyHello(){
        console.log(`Hello,我的名字是${this.name},我是做Java工作的。`)
    }
}
const employees = new Employees("Aaron");
const java = new Java("Leo");
employees.seyHello();   //  Hello
java.seyHello();    //  Hello,我的名字是Leo,我是做Java工作的。
employees.getName();    //  Aaron
java.getName(); //  Leo

Comme le montre le code ci-dessus, Java hérite de Employees Cependant, il existe seyHello méthodes dans les sous-classes et les classes parentes afin de répondre à différentes. besoins, sous-classes Après avoir hérité de la classe parent, la méthode seyHello est remplacée. Vous obtiendrez donc des résultats différents lors de votre appel. Puisque la sous-classe hérite de la classe parent, la sous-classe possède également la méthode getName de la classe parent.

Qu'est-ce que la surcharge

重载就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。（节选自百度百科）

class Employees {
    constructor(arg){
        let obj = null;
        switch(typeof arg)
        {
            case "string":
                  obj = new StringEmployees(arg);
                  break;
            case "object":
                  obj = new ObjEmployees(ObjEmployees);
                  break;
            case "number":
                obj = new NumberEmployees(ObjEmployees);
                break;
        }
        return obj;
    }
}
class ObjEmployees {
    constructor(arg){
        console.log("ObjEmployees")
    }
}
class StringEmployees {
    constructor(arg){
        console.log("StringEmployees")
    }
}
class NumberEmployees {
    constructor(arg){
        console.log("NumberEmployees")
    }
}
new Employees({})   // ObjEmployees
new Employees("123456") //  StringEmployees
new Employees(987654)   //  NumberEmployees

因为JavaScript是没有重载的概念的所以要自己编写逻辑完成重载。

在上面的代码中定义了Employees,ObjEmployees,StringEmployees,NumberEmployees类,在实例化Employees的时候在constructor里面进行了判断，根据参数的不同返回不同的对应的类。

这样完成了一个简单的类重载。

总结

1. 封装可以隐藏实现细节，使得代码模块化；

2. 继承可以扩展已存在的代码模块（类），它们的目的都是为了——代码重用。

3. 多态就是相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。多态分为两种，一种是行为多态与对象的多态。

在编程的是多多运用这个写思想对其编程时很有用的，能够使你的代码达到高复用以及可维护。

相关免费学习推荐：js视频教程

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!