Y a-t-il beaucoup de gens qui pensent que l'écriture de cours est orientée objet de nos jours? Le contenu concerne ** que même les élèves du primaire peuvent comprendre ** pour ces personnes. J'essaierai d'expliquer l'orientation de l'objet d'une manière autoproclamée avec un mélange de subjectivité. Veuillez noter que cela peut être un peu difficile à comprendre car le vocabulaire est faible.
Tout d'abord, je vais l'expliquer d'une manière assez capricieuse. Il y a différentes significations de ** "objet" **, mais ici nous expliquerons avec ** "objet" **. Il existe quatre fluctuations de base dans «objet»: ** «production», «mouvement», «changement» et «destruction» **. Ces fluctuations ont des comportements différents selon la ** nature de l '«objet» **.
Exprimé comme un "robot", il se présente comme suit.
Ensuite, «l'animal» est le suivant.
** La nature des fluctuations est similaire **, mais ** le comportement est complètement différent **. Nous allons construire un framework ** qui traite ces ** comportements séparément pour chaque propriété de l'objet ** "orienté objet" **.
Les jeux vidéo que vous connaissez tous. Tout ce qui est représenté sur cet écran est ** "objet" **. Jetons un coup d'œil aux quatre variantes de l'affichage de base dans le jeu.
| Objet | production | mouvement | changement | Destruction |
|---|---|---|---|---|
| personnage | Apparence | Fonctionnement, comportement de l'IA | Augmenter / diminuer la vie, monter de niveau | Sortez, mourez |
| Informations textuelles | afficher | Afficher l'animation | Couleur, police | Cacher |
| Contexte | afficher | faire défiler | Couleur, changer avec le temps | Cacher |
Le cadre de gestion de ceux-ci comme "objets" est "orienté objet". On peut dire que le jeu lui-même fonctionne "orienté objet" **. Les personnes impliquées dans le développement de jeux doivent avoir en commun une compréhension orientée objet.
Il y a quelques ** attributs ** que les objets ont en commun dans n'importe quel environnement.
--Identification (nom, etc.) --Position (trois dimensions)
Soit A ces ** attributs communs **. Ensuite, considérez la différence entre les animaux et les machines. (Différentes choses peuvent être supposées dans le jeu, mais ici nous prendrons le monde réel comme exemple)
** Je peux comprendre que le phénomène est différent, mais l'essence est la même **. Appelons ces différences B. Ensuite, considérez ** si la différence peut être jugée par l'apparence **. Faites attention à B ①②.
-① Les animaux font des sons avec leurs groupes vocaux, les machines font des sons avec leurs haut-parleurs ――② Le cœur des animaux se déplace par pression artérielle, le processeur de la machine se déplace par tension
** L'essence est la même, mais le mécanisme est différent. ** ** Soit cette différence C.
On dit que ce sont les trois principes orientés objet ** «héritage», «polymorphisme» et «encapsulation». Comme certains d'entre vous l'ont peut-être remarqué, l'élément ABC expliqué au niveau 3 s'applique en fait à cela.
--A: Hériter des éléments des attributs communs: ** Hériter ** --B: Polymorphisme avec la même essence mais un comportement différent: ** Polymorphisme ** --C: Mécanisme invisible de l'extérieur: ** Encapsulation **
J'écris enfin un programme, mais cette fois je l'écrirai en ** C ++ - comme la notation **.
C'est long à faire, donc je vais essayer de l'exprimer avec * "différence entre chien et singe" * qui ne produit que des caractères simples. Comme prémisse, les classes / fonctions / macros suivantes utilisées dans l'exemple sont expliquées.
| Nom | classe/une fonction/macro | La description |
|---|---|---|
| String | classe | Simplifie le traitement des chaînes. |
| une fonction | Produit une chaîne de caractères. | |
| strMarge | une fonction | Combine deux ou plusieurs chaînes. |
| std::shared_ptr |
bibliothèque std | Utilisez le pointeur intelligent. |
Différence entre chien et singe
class Animal{
private:
String name;
String voice;
String food;
protected:
void init(const String& in_name, const String& in_voice, const String& in_food)
{
this->name = in_name;
this->voice = in_voice;
this->food = in_food;
}
virtual ~Animal() {}
public:
String getName() { return this->name; }
String getVoice() { return this->voice; }
String getFood() { return this->food; }
virtual void actionRun(){} //Écraser avec la destination d'héritage
virtual void actionTalk(){} //Écraser avec la destination d'héritage
virtual void actionEat(){} //Écraser avec la destination d'héritage
};
class Dog : public Animal{
public:
Dog(){ this->init("chien", "un! un!", "OS"); }
virtual void actionRun() override { print(strMarge(this->getName(), "Promenades à quatre jambes")); }
virtual void actionTalk() override { print(strMarge(this->getName(), "Est", this->getVoice(), "Aboiement")); }
virtual void actionEat() override { print(strMarge(this->getName(), "Est", this->getFood(), "Manger avec un gorigori")); }
};
class Monkey : public Animal{
public:
Monkey(){ this->init("singe", "Clé! Clé!", "banane"); }
virtual void actionRun() override { print(strMarge(this->getName(), "Promenades avec les membres")); }
virtual void actionTalk() override { print(strMarge(this->getName(), "Est", this->getVoice(), "Cri")); }
virtual void actionEat() override { print(strMarge(this->getName(), "Est", this->getFood(), "Peler et manger à la main")); }
};
int main()
{
std::shared_ptr<Animal> dog = std::make_shared<Dog>();
std::shared_ptr<Animal> monkey = std::make_shared<Monkey>();
dog->actionRun(); //Le chien marche avec quatre pattes
dog->actionTalk(); //Le chien est un! un! Aboiement
dog->actionEat(); //Les chiens mangent des os
monkey->actionRun(); //Singe marche avec les membres
monkey->actionTalk(); //Le singe est la clé! Clé! Cri
monkey->actionEat(); //Les singes pèlent les bananes à la main et mangent
return 0;
}
Même si le ** type ** est Animal, le contenu de sortie est différent car ** l'entité (instance) ** est Dog and Monkey. Les principaux points du code ci-dessus sont résumés dans une puce.
Si ①②③ est terminé, ** le cadre orienté objet est terminé **.
En ce qui concerne le jeu réel, chaque méthode de classe écrite dans l'exemple de niveau 5 est Ce sera un mécanisme plus compliqué avec des changements d'animation et des changements de statut plutôt que de simples contenus tels que la sortie de caractères. Divisez le mécanisme compliqué en classes pour cacher le comportement de l'extérieur, ** Il est possible d'améliorer la vitesse de mise en œuvre et d'implémenter du code source lisible naturellement **, C'est un avantage absolu orienté objet.
Recommended Posts