工厂模式
工厂模式是一种创建型设计模式,提供创建对象的方式,不需要客户端实例化对象
主要包括简单工厂模式,工厂方法模式和抽象工厂模式
简单工厂模式
提供统一接口来创建对象,客户端不需要知道具体的创建逻辑
优点:将对象的创建和使用分离开,使得代码易于维护和扩展
缺点:一旦需要添加新的产品类,需要修改工厂的代码,违反了开闭原则
代码示例
public interface Product {
void operator();
}
public class ProductA implements Product {
@Override
public void operator() {
System.out.println("ProductA");
}
}
public class ProductB implements Product{
@Override
public void operator() {
System.out.println("ProductB");
}
}
public class ProductFactory {
public static Product produce(String type) {
Product product;
switch (type) {
case "A" :
return new ProductA();
case "B" :
return new ProductB();
default:
break;
}
}
}
工厂方法模式
定义一个创建对象的接口,将具体的实现延迟到子类;每个具体的产品都有对应的工厂来创建,避免了简单工厂模式中工厂类的修改。
好处:符合开闭原则,但客户端需要知道具体的工厂类
代码示例
public interface Product {
void operator();
}
public class ProductA implements Product {
@Override
public void operator() {
System.out.println("ProductA");
}
}
public class ProductB implements Product{
@Override
public void operator() {
System.out.println("ProductB");
}
}
public interface Facotry {
public Product produce();
}
public class FacotryA implements Facotry {
@Override
public Product produce() {
new ProductA();
}
}
public class FacotryB implements Facotry{
@Override
public Product produce() {
new ProductB();
}
}
抽象工厂模式
提供一个接口,用于创建一系列相关或相互依赖的对象,而不需要指定具体类。
抽象工厂模式通过提供一组接口来创建一系列相关的对象,这些对象通常组成一个产品族。
相对于工厂方法模式,更加灵活,能够创建更多类型的对象
当需要增加新的产品族时,需要修改接口及所有实现类,违反了开闭原则
代码示例
public interface ProductA {
void operator();
}
public class ProductA1 implements ProductA{
@Override
public void operator() {
System.out.println("ProductA1");
}
}
public class ProductA2 implements ProductA{
@Override
public void operator() {
System.out.println("ProductA2");
}
}
public interface ProductB {
void operator();
}
public class ProductB1 implements ProductB{
@Override
public void operator() {
System.out.println("ProductB1");
}
}
public class ProductB2 implements ProductB{
@Override
public void operator() {
System.out.println("ProductB2");
}
}
public interface Facotry {
public ProductA produceA();
public ProductB produceB();
}
public class FacotryA implements Facotry {
@Override
public ProductA produceA() {
return new ProductA1();
}
@Override
public ProductB produceB() {
return new ProductB1();
}
}
public class FacotryB implements Facotry {
@Override
public ProductA produceA() {
return new ProductA2();
}
@Override
public ProductB produceB() {
return new ProductB2();
}
}
public class Client {
public static void main(String[] args) {
Facotry facotryA = new FacotryA();
ProductA productA1 = facotryA.produceA();
ProductB productB1 = facotryA.produceB();
productA1.operator();
productB1.operator();
FacotryB facotryB = new FacotryB();
ProductA productA2 = facotryB.produceA();
ProductB productB2 = facotryA.produceB();
productA2.operator();
productB2.operator();
}
}