工厂模式

一、工厂模式：

　　1）简单工厂模式（Simple Factory）
　　2）工厂方法模式（Factory Method）
　　3）抽象工厂模式（Abstract Factory） 

二、简单工厂模式：

　　//工厂通过返回接口的实例来实现，每次工厂的扩展都要重写工厂，非常不方便；

/**
 * 抽象产品角色
 */
public interface Car {
    public void drive();
}


/**
 * 具体产品类
 */
public class benzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }
}

/**
 * 具体产品类
 */
public class bmwCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}

/**
 * 工厂类角色
 */
public class driverFactory {
    public static Car dirveCar(String params) throws Exception {
        //判断逻辑，返回具体的产品角色给Client
        if (params.equals("benzCar")) {
            return new benzCar();
        } else if (params.equals("bmwCar")) {
            return new bmwCar();
        } else {
            throw new Exception();
        }
    }
}

/**
 * 客户
 **/
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 开奔驰车
        Car car=driverFactory.dirveCar("benzCar");
        //下命令开车
        car.drive();
    }
}

三、工厂方法模式：

　　//把工厂类的方法提取，创建一个抽象工厂，新增的每个工厂实现抽象工厂的方法；

　　//通过每一个独立的工厂创建一个产品；

/**
 * 抽象产品角色
 */
public interface Car {
    public void drive();
}

/**
 * 具体产品类
 */
public class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }
}

/**
 * 具体产品类
 */
public class BmwCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}

/**
 * 抽象工厂
 */
public interface AbstractFactory {
    Car getCar();
}

/**
 * 具体工厂
 **/
public class BenzFactory implements AbstractFactory {
    @Override
    public Car getCar() {
        return new BenzCar();
    }
}

/**
 * 具体工厂
 **/
public class BmwFactory implements AbstractFactory {
    @Override
    public Car getCar() {
        return new BmwCar();
    }
}

/**
 * 客户
 **/
public class Client {
    public static void main(String[] args) throws Exception {
        // 通过宝马工厂创建宝马车
        BmwFactory bmwFactory = new BmwFactory();
        Car bmwCar = bmwFactory.getCar();
        bmwCar.drive();
        // 通过奔驰工厂创建奔驰车
        BenzFactory benzFactory = new BenzFactory();
        Car benzCar = benzFactory.getCar();
        benzCar.drive();
    }
}

驾驶宝马车......
驾驶奔驰车......

四、抽象工厂模式：

　　//工厂方法一个工厂只能创建一种车，如果需要一个工厂创建多种车，就需要抽象工厂模式；

　　通过创建车的抽象类，工厂返回车的抽象类，则车有多少个实现类，工厂就能创建多个车的品种；

/**
 * 抽象产品种类，跑车
 **/
public interface Paoche {
    void drive();
}

/**
 * 抽象产品种类，越野车
 **/
public interface Yueyeche {
    void drive();
}

/**
 * 产品实现类
 **/
public class BmwPaoche implements Paoche {
    @Override
    public void drive() {
        System.out.println("宝马跑车。。。");
    }
}

/**
 * 产品实现类
 **/
public class BmwYueyeche implements Yueyeche {
    @Override
    public void drive() {
        System.out.println("宝马越野车。。。");
    }
}

/**
 * 产品实现类
 **/
public class BenzPaoche implements Paoche {
    @Override
    public void drive() {
        System.out.println("奔驰跑车。。。");
    }
}

/**
 * 产品实现类
 **/
public class BenzYueyeche implements Yueyeche {
    @Override
    public void drive() {
        System.out.println("奔驰越野车。。。");
    }
}


/**
 * 工厂抽象类，定义了创建两种产品的方法
 **/
public interface AbstractFactory {
    Paoche getPaoche();
    Yueyeche getYueye();
}


/**
 * 具体工厂，宝马工厂
 **/
public class BmwFactory implements AbstractFactory {
    @Override
    public Paoche getPaoche() {
        return new BmwPaoche();
    }

    @Override
    public Yueyeche getYueye() {
        return new BmwYueyeche();
    }
}

/**
 * 具体工厂，奔驰工厂
 **/
public class BenzFactory implements AbstractFactory {
    @Override
    public Paoche getPaoche() {
        return new BenzPaoche();
    }

    @Override
    public Yueyeche getYueye() {
        return new BenzYueyeche();
    }
}

/**
 * 客户
 **/
public class Client {
    public static void main(String[] args) throws Exception {
        // 通过宝马工厂创建宝马跑车/宝马越野车
        BmwFactory bmwFactory = new BmwFactory();
        Paoche bmwPaoche = bmwFactory.getPaoche();
        bmwPaoche.drive();
        Yueyeche bmwYueye = bmwFactory.getYueye();
        bmwYueye.drive();
        // 通过奔驰工厂创建奔驰跑车/奔驰越野车
        BenzFactory benzFactory = new BenzFactory();
        Paoche benzPaoche = benzFactory.getPaoche();
        benzPaoche.drive();
        Yueyeche benzYueye = benzFactory.getYueye();
        benzYueye.drive();
    }
}

宝马跑车。。。
宝马越野车。。。
奔驰跑车。。。
奔驰越野车。。。

 

转载于:https://www.cnblogs.com/Tractors/p/11341216.html