目录
工厂模式分为简单工厂模式，工厂方法模式，抽象工厂模式。
简单工厂模式
简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。
类图
案例分析
- 手机接口
/**
* 手机接口
*
* @author admin
*/
public interface IPhone {
void make();
}
- 华为手机
/**
* 华为手机
*
* @author admin
*/
public class HuaweiPhone implements IPhone {
@Override
public void make() {
System.out.println("make huawei phone");
}
}
- 小米手机
/**
* 小米手机
*
* @author admin
*/
public class XiaoMiPhone implements IPhone {
@Override
public void make() {
System.out.println("make xiaomi phone");
}
}
- 手机工厂类
/**
* 手机工厂
*
* @author admin
*/
public class PhoneFactory {
public IPhone makePhone(String phoneType) {
if ("xiaomi".equals(phoneType)) {
return new XiaoMiPhone();
} else if ("huawei".equals(phoneType)) {
return new HuaweiPhone();
} else {
return null;
}
}
}
- 客户端
/**
* 客户端
*
* @author admin
*/
public class Client {
public static void main(String[] args) {
IPhone phone = new PhoneFactory().makePhone("huawei");
phone.make();
}
}
工厂方法模式
定义一个用于创建对象的接口， 让子类决定实例化哪一个类。 工厂方法使一个类的实例化延迟到其子类。
优点
- 良好的封装性， 代码结构清晰。
- 工厂方法模式的扩展性非常优秀 。
- 屏蔽产品类。
- 工厂方法模式是典型的解耦框架
类图
案例分析
- 工厂接口
/**
* 工厂接口
*
* @author admin
*/
public interface IPhoneFactory {
IPhone makePhone();
}
- 小米工厂
import org.kouhao.design.patterns.简单工厂模式.IPhone;
import org.kouhao.design.patterns.简单工厂模式.XiaoMiPhone;
/**
* 小米工厂
*
* @author admin
*/
public class XiaomiFactory implements IPhoneFactory {
@Override
public IPhone makePhone() {
return new XiaoMiPhone();
}
}
- 华为工厂
import org.kouhao.design.patterns.简单工厂模式.HuaweiPhone;
import org.kouhao.design.patterns.简单工厂模式.IPhone;
/**
* 华为工厂
*
* @author admin
*/
public class HuaweiFactory implements IPhoneFactory {
@Override
public IPhone makePhone() {
return new HuaweiPhone();
}
}
- 客户端
/**
* 客户端
*
* @author admin
*/
public class Client {
public static void main(String[] args) {
IPhoneFactory huaweiFactory = new HuaweiFactory();
huaweiFactory.makePhone();
IPhoneFactory xiaomiFactory = new XiaomiFactory();
xiaomiFactory.makePhone();
}
}
抽象工厂模式
为创建一组相关或相互依赖的对象提供一个接口， 而且无须指定它们的具体类。
优点
- 封装性
- 产品族内的约束为非公开状态 。
缺点
抽象工厂模式的最大缺点就是产品族扩展非常困难 。
使用场景
一个对象族（或是一组没有任何关系的对象）都有相同的约束， 则可以使用抽象工厂模式。
注意事项
在抽象工厂模式的缺点中， 我们提到抽象工厂模式的产品族扩展比较困难， 但是一定要清楚， 是产品族扩展困难， 而不是产品等级。
类图
案例分析
- 工厂接口
/**
* 工厂接口
*
* @author admin
*/
public interface IFactory {
IPhone makePhone();
IPc makePc();
}
- 小米工厂接口
import org.kouhao.design.patterns.简单工厂模式.IPhone;
import org.kouhao.design.patterns.简单工厂模式.XiaoMiPhone;
/**
* 小米工厂
*
* @author admin
*/
public class XiaomiFactory implements IFactory {
@Override
public IPhone makePhone() {
return new XiaoMiPhone();
}
@Override
public IPc makePc() {
return new XiaomiPc();
}
}
- 华为工厂接口
import org.kouhao.design.patterns.简单工厂模式.HuaweiPhone;
import org.kouhao.design.patterns.简单工厂模式.IPhone;
/**
* 华为工厂
*
* @author admin
*/
public class HuaweiFactory implements IFactory {
@Override
public IPhone makePhone() {
return new HuaweiPhone();
}
@Override
public IPc makePc() {
return new HuaweiPc();
}
}
- PC接口
/**
* PC 接口
*
* @author admin
*/
public interface IPc {
void make();
}
- 华为PC
/**
* 华为PC
*
* @author admin
*/
public class HuaweiPc implements IPc {
public HuaweiPc() {
this.make();
}
@Override
public void make() {
System.out.println("make huawei pc.");
}
}
- 小米PC
/**
* 小米PC
*
* @author admin
*/
public class XiaomiPc implements IPc {
public XiaomiPc(){
this.make();
}
@Override
public void make() {
System.out.println("make xiaomi pc.");
}
}
- 客户端
/**
* 客户端
*
* @author admin
*/
public class Client {
public static void main(String[] args) {
IFactory xiaomiFactory = new XiaomiFactory();
IFactory huaweiFactory = new HuaweiFactory();
xiaomiFactory.makePc();
huaweiFactory.makePc();
xiaomiFactory.makePhone();
huaweiFactory.makePhone();
}
}