设计模式主要有23种，大致可分为三类：创建型，机构行，行为型；具体如下：
创建型
1，单例设计模式
2，工厂设计模式
3，建造者设计模式
4，原型设计模式
结构型
5，代理设计模式
6，桥接设计模式
7，装饰设计模式
8，适配器设计模式
9，外观设计模式
10，享元设计模式
11，组合设计模式
行为型
持续更新中...
简介
工厂模式（Factory Design Pattern）：也是创建型中常用设计模式；又可细分为三种类型：简单工厂，工厂方法，抽象工厂；工厂顾名思义就是生产产品，在这里是指创建对象；工
简单工厂模式
下面通过动物饲养的例子，实现简单工厂模式；
1，创建一个动物接口：
public interface Animal {//动物抽象
void eat();//动物的行为
}
2，具体的动物类（具体对象类）
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("狗吃骨头！");
}
}public class Cat implements Animal {
@Override
public void eat() {
System.out.println("猫吃鱼！");
}
}
public class Sheep implements Animal {
@Override
public void eat() {
System.out.println("羊吃草！");
}
}
3，创一个饲养厂（工厂），专门饲养（创建对象）各种动物
public class AnimalFactory {
public static Animal createAnimal(String name) {
if ("dog".equalsIgnoreCase(name)) {
return new Dog();
} else if ("cat".equalsIgnoreCase(name)) {
return new Cat();
}else if ("sheep".equalsIgnoreCase(name)) {
return new Sheep();
}
return null;
}
}工厂类中创建对象的方法一般都是 create 开头，比如代码中的 createAnimal()，但有的也命名为 getInstance()、reateInstance()、newInstance()，这个我们根据具体的场景和习惯来命名就好。一般方法都是静态的，所以有些还成为静态工厂；
以上就是简单工厂模式；
使用：
public class Demo {
public static void main(String[] args) {
Animal dog = AnimalFactory.createAnimal("Dog");
dog.eat();
Animal cat = AnimalFactory.createAnimal("cat");
cat.eat();
Animal sheep = AnimalFactory.createAnimal("Sheep");
sheep.eat();
}
}总结：简单工厂存在一个问题就是，如果再增加一种动物，那就要增加一个实体类继承Animal接口，然后修改工厂类，这样不太符合开闭原则：对扩展开放，对修改关闭；实际如果不平凡的增加动物（实体类），也没有太多动物，这样的修改也是可以接受的；
工厂方法模式
如果要解决简单工厂缺点，工厂方法就应运而生了，也是简单工厂的升级；具体可以通过多态对工厂类实现可扩展；重构工厂类如下：
public interface IAnimalFactory {
Animal createAnimal();
}public class DogAnimalFactory implements IAnimalFactory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
public class CatAnimalFactory implements IAnimalFactory {
@Override
public Animal createAnimal() {
return new Cat();
}
}public class SheepAnimalFactory implements IAnimalFactory {
@Override
public Animal createAnimal() {
return new Sheep();
}
}以上就是典型的工厂方法模式实现；把工厂类又抽象了一层；具体动物类创建，就到了工厂接口的具体实现类中；
使用：
public class Demo {
public static void main(String[] args) {
IAnimalFactory dagFactory = createAnimal("dog");
Animal dog = dagFactory.createAnimal();
IAnimalFactory dagFactory = createAnimal("cat");
Animal dog = dagFactory.createAnimal();
}
public static IAnimalFactory createAnimal(String name) {
if ("dog".equalsIgnoreCase(name)) {
return new DogAnimalFactory();
} else if ("cat".equalsIgnoreCase(name)) {
return new CatAnimalFactory();
}else if ("sheep".equalsIgnoreCase(name)) {
return new SheepAnimalFactory();
}
return null;
}
}在以上的使用过程中还会发现，createAnimal()方法去掉过多的if-else,还可以创建一个简单工厂方式，去掉过多if-else，也就是工厂的工厂，用来创建工厂类对象；具体实现如下：单例模式实现简单工厂；
class AnimalFactoryMap {
private static final Map<String, IAnimalFactory> cachedFactories = new HashMap<>();
static {
cachedFactories.put("dog", new DogAnimalFactory());
cachedFactories.put("cat", new CatAnimalFactory());
cachedFactories.put("sheep", new SheepAnimalFactory());
}
public static IAnimalFactory getParserFactory(String type) {
if (type == null || type.isEmpty()) {
return null;
}
IAnimalFactory animalFactory = cachedFactories.get(type.toLowerCase());
return animalFactory;
}
}简单工厂和工厂方法什么时候用？
当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。而使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂。
抽象工厂模式
这个不好用以上案例进行解释，以一个工厂，即生产手机有生产电脑为例；如下
手机接口类
public interface Phone {
void call();
}手机实体类
public class HuaweiPhone implements Phone {
@Override
public void call() {
System.out.println("用华为手机打电话！");
}
}
public class XiaoMiPhone implements Phone {
@Override
public void call() {
System.out.println("用小米手机打电话！");
}
}
电脑接口类
public interface Computer {
void work();
}
电脑实体类
public class MacComputer implements Computer {
@Override
public void work() {
System.out.println("用苹果电脑工作");
}
}public class DellComputer implements Computer {
@Override
public void work() {
System.out.println("用戴尔电脑工作");
}
}抽象工厂类
为Computer和Phone创建接口来获取工厂；
public interface AbstractFactory {
Computer createComputer(String name);//根据name获取不同品牌的电脑对象；
Phone createPhone(String name);//根据name获取不同品牌的手机对象；
}使用：以富士康为例
public class FuShiKangFactory implements AbstractFactory {
@Override
public Computer createComputer(String name) {
if ("mac".equalsIgnoreCase(name)) {
return new MacComputer();
} else if ("dell".equalsIgnoreCase(name)) {
return new DellComputer();
}
return null;
}
@Override
public Phone createPhone(String name) {
if ("huawei".equalsIgnoreCase(name)) {
return new HuaweiPhone();
} else if ("xiaomi".equalsIgnoreCase(name)) {
return new XiaoMiPhone();
}
return null;
}
}
总结：抽象工厂的另一种写法就是把Computer和Phone的实现类都是同一个品牌；这样一个工厂就只生产一个品牌的Phone和Computer
对以上抽象工厂的改进
手机接口类
public interface Phone {
void call();
}手机实体类
public class HuaweiPhone implements Phone {
@Override
public void call() {
System.out.println("用华为手机打电话！");
}
}
public class XiaoMiPhone implements Phone {
@Override
public void call() {
System.out.println("用小米手机打电话！");
}
}电脑接口类
public interface Computer {
void work();
}
电脑实体类
public class HuaWeiComputer implements Computer {
@Override
public void work() {
System.out.println("用华为电脑工作");
}
}public class XiaoMiComputer implements Computer {
@Override
public void work() {
System.out.println("用小米电脑工作");
}
}抽象工厂类
为Computer和Phone创建接口来获取工厂；
public interface AbstractFactory2 {
Computer createComputer();
Phone createPhone();
}使用：
小米工厂
public class XiaoMiFactory implements AbstractFactory2 {
@Override
public Computer createComputer() {
return new XiaoMiComputer();
}
@Override
public Phone createPhone() {
return new XiaoMiPhone();
}
}华为工厂
public class HuaWeiFactory implements AbstractFactory2 {
@Override
public Computer createComputer() {
return new HuaweiComputer();
}
@Override
public Phone createPhone() {
return new HuaweiPhone();
}
}总结：工厂模式可以应用到自定义依赖注入框架种，通过读取配置文件，经过工厂模式创建出对象；工厂模式是用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。
扫一扫
1120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
