Analisis mendalam tentang tiga bentuk corak kilang Java yang berbeza

Corak kilang Java ialah corak reka bentuk untuk mencipta objek. Ia mengabstraksi proses penciptaan objek supaya ia boleh menentukan kelas tertentu yang ingin dibuat seketika. Ia menjadikan kod lebih boleh diselenggara, fleksibel dan boleh diperluaskan dengan memisahkan logik instantiasi daripada kod klien. Terdapat tiga varian biasa bagi corak kilang iaitu corak kilang ringkas, corak kaedah kilang dan corak kilang abstrak. Ketiga-tiga varian ini akan dianalisis secara terperinci di bawah dan contoh kod khusus akan diberikan.

1. Corak Kilang Mudah

Corak Kilang Mudah (Simple Factory Pattern) juga dipanggil corak kilang statik Ia adalah bentuk paling ringkas bagi corak kilang. Dalam corak kilang mudah, kami meletakkan logik mencipta objek dalam kelas kilang mudah dan mencipta objek dengan memanggil kaedah statik kelas kilang. Corak kilang yang ringkas sesuai untuk situasi di mana jenis objek yang dicipta agak kecil dan tidak kerap berubah.

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

// 具体产品类A
public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("Product A is used.");
    }
}

// 具体产品类B
public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("Product B is used.");
    }
}

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // Output: Product A is used.

        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // Output: Product B is used.
    }
}

2. Corak Kaedah Kilang

Corak Kaedah Kilang mewakilkan logik instantiasi kepada subkelas dan menangguhkan penciptaan objek kepada subkelas. Setiap produk tertentu sepadan dengan kilang tertentu, dan pelanggan mencipta produk dengan memanggil kaedah kilang tertentu. Corak kaedah kilang sesuai untuk situasi di mana terdapat banyak jenis objek yang dicipta dan memerlukan pengembangan fleksibel.

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

// 具体产品类A
public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("Product A is used.");
    }
}

// 具体产品类B
public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("Product B is used.");
    }
}

// 抽象工厂类
public abstract class Factory {
    public abstract Product createProduct();
}

// 具体工厂类A
public class FactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
public class FactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // Output: Product A is used.

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // Output: Product B is used.
    }
}

3. Corak Kilang Abstrak

Corak Kilang Abstrak adalah lanjutan daripada corak kaedah kilang Dalam corak kilang abstrak, kilang tertentu boleh mencipta satu siri produk yang berkaitan. Pelanggan mencipta produk dengan memanggil kaedah kilang tertentu Kilang tertentu yang berbeza boleh mencipta kombinasi produk yang berbeza. Corak kilang abstrak sesuai untuk situasi di mana satu siri produk berkaitan perlu dibuat dan konsistensi perlu dikekalkan.

// 抽象产品类A
public abstract class ProductA {
    public abstract void use();
}

// 具体产品类A1
public class ProductA1 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A1 is used.");
    }
}

// 具体产品类A2
public class ProductA2 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A2 is used.");
    }
}

// 抽象产品类B
public abstract class ProductB {
    public abstract void use();
}

// 具体产品类B1
public class ProductB1 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B1 is used.");
    }
}

// 具体产品类B2
public class ProductB2 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B2 is used.");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract ProductA createProductA();

    public abstract ProductB createProductB();
}

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

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

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

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

// 测试代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.use(); // Output: Product A1 is used.
        ProductB productB1 = factory1.createProductB();
        productB1.use(); // Output: Product B1 is used.

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.use(); // Output: Product A2 is used.
        ProductB productB2 = factory2.createProductB();
        productB2.use(); // Output: Product B2 is used.
    }
}

Melalui contoh kod di atas, anda boleh melihat dengan jelas kaedah pelaksanaan khusus dan senario aplikasi corak kilang mudah, corak kaedah kilang dan corak kilang abstrak. Dalam pembangunan sebenar, kita boleh memilih corak kilang yang sesuai untuk mencipta objek mengikut keperluan khusus untuk mencapai kebolehselenggaraan kod, fleksibiliti dan kebolehskalaan.

Atas ialah kandungan terperinci Analisis mendalam tentang tiga bentuk corak kilang Java yang berbeza. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!