Les classes sont regroupées et les instances sont définies par des règles de regroupement. L'image est comme la création d'une instance appelée Prius à partir de la classe appelée voiture.
L'essence de l'orientation objet est de faire des choses et de les utiliser pour créer des mécanismes. Lorsque vous faites des choses, faites-les concrètement, et lorsque vous les utilisez, utilisez-les tout en les comprenant de manière abstraite.
Définissez les variables et les fonctions que l'instance doit avoir. Il décrit également comment définir les paramètres initiaux lors de la création d'une instance. → Définissez une fonction constructeur pour pouvoir obtenir un argument et créer une valeur initiale. → Passez une valeur comme argument lors de la création d'une instance et entrez la valeur initiale de la variable dans chaque instance.
class Person {
private Stirng name; //Ici, les variables requises pour l'instance sont préparées.
Person(String name, ...) { ////()Vous pouvez mettre les arguments nécessaires à l'intérieur. Différents paramètres initiaux pour créer une instance sont écrits...
}
public void detailData() { //Les fonctions requises pour l'instance sont écrites ici
}
}
-Ceci écrit dans la classe signifie l'instance créée elle-même.
private Stirng name; //Définissez une variable appelée nom dans cette classe
public void nameInput(String input) { //Lorsque nameInpu t est exécuté avec la variable chaîne entrée comme argument
this.name = input; //Le nom de variable de cette instance aura la même valeur que l'entrée reçue.
}
-Il existe des variables pour les instances (flux d'instance), mais il y a aussi des variables pour les classes (flux de classe). Puisque le flux de classe est une variable de la classe, il peut être modifié chaque fois que quelque chose se produit (par exemple, chaque fois qu'une instance est créée).
Person.Java
class Person {
private static int count; //Ceci est une variable pour la classe
private Stirng name; //Ceci est une variable pour l'instance
Person(String name, ...) { ////Paramètres initiaux de création d'une instance
Person.count ++; //Désormais, chaque fois qu'une instance Person est créée, le nombre de classes Person sera+1 être
}
}
Appelez-le avec une variable nom de classe.class (lorsqu'elle est utilisée en dehors de la classe) ou avec une variable self.class (lorsqu'elle est utilisée à l'intérieur d'une classe)
C'est une fonction nécessaire pour recevoir des arguments et définir des valeurs initiales lors de la création d'une instance (plutôt, une fonction d'initialisation, qui est activée à chaque fois que cette classe est utilisée!?) Cependant, il existe plusieurs types de modèle d'entrée d'argument pour la définition de la valeur initiale. Par exemple, une personne avec un deuxième prénom a plus d'éléments à saisir qu'une personne normale. Par conséquent, nous avons également besoin d'une fonction d'entrée pour les personnes qui ont un deuxième prénom. ↓ Selon le modèle d'entrée de l'argument, la méthode du constructeur fournit également un modèle. Vous pouvez créer une méthode constructeur avec le même nom qui correspond à plusieurs modèles d'entrée d'argument par une méthode appelée overload.
Person.Java
class Person {
private Stirng firstname; //Ici, les variables requises pour l'instance sont préparées.
private Stirng lastname;
private Stirng middlename;
Person(String firstname, String lastname) { //Paramètres initiaux pour les personnes n'ayant que le prénom et le nom
this.firstname = firstname; //La valeur de firstname, qui est la chaîne utilisée pour l'argument, devient le prénom de cette instance. Les premiers noms affichés à gauche et à droite sont différents.
this.lastname = lastname;
}
//Ecrire une fonction avec le même nom
Person(String firstname, String middlename, String lastname) { //Paramètres initiaux pour le prénom, le nom et le nom intermédiaire
this.firstname = firstname;
this.lastname = lastname;
this.middlename = middlename;
}
}
overload Lorsque la surcharge crée plusieurs fonctions avec le même nom, le modèle d'entrée de l'argument est différent même si le nom est le même, alors sélectionnez la fonction la plus appropriée à partir de ce modèle. Cela se fait souvent principalement pour la fonction par défaut. ↓ Lors de la création d'une fonction de paramétrage initial, le contenu de traitement des fonctions créées par surcharge peut être dupliqué. ↓ Par exemple, il existe une fonction A qui est une fonction d'initialisation. Lorsque ceci (nom etc.) est implémenté dans la fonction A Il recherche la fonction d'initialisation avec le même nom que la fonction A, recherche la fonction B qui y traite le nom et traite le nom. Le code ci-dessous nettoie le code précédent.
Person.Java
class Person {
private Stirng firstname; //Ici, les variables requises pour l'instance sont préparées.
private Stirng lastname;
private Stirng middlename;
Person(String firstname, String lastname) {
this.firstname = firstname; //La valeur de firstname, qui est la chaîne utilisée pour l'argument, devient le prénom de cette instance. Les premiers noms affichés à gauche et à droite sont différents.
this.lastname = lastname;
}
Person(String firstname, String middlename, String lastname) { //Paramètres initiaux pour le prénom, le nom et le nom intermédiaire
this(firstname, lastname); //Cela a changé. Premier qui existe dans la fonction du même nom,Nom de famille traité.
this.middlename = middlename;
}
}
override override écrase le contenu de la classe enfant lors de la définition d'une fonction portant le même nom que la classe parent. ↓ Si une fonction portant le même nom qu'une fonction de la classe parent est normalement définie dans la classe enfant, la fonction n'hérite pas du contenu de traitement de la classe parent et n'exécute que le contenu de traitement de la classe enfant. ↓ Si vous voulez hériter du contenu de traitement de la classe parent à la fonction de la classe enfant, vous devez nommer la super.Méthode dans la fonction de la classe enfant.
Person.Java
class Person {
.
.
.
public void detailData() { //Une fonction qui affiche des informations détaillées sur une instance
System.out.println("Nom est" + this.name); //Afficher les variables d'instance
System.out.println("L'âge est" + this.age);
}
}
Child.Java
class Child extends Person { //La classe enfant hérite de la classe Person
.
.
.
public void detailData() { //Il y a une fonction avec le même nom dans la classe Person parente
super.detailData(); //Maintenant detailData dans la classe Person parente()Peut reprendre le contenu de traitement de
//Écrivez le contenu de traitement spécifique à la classe enfant à partir d'ici
.
.
}
}
L'encapsulation consiste à rendre quelque chose de facile à comprendre sans gaspillage. Lorsque vous l'utilisez, ne montrez pas d'informations telles que la configuration interne afin qu'elle puisse être utilisée tout en la comprenant de manière abstraite (vous pouvez l'utiliser sans penser aux choses difficiles).
J'écrirai ici une fonction en encapsulation.
Il limite le circuit d'accès aux variables et fonctions définies dans une certaine classe (pour la sécurité?) ↓ Lors de la définition des variables et des fonctions, vous pouvez restreindre l'accès en l'ajoutant juste avant. ・ Public → Accessible à partir de classes externes. ・ Privé → Non accessible depuis les classes externes Il est possible d'accéder en utilisant la méthode à l'intérieur de la classe qui définit la variable ou la fonction. ・ Protégé → Fondamentalement, il est impossible d'accéder à partir de classes externes comme privées. Cependant, toute classe enfant qui hérite de la classe qui définit la variable ou la fonction est accessible.
-Rendre les variables de la classe qui sont les informations de l'instance privées, et rendre publiques les fonctions de la classe qui sont les instructions de l'instance afin qu'elles soient accessibles de l'extérieur. En définissant des fonctions (par exemple get ~ () et set ~ ()) qui récupèrent et modifient des variables dans la classe, il est possible d'obtenir et de modifier les variables de l'instance.
House.Java
class House{
private Stirng name; //Les variables nécessaires sont préparées ici.
private Person owner; //Vous pouvez stocker une instance d'une autre classe Person dans une variable appelée owner.
House(String name, ...) { //Initialisation de l'instance
}
//La fonction est écrite à partir d'ici.
public setOwner(Person person) { //Prenez la variable person, qui est une instance de la classe Person, comme argument
this.owner = person; //Le propriétaire de cette instance sera le même que la variable personne saisie.
}
public getOwner() {
return this.owner; //Renvoie les informations sur le propriétaire de cette instance. Rien ne s'affiche par lui-même car il ne renvoie que des informations
}
}
Les espaces de noms sont utilisés lors de la lecture de classes, de fonctions et de variables ailleurs (exigent, incluent). À ce moment-là, s'il existe une classe, une fonction ou une variable portant le même nom, une erreur se produit. Par conséquent, j'ose créer une existence parentale en plus des classes, des fonctions et des variables. C'est l'espace de noms. La référence est [Introduction à PHP] Explication facile à comprendre de la façon d'utiliser l'espace de noms / use!
Vous pouvez utiliser extend pour créer une classe enfant qui hérite de la classe parent. Vous pouvez également modifier les valeurs initiales des variables et les paramètres des fonctions initiales pour les instances de la classe enfant. Vous pouvez hériter d'autant de classes que vous le souhaitez, vous pouvez donc créer une classe d'une classe d'une classe.
-En gros, le fichier est divisé pour chaque classe afin de le rendre plus facile à lire. -Bien que cela puisse être différent de l'héritage, vous pouvez charger des bibliothèques et des packages externes en important.
Lorsqu'une fonction est requise pour diverses classes enfants, mais que le contenu de traitement diffère selon la classe. ↓ Définissez une méthode abstraite (une fonction qui n'ose rien écrire) dans la classe parent. Ensuite, dans la classe enfant, vous devez toujours remplacer et définir la fonction. En outre, une classe qui a une méthode abstraite est appelée une classe abstraite et vous ne pouvez pas créer une instance de cette classe elle-même.
Bien qu'interdit en java, l'héritage de plusieurs classes parentes par une classe enfant est appelé héritage multiple.
Une autre instance de classe B peut être définie comme une variable dans la classe A. Par exemple, dans la classe Maison, une instance de la classe Person peut être associée en tant que variable propriétaire qui indique le propriétaire.
House.Java
class House{
private Stirng name; //Les variables nécessaires sont préparées ici.
private Person owner; //Vous pouvez stocker une instance d'une autre classe Person dans une variable appelée owner.
House(String name, ...) { //()Vous pouvez mettre les arguments nécessaires à l'intérieur. Différents paramètres initiaux pour créer une instance sont écrits...
}
//La fonction est écrite à partir d'ici.
public setOwner(Person person) { //Prenez la variable person, qui est une instance de la classe Person, comme argument
this.owner = person; //Le propriétaire de cette instance sera le même que la variable personne saisie.
}
public getOwner() {
return this.owner; //Renvoie les informations sur le propriétaire de cette instance. Rien ne s'affiche par lui-même car il ne renvoie que des informations
}
}
Person.Java
class Person {
private Stirng name; //Les variables nécessaires sont préparées ici.
Person(String name, ...) { //()Vous pouvez mettre les arguments nécessaires à l'intérieur. Différents paramètres initiaux pour créer une instance sont écrits...
}
//La fonction est écrite à partir d'ici.
public void detailData() { //Afficher des informations détaillées sur l'instance ici
}
}
Main.Java
house1 = New House("Une maison", ...);
person1 = New Person("Yamamoto", ...); //Prenez des arguments et créez une instance de chaque classe
house1.setOwner(person1); //Le propriétaire de house1 est désormais identique à la valeur de person1.
house1.getOwner().detailData(); //Cela vous donnera des informations détaillées sur le propriétaire de house1.
//Renvoyer les informations du propriétaire avec getOwner(Rien ne s'affiche par lui-même).. Après cela, les informations du propriétaire peuvent être connues en utilisant la fonction définie par Person.
Créez une instance avec new. Reçoit la valeur de l'argument, réserve une zone en mémoire pour cette instance et y stocke les informations d'instance. (Les informations sont écrites en binaire) ↓ Affectez-le à une variable. Lorsque vous créez une variable pour une instance, la zone de cette variable est allouée en mémoire. Seules les informations sur l'emplacement de la zone d'instance sont conservées dans cette zone.
At-on l'impression qu'une instance de la classe B qui hérite d'une classe A peut être traitée comme une instance de la classe A ou comme une instance de la classe B? ..
Par exemple, lors de l'exécution du même traitement de fonction sur une instance d'une autre classe, il est facile de définir une fonction pour chaque classe. Cependant, si les différentes classes héritent d'une classe parente commune, il vous suffit d'écrire le traitement de la fonction pour cette classe parente. Par conséquent, même si le nombre de classes enfants qui héritent de la classe parent augmente, il n'est pas nécessaire d'écrire le traitement des fonctions.
House.Java
class House {
.
.
.
public setOwner(Person person) { //Prenez la variable person, qui est une instance de la classe Person, comme argument
this.owner = person; //Le propriétaire de cette instance sera le même que la variable personne saisie.
}
}
Villa.Java
class Villa { //villa signifie villa
.
.
.
public setOwner(Person person) { //Prenez la variable person, qui est une instance de la classe Person, comme argument
this.owner = person; //Le propriétaire de cette instance sera le même que la variable personne saisie.
}
}
Person.Java
class Person {
.
.
.
public void buy(House house) { //Si vous recevez la variable house, qui est une instance de la classe House, comme argument
house.setOwner(this); //Cette instance est le propriétaire de la maison variable.
}
public void buy(Villa villa) { //Si vous prenez la variable villa, qui est une instance de la classe Villa, comme argument
villa.setOwner(this); //Cette instance est le propriétaire de la variable villa.
}
}
(La classe parent commune de la classe Maison et de la classe Villa est la classe Bâtiment)
Person.Java
class Person {
.
.
.
public void buy(Building building) { //Si vous recevez la variable building, qui est une instance de la classe Building, comme argument
building.setOwner(this); //Cette instance est le propriétaire du bâtiment variable.
//Si vous définissez une fonction pour la classe parent, vous n'avez pas besoin de la définir pour la classe enfant.
}
}
SOLID Une idée importante dans l'orientation objet. J'ai évoqué ce qui suit. [Quel est le principe de conception orientée objet?](Https://qiita.com/UWControl/items/98671f53120ae47ff93a#%E4%BE%9D%E5%AD%98%E9%96%A2%E4%BF%82%E9% 80% 86% E8% BB% A2% E3% 81% AE% E5% 8E% 9F% E5% 89% 87)
[[Résumé de l'architecture propre d'oncle Bob] Orienté objet ~ Principe SOLID ~](https://qiita.com/yoshinori_hisakawa/items/25576a62123607a696f6#%E3%82%A4%E3%83%B3%E3%82%BF % E3% 83% BC% E3% 83% 95% E3% 82% A7% E3% 83% BC% E3% 82% B9% E5% 88% 86% E9% 9B% A2% E3% 81% AE% E5 % 8E% 9F% E5% 89% 87-ispinterface-ségrégation-principe)
J'ai acquis une meilleure compréhension de Laravel et de l'architecture propre et orientée objet.
Single Responsibility Principle L'idée que la définition de la fonction doit être complétée dans la classe.
Open-Closed Principle En bref, chaque classe est indépendante de la classe et de l'interface.
Arrêtons de créer une (nouvelle) instance de classe B directement dans la classe A, car elle est difficile à maintenir.
Alors tu fais quoi? Résolu par un modèle de conception appelé méthode Factory. Tout d'abord, créez une classe B_Factory avec une fonction qui crée une instance de la classe B et la renvoie. ↓ La classe A utilise la classe B_Factory pour obtenir indirectement une instance de la classe B.
Liskov Substitution Principle Faisons en sorte que cela fonctionne même si la classe enfant est utilisée là où la classe parent est utilisée. En d'autres termes, la classe enfant ne peut pas définir les propriétés et les méthodes de la classe parent.
Interface Segregation Principle Pour la maintenabilité, la classe dépendra de l'interface, mais si une interface est trop grande, la plage d'influence sera grande, alors réduisons-la.
Dependency Inversion Principle Similaire au principe ouvert-fermé? La classe supérieure ne devrait pas dépendre de l'implémentation de la classe inférieure. Une classe (par exemple voiture) qui utilise ici une instance d'une classe différente du niveau supérieur. Une classe (par exemple, un moteur) qui utilise une instance de votre classe d'une classe autre que la sous-classe.
Cette solution est la même que le principe ouvert-fermé et est effectuée par la méthode Factory.
__set et __get. $ obj-> nom = valeur; activera __set → Ici, il peut être attribué en utilisant le nom et la valeur de la propriété comme arguments. Vous pouvez également accéder aux propriétés privées. __get est activé par $ obj-> nom; → Vous pouvez obtenir la valeur en spécifiant le nom de la propriété.
Les variables et méthodes statiques sont statiques, donc on a l'impression qu'il y a des variables et des méthodes dans la classe elle-même. L'avantage est qu'il peut être lu par la méthode nom de classe ::, donc il peut être utilisé sans instance.
Une interface est une chose qui a des méthodes abstraites. Les classes abstraites ne peuvent pas être héritées plusieurs fois, mais l'interface leur permet d'être héritées plusieurs fois. En outre, les méthodes abstraites incluses dans l'interface héritée doivent être remplacées et définies.
[Ce que j'ai appris après avoir combattu l'orientation objet pendant 10 ans] (https://qiita.com/tutinoco/items/6952b01e5fc38914ec4e)
[Quel est le principe de conception orientée objet?](Https://qiita.com/UWControl/items/98671f53120ae47ff93a#%E4%BE%9D%E5%AD%98%E9%96%A2%E4%BF%82%E9% 80% 86% E8% BB% A2% E3% 81% AE% E5% 8E% 9F% E5% 89% 87)
[[Résumé de l'architecture propre d'oncle Bob] Orienté objet ~ Principe SOLID ~](https://qiita.com/yoshinori_hisakawa/items/25576a62123607a696f6#%E3%82%A4%E3%83%B3%E3%82%BF % E3% 83% BC% E3% 83% 95% E3% 82% A7% E3% 83% BC% E3% 82% B9% E5% 88% 86% E9% 9B% A2% E3% 81% AE% E5 % 8E% 9F% E5% 89% 87-ispinterface-ségrégation-principe)
J'ai acquis une meilleure compréhension de Laravel et de l'architecture propre et orientée objet.
Recommended Posts