设计模式——工厂模式

1：什么是工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种设计模式是属于创建型模式，是创建对象的最佳方式。在工厂模式中，我们创建对象不会对客户端暴露，通过接口来指向新创建的对象。

2：怎样使用工厂模式

2.1:静态工厂（缺点 新增实现类需要修改工厂实现代码）

//接口
public interface Car {
    void creatCar();
}

//实现类
public class Paoche implements Car {
    public void creatCar() {
        System.out.println("跑车创建方法");
    }
}

public class Kache implements Car {
    public void creatCar() {
        System.out.println("卡车创建方法");
    }
}

//工厂
public class CarFactory {

    public static Car getCar(String type){
        //缺点 新增car的实现类 需要改动工厂的方法
        if (type==null){
            System.out.println("不支持创建对象");
            return null;
        }else if(type.equalsIgnoreCase("Kache")){
            return new Kache();//卡车实现car接口
        }else if(type.equalsIgnoreCase("Paoche")){
            return new Paoche();//跑车实现car接口
        }
        return null;
    }
    

}

2.2：静态工厂（新增实现类不需要修改工厂实现代码）

缺点：我们需要new 创建不同的工厂来得到车。这就不好了，创建型设计模式就是不想new 创建对象

我们把工厂变成接口，用多个车工厂来继承接口，新增的车 只需要新增对应的车工程就行，工厂会变多。

 

//工厂接口
public interface CarFactory {
   public Car getCar();
}
//车工厂接口
public class KacheFactory implements CarFactory {
    public Car getCar() {

        return new Kache();
    }
}

public class PaocheFactory implements CarFactory {
    public Car getCar() {
        return new Paoche();
    }
}

//测试类
     /**
     * 此方法符合开闭原则
     * 当程序扩展是 不去修改原有代码 只需要添加代码
     */
    @Test
    public void t1() {
       Car car=new KacheFactory().getCar();
       car.getName();
       car=new PaocheFactory().getCar();
       car.getName();

       //此处扩展自行车 不需要修改代码 只需要已添加代码
       car=new ZixingcheFactory().getCar();
       car.getName();
    }

2.3：抽象工厂

针对2.2的创建不同的工厂需要new 我们来创建一个超级工厂，让超级工厂来创建指定的汽车工厂，或者是飞机工厂，然后用汽车工厂生产汽车，飞机工厂生产飞机

//超级工厂
public interface AbstractFactory {
    Color getColor(String color);

    Car getCar(String car);
}

//不同的工厂实现类1
public class ColorFactory implements AbstractFactory {

    public Color getColor(String color) {
        if (("red").equalsIgnoreCase(color)){
            return new RedColor();
        }else if (("bule").equalsIgnoreCase(color)){
            return new BuleColor();
        }
        return null;
    }

    public Car getCar(String car) {
        return null;
    }
}

//不同的工厂实现类2
public class CarFactory implements AbstractFactory {
    public Color getColor(String color) {

        return null;
    }

    public Car getCar(String car) {
        if (car.equalsIgnoreCase("kache")){
            return new Kache();
        }else if (car.equalsIgnoreCase("paoche")){
            return new Paoche();
        }

        return null;
    }
}


//超级工厂生成器
public class FactoryProducer {
    public static AbstractFactory getAbstrFactory(String factoryName){
        if (("car").equalsIgnoreCase(factoryName)){
            return new CarFactory();

        }else if(("color").equalsIgnoreCase(factoryName)){
            return new ColorFactory();
        }

        return null;

    }
}

//测试方法


    @org.junit.Test
    public void t1() {

        //用工厂生成器 生产抽象
        AbstractFactory abstractFactory1 = FactoryProducer.getAbstrFactory("car");
        
        //用不同的工厂生产不同的产品
        Car car = abstractFactory1.getCar("paoche");
        car.getName();
        car = abstractFactory1.getCar("kache");
        car.getName();

        System.out.println("=================");

        AbstractFactory abstractFactory2 =                 
        FactoryProducer.getAbstrFactory("color");
        Color color = abstractFactory2.getColor("red");
        color.getColor();


    }