java工厂模式

1、简单模式

//所有车的接口  有一个共同改的方法 开车
public interface Car {
    public void drive();
}
//奥迪类  实现car接口因为奥迪车也是车 肯定可以开的嘛
public class Audi implements Car {
    public Audi(){
        System.out.println("生产出一辆奥迪");
    }
    @Override
    public void drive() {
        System.out.println("开奥迪");
    }
}
//宝马类  实现car接口因为宝马车也是车 肯定也可以开
public class Bmw implements Car{
    public Bmw(){
        System.out.println("生产出一辆宝马");
    }
    @Override
    public void drive() {
        System.out.println("开宝马");
    }
}
//生产车的工厂  该工厂接收一个车名 你只需要告诉他你要生产什么车  就可以生产出对应的车出来
public class CarFactory {
    public static Car getCar(String caename){
        if(caename.equals("audi")){
            return new Audi();
        }else if(caename.equals("bmw")){
            return new Bmw();
        }
            return null;
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        //告诉工厂类 你需要生产出一辆奥迪车  那么给昂他传一个参数audi进去
        Car audi = CarFactory.getCar("audi");
        //就可以生产出奥迪的车 调用开车的方法就可以开车啦
        audi.drive();
        //宝马类似
        Car bmw = CarFactory.getCar("bmw");
        bmw.drive();
    }
}
输出：
成产出一辆奥迪
开奥迪
生产出一辆宝马
开宝马

2、工厂方法模式

根据以上代码 大家可以发现 比传统的new方法 Audi audi = new Audi();要方便很多 如果说你因为需求 要加一个奔驰的车 那你还要Bnez benz = new Bnez(); 这样的话岂不是很麻烦,用工厂模式的话 客户端就不用在new对象 将生成对象的细节可代码都交给了工厂管理和实现 你只需要写一个getObject();方法获取到你想要的对象就ok了 囚你要加一辆奔驰的话 只需要写一个benz的类 实现car接口 然后在工厂类中进行添加相应的逻辑代码就好了

这种模式虽然好一些 但是囚我们每次要加一个汽车类的话，都要在工厂类里面修改判断逻辑代码，还是有一定的局限性，不符合开闭原则，因此我们下面介绍更好一点的方式：工厂方法模式

//首先我们将carFactory工厂类 抽象成一个接口
public interface CarFactory {
    public Car getCar();
}
//然后我们再写两个首先该接口的具体工厂类（奥迪和宝马）
public class AudiFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Audi();
    }
}
    public class BmwFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Bmw();
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        //实例化奥迪工厂类
        CarFactory factory = new AudiFactory();
        //调用奥迪工厂类里面的生产奥迪的方法
        Car audi = factory.getCar();
        audi.drive();
        //宝马和奥迪一样
        CarFactory factory2 = new BmwFactory();
        Car bmw = factory2.getCar();
        bmw.drive();
    }
}
输出结果：
生产出一辆奥迪
开奥迪
生产出一辆宝马
开宝马

这样的话 奥迪工厂类 就只专注生产奥迪的车 宝马一样只生产宝马车，如果我们需要加奔驰的话 只需要再写一个上产奔驰的工厂类去实现CarFactory接口 和一个奔驰实///体类实现car接口就好了代码如下：

public class Bnez implements Car{
 
    public Bnez() {
        System.out.println("生产出一辆奔驰");
    }
    @Override
    public void drive() {
        System.out.println("开奔驰");
    }
}
public class BnezFactory implements CarFactory{
    @Override
    public Car getCar() {
        return null;
    }
}
//在Test里面调用：
CarFactory factory = new BenzFactory();
Car benz = factory.getCar();
benz.drive();

3、抽象工厂模式

但是大家又会觉得 奥迪和宝马也不止一种车啊 也有奥迪跑车 和奥迪越野车， 宝马跑车和宝马越野车啊 的确这样 那么以上两种方就实现不了 因为car这个接口就不能通用了，他只能生产car，不能生产出跑车和越野车，所以第三种方法 我们需要将car这个接口里面的getCar()方法变成两个方法（一个上产跑车的方法getPaoche();一个生产越野车的方法getYueye()） 所以引进第三种工厂模式：抽象工厂模式

*/
//跑车接口
public interface Paoche {
    public void drive();
}
//越野车接口
public interface Yueye {
    public void drive();
}

那么这样的话奥迪车是不是就变成了两个实体类了 之前只是一个audi这个类 现在变成了 奥迪跑车类和奥迪越野车类 加上宝马的话就有四个具体实现的类了

//奥迪跑车
public class AudiPaoche implements Paoche {
    public AudiPaoche(){
        System.out.println("奥迪工厂上产出一辆奥迪跑车");
    }
    public void drive() {
        System.out.println("奥迪跑车在路上跑");
    }
}
//奥迪越野车
public class AudiYueye implements Yueye {
    public AudiYueye(){
        System.out.println("奥迪工厂生产出一辆奥迪越野车");
    }
    public void drive() {
        System.out.println("奥迪越野车在路上跑");
    }
}
//宝马跑车
public class BmwPaoche implements Paoche{
    public BmwPaoche(){
        System.out.println("宝马工厂生产出一辆宝马跑车");
    }
    public void drive() {
        System.out.println("宝马跑车在路上跑");
    }
}
//宝马越野车
public class BmwYueye implements Yueye {
    public BmwYueye(){
        System.out.println("宝马工厂生产出一辆宝马越野车");
    }
    public void drive() {
        System.out.println("宝马越野车");
    }
}
//生产跑车和越野车的接口
public interface CarFactory {
    public Paoche getPaoche();
    public Yueye getYueye();
}
//生产奥迪的工厂类实现CarFactory
public class AudiFactory implements CarFactory{
    @Override
    public Paoche getPaoche() {
        return new AudiPaoche();
}
    @Override
    public Yueye getYueye() {
        return new AudiYueye();
    }
}
//生产宝马的工厂类实现CarFactory
public class BmwFactory implements CarFactory {
    @Override
    public Paoche getPaoche() {
        return new BmwPaoche();
    }
    @Override
    public Yueye getYueye() {
        return new BmwYueye();
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        //实例化生产宝马的工厂类 来上产宝马跑车和宝马越野车  宝马工厂有 生产宝马跑车和宝马越野车  这两个方法  具体是生产跑车还是越野车  看客户端选择
        CarFactory factory = new BmwFactory();
        //在这里选择的是生产跑车  调用的是上产跑车的方法
        Paoche paoche = factory.getPaoche();
        paoche.drive();
 
        CarFactory factory2 = new AudiFactory();
        Yueye yueye = factory2.getYueye();
        yueye.drive();
    }
}
输出结果：
宝马工厂生产出一辆宝马跑车
宝马跑车在路上跑
奥迪工厂生产出一辆奥迪越野车
奥迪越野车在路上跑
//写了这么多 希望对大家有所帮助吧