Meine Reaktionsreise: Tag 15

Objektorientierte Programmierung (OOP)
Objektorientierte Programmierung ist ein Programmierparadigma, das auf dem Konzept von Objekten basiert.

Grundprinzipien von OOP
1. Kapselung:

• Gruppiert verwandte Variablen und Funktionen in einem Objekt.
• Fördert weniger Parameter in Funktionen und reduziert so die Komplexität. Beispiel:

function Circle(radius) {
    this.radius = radius;
    this.draw = function() {
        console.log('draw');
    };
}
const circle = new Circle(5);
console.log(circle.radius); // Access encapsulated property
circle.draw(); // Call encapsulated method

2.Abstraktion:

Versteckt die Details und die Komplexität und legt nur die notwendigen Teile eines Objekts frei.
Vereinfacht die Schnittstelle und reduziert die Auswirkungen von Änderungen im zugrunde liegenden Code.
Beispiel: Methoden abstrahieren und gleichzeitig die interne Logik verbergen.

3.Vererbung:

Ermöglicht einer Klasse (untergeordneten Klasse), Eigenschaften und Methoden von einer anderen Klasse (übergeordneten Klasse) zu erben.
Reduziert redundanten Code.
Beispiel:

class Animal {
    eat() {
        console.log("This animal is eating.");
    }
}
class Dog extends Animal {
    bark() {
        console.log("The dog is barking.");
    }
}
const dog = new Dog();
dog.eat(); // Inherited from Animal
dog.bark();

4.Polymorphismus:

Bezieht sich auf Objekte in vielen Formen.
Ermöglicht eine einheitliche Schnittstelle für verschiedene Objekttypen und ermöglicht so die Wiederverwendung von Code und Flexibilität.
Beispiel:

class Animal {
    sound() {
        console.log("This animal makes a sound.");
    }
}
class Dog extends Animal {
    sound() {
        console.log("The dog barks.");
    }
}
const animal = new Animal();
const dog = new Dog();
animal.sound(); // Output: This animal makes a sound.
dog.sound();    // Output: The dog barks.

Bedeutung von OOP

• Kapselung: Reduziert die Komplexität und verbessert die Wiederverwendbarkeit.
• Abstraktion: Versteckt Implementierungsdetails und vereinfacht die Interaktion.
• Vererbung: Eliminiert Codeduplizierung und fördert die Wiederverwendung.
• Polymorphismus: Ermöglicht Flexibilität und optimierte Codestrukturen.

Praxisbeispiele
Klassen und Konstruktoren

• Strukturierte, saubere Art, Objekte zu erstellen.
• Beispiel:

class Product {
    constructor(name, price) {
        this.name = name;
        this.price = price;
    }

    displayProduct() {
        console.log(`Product: ${this.name}`);
        console.log(`Price: $${this.price.toFixed(2)}`);
    }

    calculateTotal(salesTax) {
        return this.price + this.price * salesTax;
    }
}

const product1 = new Product("Laptop", 1200);
product1.displayProduct();
console.log(`Total Price: $${product1.calculateTotal(0.1).toFixed(2)}`);

Vererbung mit Tieren

• Demonstriert die Wiederverwendbarkeit und das Überschreiben von Methoden.
• Beispiel:

class Animal {
    eat() {
        console.log("This animal eats food.");
    }
}

class Bird extends Animal {
    fly() {
        console.log("This bird can fly.");
    }
}

const bird = new Bird();
bird.eat();
bird.fly();

Reflexion
Was ich gelernt habe:

• Kern-OOP-Prinzipien: Kapselung, Abstraktion, Vererbung, Polymorphismus.
• Praktische Anwendungsfälle zur Reduzierung der Codekomplexität und Verbesserung der Wiederverwendbarkeit.
• Anwenden von Konstruktoren, Methoden und Vererbung zur Lösung realer Probleme.

OOP ist eine andere Ebene.

Morgen geht es wieder los!

Das obige ist der detaillierte Inhalt vonMeine Reaktionsreise: Tag 15. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!