目录
1. 定义
客户端不直接new对象,而是通过工厂类获取所需的对象,工厂类封装了对象的具体创建过程。
2. 使用场景
对象的创建过程比较复杂,不希望重复执行创建过程,那么可将对象的创建过程封装到工厂类。即使后续需要修改类的创建过程,那么也不需要修改客户端代码,而只需要修改工厂类。
3. 工厂模式分类
简单工厂模式:工厂类根据客户端传入的条件创建相应的产品并返回。
工厂方法模式:一个产品对应一个具体的工厂类,客户端创建哪个产品就使用哪个具体的工厂类。
抽象工厂模式:一个品牌对应一个具体的工厂类,品牌工厂类含有创建此品牌下系列产品的方法。
3.1 简单工厂模式
/**
* 抽象产品类:电脑
*/
abstract class Computer {
// 抽象方法:设置操作系统
public abstract void setOS();
}
class AComputer extends Computer {
@Override
public void setOS() {
System.out.println("A—OS");
}
@Override
public String toString() {
return "我是AComputer,我的操作系统是A—OS";
}
}
class BComputer extends Computer {
@Override
public void setOS() {
System.out.println("B—OS");
}
@Override
public String toString() {
return "我是BComputer,我的操作系统是B—OS";
}
}
/**
* 简单工厂
*/
class ComputerFactory {
public static Computer createComputer(String type) {
Computer computer = null;
if (type.equalsIgnoreCase("A")) {
computer = new AComputer();
computer.setOS();
} else {
computer = new BComputer();
computer.setOS();
}
return computer;
}
}
public class FactoryTest {
public static void main(String[] args) {
Computer aComputer = ComputerFactory.createComputer("A");
System.out.println(aComputer); // 我是AComputer,我的操作系统是A—OS
Computer bComputer = ComputerFactory.createComputer("B");
System.out.println(bComputer); // 我是BComputer,我的操作系统是B—OS
}
}
简单工厂模式,代码逻辑简单且易实现,通过不同的条件创建不同的产品,但是违反了开闭原则(为修改关闭,对扩展开放),例如:后续新增CComputer,那么就需要修改ComputerFactory,在createComputer方法中添加CComputer相关的判断条件。
3.2 工厂方法模式
/**
* 抽象产品类:电脑
*/
abstract class Computer {
// 抽象方法:设置操作系统
public abstract void setOS();
}
class AComputer extends Computer {
@Override
public void setOS() {
System.out.println("A—OS");
}
@Override
public String toString() {
return "我是AComputer,我的操作系统是A—OS";
}
}
class BComputer extends Computer {
@Override
public void setOS() {
System.out.println("B—OS");
}
@Override
public String toString() {
return "我是BComputer,我的操作系统是B—OS";
}
}
/**
* 抽象工厂类
*/
abstract class AbstractComputerFactory {
// 抽象方法:创建Computer
public abstract Computer createComputer();
}
class AComputerFactory extends AbstractComputerFactory {
@Override
public Computer createComputer() {
Computer aComputer = new AComputer();
aComputer.setOS();
return aComputer;
}
}
class BComputerFactory extends AbstractComputerFactory {
@Override
public Computer createComputer() {
Computer bComputer = new BComputer();
bComputer.setOS();
return bComputer;
}
}
public class FactoryTest {
public static void main(String[] args) {
AbstractComputerFactory aFactory = new AComputerFactory();
Computer aComputer = aFactory.createComputer();
System.out.println(aComputer); // 我是AComputer,我的操作系统是A—OS
AbstractComputerFactory bFactory = new BComputerFactory();
Computer bComputer = bFactory.createComputer();
System.out.println(bComputer); // 我是BComputer,我的操作系统是B—OS
}
}
工厂方法模式,一个具体产品对应一个具体的工厂类,客户端直接调用具体的工厂类便可获得对应的产品;后续新增产品,只需新增具体产品类以及对应的工厂类,而无需修改已有代码,符合开闭原则,但是会新增很多类。例如:新增产品APhone、BPhone,那么就会新增对应的工厂类APhoneFactory、BPhoneFactory,此时我们可以通过抽象工厂模式,解决类增多的问题。
3.3 抽象工厂模式
/**
* 抽象产品类:电脑
*/
abstract class Computer {
// 抽象方法:设置操作系统
public abstract void setOS();
}
class AComputer extends Computer {
@Override
public void setOS() {
System.out.println("A—OS");
}
@Override
public String toString() {
return "我是AComputer,我的操作系统是A—OS";
}
}
class BComputer extends Computer {
@Override
public void setOS() {
System.out.println("B—OS");
}
@Override
public String toString() {
return "我是BComputer,我的操作系统是B—OS";
}
}
/**
* 抽象产品类:手机
*/
abstract class Phone {
// 抽象方法:设置操作系统
public abstract void setOS();
}
class APhone extends Phone {
@Override
public void setOS() {
System.out.println("APhone-OS");
}
@Override
public String toString() {
return "我是APhone,我的操作系统是APhone-OS";
}
}
class BPhone extends Phone {
@Override
public void setOS() {
System.out.println("BPhone-OS");
}
@Override
public String toString() {
return "我是BPhone,我的操作系统是BPhone-OS";
}
}
/**
* 抽象工厂类:品牌工厂
*/
abstract class AbstractFactory {
public abstract Computer createComputer();
public abstract Phone createPhone();
}
class AFactory extends AbstractFactory {
@Override
public Computer createComputer() {
Computer aComputer = new AComputer();
aComputer.setOS();
return aComputer;
}
@Override
public Phone createPhone() {
Phone aPhone = new APhone();
aPhone.setOS();
return aPhone;
}
}
class BFactory extends AbstractFactory {
@Override
public Computer createComputer() {
Computer bComputer = new BComputer();
bComputer.setOS();
return bComputer;
}
@Override
public Phone createPhone() {
Phone bPhone = new BPhone();
bPhone.setOS();
return bPhone;
}
}
public class FactoryTest {
public static void main(String[] args) {
AbstractFactory aFactory = new AFactory();
Computer aComputer = aFactory.createComputer();
Phone aPhone = aFactory.createPhone();
System.out.println(aComputer); // 我是AComputer,我的操作系统是A—OS
System.out.println(aPhone); // 我是APhone,我的操作系统是APhone-OS
AbstractFactory bFactory = new BFactory();
Computer bComputer = bFactory.createComputer();
Phone bPhone = bFactory.createPhone();
System.out.println(bComputer); // 我是BComputer,我的操作系统是B—OS
System.out.println(bPhone); // 我是BPhone,我的操作系统是BPhone-OS
}
}
抽象工厂模式,一个品牌对应一个具体的工厂类,品牌工厂类含有创建此品牌下系列产品的方法。
4. 参考资料
秒懂设计模式之简单工厂模式(Simple Factory Pattern)
秒懂设计模式之工厂方法模式(Factory Method Pattern)