Perbincangan mendalam tentang pelaksanaan dan aplikasi corak kilang Java

Penjelasan terperinci tentang prinsip dan aplikasi corak kilang Java

Corak kilang ialah corak reka bentuk yang biasa digunakan, yang digunakan untuk mencipta objek dan merangkum proses penciptaan objek. Terdapat banyak cara untuk melaksanakan corak kilang di Jawa, yang paling biasa ialah corak kilang mudah, corak kaedah kilang dan corak kilang abstrak. Artikel ini akan memperkenalkan prinsip dan aplikasi ketiga-tiga corak kilang ini secara terperinci, dan memberikan contoh kod yang sepadan.

1. Corak Kilang Mudah
Corak kilang yang ringkas adalah corak kilang yang paling ringkas dan biasa digunakan. Ia menggunakan kelas kilang untuk mengembalikan objek instantiated berbeza berdasarkan parameter yang diluluskan. Idea teras corak kilang mudah adalah untuk merangkum proses penciptaan objek supaya pemanggil tidak perlu mengambil berat tentang butiran penciptaan objek.

Contoh mudah diberikan di bawah. Katakan kita mempunyai Kalkulator kelas kalkulator, yang mempunyai fungsi penambahan dan penolakan:

public class Calculator {
    public double add(double a, double b) {
        return a + b;
    }
    
    public double subtract(double a, double b) {
        return a - b;
    }
}

Kita boleh menggunakan corak kilang yang mudah untuk membuat contoh Kalkulator:

public class CalculatorFactory {
    public static Calculator createCalculator() {
        return new Calculator();
    }
}

Kemudian di Kilang ini kelas digunakan dalam kod klien untuk mencipta contoh Kalkulator:

public class Client {
    public static void main(String[] args) {
        Calculator calculator = CalculatorFactory.createCalculator();
        double result = calculator.add(1.0, 2.0);
        System.out.println(result);
    }
}

Melalui kod di atas, kita dapat melihat bahawa menggunakan corak kilang yang mudah, kod pelanggan tidak perlu memanggil terus new Calculator() untuk mencipta contoh Kalkulator, tetapi dengan memanggil kaedah Statik CalculatorFactory untuk mencipta kejadian. Kelebihan ini ialah kod klien hanya perlu tahu cara menggunakan fungsi Kalkulator dan tidak perlu mengambil berat tentang proses penciptaan khususnya.

2. Corak kaedah kilang
Corak kaedah kilang merangkumi proses penciptaan objek dalam antara muka kilang, dan langkah penciptaan khusus dilaksanakan oleh kelas kilang tertentu. Dalam corak kaedah kilang, setiap kelas kilang konkrit hanya bertanggungjawab untuk mencipta objek produk tertentu.

Berikut ialah contoh pelaksanaan corak kaedah kilang Katakan kami mempunyai kedai pizza yang menyediakan pelbagai jenis pizza, seperti CheesePizza dan PepperoniPizza:

Pertama, kami menentukan antara muka pizza:

public interface Pizza {
    void prepare();
    void bake();
    void cut();
    void box();
}

Kemudian, kami tentukan. piza khusus Kelas:

public class CheesePizza implements Pizza {
    @Override
    public void prepare() {
        System.out.println("Preparing Cheese Pizza");
    }
    
    @Override
    public void bake() {
        System.out.println("Baking Cheese Pizza");
    }
    
    @Override
    public void cut() {
        System.out.println("Cutting Cheese Pizza");
    }
    
    @Override
    public void box() {
        System.out.println("Boxing Cheese Pizza");
    }
}

public class PepperoniPizza implements Pizza {
    @Override
    public void prepare() {
        System.out.println("Preparing Pepperoni Pizza");
    }
    
    @Override
    public void bake() {
        System.out.println("Baking Pepperoni Pizza");
    }
    
    @Override
    public void cut() {
        System.out.println("Cutting Pepperoni Pizza");
    }
    
    @Override
    public void box() {
        System.out.println("Boxing Pepperoni Pizza");
    }
}

Seterusnya, kami mentakrifkan antara muka kilang piza:

public interface PizzaFactory {
    Pizza createPizza();
}

Kemudian, kami melaksanakan dua kelas kilang piza khusus:

public class CheesePizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new CheesePizza();
    }
}

public class PepperoniPizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new PepperoniPizza();
    }
}

Akhir sekali, gunakan kilang piza dalam kod pelanggan untuk mencipta contoh piza:

public class Client {
    public static void main(String[] args) {
        PizzaFactory pizzaFactory = new CheesePizzaFactory();
        Pizza pizza = pizzaFactory.createPizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
}

Melalui kod di atas, kita dapat melihat bahawa menggunakan corak kaedah kilang, kod pelanggan hanya perlu mengambil berat tentang jenis kilang piza dan memanggil kaedah penciptaannya untuk mencipta objek piza yang sepadan. Dengan cara ini, apabila menambah jenis piza baharu, anda hanya perlu menambah kelas piza tertentu dan kelas kilang piza yang sepadan tanpa mengubah suai kod pelanggan.

3. Corak Kilang Abstrak
Corak kilang abstrak adalah lanjutan daripada corak kaedah kilang Ia mentakrifkan satu set antara muka kilang yang berkaitan atau bergantung melalui kelas kilang yang abstrak melaksanakan antara muka ini dan menghasilkan produk yang berbeza mengikut keperluan yang berbeza . Produk.

Berikut ialah contoh pelaksanaan corak kilang abstrak Katakan kita mempunyai kilang komputer yang boleh menghasilkan komputer jenama yang berbeza, seperti komputer Dell dan komputer Lenovo:

Pertama, kami mentakrifkan antara muka komputer dan kelas komputer tertentu:

public interface Computer {
    void use();
}

public class DellComputer implements Computer {
    @Override
    public void use() {
        System.out.println("Using Dell computer");
    }
}

public class LenovoComputer implements Computer {
    @Override
    public void use() {
        System.out.println("Using Lenovo computer");
    }
}

Kemudian, kami mentakrifkan antara muka kilang komputer abstrak:

public interface ComputerFactory {
    Computer createComputer();
}

Seterusnya, kami melaksanakan kelas kilang komputer tertentu masing-masing:

public class DellComputerFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new DellComputer();
    }
}

public class LenovoComputerFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new LenovoComputer();
    }
}

Akhir sekali, gunakan kilang abstrak dalam kod pelanggan untuk mencipta contoh komputer jenama yang berbeza:

public class Client {
    public static void main(String[] args) {
        ComputerFactory dellComputerFactory = new DellComputerFactory();
        Computer dellComputer = dellComputerFactory.createComputer();
        dellComputer.use();

        ComputerFactory lenovoComputerFactory = new LenovoComputerFactory();
        Computer lenovoComputer = lenovoComputerFactory.createComputer();
        lenovoComputer.use();
    }
}

Melalui Kod di atas, kita dapat melihat bahawa menggunakan corak kilang abstrak, kod pelanggan hanya perlu mengetahui cara menggunakan kelas kilang abstrak dan antara muka produk sebenar, tanpa mengambil berat tentang kelas kilang tertentu dan butiran pelaksanaan produk. Dengan cara ini, jika anda perlu menambah jenama komputer baharu, anda hanya perlu menambah kelas komputer tertentu dan kelas kilang komputer yang sepadan tanpa mengubah suai kod klien.

Ringkasan:
Artikel ini memperkenalkan secara terperinci prinsip dan aplikasi corak kilang di Jawa, termasuk corak kilang ringkas, corak kaedah kilang dan corak kilang abstrak. Corak kilang mudah sesuai untuk mencipta satu jenis objek; corak kaedah kilang sesuai untuk mencipta sekumpulan objek dengan perhubungan warisan; Dengan menggunakan corak kilang, kita boleh merangkum proses penciptaan objek, menjadikan kod pelanggan lebih ringkas dan lebih mudah untuk mengekalkan dan mengembangkan kod.

Atas ialah kandungan terperinci Perbincangan mendalam tentang pelaksanaan dan aplikasi corak kilang Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!