1.首先，抽象出来工厂生产出来的产品模板接口：
package com.gupaoedu.vip.factory;
//产品接口
//汽车需要满足一定的标准
public interface Car {
//规定汽车的品牌
String getName();
}
2.定义工厂中可以生产的实体：
package com.gupaoedu.vip.factory;
public class Audi implements Car{
@Override
public String getName() {
return "Audi";
}
}
package com.gupaoedu.vip.factory;
public class Benz implements Car{
@Override
public String getName() {
return "Benz";
}
}
package com.gupaoedu.vip.factory;
public class Bmw implements Car{
@Override
public String getName() {
return "BMW";
}
}
3.定义一个工厂，该工厂根据你想要的实体名称，生产出不同的实体：
package com.gupaoedu.vip.factory.simple;
import com.gupaoedu.vip.factory.Audi;
import com.gupaoedu.vip.factory.Benz;
import com.gupaoedu.vip.factory.Bmw;
import com.gupaoedu.vip.factory.Car;
//对于这个工厂来说(太强大了)
//为什么？
//这个工厂啥都能干(不符合现实)
//编码也是一种艺术(融汇贯通),艺术来源于生活，回归到生活的
public class SimpleFactory {
//实现统一管理、专业化管理
//如果没有工厂模式，小作坊，没有执行标准的
//如果买到三无产品（没有标准）
//卫生监督局工作难度会大大减轻
//中国制造(按人家的标准执行)
//中国制造向中国创造改变(技术不是问题了，问题是什么？思维能力)
//码农就是执行标准的人
//系统架构师，就是制定标准的人
//不只做一个技术者，更要做一个思考者
public Car getCar(String name){
if("BMW".equalsIgnoreCase(name)){
//Spring中的工厂模式
//Bean
//BeanFactory（生成Bean）
//单例的Bean
//被代理过的Bean
//最原始的Bean（原型）
//List类型的Bean
//作用域不同的Bean
//getBean
//非常的紊乱，维护困难
//解耦（松耦合开发）
return new Bmw();
}else if("Benz".equalsIgnoreCase(name)){
return new Benz();
}else if("Audi".equalsIgnoreCase(name)){
return new Audi();
}else{
System.out.println("这个产品产不出来");
return null;
}
}
}
4.测试类：
package com.gupaoedu.vip.factory.simple;
import com.gupaoedu.vip.factory.Car;
public class SimpleFactoryTest {
public static void main(String[] args) {
//这边就是我们的消费者
Car car = new SimpleFactory().getCar("Audi");
System.out.println(car.getName());
}
}
缺点：当生产的实体很多时，需要写大量的if-else。
改进：
当实体类过多时，就不能一个工厂生产全部实体了，那就多建几个工厂，分别生产不同的产品，比如：面粉在面粉厂中生产，水杯在水杯厂中生产。
1.定义工厂的接口
package com.gupaoedu.vip.factory.func;
import com.gupaoedu.vip.factory.Car;
//工厂接口，就定义了所有工厂的执行标准
public interface Factory {
//符合汽车上路标准
//尾气排放标准
//电子设备安全系数
//必须配备安全带、安全气囊
//轮胎的耐磨程度
Car getCar();
}
2.建立多个工厂：
package com.gupaoedu.vip.factory.func;
import com.gupaoedu.vip.factory.Audi;
import com.gupaoedu.vip.factory.Car;
public class AudiFactory implements Factory {
@Override
public Car getCar() {
return new Audi();
}
}
package com.gupaoedu.vip.factory.func;
import com.gupaoedu.vip.factory.Benz;
import com.gupaoedu.vip.factory.Car;
public class BenzFactory implements Factory {
@Override
public Car getCar() {
return new Benz();
}
}
package com.gupaoedu.vip.factory.func;
import com.gupaoedu.vip.factory.Bmw;
import com.gupaoedu.vip.factory.Car;
public class BmwFactory implements Factory {
@Override
public Car getCar() {
return new Bmw();
}
}
3.测试类：
package com.gupaoedu.vip.factory.func;
public class FactoryTest {
public static void main(String[] args) {
//工厂方法模式
//各个产品的生产商，都拥有各自的工厂
//生产工艺，生成的高科技程度都是不一样的
Factory factory = new AudiFactory();
System.out.println(factory.getCar());
//需要用户关心，这个产品的生产商
factory = new BmwFactory();
System.out.println(factory.getCar());
//增加的代码的使用复杂度
//抽象工厂模式
}
}
缺点：虽然对工厂进行了细分，但是，用户需要某个实体时，需要建一个对应的工厂，比较麻烦，怎么让用户接触不到工厂，只需要告诉工厂类需要什么，工厂类只管生产就行了？
引用抽象工厂：
1）定义一个抽象工厂，定义一个默认抽象方法protected abstract Car getCar();，只要是工厂，就得实现该方法，宝马工厂，通过重写该方法，生产宝马。不同的工厂通过重写该方法，可以生产出不同的实体，默认工厂也是一样：
package com.gupaoedu.vip.factory.abstr;
import com.gupaoedu.vip.factory.Car;
public abstract class AbstractFactory {
protected abstract Car getCar();
//这段代码就是动态配置的功能
//固定模式的委派
public Car getCar(String name){
if("BMW".equalsIgnoreCase(name)){
return new BmwFactory().getCar();
}else if("Benz".equalsIgnoreCase(name)){
return new BenzFactory().getCar();
}else if("Audi".equalsIgnoreCase(name)){
return new AudiFactory().getCar();
}else{
System.out.println("这个产品产不出来");
return null;
}
}
}
2）定义一个默认工厂方法：
package com.gupaoedu.vip.factory.abstr;
import com.gupaoedu.vip.factory.Car;
public class DefaultFactory extends AbstractFactory {
private AudiFactory defaultFactory = new AudiFactory();
public Car getCar() {
return defaultFactory.getCar();
}
}
3）构建各种工厂：
package com.gupaoedu.vip.factory.abstr;
import com.gupaoedu.vip.factory.Audi;
import com.gupaoedu.vip.factory.Car;
//具体的业务逻辑封装
public class AudiFactory extends AbstractFactory {
@Override
public Car getCar() {
return new Audi();
}
}
package com.gupaoedu.vip.factory.abstr;
import com.gupaoedu.vip.factory.Benz;
import com.gupaoedu.vip.factory.Car;
public class BenzFactory extends AbstractFactory {
@Override
public Car getCar() {
return new Benz();
}
}
package com.gupaoedu.vip.factory.abstr;
import com.gupaoedu.vip.factory.Bmw;
import com.gupaoedu.vip.factory.Car;
public class BmwFactory extends AbstractFactory {
@Override
public Car getCar() {
return new Bmw();
}
}
4）测试类：
package com.gupaoedu.vip.factory.abstr;
public class AbstractFactoryTest {
public static void main(String[] args) {
DefaultFactory factory = new DefaultFactory();
System.out.println(factory.getCar("Benz"));
//设计模式的经典之处，就在于，解决了编写代码的人和调用代码的人双方的痛处
//解放我们的双手
}
}
使用默认工厂进行生产实体，如果不传参数，使用默认工厂生产实体，如果传参数，使用父类抽象工厂生产实体。
