概念
工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
简单工厂模式
简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创造出哪一种产品的实例类,但它不属于GOF23种设计模式。
1.创建接口
public interface ICourse {
public void record();
}
2.创建接口实现类
public class JavaCourse implements ICourse{
@Override
public void record() {
System.out.println("Java 语言");
}
}
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("pythod语言");
}
}
3.创建工厂类
public class SimpleFactory {
public ICourse getCourse(String name){
if("java".equals(name)){
return new JavaCourse();
}
if("python".equals(name)){
return new PythonCourse();
}else{
return null;
}
}
}
4.创建测试类
public class FactoryTest {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
ICourse course = simpleFactory.getCourse("java");
course.record();
}
}
运行结果:
简单工厂适用于工厂类负责创建对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象的逻辑不需要关心
缺点
- 工厂类的职责相对过重,不易于扩展过于复杂的产品结构
工厂方法模式
工厂方法模式(Factory Method Pattern)是指定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行。
1.创建工厂接口
public interface ICourseFactory {
public ICourse create();
}
2.创建实现接口的工厂类
public class JavaCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new JavaCourse();
}
}
public class PythonCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new PythonCourse();
}
}
3.测试类
public class FactoryMethodTest {
public static void main(String[] args) {
ICourseFactory iCourseFactory=new JavaCourseFactory();
ICourse icourse=iCourseFactory.create();
icourse.record();
}
}
运行结果:
在工厂方法模式中用户只需要关心所需产品对应的工厂,无需关心创建细节
缺点
- 类的个数容易过多,增加复杂度
- 增加了系统的抽象性和理解难度
抽象工厂模式
抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
1.创建产品接口
public interface IAirConditioning {
public void cold();
}
public interface IPhone {
public void call();
}
2.创建产品
public class GreePhone implements IPhone {
@Override
public void call() {
System.out.println("格力电话");
}
}
public class GreeAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("好空调,格力造");
}
}
public class MideaPhone implements IPhone{
@Override
public void call() {
System.out.println("美的电话");
}
}
public class MideaAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("美的空调-精彩生活由我创造");
}
}
3.创建抽象工厂
public abstract class AbstractFactory {
public void init(){
System.out.println("开始。。。");
}
protected abstract IPhone createPhone();
protected abstract IAirConditioning createAirConditioning();
}
4.创建具体工厂
public class MideaFactory extends AbstractFactory{
@Override
protected IPhone createPhone() {
return new MideaPhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new MideaAirConditioning();
}
}
public class GreeFactory extends AbstractFactory {
@Override
protected IPhone createPhone() {
return new GreePhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new GreeAirConditioning();
}
}
4.测试
public class AbstractFactoryTest {
public static void main(String[] args) {
GreeFactory greeFactory=new GreeFactory();
greeFactory.createAirConditioning().cold();
}
}
运行结果:
缺点
- 规定了所有可能被创建的产品集合,产品族如果发生改变,那么从抽象工厂到具体工厂都要发生调整,不符合开闭原则
- 增加了系统的抽象性和理解难度
开闭原则:一个软件实体如类,模块和函数应该对扩展开放,对修改关闭。