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();
    }
}
输出结果：
宝马工厂生产出一辆宝马跑车
宝马跑车在路上跑
奥迪工厂生产出一辆奥迪越野车
奥迪越野车在路上跑
//写了这么多 希望对大家有所帮助吧