[JAVA] Erklären Sie "objektorientiert", das selbst Grundschüler auf Stufe 5 verstehen können

Gibt es viele Leute, die denken, dass Schreibkurse heutzutage objektorientiert sind? Der Inhalt handelt von **, die selbst Grundschüler für solche Menschen verstehen können **. Ich werde versuchen, die Objektorientierung selbsternannt mit einer Mischung aus Subjektivität zu erklären. Bitte beachten Sie, dass es etwas schwierig zu verstehen sein kann, da der Wortschatz niedrig ist.

Level 1 "In der Realität denken"

Zunächst werde ich es ziemlich zäh erklären. Es gibt verschiedene Bedeutungen von ** "Objekt" **, aber hier werden wir mit ** "Objekt" ** erklären. Es gibt vier grundlegende Schwankungen bei "Objekt": ** "Produktion", "Bewegung", "Veränderung" und "Zerstörung" **. Diese Schwankungen haben je nach ** Art des "Objekts" ** unterschiedliche Verhaltensweisen.

Als "Roboter" ausgedrückt, ist es wie folgt.

• ** [Produktion] Roboter ist gemacht **
• ** [Aktion] Roboter bewegt sich auf Befehl vorwärts **
• ** [Ändern] Roboter verschlechtert sich mit der Zeit **
• ** [Zerstören] Roboter explodiert und verschwindet **

Als nächstes ist das "Tier" wie folgt.

• ** [Produktion] Tiere werden geboren **
• ** [Aktion] Tier geht vorwärts **
• ** [Ändern] Tiere werden älter **
• ** [Zerstören] Tier stirbt **

** Die Art der Schwankungen ist ähnlich **, ** aber ** das Verhalten ist völlig anders **. Wir werden ein Framework ** erstellen, das diese ** Verhaltensweisen für jede Eigenschaft des Dings ** "objektorientiert" ** separat verarbeitet.

Level 2 "Spielähnliche Denkweise"

Videospiele, die Sie alle kennen. Alles, was auf diesem Bildschirm dargestellt wird, ist ** "Objekt" **. Werfen wir einen Blick auf die vier Variationen der Grundanzeige im Spiel.

Der Rahmen für die Verwaltung dieser als "Objekte" ist "objektorientiert". Man kann sagen, dass das Spiel selbst "objektorientiert" läuft **. Menschen, die an der Spieleentwicklung beteiligt sind, müssen ein objektorientiertes Verständnis gemeinsam haben.

Level 3 "Über Gemeinsamkeiten und Unterschiede nachdenken"

Es gibt einige ** Attribute **, die Objekte in jeder Umgebung gemeinsam haben.

• Identifizierung (Name usw.) --Position (dreidimensional)
• Größe
• Sichtbar oder unsichtbar
• etc...

Sei A diese ** gemeinsamen Attribute **. Betrachten Sie als nächstes den Unterschied zwischen Tieren und Maschinen. (Verschiedene Dinge können im Spiel angenommen werden, aber hier nehmen wir die reale Welt als Beispiel)

• Stimme für Tiere, elektronischer Ton für Maschinen (macht Geräusche) ... ① --Tier ist das Herz, Maschine ist die CPU (aktiv) ... ② --Tier, Maschine ... etc ...

** Ich verstehe irgendwie, dass das Phänomen anders ist, aber das Wesen ist das gleiche **. Nennen wir diese Unterschiede B. Als nächstes überlegen Sie **, ob der Unterschied anhand des Aussehens beurteilt werden kann **. Achten Sie auf B ①②.

-① Tiere machen Geräusche mit ihren Stimmbändern, Maschinen machen Geräusche mit ihren Lautsprechern ――② Das Tierherz bewegt sich durch den Blutdruck, die CPU der Maschine durch die Spannung

** Die Essenz ist dieselbe, aber der Mechanismus ist unterschiedlich. ** ** ** Sei dieser Unterschied C.

Stufe 4 "Drei Prinzipien der Objektorientierung"

Es sollen die drei objektorientierten Prinzipien ** "Vererbung", "Polymorphismus" und "Einkapselung" sein. Wie einige von Ihnen vielleicht bemerkt haben, gilt das in Level 3 erläuterte Element ABC tatsächlich dafür.

--A: Elemente mit gemeinsamen Attributen erben: ** Erben **

• B: Polymorphismus mit der gleichen Essenz, aber unterschiedlichem Verhalten: ** Polymorphismus **
• C: Mechanismus von außen unsichtbar: ** Verkapselung **

Level 5 "Versuche ein Programm zu schreiben"

Ich schreibe endlich ein Programm, aber dieses Mal schreibe ich es in ** C ++ - wie Notation **.

• (Weil ich vor acht Jahren als Student C ++ geschrieben habe ... Wir überprüfen den Vorgang nicht. Bitte weisen Sie auf Fehler hin. ) * ** Das Verständnis von Klassen ist für die objektorientierte Programmierung fast unerlässlich. Wenn Sie Klassen in einer beliebigen Sprache verstehen, sollten Sie das folgende Beispiel verstehen können. Kennen Sie die Spezifikationen der Klasse für die Sprache, die Sie jetzt lernen möchten. Jede Sprache hat ** "Klassenvererbung" ** und ** "Methodenüberschreibung" **, suchen Sie also nach diesem Wort. Selbst wenn es sich um eine Sprache ohne Klassen handelt, ist eine ** Objektorientierung möglich, indem das Verhalten entsprechend der Art der Daten geändert wird **.

Es ist lang, es zu tun, also werde ich versuchen, es mit * "Unterschied zwischen Hund und Affe" * auszudrücken, der nur einfache Zeichen ausgibt. Als Voraussetzung werden die folgenden im Beispiel verwendeten Klassen / Funktionen / Makros erläutert.

Unterschied zwischen Hund und Affe

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(){}  //Mit Vererbungsziel überschreiben
  virtual void actionTalk(){} //Mit Vererbungsziel überschreiben
  virtual void actionEat(){}  //Mit Vererbungsziel überschreiben
};

class Dog : public Animal{
public:
  Dog(){ this->init("Hund", "einer! einer!", "Knochen"); }
  virtual void actionRun() override { print(strMarge(this->getName(), "Geht mit vier Beinen")); }
  virtual void actionTalk() override { print(strMarge(this->getName(), "Ist", this->getVoice(), "Gebell")); }
  virtual void actionEat() override { print(strMarge(this->getName(), "Ist", this->getFood(), "Iss mit einem Gorigori")); }
};

class Monkey : public Animal{
public:
  Monkey(){ this->init("Affe", "Schlüssel! Schlüssel!", "Banane"); }
  virtual void actionRun() override { print(strMarge(this->getName(), "Geht mit Gliedern")); }
  virtual void actionTalk() override { print(strMarge(this->getName(), "Ist", this->getVoice(), "Schrei")); }
  virtual void actionEat() override { print(strMarge(this->getName(), "Ist", this->getFood(), "Von Hand schälen und essen")); }
};

int main()
{
  std::shared_ptr<Animal> dog    = std::make_shared<Dog>();
  std::shared_ptr<Animal> monkey = std::make_shared<Monkey>();
  
  dog->actionRun();     //Der Hund geht mit vier Beinen
  dog->actionTalk();    //Der Hund ist einer! einer! Gebell
  dog->actionEat();     //Hunde fressen Knochen

  monkey->actionRun();  //Affe geht mit Gliedern
  monkey->actionTalk(); //Affe ist der Schlüssel! Schlüssel! Schrei
  monkey->actionEat();  //Affen schälen Bananen von Hand und essen

  return 0;
}

Selbst wenn ** Typ ** Tier ist, ist der Ausgabeinhalt unterschiedlich, da ** Entität (Instanz) ** Hund und Affe ist. Die Hauptpunkte des obigen Codes sind in einem Aufzählungszeichen zusammengefasst.

• (1) Wenn Sie jede Klasse von Hunden und Affen deklarieren, ** erben ** Sie die Klasse Tier, die gemeinsame Attribute verwaltet.
• Zum Zeitpunkt der Initialisierung wird jedes gemeinsame Attribut initialisiert. -② Überschreiben (überschreiben) ** drei virtuelle Tierfunktionen in jeder Klasse und implementieren Sie das Verhalten separat. ** (Polymorphismus) ** ――③ Ich habe die gemeinsame Methode in der Hauptfunktion aufgerufen, aber verschiedene Sätze wurden ausgegeben, ohne etwas zu wissen. (Verkapselung)

Wenn ①②③ abgeschlossen ist, ** ist das objektorientierte Framework abgeschlossen **.

Zusammenfassung

Wenn es um das eigentliche Spiel geht, ist jede im Level 5-Beispiel geschriebene Klassenmethode Es wird ein komplizierterer Mechanismus mit Animations- und Statusänderungen sein, anstatt mit einfachen Inhalten wie der Zeichenausgabe. Teilen Sie den komplizierten Mechanismus in Klassen ein, um das Verhalten von außen zu verbergen. ** Es ist möglich, die Implementierungsgeschwindigkeit zu verbessern und lesbaren Quellcode auf natürliche Weise zu implementieren **, Es ist ein absoluter objektorientierter Vorteil.