设计模式----------工厂(Factory)模式

　　作用

　　　　实现了创建者和调用者分离。

　　工厂模式核心/本质：

　　　　实例化对象不在使用new，而是用工厂方法代替。

　　　　将选择实现类，创建对象统一管理和控制，从而实现调用者和我们实现类解耦

　工厂模式详细分类

　　1.简单工厂模式（用来生产同一等级结构中的任意产品（对于新增的产品，需要覆盖已有的代码））

　　　　实现以汽车为例

1 //汽车接口 2 public interface Car { 3     void carName(); 4 } 5  6 //三个实现类 7 public class Audi implements Car { 8     @Override 9     public void carName() {10         System.out.println("I`m Audi Car");11     }12 }13 14 public class Benz implements Car {15     @Override16     public void carName() {17         System.out.println("I`m Benz Car");18     }19 }20 21 public class BMW implements Car {22     @Override23     public void carName() {24         System.out.println("I`m BMW Car");25     }26 }27 28 //测试方法29 public static void main(String[] args) {30         Car c1 = new Audi();31         Car c2 = new Benz();32         Car c3 = new BMW();33         c1.carName();34         c2.carName();35         c3.carName();36     }

　　此时如果需要增加一个类，那么开发人员又需要new一个对象。

　　解决方案------简单工厂模式  /  静态工厂模式

1 package com.qing.factory; 2  3 public class FactoryMethod { 4     /* 5         解决方案一 6             此时外部调用只需要传一个名字就可new一个该对象。但是此解决方案需改动方法内部代码结构 7             违反了开闭原则 8      */ 9     public static Car getCar(String carName){10         if(carName == "Audi") {11             return new Audi();12         } else if(carName == "Benz") {13             return new Benz();14         }else if(carName == "BMW") {15             return new BMW();16         }else{17             return null;18         }19     }20     /*21         解决方案二　　　　　　　　　直接添加get方法获取对象22             这种解决方案虽然也违反了开闭原则，但不涉及方法内部代码结构的改动，23             在小型解决方案推荐使用此方案24      */25     public static Car getAudi(){26         return new Audi();27     }28     public static Car getBenz(){29         return new Benz();30     }31     public static Car getBMW(){32         return new BMW();33     }34     public static void main(String[] args) {35         Car audi = FactoryMethod.getAudi();36     }37 }

　　2. 工厂方法模式（用来生产同一等级结构中的任意产品（支持增加任意产品） ）

1 //车接口 2 public interface Car { 3     void carName(); 4 } 5 //车工厂接口 6 public interface CarFactory { 7     Car getCar(); 8 } 9 //奥迪车实现类10 public class Audi implements Car {11     @Override12     public void carName() {13         System.out.println("I`m Audi Car");14     }15 }16 //奥迪车工厂实现类17 public class AudiFactory implements CarFactory{18     @Override19     public Car getCar() {20         return new Audi();21     }22 }23 //奔驰车实现类24 public class Benz implements Car {25     @Override26     public void carName() {27         System.out.println("I`m Benz Car");28     }29 }30 //奔驰车工厂实现类31 public class BenzFactory implements CarFactory {32     @Override33     public Car getCar() {34         return new Benz();35     }36 }37 //宝马车实现类38 public class BMW implements Car {39     @Override40     public void carName() {41         System.out.println("I`m BMW Car");42     }43 }44 //宝马车工厂实现类45 public class BMWFactory implements CarFactory {46     @Override47     public Car getCar() {48         return new BMW();49     }50 }51 52 //测试方法53 public class MyTest {54     public static void main(String[] args) {55         Car c1=new AudiFactory().getCar();56         Car c2=new BenzFactory().getCar();57         Car c3=new BMWFactory().getCar();58         c1.carName();59         c2.carName();60         c3.carName();61     }62 }

　　　　工厂方法模式虽然遵守设计原则，但是从结构复杂度、代码复杂度、编程复杂度、管理复杂度来说，简单工厂模式更容易实现。如下图，实现相同的功能，多了几个类

　　　　

　　3.抽象工厂模式（围绕一个超级工厂创建其他工厂，又称为其他工厂的工厂）

　 　　　　直接上代码，整理手机、电脑、魅族、小米之间的瓜关系

1 //手机产品接口 2 public interface Phone { 3     void start(); 4     void shutdown(); 5 } 6 //魅族手机 7 public class MezuPhone implements Phone { 8     @Override 9     public void start() {10         System.out.println("魅族手机开机");11     }12 13     @Override14     public void shutdown() {15         System.out.println("魅族手机关机");16     }17 }18 //小米手机19 public class MiPhone implements Phone {20     @Override21     public void start() {22         System.out.println("小米手机开机");23     }24 25     @Override26     public void shutdown() {27         System.out.println("小米手机关机");28     }29 }30 //电脑产品接口31 public interface Computer {32     void start();33     void shutdown();34 }35 //魅族电脑36 public class MezuComputer implements Computer{37     @Override38     public void start() {39         System.out.println("魅族电脑开机");40     }41 42     @Override43     public void shutdown() {44         System.out.println("魅族电脑关机");45     }46 }47 //小米电脑48 public class MiComputer implements Computer {49     @Override50     public void start() {51         System.out.println("小米电脑开机");52     }53 54     @Override55     public void shutdown() {56         System.out.println("小米电脑关机");57     }58 }59 //产品工厂60 public interface ProductFactory {61     Phone getPhone();62 63     Computer getComputer();64 }65 //魅族工厂66 public class MezuProduct implements ProductFactory {67     @Override68     public Phone getPhone() {69         return new MezuPhone();70     }71 72     @Override73     public Computer getComputer() {74         return new MezuComputer();75     }76 }77 //小米工厂78 public class MiProduct implements ProductFactory {79     @Override80     public Phone getPhone() {81         return new MiPhone();82     }83 84     @Override85     public Computer getComputer()  {86         return new MiComputer();87     }88 }

　　上图可看出产品工厂（ProductFactory）可以创建魅族和小米的产品，就可以分别获取手机和电脑对象了（可以把小米和魅族看作产品族，手机和电脑看作是产品系列）。总之一句话，抽象工厂是工厂的工厂

　　 引用一句维基百科的说明：

　　 工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列。

1 bgftg2 3 4 ger5 ge6 7 gers

View Code

工厂模式依赖的原则

开闭原则：一个软件的实体应当对扩展开放，对修改关闭

依赖倒转原则：要针对接口编程，不要针对实现编程

迪米特法则：只与直接朋友通信，避免和陌生人通信