Application du principe ouvert/fermé avec Typescript et Java

Concepts

Abstraction

L'abstraction dans les concepts orientés objet est une pratique consistant à définir uniquement les aspects essentiels qu'une classe doit avoir. Les classes, par nature, doivent être incomplètes et imprécises pour que l'on puisse modéliser les spécificités à travers les classes enfants. Ainsi naît la notion de classes filles, de classes mères et d'héritage.

Patrimoine

L'héritage est la représentation des relations entre classes dans lesquelles une classe en étend une autre afin d'hériter des comportements de la classe parent.

SOLIDE

SOLID est un acronyme qui représente cinq principes fondamentaux de la programmation orientée objet, proposés par Robert C. Martin - Oncle Bob. Ici vous pouvez en savoir plus sur son article.
Ces principes visent à améliorer la structure et la maintenance du code, le rendant plus flexible, évolutif et plus facile à comprendre. De tels principes aident le programmeur à créer des codes plus organisés, en répartissant les responsabilités, en réduisant les dépendances, en simplifiant le processus de refactorisation et en favorisant la réutilisation du code.

Principe ouvert/fermé

Le « O » dans l'acronyme signifie « Principe ouvert/fermé ». La phrase utilisée par Oncle Bob pour définir ce principe était :

"Une classe doit être ouverte en extension mais fermée en modification"

Selon ce principe, nous devons développer une application garantissant que nous écrivons des classes ou des modules de manière générique afin que chaque fois que vous ressentez le besoin d'étendre le comportement de la classe ou de l'objet, vous n'ayez pas besoin de changer la classe elle-même. . L'extension ici peut être lue comme un ajout ou une modification de procédures.

L’objectif est de permettre l’ajout de nouvelles fonctionnalités sans avoir besoin de modifier le code existant. Cela minimise le risque d'introduction de bugs et rend le code plus maintenable.

Application pratique

Imaginez que vous ayez une classe DiscountCalculator qui calcule les remises sur les produits. Initialement, nous avons deux catégories de produits : l'électronique et l'habillement. Commençons sans appliquer l'OCP (Principe Ouvert/Fermé) :

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
    }
}

Manuscrit

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

Problèmes liés à la non-application de l'OCP

Violation d'encapsulation : Chaque fois qu'un nouveau type de produit nécessite une remise différente, il sera nécessaire de modifier la méthode calculateDiscount, en incluant une nouvelle condition dans le if.

Difficulté de maintenance : Si la méthode grandit avec trop de if/else ou de commutateurs, elle deviendra difficile à maintenir et à tester.

Risque d'introduction de bugs : Les modifications apportées à la méthode peuvent introduire des bugs dans d'autres parties du code qui dépendent de cette méthode.

Comment réparer ?

Maintenant, appliquons le principe Ouvert/Fermé en refactorisant le code pour permettre l'ajout de nouveaux types de remises sans modifier le code existant.

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
    }
}

Manuscrit

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

Conclusion

L'application du principe ouvert/fermé est essentielle si nous devons ajouter de nouvelles fonctionnalités ou de nouveaux comportements sans avoir à modifier si profondément la base de code existante. En fait, au fil du temps, on constate qu'il est pratiquement impossible d'éviter de changer à 100 % la base de code, mais il est possible d'atténuer la quantité brute de code à modifier pour insérer une nouvelle fonctionnalité.

Ce principe rend le code plus adaptable aux changements, que ce soit pour répondre à de nouvelles exigences ou corriger des erreurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!