Konzepte
Abstraktion
Abstraktion in objektorientierten Konzepten ist eine Praxis, bei der nur wesentliche Aspekte definiert werden, die eine Klasse haben muss. Klassen müssen von Natur aus unvollständig und ungenau sein, damit wir Besonderheiten durch untergeordnete Klassen modellieren können. So entsteht das Konzept von Tochterklassen, Mutterklassen und Vererbung.
Erbe
Vererbung ist die Darstellung von Beziehungen zwischen Klassen, in denen eine Klasse eine andere erweitert, um das Verhalten der übergeordneten Klasse zu erben.
SOLIDE
SOLID ist ein Akronym, das fünf grundlegende Prinzipien der objektorientierten Programmierung darstellt, vorgeschlagen von Robert C. Martin – Onkel Bob. Hier können Sie mehr über seinen Artikel lesen.
Diese Prinzipien zielen darauf ab, die Struktur und Wartung des Codes zu verbessern und ihn flexibler, skalierbarer und verständlicher zu machen. Solche Prinzipien helfen dem Programmierer, besser organisierte Codes zu erstellen, Verantwortlichkeiten aufzuteilen, Abhängigkeiten zu reduzieren, den Refactoring-Prozess zu vereinfachen und die Wiederverwendung von Code zu fördern.
Offen/Geschlossen-Prinzip
Das „O“ im Akronym steht für „Offenes/Geschlossenes Prinzip“. Der Satz, mit dem Onkel Bob dieses Prinzip definierte, war:
„Eine Klasse muss für Erweiterungen geöffnet, aber für Änderungen geschlossen sein“
Gemäß diesem Prinzip müssen wir eine Anwendung entwickeln, die sicherstellt, dass wir Klassen oder Module auf generische Weise schreiben, sodass Sie die Klasse selbst nicht ändern müssen, wenn Sie das Bedürfnis verspüren, das Verhalten der Klasse oder des Objekts zu erweitern . Erweiterung kann hier als Ergänzung oder Änderung von Verfahren gelesen werden.
Ziel ist es, das Hinzufügen neuer Funktionalitäten zu ermöglichen, ohne dass der bestehende Code geändert werden muss. Dies minimiert das Risiko der Einführung von Fehlern und macht den Code wartbarer.
Praktische Anwendung
Stellen Sie sich vor, Sie haben eine DiscountCalculator-Klasse, die Produktrabatte berechnet. Zunächst haben wir zwei Produktkategorien: Elektronik und Bekleidung. Beginnen wir ohne Anwendung des OCP (Offen/Geschlossen-Prinzip):
Java
class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
class DiscountCalculator {
public double calculateDiscount(Product product) {
if (product.getName().equals("Electronics")) {
return product.getPrice() * 0.9; // 10% de desconto
} else if (product.getName().equals("Clothing")) {
return product.getPrice() * 0.8; // 20% de desconto
}
return product.getPrice();
}
}
public class Main {
public static void main(String[] args) {
Product electronics = new Product("Electronics", 100);
Product clothing = new Product("Clothing", 50);
DiscountCalculator calculator = new DiscountCalculator();
System.out.println(calculator.calculateDiscount(electronics)); // 90
System.out.println(calculator.calculateDiscount(clothing)); // 40
}
}
Nach dem Login kopieren
Typoskript
class Product {
private _name: string;
private _price: number;
constructor(name: string, price: number) {
this._name = name;
this._price = price;
}
public get name() { return this.name };
public set name(value: string) { this.name = value };
public get price() { return this.price };
public set price(value: number) { this.price = value };
}
class DiscountCalculator {
public calculateDiscount(product: Product): number {
if (product.name === 'Electronics') {
return product.price * 0.9; // 10% de desconto
} else if (product.name === 'Clothing') {
return product.price * 0.8; // 20% de desconto
}
return product.price;
}
}
const electronics = new Product('Electronics', 100);
const clothing = new Product('Clothing', 50);
const calculator = new DiscountCalculator();
console.log(calculator.calculateDiscount(electronics)); // 90
console.log(calculator.calculateDiscount(clothing)); // 40
Nach dem Login kopieren
Probleme bei Nichtanwendung von OCP
Verstoß gegen die Kapselung: Jedes Mal, wenn ein neuer Produkttyp einen anderen Rabatt erfordert, muss die Methode „calcuteDiscount“ geändert werden, einschließlich einer neuen Bedingung im if.
Schwierigkeit bei der Wartung:Wenn die Methode mit zu vielen if/else- oder Schaltern wächst, wird es schwierig, sie zu warten und zu testen.
Risiko der Einführung von Fehlern: Änderungen an der Methode können zu Fehlern in anderen Teilen des Codes führen, die von dieser Methode abhängen.
Wie beheben?
Jetzt wenden wir das Offen/Geschlossen-Prinzip an, indem wir den Code umgestalten, um das Hinzufügen neuer Arten von Rabatten zu ermöglichen, ohne den vorhandenen Code zu ändern.
Java
class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
interface DiscountStrategy {
double calculate(Product product);
}
class ElectronicsDiscount implements DiscountStrategy {
@Override
public double calculate(Product product) {
return product.getPrice() * 0.9; // 10% de desconto
}
}
class ClothingDiscount implements DiscountStrategy {
@Override
public double calculate(Product product) {
return product.getPrice() * 0.8; // 20% de desconto
}
}
class NoDiscount implements DiscountStrategy {
@Override
public double calculate(Product product) {
return product.getPrice();
}
}
class DiscountCalculator {
private DiscountStrategy discountStrategy;
public DiscountCalculator(DiscountStrategy discountStrategy) {
this.discountStrategy = discountStrategy;
}
public double calculateDiscount(Product product) {
return discountStrategy.calculate(product);
}
}
public class Main {
public static void main(String[] args) {
Product electronics = new Product("Electronics", 100);
Product clothing = new Product("Clothing", 50);
Product books = new Product("Books", 30);
DiscountCalculator electronicsDiscount = new DiscountCalculator(new ElectronicsDiscount());
DiscountCalculator clothingDiscount = new DiscountCalculator(new ClothingDiscount());
DiscountCalculator booksDiscount = new DiscountCalculator(new NoDiscount());
System.out.println(electronicsDiscount.calculateDiscount(electronics)); // 90
System.out.println(clothingDiscount.calculateDiscount(clothing)); // 40
System.out.println(booksDiscount.calculateDiscount(books)); // 30
}
}
Nach dem Login kopieren
Typoskript
class Product {
private _name: string;
private _price: number;
constructor(name: string, price: number) {
this._name = name;
this._price = price;
}
public get name() { return this.name };
public set name(value: string) { this.name = value };
public get price() { return this.price };
public set price(value: number) { this.price = value };
}
interface DiscountStrategy {
calculate(product: Product): number;
}
class ElectronicsDiscount implements DiscountStrategy {
calculate(product: Product): number {
return product.price * 0.9; // 10% de desconto
}
}
class ClothingDiscount implements DiscountStrategy {
calculate(product: Product): number {
return product.price * 0.8; // 20% de desconto
}
}
class NoDiscount implements DiscountStrategy {
calculate(product: Product): number {
return product.price;
}
}
class DiscountCalculator {
private discountStrategy: DiscountStrategy;
constructor(discountStrategy: DiscountStrategy) {
this.discountStrategy = discountStrategy;
}
public calculateDiscount(product: Product): number {
return this.discountStrategy.calculate(product);
}
}
const electronics = new Product('Electronics', 100);
const clothing = new Product('Clothing', 50);
const books = new Product('Books', 30);
const electronicsDiscount = new DiscountCalculator(new ElectronicsDiscount());
const clothingDiscount = new DiscountCalculator(new ClothingDiscount());
const booksDiscount = new DiscountCalculator(new NoDiscount());
console.log(electronicsDiscount.calculateDiscount(electronics)); // 90
console.log(clothingDiscount.calculateDiscount(clothing)); // 40
console.log(booksDiscount.calculateDiscount(books)); // 30
Nach dem Login kopieren
Abschluss
Die Anwendung des Offen/Geschlossen-Prinzips ist unerlässlich, wenn wir neue Funktionen oder Verhaltensweisen hinzufügen müssen, ohne die bestehende Codebasis so tiefgreifend ändern zu müssen. Tatsächlich stellen wir im Laufe der Zeit fest, dass es praktisch unmöglich ist, eine 100-prozentige Änderung der Codebasis zu vermeiden, aber es ist möglich, die grobe Menge an Code zu verringern, die geändert werden muss, um eine neue Funktionalität einzufügen.
Dieses Prinzip macht den Code anpassungsfähiger an Änderungen, sei es um neue Anforderungen zu erfüllen oder Fehler zu korrigieren.
Das obige ist der detaillierte Inhalt vonAnwendung des Open/Closed-Prinzips mit Typescript und Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
