工厂模式

工厂模式

1.简单工厂模式

1.1 首先创建一个接口

package org.best.factory.simpleFactory;

public interface Car {
    void run();
}

1.2 创建实现类

package org.best.factory.simpleFactory;
//实现类1
public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰飞起来了");
    }
}

//实现类2

package org.best.factory.simpleFactory;

public class WuLing implements Car {
    @Override
    public void run() {
        System.out.println("五菱飞起来了");
    }
}

1.3 创建工厂

package org.best.factory.simpleFactory;
/**
 * 当有了新车的时候，我们只能修改源代码,不符合开闭原则
 */
public class SimpleFactory {
    private SimpleFactory(){}
    public static Car getCar(String name){
        if (name==null){
            return null;
        }
        if ("wuling".equals(name)){
            return new WuLing();
        }else if ("benchi".equals(name)){
            return new BenChi();
        }else {
            return null;
        }
    }
}

1.5 测试简单工厂

package org.best.factory.simpleFactory;

public class TestSimple {
    public static void main(String[] args) {
        WuLing wuling = (WuLing) SimpleFactory.getCar("wuling");
        wuling.run();

        BenChi benchi = (BenChi) SimpleFactory.getCar("benchi");
        benchi.run();

        //五菱飞起来了 
        //奔驰飞起来了
    }
}

2.工厂方法模式

2.1 创建接口

package org.best.factory.MethodFactory;
/**
 * 汽车接口
 */
public interface Car {
    void run();
}



package org.best.factory.MethodFactory;
/**
 * 汽车工厂接口
 */
public interface CarFactory {
    Car getCar();
}

2.2 创建汽车实现类

package org.best.factory.MethodFactory;
public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰飞起来了");
    }
}


package org.best.factory.MethodFactory;
import org.best.factory.MethodFactory.Car;
public class WuLing implements Car {
    @Override
    public void run() {
        System.out.println("五菱飞起来了");
    }
}

2.3 创建汽车工厂实现类

package org.best.factory.MethodFactory;
public class BenChiFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BenChi();
    }
}


package org.best.factory.MethodFactory;
public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

2.4 创建测试类

package org.best.factory.MethodFactory;

public class TestMethodFactory {
    public static void main(String[] args) {
       //工厂方法解决了简单工厂的弊端，可扩展，但代码量增加
        BenChi  car = (BenChi) new BenChiFactory().getCar();
        car.run();
        //奔驰飞起来了


        WuLing car1 = (WuLing) new WuLingFactory().getCar();
        car1.run();
        //五菱飞起来了
    }
}

3.抽象工厂模式

3.1 创建接口

package org.best.factory.abstractFactory;
/**
 * 防冻液
 */
public interface Fdy {
    void FdyName();
}


package org.best.factory.abstractFactory;
/**
 * 轮胎
 */
public interface LunTai {
    void LunTainame();
}

3.2 创建Fdy实现类

package org.best.factory.abstractFactory;

public class BenChiFdy implements Fdy {

    @Override
    public void FdyName() {
        System.out.println("奔驰防冻液");
    }
}

package org.best.factory.abstractFactory;

public class WuLingFdy implements Fdy {
    @Override
    public void FdyName() {
        System.out.println("五菱防冻液");
    }
}

3.3 创建LunTai实现类

package org.best.factory.abstractFactory;

public class BenChiLunTai implements LunTai{

    @Override
    public void LunTainame() {
        System.out.println("奔驰轮胎,飞驰天下");
    }
}


package org.best.factory.abstractFactory;

public class WuLingLunTai implements LunTai{

    @Override
    public void LunTainame() {
        System.out.println("五零轮胎，飞驰天下");
    }
}

3.4 创建抽象工厂

package org.best.factory.abstractFactory;

/**
 * 抽象工厂模式：用来生产不同产品族的全部产品。在有多个业务品种、业务分类时，
 * 通过抽象工作模式产生需要的对象是一种非常好的解决方式。
 */
public interface AbstractFactory {
   Fdy getFdy();

    LunTai getLunTai();
}

3.5 创建抽象工厂实现类

package org.best.factory.abstractFactory;

public class BenChiFactory implements AbstractFactory {
    @Override
    public Fdy getFdy() {
        return new BenChiFdy();
    }

    @Override
    public LunTai getLunTai() {
        return new BenChiLunTai();
    }
}




package org.best.factory.abstractFactory;

public class WuLingFactory implements AbstractFactory{


    @Override
    public Fdy getFdy() {
        return new WuLingFdy();
    }

    @Override
    public LunTai getLunTai() {
        return new WuLingLunTai();
    }
}

3.6 创建测试类

package org.best.factory.abstractFactory;

public class TestAbstract {
    public static void main(String[] args) {
        BenChiFdy fdy = (BenChiFdy) new BenChiFactory().getFdy();
        BenChiLunTai lunTai = (BenChiLunTai) new BenChiFactory().getLunTai();
        lunTai.LunTainame();
        fdy.FdyName();


        WuLingFdy fdy1 = (WuLingFdy) new WuLingFactory().getFdy();
        fdy1.FdyName();
        WuLingLunTai lunTai1 = (WuLingLunTai) new WuLingFactory().getLunTai();
        lunTai1.LunTainame();

     /*   奔驰轮胎,飞驰天下
        奔驰防冻液 
                五菱防冻液
        五零轮胎，飞驰天下*/
    }
}