Konsep asas dan prinsip corak kilang dalam Java
Corak kilang ialah corak reka bentuk biasa yang bertujuan untuk mencipta objek melalui antara muka biasa tanpa mengetahui butiran pelaksanaan khusus. Corak ini boleh memberikan kita struktur kod yang lebih fleksibel dan boleh diperluaskan. Di Jawa, terdapat banyak cara untuk melaksanakan corak kilang, termasuk corak kilang mudah, corak kaedah kilang dan corak kilang abstrak.
Corak Kilang Mudah ialah bentuk paling asas corak kilang, yang mencipta objek melalui kelas kilang. Kelas kilang ini biasanya mengandungi kaedah statik untuk mencipta contoh objek yang berbeza berdasarkan parameter yang berbeza. Berikut ialah contoh mudah:
public 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 interface Product { void doSomething(); } public class ConcreteProductA implements Product { @Override public void doSomething() { System.out.println("Product A do something."); } } public class ConcreteProductB implements Product { @Override public void doSomething() { System.out.println("Product B do something."); } } public class Main { public static void main(String[] args) { Product productA = SimpleFactory.createProduct("A"); productA.doSomething(); Product productB = SimpleFactory.createProduct("B"); productB.doSomething(); } }
Dalam kod di atas, SimpleFactory
ialah kelas kilang ringkas yang mencipta objek produk yang sepadan berdasarkan parameter yang dihantar. Product
ialah antara muka abstrak yang mentakrifkan gelagat asas objek produk. ConcreteProductA
dan ConcreteProductB
ialah kelas produk khusus yang masing-masing melaksanakan antara muka Product
. SimpleFactory
是一个简单的工厂类,根据传入的参数创建相应的产品对象。Product
是一个抽象接口,定义了产品对象的基本行为。ConcreteProductA
和ConcreteProductB
是具体的产品类,分别实现了Product
接口。
工厂方法模式是在简单工厂模式的基础上进行了一定改进,它将具体的产品创建移到各自的工厂类中。这种模式通过定义一个抽象的工厂接口和多个具体的工厂类来实现对象的创建。以下是一个示例:
public interface Factory { Product createProduct(); } public class ConcreteFactoryA implements Factory { @Override public Product createProduct() { return new ConcreteProductA(); } } public class ConcreteFactoryB implements Factory { @Override public Product createProduct() { return new ConcreteProductB(); } } public class Main { public static void main(String[] args) { Factory factoryA = new ConcreteFactoryA(); Product productA = factoryA.createProduct(); productA.doSomething(); Factory factoryB = new ConcreteFactoryB(); Product productB = factoryB.createProduct(); productB.doSomething(); } }
在上述代码中,Factory
是一个抽象的工厂接口,定义了创建产品的方法。ConcreteFactoryA
和ConcreteFactoryB
是具体的工厂类,分别创建ConcreteProductA
和ConcreteProductB
产品对象。
抽象工厂模式是工厂方法模式的进一步扩展,它对一组相关或有依赖关系的产品进行创建。这种模式提供了一个抽象的工厂接口和多个具体的工厂类,每个工厂类负责创建一组相关的产品。以下是一个示例:
public interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); } public class ConcreteFactory1 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA1(); } @Override public ProductB createProductB() { return new ConcreteProductB1(); } } public class ConcreteFactory2 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA2(); } @Override public ProductB createProductB() { return new ConcreteProductB2(); } } public interface ProductA { void doSomething(); } public class ConcreteProductA1 implements ProductA { @Override public void doSomething() { System.out.println("ProductA1 do something."); } } public class ConcreteProductA2 implements ProductA { @Override public void doSomething() { System.out.println("ProductA2 do something."); } } public interface ProductB { void doSomething(); } public class ConcreteProductB1 implements ProductB { @Override public void doSomething() { System.out.println("ProductB1 do something."); } } public class ConcreteProductB2 implements ProductB { @Override public void doSomething() { System.out.println("ProductB2 do something."); } } public class Main { public static void main(String[] args) { AbstractFactory factory1 = new ConcreteFactory1(); ProductA productA1 = factory1.createProductA(); productA1.doSomething(); ProductB productB1 = factory1.createProductB(); productB1.doSomething(); AbstractFactory factory2 = new ConcreteFactory2(); ProductA productA2 = factory2.createProductA(); productA2.doSomething(); ProductB productB2 = factory2.createProductB(); productB2.doSomething(); } }
在上述代码中,AbstractFactory
是一个抽象的工厂接口,定义了创建多个产品的方法。ConcreteFactory1
和ConcreteFactory2
是具体的工厂类,分别创建ProductA
和ProductB
一组产品对象。ProductA
和ProductB
是抽象的产品接口,定义了产品的基本行为。ConcreteProductA1
、ConcreteProductA2
、ConcreteProductB1
和ConcreteProductB2
是具体的产品类,分别实现了ProductA
和ProductB
Factory
ialah antara muka kilang abstrak yang mentakrifkan kaedah untuk mencipta produk. ConcreteFactoryA
dan ConcreteFactoryB
ialah kelas kilang khusus yang masing-masing mencipta objek produk ConcreteProductA
dan ConcreteProductB
. 🎜AbstractFactory
ialah antara muka kilang abstrak yang mentakrifkan kaedah untuk mencipta berbilang produk. ConcreteFactory1
dan ConcreteFactory2
ialah kelas kilang khusus yang mencipta satu set objek produk masing-masing ProductA
dan ProductB
. ProductA
dan ProductB
ialah antara muka produk abstrak yang mentakrifkan gelagat asas produk. ConcreteProductA1
, ConcreteProductA2
, ConcreteProductB1
dan ConcreteProductB2
ialah kelas produk tertentu, yang melaksanakan ProductA
antara muka kod> dan Atas ialah kandungan terperinci Konsep dan prinsip asas corak kilang berasaskan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!