设计模式——简单工厂、工厂方法、抽象工厂

简单工厂模式

/**
 * 汽车形状接口
 */
public interface Car {
    /**
     * 显示汽车品牌方法
     */
    void showBrand();
}

定义一个统一汽车接口。

/**
 * 奔驰汽车
 */
public class BENZCar implements Car{
    @Override
    public void showBrand() {
        System.out.println("奔驰");
    }
}

定义不同品牌汽车去实现统接口。

/**
 * 宝马汽车
 */
public class BMWCar implements Car {
    @Override
    public void showBrand() {
        System.out.println("宝马");
    }
}

定义一个工厂去生产汽车。

/**
 * 汽车工厂
 */
public class CarFactory {
    /**
     * 根据汽车型号生产汽车
     *
     * @param brand
     * @return
     */
    public Car getCar(String brand) {
        if ("BENZ".equals(brand)) {
            //生产奔驰
            return new BENZCar();
        }
        if ("BMW".equals(brand)) {
            //生产宝马
            return new BMWCar();
        }
        return null;
    }
}

测试根据用户需要什么汽车生产什么汽车。

  public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        //根据客户需要生产汽车
        Car BMWCar = carFactory.getCar("BMW");//生产宝马
        Car BENZCar = carFactory.getCar("BENZ");//生产奔驰
        BMWCar.showBrand();
        BENZCar.showBrand();
    }

工厂方法

定义一个工厂接口生产汽车。

/**
 * 工厂接口
 */
public interface Factory {
    //生产汽车
    Car getCar();
}

各个品牌汽车工厂去实现工厂接口。

/**
 * 奔驰工厂
 */
public class BENZFactory implements Factory {
    /**
     * 生产奔驰汽车
     *
     * @return
     */
    @Override
    public Car getCar() {
        return new BENZCar();
    }
}

/**
 * 宝马工厂
 */
public class BMWFactory implements Factory {
    /**
     * 生产宝马汽车
     *
     * @return
     */
    @Override
    public Car getCar() {
        return new BMWCar();
    }
}

不同工厂生产不同汽车。

 public static void main(String[] args) {
        //生产宝马汽车
        Factory BMWFactory = new BMWFactory();
        Car BMWCar = BMWFactory.getCar();
        //生产奔驰汽车
        Factory BENZFactory = new BENZFactory();
        Car BENZCar = BENZFactory.getCar();
        BMWCar.showBrand();
        BENZCar.showBrand();
    }

抽象工厂

定义工厂抽象类

/**
 * 抽象工厂
 */
public abstract class AbstractFactory {
    //获取轮胎
    abstract Tyre getTyre(String brand);

    //获取汽车
    abstract Car getCar(String brand);
}

定义轮胎类和轮胎工厂

/**
 * 轮胎接口
 */
public interface Tyre {
    /**
     * 显示轮胎品牌
     */
    void showBrand();
}

/**
 * 固特异轮胎
 */
public class Goodyear implements Tyre {
    @Override
    public void showBrand() {
        System.out.println("固特异轮胎");
    }
}

/**
 * 米其林轮胎
 */
public class Michelin implements Tyre {
    @Override
    public void showBrand() {
        System.out.println("米其林轮胎");
    }
}

/**
 * 轮胎工厂继承抽象工厂类
 */
public class TyreFactory2 extends AbstractFactory {
    /**
     * 根据轮胎型号生产轮胎
     *
     * @param brand
     * @return
     */
    public Tyre getTyre(String brand) {
        if ("Michelin".equals(brand)) {
            //生产米其林轮胎
            return new Michelin();
        }
        if ("Goodyear".equals(brand)) {
            //生产固特异轮胎
            return new Goodyear();
        }
        return null;
    }

    @Override
    Car getCar(String brand) {
        return null;
    }
}

更改汽车工厂类

/**
 * 汽车工厂继承抽象工厂类
 */
public class CarFactory2 extends AbstractFactory {
    /**
     * 根据汽车型号生产汽车
     *
     * @param brand
     * @return
     */
    public Car getCar(String brand) {
        if ("BENZ".equals(brand)) {
            //生产奔驰
            return new BENZCar();
        }
        if ("BMW".equals(brand)) {
            //生产宝马
            return new BMWCar();
        }
        return null;
    }

    @Override
    Tyre getTyre(String brand) {
        return null;
    }

}

定义一个工厂制造器

/**
 * 工厂创造器
 */
public class FactoryProducer {
    public static AbstractFactory getFactory(String type) {
        if ("Car".equals(type)) {
            return new CarFactory2();
        } else if ("Tyre".equals(type)) {
            return new TyreFactory2();
        }
        return null;
    }
}

测试

public static void main(String[] args) {
        //获取汽车工厂
        AbstractFactory carFactory = FactoryProducer.getFactory("Car");
        //制造汽车
        Car bmw = carFactory.getCar("BMW");
        Car benz = carFactory.getCar("BENZ");
        benz.showBrand();
        bmw.showBrand();

        //获取轮胎工厂
        AbstractFactory tyreFactory = FactoryProducer.getFactory("Tyre");
        //制造轮胎
        Tyre michelin = tyreFactory.getTyre("Michelin");
        Tyre goodyear = tyreFactory.getTyre("Goodyear");
        michelin.showBrand();
        goodyear.showBrand();
    }

 

来源：https://www.cnblogs.com/lingdu9527/p/11213031.html