抽象工厂模式
/**
抽象工厂
*/
public interface AbstractFactory {
/*创建 A 产品家族的产品/
public AbstractProductA createProductA();
/*创建 B 产品家族的产品/
public AbstractProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
//创建一个来自 A 产品家族的产品
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
//创建一个来自 B 产品家族的产品
return new ProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
//创建一个来自 A 产品家族的产
品
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
//创建一个来自 B 产品家族的产品
return new ProductB2();
}
}
/**
产品 A 家族
*/
public abstract class AbstractProductA {
/*每个产品共有的方法/
public void shareMethod() {
}
/*每个产品不同实现的方法/
public abstract void doSomething();
}
/**
产品 B 家族
*/
public abstract class AbstractProductB {
/*每个产品共有的方法/
public void shareMethod() {
}
/*每个产品不同实现的方法/
public abstract void doSomething();
}
public class ProductA1 extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("产品 A1 的实现方法");
}
}
public class ProductA2 extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("产品 A2 的实现方法");
}
}
public class ProductB1 extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("产品 B1 的实现方法");
}
}
public class ProductB2 extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("产品 B2 的实现方法");
}
}
public class Client {
public static void main(String[] args) {
//创建两个工厂
AbstractFactory factory1 = new ConcreteFactory1();
AbstractFactory factory2 = new ConcreteFactory2();
//使用 factory1 来创建一组产品，它们来自不同的产品家族
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
//使用 factory2 来创建一组产品，它们来自不同的产品家族
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
//do something...
}
}
客户端代码无需关心具体的产品对象，只通过创建工厂即可获得产品，客户端只需持有抽象工厂和抽象产品的引用即可后续操作。抽象工厂是工厂方法的升级，工厂方法是创建一种类型的产品，而抽象工厂重在生产一组相关的产品。
抽象工厂的优缺点
抽象工厂致力于解耦高层模块和低层模块，高层和低层模块都保持对抽象的依赖，是遵循依赖倒置原则的模范，同时也遵循迪米特法则，对客户端屏蔽了创建产品族的细节，但是也有缺点就是每增加一个新的产品家族，可能所有的工厂实现类都要修改，假如工厂类比较多，就会比较麻烦难以维护，但是即便如此，也阻挡不了使用它的优势，在产品族确定的情况下，可以扩展任意工厂类来实现新产品的创造。
举例
以超市中销售的饮料为例，我们知道现在超市中的饮料大致分为几大类如碳酸饮料、果汁饮料、凉茶饮料等，例如碳酸饮料有可口可乐、雪碧等，果汁饮料有汇源果汁、果粒橙等，凉茶饮料有加多宝、王老吉等，如果我们使用抽象工厂来生产超市所需的这几种饮料，那么每个工厂应该都能够生产碳酸饮料、果汁饮料的和凉茶饮料，用代码表示这个过程：
/**
抽象饮料类
*/
public abstract class Drink {
/*打印名称/
abstract void printName();
/*打印售价/
abstract void printPrice();
}
public abstract class CarbonatedDink extends Drink {
/*所有该类饮料共有的属性/
public void commonProperty() {
System.out.println("碳酸饮料中都含有二氧化碳");
}
}
public abstract class JuiceDink extends Drink {
/*所有该类饮料共有的属性/
public void commonProperty() {
System.out.println("果汁饮料中都含有果汁浓缩汁");
}
}
public abstract class CoolTeaDrink extends Drink {
/*所有该类饮料共有的属性/
public void commonProperty() {
System.out.println("凉茶饮料中都含有中草药成分");
}
}
public class CocaCola extends CarbonatedDink {
@Override
void printName() {
System.out.println("可口可乐");
}
@Override
void printPrice() {
System.out.println("2.5 元");
}
}
public class Sprite extends CarbonatedDink {
@Override
void printName() {
System.out.println("雪碧");
}
@Override
void printPrice() {
System.out.println("2.5 元");
}
}
public class HuiYuanGuozhi extends JuiceDink {
@Override
void printName() {
System.out.println("汇源果汁");
}
@Override
void printPrice() {
System.out.println("2.0 元");
}
}
public class GuoLiCheng extends JuiceDink {
@Override
void printName() {
System.out.println("果粒橙");
}
@Override
void printPrice() {
System.out.println("3.5 元");
}
}
public class JiaDuoBao extends CoolTeaDrink {
@Override
void printName() {
System.out.println("加多宝凉茶");
}
@Override
void printPrice() {
System.out.println("3.5 元");
}
}
public class WangLaoji extends CoolTeaDrink {
@Override
void printName() {
System.out.println("王老吉凉茶");
}
@Override
void printPrice() {
System.out.println("3.5 元");
}
}
/**
生产饮料的抽象工厂
*/
public interface DrinkFactory {
/*创建碳酸饮料/
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论