Pembangunan Berorientasikan PADAT

Dalam pembangunan perisian, penyelenggaraan kod, sambungan dan fleksibiliti adalah penting untuk kejayaan jangka panjang sesuatu projek. Prinsip SOLID telah dirumuskan untuk membimbing pembangun dalam mencipta kod yang lebih mudah difahami, diubah suai dan dikembangkan. Dalam artikel ini, kita akan bercakap tentang setiap lima prinsip SOLID dan cara menggunakannya dengan contoh praktikal dalam Java.

1. Prinsip Tanggungjawab Tunggal

Prinsip Tanggungjawab Tunggal (SRP) menetapkan bahawa kelas mesti mempunyai hanya satu sebab untuk berubah, iaitu, ia mesti mempunyai satu tanggungjawab dalam sistem.

// Antes de aplicar o SRP
class ProductService {
    public void saveProduct(Product product) {
        // Lógica para salvar o produto no banco de dados
    }

    public void sendEmail(Product product) {
        // Lógica para enviar um email sobre o produto
    }
}

// Após aplicar o SRP
class ProductService {
    public void saveProduct(Product product) {
        // Lógica para salvar o produto no banco de dados
    }
}

class EmailService {
    public void sendEmail(Product product) {
        // Lógica para enviar um email sobre o produto
    }
}

Dalam contoh, kami memisahkan tanggungjawab untuk menyimpan produk dalam pangkalan data daripada tanggungjawab untuk menghantar e-mel tentang produk tersebut. Ini memudahkan perubahan pada masa hadapan, kerana perubahan dalam menghantar e-mel tidak lagi menjejaskan logik penjimatan produk.

2. Prinsip Terbuka/Tertutup

Prinsip Terbuka/Tertutup (OCP) mencadangkan bahawa entiti perisian (kelas, modul, fungsi, dll.) harus dibuka untuk sambungan, tetapi ditutup untuk pengubahsuaian. Ini dicapai melalui penggunaan abstraksi dan warisan.

// Exemplo inicial violando o OCP
class AreaCalculator {
    public double calculateArea(Rectangle[] rectangles) {
        double area = 0;
        for (Rectangle rectangle : rectangles) {
            area += rectangle.width * rectangle.height;
        }
        return area;
    }
}

// Exemplo após aplicar o OCP
interface Forma {
    double calculateArea();
}
class Rectangle implements Forma {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return width * height;
    }
}

class AreaCalculator {
    public double calculateArea(Forma [] formas) {
        double area = 0;
        for (Forma formas: formas) {
            area += forma.calculateArea();
        }
        return area;
    }
}

Dalam contoh kedua ini, pada mulanya kelas AreaCalculator bergantung secara langsung pada kelas Rectangle. Ini bermakna jika anda ingin menambah jenis bentuk lain, seperti bulatan atau segi tiga, anda perlu mengubah suai kelas AreaCalculator, sekali gus melanggar OCP. Dengan penciptaan antara muka Shape, kelas AreaCalculator mampu menerima bentuk geometri baharu tanpa mengubah suai kod sedia ada.

3. Prinsip Penggantian Liskov

Prinsip Penggantian Liskov (LSP) menyatakan bahawa objek kelas super mesti boleh digantikan oleh objek subkelasnya tanpa menjejaskan integriti sistem. Dalam erti kata lain, gelagat subkelas mesti konsisten dengan gelagat superclass.

// Classe base
class Bird {
    public void fly() {
        // Método padrão que imprime "Flying"
        System.out.println("Flying");
    }
}

// Classe derivada que viola o LSP
class Duck extends Bird {
    @Override
    public void fly() {
        // Sobrescrita que imprime "Ducks cannot fly"
        System.out.println("Ducks cannot fly");
    }
}

Masalah: Kelas Itik mengatasi kaedah fly() untuk mencetak "Itik tidak boleh terbang", jadi kami menukar tingkah laku lalai yang ditakrifkan dalam kelas asas Burung, iaitu semua burung terbang ("Terbang"). Ini melanggar LSP kerana sebarang kod yang menjangkakan objek Burung atau subkelasnya terbang tidak akan berfungsi dengan betul dengan Itik, yang kita sedia maklum tidak terbang.

// Classe derivada que respeita o LSP
interface Bird {
    void fly();
}
class Eagle implements Bird {
    @Override
    public void fly() {
        System.out.println("Flying like an Eagle");
    }
}
class Duck implements Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ducks cannot fly");
    }
}

Dengan pendekatan ini, Helang dan Itik boleh ditukar ganti di mana Burung dijangka, tanpa melanggar jangkaan yang ditetapkan oleh antara muka Burung. Pengecualian yang dilemparkan oleh Duck secara jelas menyatakan bahawa itik tidak terbang, tanpa mengubah suai tingkah laku kelas super dengan cara yang boleh menyebabkan masalah yang tidak dijangka dalam kod.

4. Prinsip Pengasingan Antara Muka

Prinsip Pengasingan Antara Muka (ISP) mencadangkan bahawa antara muka kelas harus khusus kepada pelanggan yang menggunakannya. Ini mengelakkan antara muka "gemuk" yang memerlukan pelaksanaan kaedah yang tidak digunakan oleh pelanggan.

// Exemplo antes de aplicar o ISP
interface Worker {
    void work();
    void eat();
    void sleep();
}

class Programmer implements Worker {
    @Override
    public void work() {
        // Lógica específica para programar
    }
    @Override
    public void eat() {
        // Lógica para comer
    }
    @Override
    public void sleep() {
        // Lógica para dormir
    }
}

// Exemplo após aplicar o ISP
interface Worker {
    void work();
}
interface Eater {
    void eat();
}
interface Sleeper {
    void sleep();
}
class Programmer implements Worker, Eater, Sleeper {
    @Override
    public void work() {
        // Lógica específica para programar
    }
    @Override
    public void eat() {
        // Lógica para comer
    }
    @Override
    public void sleep() {
        // Lógica para dormir
    }
}

Dalam contoh, kami membahagikan antara muka Pekerja kepada antara muka yang lebih kecil (Kerja, Makan, Tidur) untuk memastikan kelas yang melaksanakannya hanya mempunyai kaedah yang diperlukan untuknya. Ini menghalang kelas daripada terpaksa melaksanakan kaedah yang tidak berkaitan dengannya, meningkatkan kejelasan dan perpaduan kod.

5. Prinsip Inversi Ketergantungan

Prinsip Pembalikan Ketergantungan (DIP) mencadangkan bahawa modul peringkat tinggi (seperti kelas perniagaan atau aplikasi, yang melaksanakan peraturan perniagaan utama) tidak boleh bergantung pada modul peringkat rendah (kelas infrastruktur, seperti akses kepada data luaran dan perkhidmatan yang menyokong operasi peringkat tinggi). Kedua-duanya mesti bergantung pada abstraksi.

// Exemplo antes de aplicar o DIP
class BackendDeveloper {
    public void writeJava() {
        // Lógica para escrever em Java
    }
}
class Project {
    private BackendDeveloper developer;

    public Project() {
        this.developer = new BackendDeveloper();
    }
    public void implement() {
        developer.writeJava();
    }
}

// Exemplo após aplicar o DIP
interface Developer {
    void develop();
}
class BackendDeveloper implements Developer {
    @Override
    public void develop() {
        // Lógica para escrever em Java
    }
}
class Project {
    private Developer developer;

    public Project(Developer developer) {
        this.developer = developer;
    }
    public void implement() {
        developer.develop();
    }
}

Kelas Projek kini bergantung pada abstraksi (Pembangun) dan bukannya pelaksanaan konkrit (BackendDeveloper). Ini membolehkan pelbagai jenis pembangun (cth. FrontendDeveloper, MobileDeveloper) disuntik dengan mudah ke dalam kelas Projek tanpa mengubah suai kodnya.

Kesimpulan

Mengguna pakai prinsip SOLID bukan sahaja meningkatkan kualiti kod anda, ia juga mengukuhkan kemahiran teknikal anda, meningkatkan kecekapan kerja anda dan meningkatkan laluan kerjaya anda sebagai pembangun perisian.

Atas ialah kandungan terperinci Pembangunan Berorientasikan PADAT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!