设计模式-工厂模式

二十三种设计模式分为三大类：

• 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

• 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

• 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

---

工厂模式是一种创建型模式，见名知意，就是定义一个用于创建对象的借口，让子类决定实例化哪一个类，简单来说就是用来创建类的，工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。详细的，百度百科讲解的挺详细的
                                 
                                 

工厂模式目前来说，主要由三类：简单工厂模式、工厂方法模式和抽象工厂模式。下面就这三种来具体论述一下：

1. 简单工厂模式：

      简单工厂模式思路是，首先我们把一些共性的东西拿出来，进行抽象,然后我们在定义一个类作为工厂类，工厂类的作用就是根据传过来的字符串或者其他Key值给返回一个相对应的实体类。

public interface Car {
    void run();
}

class Byd implements Car{
    @Override
    public void run() {
        System.out.println("比亚迪");
    }
}

class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

public class CarFactory {
    public static Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){
            return new Byd();
        }else{
            return null;
        }
    }
}

//或者下面的方式，又或者利用其它的语句
class CarFactory2 {
    public static Car createAudi(){
        return new Audi();
    }
    public static Car createByd(){
        return new Byd();
    }
}

/**
 * 测试简单工厂模式
 * 缺点在如果需要添加新的产品的话，比如说需要新加入奔驰，那么需要修改代码
 * 这是违反开闭原则
 * @author Administrator
 *
 */
public class Client02 {
    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

        c1.run();
        c2.run();

    }
}

                                                                  

2. 工厂方法模式：

      工厂方法模式就是在简单工厂模式的基础上进一步的改进，思路是定义一个用于创建对象的接口，让子类决定实例化哪一个类。

public interface Car {
    void run();
}

class Byd implements Car{
    @Override
    public void run() {
        System.out.println("比亚迪");
    }
}

class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

/**
 * 这样进行拓展的时候，就不需要修改代码了，比如说，需要添加一个奔驰类，就直接再添加一个奔驰工厂就行了
 * 定义一个用于创建对象的借口，让子类决定实例化哪一个类
 * @author Administrator
 *
 */
public interface CarFactory {
    Car createCar();
}

class AudiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Audi();
    }
}

class BydFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Byd();
    }
}

/**
 * 工厂方法模式
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();

        c1.run();
        c2.run();
    }
}

                                   

3. 抽象工厂模式：

      其实抽象工厂模式是最难理解的，通常都是用来与方法工厂模式来进行对比。抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

这里我们举一个例子，比如客户需要买车，然而现在的车有好的有一般的，好车自然用的发动机、轮胎和座椅之类的都要高级一点，而一般的自然采用一般的配件，所以发动机厂家有会有好发动机和一般发动机，座椅厂家和轮胎厂家也是一样。这时候就用抽象工厂模式用来创建一组相关或者相互依赖的对象。

好车（LuxuryFactory）出产，采用好的发动机（LuxuryEngine）、座椅（LuxurySeat）和轮胎（LuxuryTyre）。
一般的车（LowFactory）出产，采用一般的发动机（LowEngine）、座椅（LowSeat）和轮胎（LowTyre）。

那么使用抽象工厂模式，在为好车生产相关配件时，就无需制定配件的型号，它会自动根据车型生产对应的配件型号Luxury+。

所以对应的关系图就如下所示：

public interface Car {
    void run();
}

class Byd implements Car{
    @Override
    public void run() {
        System.out.println("比亚迪");
    }
}

class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

/**
*  发动机
*/
public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转得快");
    }

    @Override
    public void start() {
        System.out.println("启动快！可以自动启停");
    }
}

class LowEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转得慢");
    }

    @Override
    public void start() {
        System.out.println("启动慢！");
    }
}

/**
*  座位
*/
public interface Seat {
    void massage();
}

class LuxurySeat implements Seat{
    @Override
    public void massage() {
        System.out.println("可以自动按摩");
    }
}

class LowSeat implements Seat{
    @Override
    public void massage() {
        System.out.println("不能按摩");
    }
}

/**
*  车轮
*/
public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("旋转不磨损");
    }
}

class LowTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("旋转磨损快");
    }
}

/**
 * 这是一个产品族的接口
 * @author Administrator
 *
 */
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

/**
*  豪车工厂
*/
class LuxuryFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

/**
*  低端车工厂
*/
class LowFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

/**
 * 抽象工厂模式
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        CarFactory factory = new LuxuryFactory();
        Engine e = factory.createEngine();
        e.run();
        e.start();
    }
}

类似的例子可以见这里