目录
一、前言
在工厂模式中,分为三种,第一种就是简单工厂模式、第二种是工厂方法模式,第三种是抽象工厂模式。所谓工厂模式,就是指有一个专门的容器之类的地方,为用户创建对象,用户不用再手动去创建对象。容器根据用户传的参数或者调用的子类来自动为其创建对象。这种设计模式在Spring中大量的使用到了。
二、简单工厂模式
先介绍一下简单工厂模式,简单工厂模式中,工厂会根据用户传递的参数的不同,返回不同的对象。我们拿手机来举例子,比如有一个手机工厂,他能够生产手机,然后工厂的生成线可以生产三种手机,一种是华为,一种是小米,还有一种是中兴。当批发商需要的时候,就告诉工厂生成哪种手机就行。
首先我们得有一个手机的接口:
public interface Phone{
public void creat();
}
然后我们得有三条手机生产的方法:
public class HuaWei implements Phone{
@Override
public void create() {
System.out.println("我是中国的华为");
}
}
public class XiaoMi implements Phone{
@Override
public void create() {
System.out.println("我是中国的小米");
}
}
public class ZhongXing implements Phone{
@Override
public void create() {
System.out.println("我是中国的中兴");
}
}
好了,既然有了这些,我们此时需要工厂了:
public class PhoneFactory {
public Shape getShape(String type) {
if ("HuaWei".equals(type)) {
return new HuaWei();
} else if ("XiaoMi".equals(type)) {
return new XiaoMi();
} else if ("ZhongXing".equals(type)) {
return new ZhongXing();
} else {
return null;
}
}
}
接着我们调用测试一下即可,值需要传入参数即可:
public class SimpleFactoryTest {
public static void main(String[] args) {
PhoneFactory phoneFactory = new PhoneFactory ();
phoneFactory.getPhone("HuaWei").create();
phoneFactory.getPhone("XiaoMi").create();
phoneFactory.getPhone("ZhongXing").create();
}
}
三、工厂方法模式
这是简单工厂模式,但是传参数也不是回事儿,看着还是挺别扭的,有没有办法直接根据子类来决定调用哪个生产方法呢?当然有,这时我们可以来看一下工厂方法模式。这里其实只需要扩展一下工厂方法即可,其余手机生产方式还是一样。我们将上面的PhoneFactory改为下面的代码:
public interface Factory {
public Phone getPhone();
}
然后扩展三个创建对象的工厂方法,也就是实现Factory:
public class HuaWeiFactory implements Factory {
@Override
public Phone getPhone() {
return new HuaWei();
}
}
public class XiaoMiFactory implements Factory {
@Override
public Phone getPhone() {
return new XiaoMi();
}
}
public class ZhongXingFactory implements Factory {
@Override
public Phone getPhone() {
return new ZhongXing();
}
}
接着我们在调用的时候,就可以根据子类来让工厂选择创建哪一个的对象了:
public class MethodFactoryTest {
public static void main(String[] args) {
Factory huaWeiFactory = new HuaWeiFactory();
huaWeiFactory .getPhone().create();
Factory xiaoMiFactory = new XiaoMiFactory();
xiaoMiFactory.getPhone().create();
Factory zhongXingFactory = new ZhongXingFactory();
zhongXingFactory.getPhone().create();
}
}
四、抽象工厂模式
在实际生活中,我们都知道,这三家手机厂商都是有各自的生态链的,比如华为除了手机,还涉及芯片、通讯等,小米除了手机,还涉及其很多智能家居等,中兴同样也是,除了手机,其通讯也是很不错的,那么我们假设这三家企业除了手机以外,都涉及到生成耳机,一般都是跟手机配套的,那现在就需要使用到抽象工厂模式。这里我们可以把上面那些工厂看成一个独立个体,再创建三个独立生产耳机的工厂个体,再建立一个超级工厂来管理这些独立个体。
其实总的来说跟工厂方法模式差不多,只是在工厂里面再加上新的方法,相当于加上新的工厂,之前的手机生产线不用改变,再添加三条耳机生产线:
public interface Earphone{
public void create();
}
public class HuaWeiEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是华为耳机");
}
}
public class XiaoMiEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是小米耳机");
}
}
public class ZhongXingEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是中兴耳机");
}
}
接着我们在工厂里面增加即可:
public interface Factory {
public Phone getPhone();
public Earphone getEarphone();
}
public class HuaWeiFactory implements Factory {
@Override
public Phone getPhone() {
return new HuaWei();
}
@Override
public Earphone getEarphone() {
return new HuaWeiEarphone();
}
}
public class XiaoMiFactory implements Factory {
@Override
public Phone getPhone() {
return new XiaoMi();
}
@Override
public Earphone getEarphone() {
return new XiaoMiEarphone();
}
}
public class ZhongXingFactory implements Factory {
@Override
public Phone getPhone() {
return new ZhongXing();
}
@Override
public Earphone getEarphone() {
return new ZhongXingEarphone();
}
}
最后调用:
public class AbstractFactoryTest {
public static void main(String[] args) {
Factory huaWeiFactory = new HuaWeiFactory();
huaWeiFactory.getPhone().create();
huaWeiFactory.getEarphone.create();
Factory xiaoMiFactory = new XiaoMiFactory();
xiaoMiFactory.getPhone().create();
xiaoMiFactory.getEarphone.create();
Factory zhongXingFactory = new ZhongXingFactory();
zhongXingFactory.getPhone().create();
zhongXingFactory.getEarphone.create();
}
}
针对于这三种工厂模式,其实很好的体现了面向对象编程的六大原则之一的依赖倒置原则。具体指的就是编程的时候依赖于抽象而不是依赖于具体。
在写完上面三个工厂后,我自己的一些思考是这样的,其实针对于这三种,很难具体分出具体是什么,比如工厂方法模式与抽象工厂模式,无法就是一个是一个工厂,一个是多个工厂组建成超级工厂而已。有时候我们写业务的时候,刚开始需求可能只有一个,这时用到工厂方法模式,后期需求增加,可能就需要增加工厂,此时就变成抽象工厂模式了。所以我个人认为这两者其实界限不是特别的明显,无非就是一个和多个等级的关系,其实认同为一个也问题不大。