Penyelidikan mengenai tiga kaedah reka bentuk corak kilang Java

Terokai tiga idea reka bentuk Java Factory Pattern

Corak kilang ialah corak reka bentuk yang biasa digunakan untuk mencipta objek tanpa menentukan kelas tertentu. Di Jawa, corak kilang boleh dilaksanakan dalam pelbagai cara. Artikel ini akan meneroka pelaksanaan tiga corak kilang Java berdasarkan idea reka bentuk yang berbeza dan memberikan contoh kod khusus.

1. Corak Kilang Mudah

Corak Kilang Mudah ialah corak kilang yang paling asas, yang mencipta objek melalui kelas kilang. Kelas kilang menentukan jenis objek tertentu yang perlu dibuat berdasarkan parameter permintaan pelanggan. Berikut ialah contoh corak kilang yang mudah:

// 抽象产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用具体产品A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用具体产品B");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

2. Corak Kaedah Kilang

Corak Kaedah Kilang mentakrifkan antara muka untuk mencipta objek dan membolehkan subkelas menentukan kelas mana yang hendak dijadikan instantiat. Corak kaedah kilang boleh mencapai penyahgandingan produk dan pelanggan. Berikut ialah contoh corak kaedah kilang:

// 抽象产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用具体产品A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用具体产品B");
    }
}

// 抽象工厂类
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

3. Corak Kilang Abstrak

Corak kilang abstrak ialah corak reka bentuk peringkat lebih tinggi yang menggabungkan pelbagai kaedah kilang bersama-sama. Ia menyediakan antara muka untuk mencipta pelbagai jenis keluarga produk. Berikut ialah contoh corak kilang abstrak:

// 抽象产品A接口
interface ProductA {
    void useProductA();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void useProductA() {
        System.out.println("使用具体产品A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void useProductA() {
        System.out.println("使用具体产品A2");
    }
}

// 抽象产品B接口
interface ProductB {
    void useProductB();
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void useProductB() {
        System.out.println("使用具体产品B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void useProductB() {
        System.out.println("使用具体产品B2");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.useProductA();
        productB1.useProductB();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.useProductA();
        productB2.useProductB();
    }
}

Melalui contoh di atas, kita boleh melihat pelaksanaan khusus corak kilang Java di bawah idea reka bentuk yang berbeza. Corak kilang ringkas sesuai untuk situasi di mana terdapat sedikit objek dan mudah, corak kaedah kilang memberikan fleksibiliti yang lebih tinggi, dan corak kilang abstrak sesuai untuk mencipta beberapa keluarga produk. Dalam aplikasi sebenar, anda boleh memilih corak kilang yang sesuai untuk mencipta objek mengikut keperluan perniagaan tertentu.

Atas ialah kandungan terperinci Penyelidikan mengenai tiga kaedah reka bentuk corak kilang Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!