工厂模式
工厂顾名思义就是创建产品，
根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，
根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。
该模式用于封装和管理对象的创建，是一种创建型模式
简单工厂模式（静态工厂模式）
- 产品
graph TD
A[Phone] --实现--> B[iPhone]
A[Phone] --实现--> C[MiPhone]
- 工厂
graph TD
A[MethodA] --调用传入 MiPhone--> B[FactoryBean.getPhoneBean]
C[MethodB] --调用传入 iPhone--> B[FactoryBean.getPhoneBean]
D[Methodc] --调用传入 其他--> B[FactoryBean.getPhoneBean]
B --返回 MiPhone 对象-->E[MiPhone]
B --返回 iPhone 对象-->F[iPhone]
B --返回 默认 对象-->G[山寨机]
- 产品demo代码
/**
* @author : mengshuo
* @Description : 手机抽象类
*/
public interface Phone {
/**
* 获取手机信息
*/
void getInfo();
}
/**
* @author : mengshuo
* @Description : 小米手机类
*/
public class MiPhone implements Phone {
@Override
public void getInfo() {
System.out.println("Are You OK ?\n ——By 雷军");
}
}
/**
* @author : mengshuo
* @Description :
*/
public class IPhone implements Phone {
@Override
public void getInfo() {
System.out.println("Do you have IPhone ? \n Me: No!");
}
}
- 工厂demo代码
public class FactoryBean {
public static Phone getPhoneBean(String type) {
if (type.equals("MiPhone")) {
return new MiPhone();
} else if (type.equals("iPhone")) {
return new IPhone();
}
return () -> System.out.println("安卓系统的iPhone!");
}
}
- 方法调用
/**
* @author : mengshuo
* @Description :
*/
public class TestFactory {
public static void main(String[] args) {
/**
* 简单工厂模式
*/
FactoryBean.getPhoneBean("MiPhone").getInfo();
FactoryBean.getPhoneBean("IPhone").getInfo();
FactoryBean.getPhoneBean("123456").getInfo();
}
}
// 结果：
// Are You OK ?
// ——By 雷军
//
// Do you have IPhone ?
// Me: No!
//
// 安卓系统的iPhone!
工厂方法模式
- 产品
graph TD
A[Phone] --实现--> B[iPhone]
A[Phone] --实现--> C[MiPhone]
- 工厂
graph TD
A[FactoryBean] --实现-->B[IPhoneFactoryBean]
A[FactoryBean] --实现-->C[MiPhoneFactoryBean]
A[FactoryBean] --实现-->D[DefaultPhoneFactoryBean ]
B --getPhone方法-->E[返回 iPhone 对象]
C --getPhone方法-->F[返回 MiPhone 对象]
D --getPhone方法-->G[返回 默认Phone对象]
- 产品demo代码
/**
* @author : mengshuo
* @Description : 手机抽象类
*/
public interface Phone {
/**
* 获取手机信息
*/
void getInfo();
}
/**
* @author : mengshuo
* @Description : 小米手机类
*/
public class MiPhone implements Phone {
@Override
public void getInfo() {
System.out.println("Are You OK ?\n ——By 雷军");
}
}
/**
* @author : mengshuo
* @Description :
*/
public class IPhone implements Phone {
@Override
public void getInfo() {
System.out.println("Do you have IPhone ? \n Me: No!");
}
}
- 工厂方法demo代码
/**
* @author : mengshuo
* @Description :
*/
public interface PhoneFactoryBean {
Phone getPhone();
}
/**
* @author : mengshuo
* @Description :
*/
public class MiPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return new MiPhone();
}
}
/**
* @author : mengshuo
* @Description :
*/
public class IPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return new IPhone();
}
}
/**
* @author : mengshuo
* @Description :
*/
public class DefaultPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return ()->{
System.out.println("安卓系统的iphone!");
};
}
}
- 测试代码
/**
* @author : mengshuo
* @Description :
*/
public class TestFactory {
public static void main(String[] args) {
/**
* 方法工厂模式
*/
new MiPhoneFactoryBean().getPhone().getInfo();
new IPhoneFactoryBean().getPhone().getInfo();
new DefaultPhoneFactoryBean().getPhone().getInfo();
}
}
抽象工厂模式
- 产品
graph TD
A[mi.com] --小米产品族--> C[MiPhone]
A[mi.com] --小米产品族--> D[MiBook]
B[apple.com] --苹果产品族--> E[iPhone]
B[apple.com] --苹果产品族--> F[MacBook]
G[Phone] --手机-->A
G[Phone] --手机-->B
H[PC] --PC-->A
H --PC-->B
- 工厂
graph TD
A[FactoryBean] --实现-->B[IPhoneFactoryBean]
A[FactoryBean] --实现-->C[MiPhoneFactoryBean]
A[FactoryBean] --实现-->D[DefaultPhoneFactoryBean ]
B --getPhone方法-->E[返回 iPhone 对象]
B --getPc方法--> H[返回 MacBook 对象]
C --getPhone方法-->F[返回 MiPhone 对象]
C --getPc方法--> I[返回 MiBook 对象]
D --getPhone方法-->G[返回 默认Phone对象]
D --getPc方法-->J[返回 默认Pc对象]
- 产品demo代码
/**
* @author : mengshuo
* @Description : 手机接口
*/
public interface Phone {
/**
* 获取手机信息
*/
void getInfo();
}
/**
* @author : mengshuo
* @Description : 小米手机
*/
public class MiPhone implements Phone {
@Override
public void getInfo() {
System.err.println("Are You OK ?\n ——By 雷军");
}
}
/**
* @author : mengshuo
* @Description : iphone
*/
public class IPhone implements Phone {
@Override
public void getInfo() {
System.err.println("Do you have IPhone ? \n Me: No!");
}
}
/*----------------------------------------------------------------------------------------*/
/**
* @author : mengshuo
* @Description : PC接口
*/
public interface PC {
void getInfo();
}
/**
* @author : mengshuo
* @Description : 小米PC
*/
public class MiPc implements PC {
@Override
public void getInfo() {
System.out.println("MiPc!");
}
}
/**
* @author : mengshuo
* @Description : MackBook
*/
public class MacBook implements PC {
@Override
public void getInfo() {
System.out.println("MacBook!");
}
}
- 抽象工厂demo代码
/**
* @author : mengshuo
* @Description : 抽象工厂接口
*/
public interface PhoneFactoryBean {
/**
* 获取Phone对象
* @return
*/
Phone getPhone();
/**
* 获取Pc对象
* @return
*/
PC getPc();
}
/**
* @author : mengshuo
* @Description : mi.com 产品族工厂
*/
public class MiPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return new MiPhone();
}
@Override
public PC getPc() {
return new MiPc();
}
}
/**
* @author : mengshuo
* @Description : apple.com 产品族工厂
*/
public class IPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return new IPhone();
}
@Override
public PC getPc() {
return new MacBook();
}
}
/**
* @author : mengshuo
* @Description : 默认的工厂
*/
public class DefaultPhoneFactoryBean implements PhoneFactoryBean {
@Override
public Phone getPhone() {
return ()->{
System.err.println("安卓系统的iphone!");
};
}
@Override
public PC getPc() {
return ()->{
System.out.println("UOS 统一操作系统的PC!");
};
}
}
- 测试代码
/**
* @author : mengshuo
* @Description :
*/
public class TestFactory {
public static void main(String[] args) {
/**
* 抽象工厂模式
*/
//获取手机信息
Phone phone = new MiPhoneFactoryBean().getPhone();
phone.getInfo();
phone = new IPhoneFactoryBean().getPhone();
phone.getInfo();
phone = new DefaultPhoneFactoryBean().getPhone();
phone.getInfo();
//获取PC信息
PC pc = new MiPhoneFactoryBean().getPc();
pc.getInfo();
pc = new IPhoneFactoryBean().getPc();
pc.getInfo();
pc = new DefaultPhoneFactoryBean().getPc();
pc.getInfo();
}
}
// 结果：
// Are You OK ?
// ——By 雷军
// Do you have IPhone ?
// Me: No!
// 安卓系统的iphone!
// MiPc!
// MacBook!
// UOS 统一操作系统的PC!
- 抽象工厂代码结构
总结
- 简单工厂模式：
优点：可以跟据参数的不同返回不同的对象
缺点：纵向扩展性较差有新的产品需要去改动代码 - 方法工厂模式
优点：相比简单工厂模式纵向扩展性要强
缺点：如果产品较多需要创建较多的类 - 抽象工厂模式
优点：相比方法工厂模式创建类的数量减少，一个产品族只需一个工厂类即可
缺点：当产品族的品类增加或者减少时需要改动代码