Untersuchen der Struktur objektorientierter Programme

11 Minuten

Objektorientierte Programmierung (OOP) verwendet Objekte, um reale Entitäten zu modellieren.

Für Entwickler, die mit der strukturierten Programmierung vertraut sind, kann ein Vergleich zwischen strukturierter Programmierung und objektorientierter Programmierung helfen, die Unterschiede zwischen den beiden Ansätzen zu klären. Darüber hinaus kann das Wachstum Ihres Verständnisses der Kapselung und des Klassenlebenszyklus Ihnen helfen, sichere und robuste Lösungen zu entwickeln.

Vergleich Object-Oriented Programmierung mit strukturierter Programmierung

Strukturierte Programmierung und objektorientierte Programmierung (OOP) sind zwei unterschiedliche Ansätze für die Softwareentwicklung mit jeweils eigenen Prinzipien und Methoden. Die strukturierte Programmierung basiert auf einem Top-Down-Ansatz, bei dem das Programm in kleinere, verwaltbare Funktionen oder Verfahren unterteilt ist. Dieser Ansatz betont einen klaren und logischen Kontrollfluss mithilfe von Schleifen, Bedingungen und Unterroutinen. Objektorientierte Programmierung organisiert Softwaredesign um Objekte, die sowohl Daten als auch Verhalten kapseln, um eine modularere und wiederverwendbare Codestruktur zu fördern. Während sich die strukturierte Programmierung auf die Abfolge der auszuführenden Aktionen konzentriert, betont die objektorientierte Programmierung die objekte, die an den Aktionen beteiligt sind.

Wir können reale Beispiele für Bauprojekte als Metaphern verwenden, um die Unterschiede zwischen strukturierter Programmierung und objektorientierter Programmierung zu veranschaulichen.

Beispiel für Object-Oriented Programmierung

Stellen Sie sich objektorientierte Programmierung als Entwurf und Bau einer Stadt vor. In dieser Metapher stellt jedes Gebäude eine Klasse dar, und die Räume und Einrichtungen jedes Gebäudes stellen die Eigenschaften und Methoden dieser Klasse dar. Ebenso wie eine Stadt aus verschiedenen Gebäuden besteht, die jeweils einem bestimmten Zweck dienen (Wohn-, Gewerbe-, Industrie-), besteht ein OOP-Programm aus verschiedenen Klassen, die jeweils für die Behandlung bestimmter Aufgaben konzipiert sind. Die Gebäude (Klassen) werden basierend auf Blaupausen (Klassendefinitionen) erstellt, und jedes Gebäude kann mehrere Instanzen (Objekte) aufweisen, die dieselbe Struktur aufweisen, aber unterschiedliche Zustände (Daten) aufweisen können.

In dieser Stadt ist Kapselung wie die Wände eines Gebäudes, das seine innenliegende Struktur schützt und nur den Zugang durch bestimmte Türen und Fenster (Methoden) zulässt. Kapselung stellt sicher, dass die internen Arbeiten eines Gebäudes (Klasse) von der Außenwelt verborgen sind, und Interaktionen mit dem Gebäude werden kontrolliert und sicher.

Diese Metapher des Stadtbaus hebt die modulare und wiederverwendbare Natur von OOP hervor, in der jede Klasse (Gebäude) unabhängig entwickelt, getestet und gepflegt werden kann, aber sie alle arbeiten zusammen, um eine zusammenhängende und funktionale Stadt (Programm) zu bilden. Ebenso wie eine gut geplante Stadt eine effiziente Verwaltung und Skalierbarkeit ermöglicht, fördert ein gut gestaltetes OOP-Programm die Pflegebarkeit, Flexibilität und Skalierbarkeit.

Beispiel für strukturierte Programmierung

Stellen Sie sich die strukturierte Programmierung als Quilt vor. In dieser Metapher stellt jedes Stück Stoff eine Funktion oder Prozedur in Ihrem Programm dar. Genau wie eine Quilt aus vielen einzelnen Patches besteht, besteht ein strukturiertes Programm aus verschiedenen Funktionen, die für die Durchführung bestimmter Aufgaben konzipiert sind. Jede Funktion ist wie ein Patch, der unabhängig entwickelt, getestet und gepflegt werden kann. Wenn Sie diese Patches in einer bestimmten Reihenfolge zusammenewen, erstellen Sie eine vollständige Quilt, genauso wie Sie Funktionen kombinieren, um ein vollständiges Programm zu bilden.

Bei der strukturierten Programmierung liegt der Fokus auf dem logischen Steuerungsfluss, ähnlich wie beim Planen des Layouts und der Sequenz von Patches, um ein zusammenhängendes Design zu erstellen. Der Quilter stellt sicher, dass jeder Patch perfekt mit den anderen passt, wobei ein klares und organisiertes Muster beibehalten wird. Ebenso stellt ein strukturierter Programmierer sicher, dass jede Funktion nahtlos in das gesamte Programm passt und einen klaren und logischen Kontrollfluss über die Verwendung von Schleifen, Bedingungen und Unterroutinen gewährleistet.

Diese Quiltingmetapher hebt die modulare Art der strukturierten Programmierung hervor, bei der jede Funktion (oder jedes Patch) bei Bedarf wiederverwendet und neu angeordnet werden kann. Ebenso wie ein Quilter einzelne Patches ersetzen oder ändern kann, ohne die gesamte Quilt zu unterbrechen, kann ein Programmierer einzelne Funktionen aktualisieren oder verfeinern, ohne das gesamte Programm zu beeinträchtigen. Diese Modularität macht die strukturierte Programmierung zu einem effektiven Ansatz für die Erstellung von klarem, verwendbarem und wiederverwendbarem Code. Da das Programm jedoch in Größe und Komplexität wächst, kann die Verwaltung der Interaktionen zwischen Funktionen schwieriger werden. Ebenso wie eine Quilt mit zu vielen Patches unübersichtlich und schwierig zu verwalten ist, kann ein strukturiertes Programm mit zahlreichen Funktionen und Verfahren mühsam und schwer zu verwalten sein. Da sich die Anzahl der Patches (Funktionen) erhöht, wird es schwieriger, nachzuverfolgen, wie sie zusammenpassen und interagieren. Dies führt zu Problemen wie Codeduplizierung, Schwierigkeiten beim Debuggen und mangelndem Zusammenhalt. In großen Anwendungen kann der lineare und top-down-Ansatz der strukturierten Programmierung zu einem vermischen Web von interdependenten Funktionen führen, wodurch es schwierig ist, die Codebasis zu verstehen und zu ändern. Diese Komplexität kann die Skalierbarkeit und Wartung behindern, was letztendlich die gesamte Qualität und Leistung der Software beeinflusst.

Untersuchen der Verwendung von Klassen in Object-Oriented Programmierung

Klassen sind die Bausteine der objektorientierten Programmierung (OOP) und werden verwendet, um die Struktur und das Verhalten von Objekten in einem Programm zu definieren. Das Verständnis der Vorteile, die durch Kapselung und den Lebenszyklus von Klassen bereitgestellt werden, hilft Ihnen zu verstehen, wie objektorientierte Programmierung funktioniert.

Verkapselung

Kapselung ist eines der Grundprinzipien der objektorientierten Programmierung (OOP). Es bezieht sich auf die Bündelung von Daten (Feldern) und Methoden (Verhalten), die mit den Daten in einer einzelnen Einheit arbeiten, in der Regel eine Klasse. Die Kapselung schränkt den direkten Zugriff auf einige Komponenten eines Objekts ein, wodurch die versehentliche Änderung von Daten verhindert werden kann.

Kapselung bietet die folgenden Vorteile:

Daten ausblenden: Die Kapselung ermöglicht das Ausblenden des internen Zustands eines Objekts von außen. Dies bedeutet, dass die interne Darstellung eines Objekts geändert werden kann, ohne dass sich dies auf den externen Code auswirkt, der das Objekt verwendet. Wenn Sie z. B. private Felder verwenden und öffentliche Getter- und Settermethoden bereitstellen, können Sie steuern, wie auf die Daten zugegriffen und geändert wird.

Verbesserte Verwendbarkeit: Die Kapselung erleichtert das Verwalten und Ändern von Code. Änderungen an der internen Implementierung einer Klasse wirken sich nicht auf den Code aus, der die Klasse verwendet, solange die öffentliche Schnittstelle unverändert bleibt. Diese Trennung von Bedenken ermöglicht Es Entwicklern, sich auf bestimmte Teile des Codes zu konzentrieren, ohne sich Gedanken über unbeabsichtigte Nebenwirkungen machen zu müssen.

Erhöhte Flexibilität: Kapselung ermöglicht flexibleren und modulareren Code. Indem Sie klare Schnittstellen definieren, können Sie Teile des Codes ganz einfach ersetzen oder aktualisieren, ohne dass sich dies auf andere Teile auswirkt. Dank dieser Modularität können Sie Code einfacher wiederverwenden und komplexe Systeme aus einfacheren Komponenten erstellen.

Erweiterte Sicherheit: Die Kapselung schützt die Integrität der Daten eines Objekts, indem nicht autorisierter Zugriff und Änderungen verhindert werden. Durch die Steuerung des Zugriffs auf die Daten über Methoden können Sie Regeln und Einschränkungen für die Verwendung der Daten erzwingen. Diese Erzwingung verhindert Fehler und stellt sicher, dass das Objekt in einem gültigen Zustand verbleibt.

Abstraktion: Kapselung unterstützt das Konzept der Abstraktion, indem nur die notwendigen Details eines Objekts für die Außenwelt verfügbar sind. Dies vereinfacht die Schnittstelle und erleichtert das Verständnis und die Verwendung des Objekts. Benutzer des Objekts müssen die interne Implementierung nicht kennen, wodurch die Codekomplexität reduziert und die Lesbarkeit verbessert wird.

Anmerkung

Bei der Kapselung geht es darum, die Datenmember, die Benutzer einer Klasse nicht benötigen, auszublenden. Datenmmber werden mithilfe des Schlüsselworts private Accessor gekapselt oder ausgeblendet. Der Zugriff auf ausgeblendete Feldvariablen wird mithilfe von Eigenschaften und Methoden gesteuert. Auf ausgeblendete Datenmmber kann nicht direkt zugegriffen werden.


public class Person
{
    // Private fields
    private string firstName;
    private string lastName;
    private int age;

    // Public properties with getters and setters
    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }

    public string LastName
    {
        get { return lastName; }
        set { lastName = value; }
    }

    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
            else
            {
                throw new ArgumentException("Age can't be negative");
            }
        }
    }

    // Public method
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

In diesem Beispiel:

Die Felder firstName, lastNameund age sind private, was bedeutet, dass sie nicht direkt von außerhalb der Klasse aufgerufen werden können.
Öffentliche Eigenschaften FirstName, LastNameund Age ermöglichen kontrollierten Zugriff auf die privaten Felder.
Die Age-Eigenschaft enthält Validierungslogik, um sicherzustellen, dass das Alter nicht auf einen negativen Wert festgelegt werden kann.
Die Introduce-Methode bietet eine Möglichkeit, mit den Daten des Objekts zu interagieren, ohne die internen Implementierungsdetails verfügbar zu machen.

Klassenlebenszyklus

In einer C#-Anwendung umfasst der Lebenszyklus einer Klasse mehrere Phasen von der Definition bis hin zur eventuellen Zerstörung. Der Lebenszyklus einer Klasse umfasst die folgenden Schritte:

Klassendefinition: Definieren Sie die Klasse mit ihren Membern.
Kompilierung: Kompilieren Sie die Klasse in IL-Code.
Laden: Laden sie die Assembly in den Arbeitsspeicher.
Instanziierung: Erstellen Sie eine Instanz der Klasse.
Initialisierung: Initialisieren sie die Felder und Eigenschaften des Objekts.
Verwendung: Verwenden Sie das Objekt in der Anwendung.
Garbage Collection: Reclaim the object's memory when it's longer needed.
Zerstörung: Ausführen der Bereinigungslogik und Freigeben des Speichers.

Hier ist ein Beispiel, das als Erläuterung der einzelnen Schritte im Lebenszyklus einer Klasse enthält:

Klassendefinition

Definition: Eine Klasse wird im Quellcode mit ihren Eigenschaften, Methoden und anderen Membern definiert.

Zum Beispiel:


public class Person
{
    // auto-implemented properties for name and age
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    // method to introduce the person
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

Compilierung

Kompilierung: Der Quellcode wird vom C#-Compiler in eine Zwischensprache (IL) kompiliert. Der IL-Code wird in einer Assembly (DLL- oder EXE-Datei) gespeichert.

Beispiel: Die Person-Klasse wird in IL-Code kompiliert und in der Assembly enthalten.
Laden

Laden: Wenn die Anwendung ausgeführt wird, lädt die Common Language Runtime (CLR) die Assembly in den Arbeitsspeicher.

Beispiel: Die Assembly, die die Person Klasse enthält, wird vom CLR in den Arbeitsspeicher geladen.
Instanziierung

Instanziierung: Eine Instanz der Klasse wird mithilfe des schlüsselworts new erstellt. Der Konstruktor der Klasse wird aufgerufen, um das Objekt zu initialisieren.

Zum Beispiel:
```
Person person1 = new Person { FirstName = "Tim", LastName = "Shao", Age = 25 };
```
Initialisierung

Initialisierung: Der Konstruktor initialisiert die Felder und Eigenschaften des Objekts. Jede im Konstruktor definierte Initialisierungslogik wird ausgeführt.

Beispiel: Das Person-Objekt person1 wird mit den angegebenen Werten für FirstName, LastNameund Ageinitialisiert.
Verwendung

Verwendung: Das Objekt wird in der Anwendung verwendet. Auf Methoden und Eigenschaften des Objekts wird bei Bedarf zugegriffen und geändert.

Zum Beispiel:
```
person1.Introduce();
```
Müllabfuhr

Garbage Collection: Wenn das Objekt nicht mehr benötigt wird und keine Verweise darauf vorhanden sind, gibt der Garbage Collector (GC) den vom Objekt verwendeten Speicher zurück. Der Destruktor (Finalizer) wird aufgerufen, wenn er definiert ist.

Beispiel: Wenn person1 nicht mehr an einer beliebigen Stelle im Code referenziert wird, übernimmt die GC schließlich den Speicher.
Zerstörung

Zerstörung: Der Speicher des Objekts wird freigegeben, und jede bereinigungslogik, die im Destruktor definiert ist (der Finalizer, falls angegeben), wird ausgeführt.

Beispiel: Das Person Objekt person1 wird zerstört, und sein Speicher wird von der GC zurückgefordert.

Feedback

War diese Seite hilfreich?