Bases de la programmation orientée objet JavaScript : encapsulation

Pendant longtemps (je veux me réjouir ici), js a été "une sorte d'embellissement, remplissant des fonctions très limitées, comme la validation de formulaire, et son langage lui-même a été considéré comme un langage procédural. Il est difficile de remplir des fonctions complexes. Cependant (je tiens à le dire avec amertume et tristesse), "l'émergence d'Ajax a fait des scripts complexes un composant nécessaire, ce qui a mis en avant de nouvelles exigences pour la programmation JavaScript. De nombreuses applications Ajax ont commencé à utiliser JavaScript orienté objet. Les propriétés sont développées pour rendre la logique plus claire. En fait, JavaScript fournit un mécanisme complet pour mettre en œuvre des idées de développement orientées objet. Oh mon Dieu, je ne voulais pas apprendre et je n’ai pas osé apprendre, mais maintenant je dois serrer les dents et apprendre.
Il y a tellement de bêtises à propos des objets ici. Nous savons tous que les trois principales caractéristiques de la programmation orientée objet sont : l'encapsulation, l'héritage et le polymorphisme. Ci-dessous, nous enregistrerons quelques expériences d’apprentissage autour de ces trois caractéristiques.
D'accord, commençons par l'encapsulation. Comme nous le savons tous, les objets sont l'unité la plus basique de l'encapsulation. L'encapsulation évite l'impact des changements provoqués par les interdépendances des programmes. L'encapsulation orientée objet est plus claire et plus puissante que l'encapsulation de langage traditionnel. Le code n'est pas cher. Regardons un code simple :

// Définir une classe en définissant une fonction
function class1() {
// Définition des membres de la classe et du constructeur
// Ici, class1 est à la fois une fonction et une classe. En tant que fonction, il peut être compris comme le constructeur d'une classe, responsable de l'initialisation.
}

// Utiliser l'opérateur new pour obtenir une instance d'une classe
var obj = new class1();
/* Mettre de côté la notion de classe, de la forme de le code, class1 est une fonction, donc toutes les fonctions peuvent-elles être utilisées avec new ? La réponse est oui.
En JavaScript, les fonctions et les classes sont le même concept. Lorsqu'une nouvelle fonction est créée, un objet sera renvoyé. S'il n'y a aucun membre de classe initialisé dans cette fonction, un objet vide sera renvoyé.
En fait, lorsqu'une nouvelle fonction est créée, cette fonction est le constructeur de la classe représentée, et tout le code qu'elle contient peut être considéré comme travaillant pour initialiser un objet. Les fonctions utilisées pour représenter les classes sont également appelées constructeurs.
En JavaScript, chaque objet peut être considéré comme une collection de plusieurs propriétés (méthodes)
*/

function test() {
alert( typeof (obj)); }




Le code ci-dessus définit une classe class1, qui est une simple encapsulation en js Voyons comment js définit une "classe statique",

fonction. class1() { // Constructeur
}
// Propriété statique
class1.staticProperty = " test "
// Méthode statique
class1.staticMethod = function () {
alert(class1.staticProperty);
}

function test() {
// Appeler la méthode statique
class1.staticMethod(
alert( typeof ( class1));

}

Ensuite, regardez "classe abstraite" :

/*
Dans les langages orientés objet traditionnels, les méthodes virtuelles dans les classes abstraites doivent d'abord être déclarées, mais peut être appelé à partir d’autres méthodes.
En JavaScript, les méthodes virtuelles peuvent être considérées comme des méthodes qui ne sont pas définies dans la classe, mais qui ont été utilisées via ce pointeur.
Contrairement aux méthodes traditionnelles orientées objet, les méthodes virtuelles n'ont pas besoin d'être déclarées ici mais sont utilisées directement. Ces méthodes seront implémentées dans la classe dérivée

*/

// Définir la méthode d'extension
Object.extend = function (destination, source) {
for (property in source) {
destination[propriété] = source[propriété];
}
return destination;
}
Object.prototype.extend = function (object) {
return Object. extend. apply( this , [ this , object]);
}
// Définir une classe de base abstraite, pas de constructeur
function base() { }
base.prototype = {
initialize: function () {
this .oninit(); // Appelé une méthode virtuelle
}
}
// Définir class1
function class1() {
// Constructeur
}
// Laisser class1 hériter de base et implémenter la méthode oninit
class1.prototype = ( new base()).extend({
oninit: function () { // Implémenter le méthode virtuelle oninit dans la classe de base abstraite
// Implémentation de la fonction oninit
}
});

Nous voyons que ci-dessus "laisser la classe 1 hériter de la base et y implémenter oninit" Méthode ", la notion d'"héritage" est utilisée, veuillez faire attention. Jetons un coup d'œil à l'effet de l'exécution :

function test() {
var obj = new class1();
obj.oninit = function () { alert( " test " ); }
obj.oninit();
}

Pour plus de bases de programmation orientée objet javascript : articles liés à l'encapsulation, veuillez prêter attention au site Web chinois de PHP. !