设计模式——工厂方法模式、抽象工厂模式

技术2026-02-21 12

模式引入：

工厂：任何可以产生对象的方法或者类。

简单工厂

注：这不属于23中设计模式之一

场景引入

首先，我们想象这样一个场景：创业初期，一个人开了一个工厂生产手机和智能手表。（现实生活中，当然是先生产一个，但是为了好写一些，就假装有两种产品，其实一种产品的也算）

代码实现

device interface

/* 接口,用来说明设备的生产过程 */ public interface device { void process(); }

phone.class

// 手机类，用来说明手机是怎么生产的 public class phone implements device{ public void process() { System.out.println("手机的生产过程就是先这样这样，再那样那样，就生产出来了"); } }

Watch.class

// 智能手环，用来说明智能手环是怎么生产的 public class Watch implements device { public void process() { System.out.println("智能手环的生产方式就是先那样那样，再这样这样，就生产出来了"); } }

SimpleFactory.class

//这就是开的那个工厂，可以生产手机和智能手环 public class SimpleFactory { public device create(String s){ if(s.equals("phone")){ return new phone(); }else if(s.equals("watch")){ return new Watch(); } else { **//注意这里** throw new RuntimeException("你说的产品我们还没有，如果你们需要，我们今后会生产的"); } } }

test.class

public class Test { public static void main(String[] args) { SimpleFactory factory = new SimpleFactory(); device phone = factory.create("phone"); phone.process(); device watch = factory.create("watch"); watch.process(); /* **注意这里** device ipad = factory.create("ipad"); ipad.process(); */ } }

代码简要说明

在简单工厂中，我们只需要说明，我们需要的是什么，工厂就能调用相应的方法给我们生产出我们需要的设备。

拓展

注意在SimpleFactory类中的最后一个else语句，以及test类中最后一个注释掉的语句。如下： SimpleFactory: Test: 想象一个具体的情况：创业者觉得自己现在生产的东西不够多，想要更多的产品。（当然，一般情况下是：人们觉得这个工厂生产的东西好，想要看看这个工产是都生产其他产品。比如这里代码中的ipad）。这种情况下，我们就需要在原来的代码中增加一个Ipad类：

public class Ipad implements device{ public void process() { System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了"); } }

然后为了这个工产能够生产Ipad，SimpleFactory类就需要改成下面这样：

public class SimpleFactory { public device create(String s){ if(s.equals("phone")){ return new phone(); }else if(s.equals("watch")){ return new Watch(); }else if(s.equals("ipad")){ return new Ipad(); } else { throw new RuntimeException("你说的产品我们还没有，如果你们需要，我们今后会生产的"); } } }

增加一个ipad类其实并不影响，主要问题出现在修改了SimpleFactory类中的代码。这就好比为了生产新的产品Ipad，发现原来的场地不够用，就把原来的工产拆了，然后建了一个更大的工厂（有钱任性，我们管不了，但是至少正常人不会这么干）。这样就显示出了简单工场模式的缺点：扩展性差。就是说不能生产新的产品。

工厂方法模式

场景引入

但是，如果创业者想要把企业做大，他肯定会在工厂中生产新产品。（有钱人总想变得更有钱，只有我被贫穷蒙蔽的双眼）。那么如果我们要生产新的产品，上面说的简单共产模式就不管用了，就引入了我们的工厂方法模式。这就好像是：为每一个设备创建一个工厂

代码实现

device interface

/* 接口,用来说明设备的生产过程 */ public interface device { void process(); }

phone.class

Watch.class

Ipad.class

// Ipad，用来说明Ipad是怎么生产的 public class Ipad implements device{ public void process() { System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了"); } }

Factory.class

//把厂抽象出来，自己不做具体的生产实现 public abstract class Factory { abstract device create(); }

phoneFactory.class

//生产手机的工厂，具体实现生产手机 public class phoneFactory extends Factory { device create() { return new phone(); } }

WatchFactory.class

//生产智能手表的工厂，具体实现生产智能手表 public class WatchFactory extends Factory{ device create() { return new Watch(); } }

IpadFactory.class

//生产Ipad的工厂，具体实现生产Ipad public class IpadFactory extends Factory{ device create() { return new Ipad(); } }

Test.class

public class Test { public static void main(String[] args) { Factory factory = new WatchFactory(); device watch = factory.create(); watch.process(); factory = new IpadFactory(); device ipad = factory.create(); ipad.process(); factory = new phoneFactory(); device phone = factory.create(); phone.process(); } }

代码简要说明

在共产方法模式下，工厂不在做具体的生产实现，而是交给各个具体的分工厂去实现。但是，这种情况下，这时候，你要的产品就通过产品的具体类名体现出来：这时候，当增加新的产品时，我们就不需要再改变工厂类了。比如，我们要增加一个新的产品：电脑。只需要增加新的类和具体的工厂。如下： Computer：

public class Computer implements device{ public void process() { System.out.println("电脑就是瞎捯饬捯饬就生产出来了"); } }

ComputerFactory

public class ComputerFactory extends Factory{ device create() { return new Computer(); } }

然后我们再测试类中就可以直接使用了： Test：

这就好像是开分工厂一样，这样就不需要将原来的工厂拆除，再建新的工厂。

抽象工厂模式

情景引入

刚刚那个创业者成功了，这时候就开始有人眼红了。于是，也想开始和他一样，做同样的工厂。因为有了前人的经验，新来的创业者发现这个工厂生产的东西已经固定下来了，而且用多个分厂，用显得非常的麻烦。于是，新来的创业者开的厂就把这些整合起来，用一个厂进行生产。抽象工厂模式的概念就是：一个抽象类中包含多个抽象产品类

代码实现

device interface

/* 接口,用来说明设备的生产过程 */ public interface device { void process(); }

phone.class

Watch.class

Ipad.class

// Ipad，用来说明Ipad是怎么生产的 public class Ipad implements device{ public void process() { System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了"); } }

Computer.class

public class Computer implements device{ public void process() { System.out.println("电脑就是瞎捯饬捯饬就生产出来了"); } }

Factory.class

public abstract class Factory { abstract device phoneCreate(); abstract device ipadCreate(); abstract device watchCreate(); abstract device computerCreate(); }

NewFactory.class

public class NewFactory extends Factory { device phoneCreate() { System.out.println("我是新创业者"); return new phone(); } device ipadCreate() { System.out.println("我是新创业者"); return new Ipad(); } device watchCreate() { System.out.println("我是新创业者"); return new Watch(); } device computerCreate() { System.out.println("我是新创业者"); return new Computer(); } }

OldFactory.class

public class OldFactory extends Factory{ device phoneCreate() { System.out.println("我是老创业者"); return new phone(); } device ipadCreate() { System.out.println("我是老创业者"); return new Ipad(); } device watchCreate() { System.out.println("我是老创业者"); return new Watch(); } device computerCreate() { System.out.println("我是老创业者"); return new Computer(); } }

Test.class

public class Test { public static void main(String[] args) { Factory factory = new NewFactory(); device Newfactory = factory.computerCreate(); Newfactory.process(); Newfactory = factory.ipadCreate(); Newfactory.process(); Newfactory = factory.phoneCreate(); Newfactory.process(); Newfactory = factory.watchCreate(); Newfactory.process(); System.out.println("=============="); factory = new OldFactory(); device old = factory.computerCreate(); old.process(); old = factory.ipadCreate(); old.process(); old = factory.phoneCreate(); old.process(); old = factory.watchCreate(); old.process(); } }

代码解读

抽象工厂模式就像是工厂方法模式的整合，因为那里面的具体工厂太多了，就显得很复杂，将一些产品放在一起进行抽象工厂，就会减少其复杂性。

写在最后

故事完整串联简单工厂模式，工厂方法模式、抽象工厂模式：简单工厂模式就像是早期的工厂，当要增加生产新的产品。因为地方不够，就用分工厂来进行解决，其实这里我们把简单共产模式想成早期的生产一样产品的更好理解。然后当新工厂不断增加时，工厂太多就不好进行管理，然后将一些工厂进行整合，形成抽象工厂模式。这就好像时现实生活中的工厂有很多的生产线，每条工厂线生产不同的产品。生活中就是将每个共产的量缩小，使得每个工厂都能生产公司的所有产品。或者是一个人用别人已有的模式来进行生产。具体的情况有很多很多。说多了，更容易让人不好理解，我就不多说啦。QAQ，该睡觉了，不然要猝死了。不懂的可以留言~~~~~

Processed: 0.013, SQL: 9