工厂模式
1、普通工厂模式
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
使用场景
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。
普通工厂模式实现步骤
1.创建接口和创建实现这个接口的实体类。
2.创建一个工厂，可以基于给定信息生成实体类的对象。
创建一个接口：
public interface Car {
void build();
}创建实现接口的实体类：
Audi.java
public class Audi implements Car{
@Override
public void build() {
System.out.println("This is a Audi car！");
}
}Benz.java
public class Benz implements Car{
@Override
public void build() {
System.out.println("This is a Benz car！");
}
}创建一个工厂，生成基于给定信息的实体类的对象。
public class CarFactory {
public Car getCar(String carName){
if(carName == null){
return null;
}
if (carName.equalsIgnoreCase("Audi")){
return new Audi();
}else if (carName.equalsIgnoreCase("Benz")){
return new Benz();
}
return null;
}
}使用该工厂，通过传递信息来获取实体类的对象。
public class CarDemo {
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
Car audi = carFactory.getCar("Audi");
audi.build();//This is a Audi car！
}
}2、抽象工厂模式
通过一个超级工厂创建其他工厂。在抽象工厂模式中，不需要指定产出产品工厂的类。每个生成的工厂按照工厂模式提供对象。
实现步骤
1.创建 Car和 Motorcycle 接口和实现这些接口的实体类。
2.创建抽象工厂类 AbstractFactory。
3.定义工厂类 CarFactory 和 MotorFactory，这两个工厂类都是扩展了 AbstractFactory。
4.创建一个工厂创造器/生成器类 FactoryProducer。
代码
为汽车创建一个接口
public interface Car {
void build();
}创建实现汽车接口的实体类 Audi.java
public class Audi implements Car{
@Override
public void build() {
System.out.println("This is a Audi car！");
}
}Benz.java
public class Benz implements Car{
@Override
public void build() {
System.out.println("This is a Benz car！");
}
}为摩托车创建一个接口
public interface Motorcycle {
void makeMotorcycle();
}创建实现摩托车接口的实体类 Honda.java
public class Honda implements Motorcycle {
@Override
public void makeMotorcycle() {
System.out.println("造一个本田摩托");
}
}创建实现摩托接口的实体类 Spring.java。
public class Spring implements Motorcycle {
@Override
public void makeMotorcycle() {
System.out.println("造一个春风摩托");
}
}为Car和Color对象创建抽象类获取工厂。
public abstract class AbstracFactory {
public abstract Motorcycle getMotor(String color);
public abstract Car getCar(String car);
}创建Motor工厂类集成工厂抽象类。基于给定的信息生成实体类对象。
public class MotorFactory extends AbstracFactory{
@Override
public Motorcycle getMotor(String color) {
if (color == null){
return null;
}
if (color.equalsIgnoreCase("Spring")){
return new Spring();
}else if (color.equalsIgnoreCase("Honda")){
return new Honda();
}
return null;
}
@Override
public Car getCar(String car) {
return null;
}
}创建car工厂类集成工厂抽象类。基于给定的信息生成实体类对象。
public class CarFactory extends AbstracFactory{
@Override
public Motorcycle getMotor(String color) {
return null;
}
@Override
public Car getCar(String carName){
if(carName == null){
return null;
}
if (carName.equalsIgnoreCase("Audi")){
return new Audi();
}else if (carName.equalsIgnoreCase("Benz")){
return new Benz();
}
return null;
}
}创建一个工厂创造类，通过给定条件获取工厂。
public class FactoryProducer {
public static AbstracFactory getFactory(String choice){
if (choice.equalsIgnoreCase("Car")){
return new CarFactory();
}else if (choice.equalsIgnoreCase("Motor")){
return new MotorFactory();
}
return null;
}
}使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
AbstracFactory motorFactory = FactoryProducer.getFactory("Motor");
Motorcycle motor = motorFactory.getMotor("Spring");
motor.makeMotorcycle();//造一个春风摩托
AbstracFactory carFactory = FactoryProducer.getFactory("CAR");
Car audi = carFactory.getCar("Audi");//This is a Audi car！
audi.build();
}
}若要增加新的产品，只需要在AbstracFactory中增加创建产品的接口，并在具体工厂中实现新加产品的创建。
