Hauptkonzepte der objektorientierten Programmierung -Nesne Yönelimli Programlamanın Ana Kavramları — OOB Main Concepts

OOB kavramına ait ana konuları anlatmaya çalışacağım yazımı okuduğunuz için teşekkür ederim.

Thank you for reading my article where I will try to explain the main topics of the OOB concept.

Vielen Dank für die Lektüre meines Artikels, in dem ich versuchen werde, die wichtigsten Themen des OOB-Konzepts zu erklären.

1.Soyutlama (Abstraction)

Soyutlama, bir problemi çözmek için gerekli olan özellik ve davranışları belirleyip sadeleştirme işlemidir. Örneğin, tüm evcil hayvanlarda ortak olan özellikleri (isim, cins, ağırlık gibi) tek bir sınıfta toplayarak, her hayvan türü için bu bilgilerin temelini oluşturabiliriz. Böylece, her özel hayvan türü için ayrı ayrı tekrarlanmamış olur.

Örnekte bir veteriner programı tasarladığımızı düşünün. Neredeyse bütün hayvanların ortak özelliklerinden bir kaçı, adı, cinsi, kilosu gibi özellikleri her hayvanı bir sınıf olarak tanımlamamız gerektiğinde tekrar tekrar yazabiliriz. Ancak bu bir çok açıdan yorucu ve karmaşık olur.

Bunun yerine biz bu özellikleri ev hayanları sınıfı altında soyutlama yöntemi ile tanımlayabiliyoruz. İkinci kısımdaki kalıtım özelliği ile biz bu alanları kullanma kabiliyetini her hayvan için edineceğiz.

Örnek Kod:

class Pet {
    private String name;
    private String breed;
    private double weight;

//burada yaptığımız tanımlamalar sayesinde tekrar tekrar her sınıfta private
// gibi veri tipi, getter setter methodlarını eklemek zorunda olmayacağız

public Pet(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public String getBreed() {
        return breed;
    }
    public double getWeight() {
        return weight;
    }
}

2. Kalıtım (Inheritance)

Kalıtım, ortak özellik ve metotları üst sınıfta (örneğin Pet) tanımlayarak, daha spesifik alt sınıflara (örneğin Dog ve Cat) aktarmayı sağlar. Bu, kod tekrarını azaltır ve ortak özelliklerin yönetimini kolaylaştırır.

Şimdi diyelim biz kalıtım özelliğini kullanmadık. Bir program tasarladık ve her hayvan için teker teker kodda bu alanları yazmış olalım. Dünyanın en iyi veterineri bizimle işe başladı ve biz 65.727 tane daha hayvan için bu alanları tanımlamamız gerekecek. 65 bin küsur sayfada teker teker private string name yazmak ister misiniz?

class elefant {
    private String name;
    private String breed;
    private double weight;

public Pet(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public String getBreed() {
        return breed;
    }
    public double getWeight() {
        return weight;
    }
}
// bunu 65 bin satır boyunca yapacağına pet klasından 
// kalıtılmını almak emin ol daha kolay

Örnek Kod:

class Dog extends Pet {
    public Dog(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}
// onlarca satır yazmak yerine daha az satır ile tanımlamalar yapıldı

class Cat extends Pet {
    public Cat(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}

class Elefant extends Pet{
    public Elefant(String name, String breed, double weight){
        super (name,breed,weight);
  }
}

3. Kapsülleme (Encapsulation)

Kapsülleme, nesnenin iç durumunun (verilerinin) dış erişime kapatılarak, yalnızca belirlenmiş metotlar (getter/setter) üzerinden erişilmesini sağlar. Böylece nesnenin durumu koruma altına alınır, istenmeyen değişikliklerin ve yan etkilerin önüne geçilir.

Özel (Private) Alanların Tanımlanması:

• İşlem: Sınıf içindeki değişkenleri (özellikleri) private erişim belirleyicisiyle tanımlamak.
• Etkisi: Bu, dış sınıfların ve dış kodun doğrudan bu verilere erişmesini engeller.
• Örnek:

class Dog {     
// Sadece Dog sınıfı erişebilir.     
private String favoriteToy; }

Veriye Erişim İçin Getter Metotlarının Oluşturulması:

• İşlem: private olarak tanımlanmış alanın değerini dışarıya vermek için public bir metot yazmak.
• Etkisi: Dış dünya, nesnenin durumunu (örneğin, favori oyuncağı) öğrenmek istediğinde bu metodu kullanır; fakat doğrudan alanı değiştiremez.
• Örnek:

public String getFavoriteToy() {     

// işlemi getFavoriteToy methodu ile yapıyoruz böylece favoriteToy alanı
// dışarıya kapalı oluyor

return favoriteToy; 

}

Veriye Değişiklik Yapmak İçin Setter Metotlarının Oluşturulması:

• İşlem: private alandaki değeri değiştirmek için kontrol edilen bir metot oluşturmak.
• Etkisi: Nesnenin durumundaki değişiklikler, belirli kurallar veya kontroller eklenerek yapılabilir. Böylece yanlış veya istenmeyen verinin girilmesi engellenir.
• Örnek:

public void setFavoriteToy(String toy) {     
// Örneğin burada geçerli bir değer kontrolü yapılabilir.     

if(toy != null && !toy.isEmpty()) {         
this.favoriteToy = toy;
  }
}

Neden Getter ve Setter Metotları Kullanılır?

Kontrollü Erişim Sağlamak:

• Doğrudan Erişim Sorunu: Eğer veriye direkt olarak erişime izin verilseydi, başka sınıflar doğrudan bu veriyi okuyabilir veya değiştirebilirdi. Bu, verinin beklenmeyen veya hatalı bir şekilde değiştirilmesine yol açabilirdi.
• Getter/Setter Çözümü: Getter ve setter metotları sayesinde, veriye ulaşım ve veri değiştirme işlemleri kontrol altında tutulur. Setter metotlarında veri geçerliliği, format kontrolü gibi ek işlemler yapılabilir.

Güvenlik ve Veri Bütünlüğü:

• Veri Koruması: Nesnenin iç verilerini doğrudan açığa çıkarmamak, veri bütünlüğünü korumanın en önemli yollarından biridir. Böylece, nesnenin durumu beklenmedik değişikliklerden korunur.
• İlgili İşlemlerin Takibi: Bir verinin değiştirilmesi sırasında ek işlemler (örneğin, loglama, güncelleme işlemleri) yapılmak isteniyorsa, setter metoduna bu işlemler eklenebilir.

Bakım ve Esneklik:

• Değişen Gereksinimler: Kodun ilerleyen dönemlerinde iç veri yapısını veya temsil şeklini değiştirmek gerekebilir. Getter ve setter metotları kullanılıyorsa, dış dünya bu metotlara bağlı kalır; yani iç yapı değişse bile, metotların dışarıya sunduğu arayüz aynı kalabilir.
• Kodun Tek Noktadan Yönetimi: Veriye erişim ve veri değiştirme işlemleri tek bir noktada (getter/setter metotları) toplandığı için, bu metotlarda yapılacak değişiklik tüm sistemi etkileyecek şekilde merkezi olarak uygulanır.

Örnek Kod:

class Dog extends Pet {
    private String favoriteToy;

public Dog(String name, String breed, double weight, String favoriteToy) {
        super(name, breed, weight);
        this.favoriteToy = favoriteToy;
    }
    public void setFavoriteToy(String toy) {
        this.favoriteToy = toy;
    }
    public String getFavoriteToy() {
        return favoriteToy;
    }
}

4. Çok Biçimlilik (Polymorphism)

Çok biçimlilik, aynı arayüz veya metodun farklı nesneler tarafından farklı şekillerde uygulanabilmesini sağlar. Bu, aynı metodun çağrılmasıyla farklı nesnelerin kendi özelliklerine uygun işlemleri gerçekleştirmesine olanak tanır. Örneğin, tüm evcil hayvanlar için ortak bir speak() metodu tanımladığımızda, her hayvan türü bu metodu kendi sesini çıkartacak şekilde yeniden tanımlayabilir.

Örnek Kod:

class Pet {
    public void speak() {
        System.out.println("This pet makes no sound.");
    }
}

class Dog extends Pet {
    @Override
    public void speak() {
        System.out.println("Bark!");
    }
}

class Cat extends Pet {
    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

class Elefant extends Pet{
@Override
    public void speak() {
        System.out.println("Ruaaaa!");
  }  
}

Bu örnekte:

• Pet sınıfında tanımlanan speak() metodu, genel bir davranışı temsil eder.
• Dog sınıfında speak() metodu ezilerek (“override”) farklı bir uygulama (havlama) gerçekleştirilir.
• Cat sınıfında ise yine speak() metodu ezilerek (override) kediye özgü bir ses (miyavlama) ortaya konur.
• Elefant sınıfında da aynı işlem yapılmış olur.

Polimorfizmin Avantajları:

• Esneklik: Uygulama içerisinde Pet tipinde referanslar kullanarak farklı türde evcil hayvanların, yani Dog, Cat gibi, üzerinde aynı işlemi (örneğin speak()) çağırabilirsiniz. Her biri kendi sınıfında tanımlı olan davranışı sergileyecektir.
• Genişletilebilirlik: Yeni bir evcil hayvan türü eklemek istediğinizde, sadece Pet sınıfından kalıtım alıp kendi özel speak() metodunuzu tanımlamanız yeterli olacaktır. Ana uygulamada herhangi bir değişiklik yapmaya gerek kalmaz.
• Bakım Kolaylığı: Farklı nesneler arasında ortak bir arayüz kullanıldığından, sistemin bakımı, genişletilmesi ve anlaşılması kolaylaşır.

Bu yapı, nesne yönelimli programlamanın temel kavramlarını düzenli bir şekilde kullanarak hem kodun okunabilirliğini artırır hem de yeniden kullanılabilir ve sürdürülebilir bir sistem geliştirme imkanı sunar.

English Version

Main Concepts of Object-Oriented Programming

Abstraction Abstraction is the process of identifying and simplifying the necessary attributes and behaviors needed to solve a problem. For instance, by gathering the common characteristics of all pets (such as name, breed, weight, etc.) into a single class, we can lay the foundational information for each specific type of animal. This way, we avoid repeating the same attributes for every pet type.

Imagine we are designing a veterinary program. Almost all animals share some common attributes such as name, breed, and weight. If we were to define these attributes separately in each class, it would be repetitive and cumbersome. Instead, we can define these properties under the Pet class using abstraction. Through the inheritance feature (explained in the second part), each animal will have access to these fields.

Example Code:

class Pet {
    private String name;
    private String breed;
    private double weight;

    // With these definitions, we no longer need to repeatedly add private,
    // data types, and getter/setter methods in every class.
    public Pet(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public String getBreed() {
        return breed;
    }

    public double getWeight() {
        return weight;
    }
}

Inheritance Inheritance allows us to define common attributes and methods in a parent class (for example, Pet), and then pass those attributes to more specific subclasses (for example, Dog and Cat). This reduces code repetition and simplifies the management of common properties.

Now, consider if we didn’t use inheritance. Suppose we designed a program and manually wrote these fields for each animal. Imagine if the world’s best veterinarian joined our team and we had to define these attributes for 65,727 more animals. Would you really want to write private String name over and over for 65 thousand lines?

class Elephant {
    private String name;
    private String breed;
    private double weight;

    public Elephant(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public String getBreed() {
        return breed;
    }

    public double getWeight() {
        return weight;
    }
}

Instead of writing 65,000 lines of repetitive code, you can inherit from the Pet class, which makes it much easier:

Example Code:

class Dog extends Pet {
    public Dog(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}

class Cat extends Pet {
    public Cat(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}

class Elefant extends Pet {
    public Cat(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}

1. Encapsulation Encapsulation involves restricting direct access to an object’s internal state (its data) and only allowing it via designated methods (getters/setters). This protects the object’s state from unwanted changes or side effects.

Defining Private Fields:

• Process: Define the attributes (properties) inside a class with the private access modifier.
• Effect: This prevents external classes and code from directly accessing these fields.

Example:

class Dog {          
// Only the Dog class can access this field.     
private String favoriteToy; 
}

Creating Getter Methods for Accessing the Data:

• Process: Write a public method that returns the value of the private field.
• Effect: The external code uses this method to get the object’s state (for example, its favorite toy), but cannot directly modify the field.

Example:

public String getFavoriteToy() {          
// We access the favoriteToy field via the getFavoriteToy method,     
// keeping it encapsulated.     
return favoriteToy;  }

Creating Setter Methods for Modifying the Data:

• Process: Create a method that allows the private field to be changed under controlled conditions.
• Effect: You can include validation or checks within the setter method to prevent invalid or unwanted changes to the data.

Example:

public void setFavoriteToy(String toy) {
// For example, here we can validate the toy's value.
if(toy != null && !toy.isEmpty()) {
this.favoriteToy = toy;
  }
}

Why Use Getter and Setter Methods?

• Controlled Access:
• Direct Access Issue: Without restrictions, direct access to the data might allow other classes to read or modify it in unintended or erroneous ways.
• Getter/Setter Solution: Using getters and setters, access to the data is controlled, and additional operations such as value validation can be performed within the setter.

Security and Data Integrity:

• Data Protection: By not exposing the internal data directly, the integrity of the data is preserved, protecting it from unexpected modifications.
• Tracking Operations: If additional tasks (like logging or updating related components) need to be performed when data changes, these can be integrated into the setter method.

Maintenance and Flexibility:

• Changing Requirements: In later stages, if the internal data structure needs to change, as long as you maintain the same getter and setter interfaces, the external code remains unaffected.
• Centralized Management: Managing all data access and modifications through these methods allows changes to propagate consistently throughout the system.

Example Code:

class Dog extends Pet {     
private String favoriteToy;      
public Dog(String name, String breed, double weight, String favoriteToy) { 

super(name, breed, weight);         
this.favoriteToy = favoriteToy;  
}          

public void setFavoriteToy(String toy) {         
this.favoriteToy = toy;
}          
public String getFavoriteToy() {         
return favoriteToy;
  } 
}

1. Polymorphism Polymorphism allows the same interface or method to be used by different objects in different ways. This means that when the same method is called, each object can execute its own version of that method according to its specific characteristics. For example, if we define a common speak() method for all pets, each pet type can override this method to produce its distinct sound.
2. Example Code:

class Pet {     
public void speak() {         
System.out.println("This pet makes no sound.");     
  }
}  

class Dog extends Pet {     

@Override     
public void speak() {         
System.out.println("Bark!");     
  } 
}  

class Cat extends Pet {     

@Override     
public void speak() {         
System.out.println("Meow!");     
  } 
}

class Elefant extends Pet{

@Override
    public void speak() {
        System.out.println("Ruaaaa!");
  }  
}

In this example:

• The speak() method defined in the Pet class represents a general behavior.
• In the Dog class, the speak() method is overridden to produce a specific behavior (barking).
• In the Cat class, the speak() method is similarly overridden to output a cat’s distinctive sound (meowing).
• In the Elefant class, the speak() method is similarly overridden.

Advantages of Polymorphism:

• Flexibility: You can use references of type Pet to perform operations on different pet types (like Dog ,CatandElefant) by simply calling speak(). Each will perform its specific action.
• Extensibility: To add a new pet type, simply inherit from the Pet class and implement your own speak() method. The main application remains unchanged.
• Ease of Maintenance: Since different objects use a common interface, managing, extending, and understanding the system becomes simpler.

This structure, by employing the fundamental concepts of object-oriented programming, increases code readability and offers a sustainable, reusable, and maintainable system development framework.

Deutsch Fussung

Hauptkonzepte der objektorientierten Programmierung

Abstraktion

Abstraktion ist der Prozess der Identifizierung und Vereinfachung der notwendigen Attribute und Verhaltensweisen, die zur Lösung eines Problems erforderlich sind. Zum Beispiel können wir, indem wir die gemeinsamen Merkmale aller Haustiere (wie Name, Rasse, Gewicht usw.) in einer einzelnen Klasse zusammenfassen, die grundlegenden Informationen für jede spezifische Tierart festlegen. Auf diese Weise vermeiden wir, dass dieselben Attribute für jeden Haustiertyp wiederholt werden.

Stellen Sie sich vor, wir entwerfen ein Programm für eine Tierklinik. Fast alle Tiere haben gemeinsame Attribute wie Name, Rasse und Gewicht. Wenn wir diese Attribute in jeder Klasse separat definieren würden, wäre das redundant und umständlich. Stattdessen können wir diese Eigenschaften mithilfe der Abstraktion in der Klasse Pet (Haustier) definieren. Durch das Vererbungskonzept (im nächsten Abschnitt erläutert) hat jedes Tier dann Zugriff auf diese Felder.

Beispielcode:

class Pet {
    private String name;
    private String breed;
    private double weight;

// Mit diesen Definitionen müssen wir nicht in jeder Klasse erneut "private",
    // Datentypen und Getter/Setter-Methoden hinzufügen.
    public Pet(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public String getBreed() {
        return breed;
    }

    public double getWeight() {
        return weight;
    }
}

Vererbung

Vererbung ermöglicht es uns, gemeinsame Attribute und Methoden in einer Elternklasse (zum Beispiel Pet) zu definieren und diese Attribute dann an spezifischere Unterklassen (zum Beispiel Dog und Cat) weiterzugeben. Dies reduziert Codewiederholungen und vereinfacht die Verwaltung gemeinsamer Eigenschaften.

Stellen Sie sich vor, wir würden keine Vererbung verwenden. Angenommen, wir entwerfen ein Programm und schreiben diese Felder manuell für jedes Tier. Was, wenn der weltbeste Tierarzt in unser Team kommt und wir diese Attribute für 65.727 weitere Tiere definieren müssten? Möchten Sie wirklich “private String name” 65.000 Mal wiederholen?

class Elephant {
    private String name;
    private String breed;
    private double weight;

public Elephant(String name, String breed, double weight) {
        this.name = name;
        this.breed = breed;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public String getBreed() {
        return breed;
    }

    public double getWeight() {
        return weight;
    }
}

Anstatt 65.000 Zeilen redundanten Codes zu schreiben, können Sie von der Pet-Klasse erben, was es viel einfacher macht:

Beispielcode:

class Dog extends Pet {
    public Dog(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}
class Cat extends Pet {
    public Cat(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}
class Elefant extends Pet {
    public Elefant(String name, String breed, double weight) {
        super(name, breed, weight);
    }
}

Kapselung

Kapselung bedeutet, dass der direkte Zugriff auf den internen Zustand eines Objekts (seine Daten) eingeschränkt wird und nur über bestimmte Methoden (Getter/Setter) erfolgt. Dies schützt den Zustand des Objekts vor unerwünschten Änderungen oder Nebenwirkungen.

Definition privater Felder:

• Prozess: Definieren Sie die Attribute (Eigenschaften) innerhalb einer Klasse mit dem private-Zugriffsmodifikator.
• Wirkung: Dadurch wird verhindert, dass externe Klassen oder Code direkt auf diese Felder zugreifen.

Beispiel:

class Dog {
    // Nur die Klasse Dog kann auf dieses Feld zugreifen.
    private String favoriteToy;
}

Erstellen von Getter-Methoden zum Zugriff auf die Daten:

• Prozess: Schreiben Sie eine öffentliche Methode, die den Wert des privaten Feldes zurückgibt.
• Wirkung: Externer Code verwendet diese Methode, um den Zustand des Objekts abzurufen (zum Beispiel sein Lieblingsspielzeug), kann das Feld jedoch nicht direkt ändern.

Beispiel:

public String getFavoriteToy() {
    // Wir greifen über die Methode getFavoriteToy auf das Feld favoriteToy zu,
    // wodurch es gekapselt bleibt.
    return favoriteToy;
}

Erstellen von Setter-Methoden zum Ändern der Daten:

• Prozess: Erstellen Sie eine Methode, die es erlaubt, das private Feld unter kontrollierten Bedingungen zu verändern.
• Wirkung: Sie können innerhalb der Setter-Methode Validierungen oder Prüfungen einbauen, um ungültige oder unerwünschte Änderungen zu verhindern.

Beispiel:

public void setFavoriteToy(String toy) {
    // Beispiel: Hier können wir den Wert von toy validieren.
    if (toy != null && !toy.isEmpty()) {
        this.favoriteToy = toy;
    }
}

Warum Getter- und Setter-Methoden verwenden?

• Kontrollierter Zugriff:
• Problem des direkten Zugriffs: Ohne Einschränkungen könnte der direkte Zugriff auf die Daten es anderen Klassen erlauben, diese in unbeabsichtigter oder fehlerhafter Weise zu lesen oder zu ändern.
• Lösung mit Getter/Setter: Durch die Verwendung von Getter- und Setter-Methoden wird der Zugriff auf die Daten kontrolliert und es können zusätzliche Operationen wie beispielsweise eine Validierung innerhalb des Setters durchgeführt werden.
• Sicherheit und Datenintegrität:
• Datenschutz: Durch das Nicht-Offenlegen der internen Daten wird die Integrität der Daten bewahrt und vor unerwarteten Änderungen geschützt.
• Nachverfolgung von Operationen: Falls zusätzliche Aufgaben (wie Logging oder das Aktualisieren verwandter Komponenten) beim Ändern der Daten erforderlich sind, können diese in die Setter-Methode integriert werden.
• Wartbarkeit und Flexibilität:
• Änderungsanforderungen: Wenn sich in späteren Phasen die interne Datenstruktur ändern sollte, bleibt der externe Code funktionsfähig, solange die gleichen Getter- und Setter-Schnittstellen beibehalten werden.
• Zentralisierte Verwaltung: Durch die zentrale Verwaltung aller Zugriffe und Änderungen über diese Methoden können Änderungen konsistent im gesamten System propagiert werden.

Beispielcode:

class Dog extends Pet {
    private String favoriteToy;

    public Dog(String name, String breed, double weight, String favoriteToy) {
        super(name, breed, weight);
        this.favoriteToy = favoriteToy;
    }

    public void setFavoriteToy(String toy) {
        // Hier können zusätzliche Validierungen durchgeführt werden
        this.favoriteToy = toy;
    }

    public String getFavoriteToy() {
        return favoriteToy;
    }
}

Polymorphie

Polymorphie ermöglicht es, dieselbe Schnittstelle oder Methode von verschiedenen Objekten auf unterschiedliche Weise nutzen zu lassen. Das bedeutet, dass wenn dieselbe Methode aufgerufen wird, jedes Objekt seine eigene Version dieser Methode entsprechend seinen spezifischen Eigenschaften ausführen kann. Zum Beispiel können wir, wenn wir eine gemeinsame Methode speak() für alle Haustiere definieren, jede Tierart diese Methode überschreiben, um ihren eigenen, charakteristischen Laut zu erzeugen.

Beispielcode:

class Pet {
    public void speak() {
        System.out.println("Dieses Haustier macht keinen Ton.");
    }
}

class Dog extends Pet {
    @Override
    public void speak() {
        System.out.println("Wuff!");
    }
}
class Cat extends Pet {
    @Override
    public void speak() {
        System.out.println("Miau!");
    }
}
class Elefant extends Pet {
    @Override
    public void speak() {
        System.out.println("Ruaaaa!");
    }
}

In diesem Beispiel:

• Definiert die Methode speak() in der Klasse Pet ein allgemeines Verhalten.
• Überschreibt die Methode speak() in der Klasse Dog das allgemeine Verhalten, um ein spezifisches Verhalten (Bellen) zu implementieren.
• Überschreibt die Methode speak() in der Klasse Cat ebenfalls, um den charakteristischen Laut einer Katze (Miau) auszugeben.
• Ebenso wird in der Klasse Elefant die Methode speak() überschrieben.

Vorteile der Polymorphie:

• Flexibilität: Sie können Referenzen des Typs Pet verwenden, um Operationen an verschiedenen Haustierarten (wie Dog, Cat und Elefant) durchzuführen, indem Sie einfach speak() aufrufen. Jede wird ihre spezifische Aktion ausführen.
• Erweiterbarkeit: Um einen neuen Haustiertyp hinzuzufügen, müssen Sie lediglich von der Klasse Pet erben und Ihre eigene speak()-Methode implementieren. Die Hauptanwendung bleibt unverändert.
• Wartbarkeit: Da unterschiedliche Objekte eine gemeinsame Schnittstelle verwenden, wird das System einfacher zu verwalten, zu erweitern und zu verstehen.

Diese Struktur, die die grundlegenden Konzepte der objektorientierten Programmierung anwendet, erhöht die Lesbarkeit des Codes und bietet ein nachhaltiges, wiederverwendbares und wartbares Systementwicklungsrahmenwerk.