简单工厂模式
别名:静态工厂模式,静态工厂方法模式
简单工厂模式是创建/获取型模式,它关注对象创建或提供。
它可以解耦及减少代码冗余,当增加或修改某些实现的时候可以只增加/修改实现类和工厂类。
假如你现在要举行宴会,按照不同的客人分发不同的礼物
先看类图
这里Gift就是抽象的礼物接口
public interface Gift {
String getName();
}
Belt, Lipstick, Candy 是具体的实现
public class Belt implements Gift {
@Override
public String getName() {
return "皮带";
}
}
public class Lipstick implements Gift {
@Override
public String getName() {
return "口红";
}
}
public class Candy implements Gift {
@Override
public String getName() {
return "糖果";
}
}
我们使用一个简单工厂封装分发礼物的复杂性
public class GiftFactory {
public static Gift allotGift(String type) {
switch (type) {
case "Child":
return new Candy();
case "Man":
return new Belt();
case "Woman":
return new Lipstick();
default:
throw new RuntimeException("No gift for " + type);
}
}
}
接下来我们就可以快乐的发礼物了
public class AllotGifts {
public static void main(String[] args) {
System.out.println("现在开始分发礼物");
System.out.println("首先是一位男士");
System.out.println("分给他一件" + GiftFactory.allotGift("Man").getName());
System.out.println("然后是一位女士");
System.out.println("分给她一件" + GiftFactory.allotGift("Woman").getName());
System.out.println("还有一个孩子");
System.out.println("分给他一件" + GiftFactory.allotGift("Child").getName());
}
}
结果就是这样
这个时候如果想对老人赠送特殊的礼物,只需要增加一个Gift的实现类并修改工厂类就可以了。
简单工厂如果需要扩展的话,不仅需要新增实现,还要修改工厂类,这在一定程度上违背了开闭原则。
工厂方法模式
现实中的宴会当然会有很多男士、女士和孩子,这个时候我们也可以考虑工厂方法模式,它更加符合开闭原则。
首先要有一个抽象的工厂接口
public interface IFactory {
Gift newGift();
}
然后实现各自的工厂
public class BeltFactory implements IFactory {
@Override
public Gift newGift() {
return new Belt();
}
}
public class LipstickFactory implements IFactory {
@Override
public Gift newGift() {
return new Lipstick();
}
}
发放礼物的时候就可以这样
public class AllotGifts {
public static void main(String[] args) {
System.out.println("现在给男士发礼物");
IFactory factory = new BeltFactory();
System.out.println("首先是第一位男士");
System.out.println("分给他一件" + factory.newGift().getName());
System.out.println("第二位男士");
System.out.println("分给他一件" + factory.newGift().getName());
System.out.println("现在给女士发礼物");
IFactory anotherFactory = new LipstickFactory();
System.out.println("首先是第一位女士");
System.out.println("分给她一件" + anotherFactory.newGift().getName());
System.out.println("第二位女士");
System.out.println("分给她一件" + anotherFactory.newGift().getName());
}
}
抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类
例如现在的手机厂商大多还会生产平板电脑
先定义手机和平板
public abstract class Mobile {
abstract String getBrand();
@Override
public String toString() {
return getBrand()+"的手机";
}
}
public abstract class Pad {
abstract String getBrand();
@Override
public String toString() {
return getBrand()+"的平板";
}
}
根据品牌不同又分为华为的和苹果的
public class AppleMobile extends Mobile {
@Override
String getBrand() {
return "苹果";
}
}
public class ApplePad extends Pad {
@Override
String getBrand() {
return "苹果";
}
}
public class HuaweiMobile extends Mobile {
@Override
String getBrand() {
return "华为";
}
}
public class HuaweiPad extends Pad {
@Override
String getBrand() {
return "华为";
}
}
定义抽象的工厂
public interface DeviceFactory {
Mobile getMobile();
Pad getPad();
}
具体的工厂实现
public class AppleDeviceFactory implements DeviceFactory {
@Override
public Mobile getMobile() {
return new AppleMobile();
}
@Override
public Pad getPad() {
return new ApplePad();
}
}
public class HuaweiDeviceFactory implements DeviceFactory {
@Override
public Mobile getMobile() {
return new HuaweiMobile();
}
@Override
public Pad getPad() {
return new HuaweiPad();
}
}
生产设备
public class ProduceDevice {
public static void main(String[] args) {
DeviceFactory factory = new AppleDeviceFactory();
System.out.println(factory.getMobile());
System.out.println(factory.getPad());
factory = new HuaweiDeviceFactory();
System.out.println(factory.getMobile());
System.out.println(factory.getPad());
}
}
这样当换品牌生产的时候,只需要变更工厂实现,就可以改变所有的产品