Perbandingan dan senario aplikasi: Perbandingan corak kilang dan corak reka bentuk lain di Jawa

Perbandingan dan senario aplikasi Corak Kilang dan corak reka bentuk lain dalam Java

Dalam proses pembangunan perisian, corak reka bentuk ialah penyelesaian yang terbukti dan boleh digunakan semula yang menerangkan satu set interaksi bersama dan objek untuk menyelesaikan perisian tertentu masalah reka bentuk. Corak reka bentuk boleh membantu pembangun mengatur dan mengurus kod dengan lebih baik, serta meningkatkan kebolehbacaan, kebolehselenggaraan dan kebolehskalaan kod. Di Jawa, terdapat banyak corak reka bentuk yang biasa digunakan, antaranya corak kilang merupakan corak reka bentuk yang sangat penting dan biasa digunakan.

Corak kilang ialah corak reka bentuk ciptaan yang menyediakan amalan terbaik untuk mencipta objek. Ia mentakrifkan kilang abstrak, yang digunakan untuk mencipta objek kilang konkrit, dan kilang konkrit melaksanakan antara muka kilang abstrak dan bertanggungjawab untuk mencipta objek produk tertentu. Corak kilang menjadikan sistem lebih berskala dengan memisahkan penciptaan dan penggunaan objek, dan menjadikan kod lebih fleksibel dan lebih mudah untuk diselenggara.

Serupa dengan corak kilang ialah corak kilang abstrak dan corak tunggal. Corak kilang abstrak menambah konsep keluarga produk kepada corak kilang Ia mengabstrakkan penciptaan produk ke dalam kaedah abstrak, yang dilaksanakan oleh kilang produk tertentu. Corak tunggal hanya boleh mencipta satu objek contoh Ia menswastakan kaedah pembinaan untuk memastikan objek itu hanya boleh dibuat dengan cara tertentu.

Di bawah kami menggunakan contoh kod khusus untuk menunjukkan perbandingan dan senario aplikasi corak kilang dan corak reka bentuk lain. Katakan kita perlu mencipta kelas kalkulator yang merangkumi dua operasi: penambahan dan pendaraban.

Pertama, mari kita lihat situasi mencipta kalkulator menggunakan kaedah biasa:

public class Calculator {
    private int num1;
    private int num2;

    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int add() {
        return num1 + num2;
    }

    public int multiply() {
        return num1 * num2;
    }
}

Dalam kes ini, kita menulis logik untuk mencipta objek secara terus dalam kelas Kalkulator, jadi jika kita perlu menambah kaedah pengiraan lain, kita perlu Ubah suai kod kelas Kalkulator. Ini memusnahkan kebolehskalaan dan kebolehselenggaraan kod.

Seterusnya, kami menggunakan corak kilang untuk memfaktorkan semula:

Pertama, cipta antara muka kilang abstrak CalculatorFactory:

public interface CalculatorFactory {
    Calculator createCalculator();
}

Kemudian, buat kelas kilang konkrit AdditionFactory dan MultiplicationFactory:

public class AdditionFactory implements CalculatorFactory {
    private int num1;
    private int num2;

    public AdditionFactory(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public Calculator createCalculator() {
        return new Calculator(num1, num2) {
            public int calculate() {
                return num1 + num2;
            }
        };
    }
}

public class MultiplicationFactory implements CalculatorFactory {
    private int num1;
    private int num2;

    public MultiplicationFactory(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public Calculator createCalculator() {
        return new Calculator(num1, num2) {
            public int calculate() {
                return num1 * num2;
            }
        };
    }
}

Akhir sekali, gunakan corak kilang untuk mencipta kilang objek:

public class Main {
    public static void main(String[] args) {
        CalculatorFactory additionFactory = new AdditionFactory(2, 3);
        CalculatorFactory multiplicationFactory = new MultiplicationFactory(2, 3);

        Calculator additionCalculator = additionFactory.createCalculator();
        Calculator multiplicationCalculator = multiplicationFactory.createCalculator();

        System.out.println("Addition: " + additionCalculator.calculate());
        System.out.println("Multiplication: " + multiplicationCalculator.calculate());
    }
}

Melalui corak kilang, kami mengabstrakkan logik penciptaan objek, dan membiarkan kelas kilang tertentu bertanggungjawab untuk mencipta objek kalkulator yang berbeza, sekali gus mencapai pemisahan dan penyahgandingan kod. Jika anda perlu menambah kaedah pengiraan lain, anda hanya perlu mencipta kelas kilang tertentu yang sepadan.

Ringkasnya, corak kilang ialah corak reka bentuk yang sangat penting dan biasa digunakan yang boleh meningkatkan kebolehskalaan dan kebolehselenggaraan kod. Berbanding dengan corak kilang abstrak dan corak tunggal, corak kilang digunakan terutamanya untuk mencipta objek, manakala corak kilang abstrak digunakan untuk mencipta objek keluarga produk, dan corak tunggal digunakan untuk mencipta objek tunggal. Dalam pembangunan sebenar, memilih corak reka bentuk yang sesuai mengikut keperluan dan senario tertentu boleh meningkatkan kualiti dan kebolehselenggaraan kod.

Atas ialah kandungan terperinci Perbandingan dan senario aplikasi: Perbandingan corak kilang dan corak reka bentuk lain di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!