Aplikasi o Prinsip Terbuka/Tertutup com TypeScript e Java

Konsep

Abstraksi

Abstraksi dalam konsep berorientasikan objek ialah amalan mentakrifkan hanya aspek penting yang mesti ada pada kelas. Kelas, secara semula jadi, mestilah tidak lengkap dan tidak tepat supaya kita boleh memodelkan kekhususan melalui kelas kanak-kanak. Maka timbullah konsep kelas anak perempuan, kelas ibu dan warisan.

Warisan

Warisan ialah perwakilan perhubungan antara kelas di mana satu kelas melanjutkan kelas lain untuk mewarisi gelagat kelas induk.

PADAT

SOLID ialah akronim yang mewakili lima prinsip asas pengaturcaraan berorientasikan objek, yang dicadangkan oleh Robert C. Martin - Uncle Bob. Di sini anda boleh membaca lebih lanjut tentang artikelnya.
Prinsip ini bertujuan untuk menambah baik struktur dan penyelenggaraan kod, menjadikannya lebih fleksibel, berskala dan lebih mudah difahami. Prinsip sedemikian membantu pengaturcara mencipta kod yang lebih teratur, membahagikan tanggungjawab, mengurangkan kebergantungan, memudahkan proses pemfaktoran semula dan menggalakkan penggunaan semula kod.

Prinsip Terbuka/Tertutup

"O" dalam akronim bermaksud "Prinsip Terbuka/Tertutup". Frasa yang uncle bob gunakan untuk mentakrifkan prinsip ini ialah:

"Kelas mesti dibuka untuk sambungan tetapi ditutup untuk pengubahsuaian"

Mengikut prinsip ini, kami mesti membangunkan aplikasi yang memastikan kami menulis kelas atau modul dengan cara generik supaya apabila anda merasakan keperluan untuk melanjutkan tingkah laku kelas atau objek, anda tidak perlu menukar kelas itu sendiri . Sambungan di sini boleh dibaca sebagai tambahan atau perubahan prosedur.

Objektifnya adalah untuk membenarkan penambahan fungsi baharu tanpa perlu menukar kod sedia ada. Ini meminimumkan risiko memperkenalkan pepijat dan menjadikan kod lebih boleh diselenggara.

Aplikasi praktikal

Bayangkan anda mempunyai kelas DiskaunKalkulator yang mengira diskaun produk. Pada mulanya, kami mempunyai dua kategori produk: Elektronik dan Pakaian. Mari kita mulakan tanpa menggunakan OCP (Prinsip Terbuka/Tertutup):

Jawa

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

Skrip taip

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

Masalah dengan Tidak Memohon OCP

Pelanggaran Enkapsulasi: Setiap kali jenis produk baharu memerlukan diskaun berbeza, kaedah hitungDiskaun perlu diubah, termasuk bersyarat baharu dalam if.

Kesukaran dalam penyelenggaraan: Jika kaedah berkembang dengan terlalu banyak if/else atau suis, ia akan menjadi sukar untuk diselenggara dan diuji.

Risiko memperkenalkan pepijat: Perubahan pada kaedah boleh memperkenalkan pepijat ke bahagian lain kod yang bergantung pada kaedah itu.

Bagaimana untuk membetulkan?

Sekarang, mari kita gunakan Prinsip Terbuka/Tertutup dengan memfaktorkan semula kod untuk membolehkan penambahan jenis diskaun baharu tanpa mengubah suai kod sedia ada.

Jawa

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

Skrip taip

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

Kesimpulan

Menggunakan Prinsip Terbuka/Tertutup adalah penting jika kita perlu menambah ciri atau gelagat baharu tanpa perlu mengubah suai asas kod sedia ada dengan begitu mendalam. Malah, dari masa ke masa, kita melihat bahawa hampir mustahil untuk mengelakkan 100% menukar asas kod, tetapi adalah mungkin untuk mengurangkan jumlah kasar kod yang akan ditukar untuk memasukkan fungsi baharu.

Prinsip ini menjadikan kod lebih mudah disesuaikan dengan perubahan, sama ada untuk memenuhi keperluan baharu atau membetulkan ralat.

Atas ialah kandungan terperinci Aplikasi o Prinsip Terbuka/Tertutup com TypeScript e Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!