工厂模式(Factory Pattern)

在Java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，又假如我们要更换对象，就要将所有new对象的地方都要需改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只要和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂中更换对象即可，达到了与对象解耦的目的。所以说，工厂模式最大的优点是：减低耦合。

工厂模式类型

简单工厂模式（Simple Factory Pattern）：不属于23中设计模式，因为违反了开闭原则

简单工厂模式不是一个正式的设计模式，但它是工厂模式的基础。它使用一个单独的工厂类来创建不同的对象，根据传入的参数决定创建哪种类型的对象。

工厂方法模式（Factory Method Pattern）：

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪个类。工厂方法将对象的创建延迟到子类。

抽象工厂模式（Abstract Factory Pattern）：

抽象工厂模式提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

简单工厂模式：

结构：
抽象产品：定义了产品的规范，描述了产品的主要特征和功能
具体产品：实现了抽象产品接口，定义了产品的具体功能（实现或者继承了抽象产品的子类）
具体工厂：提供了创建产品的方法，调用者通过该方法来创建产品

步骤 1:
创建一个接口:Shape.java

public interface Shape{
    void Shape();            
}

步骤 2:
创建实现接口的实体类。
Rectangle.java

public class Restangle implements Shape{
    @Override
    public void Shape(){
        System.out.println("Rectangle");                
    }
}

Square.java

public class Square implements Shape{
    @Override
    public void Shape(){
        System.out.println("Square");                
    }
}

步骤 3:
创建一个工厂，生成基于给定信息的实体类的对象。
ShapeFactory.java

public calss ShapeFactory{

    //使用getShape()方法获取到形状类型的对象
    public Shape getShape(String shapeType){
        if(shapeTuype==null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("Rectangle")){
            return new Restangle();
        }
        if(shapeType.equalsIgnoreCase("Square")){
            return new Square();
        }

    }
}

步骤4：
使用该工厂，通过传递类型信息来获取实体类对象
FactoryPatternDemo.java

public class FactoryPatternDemo{
    public static void main(String[] args){
        ShapeFactory shapeFactory =new ShapeFactory();
        //获取矩形对象,并调用绘制方法
        Shape shape1=shapeFactory.getShape("Rectangle");
        shape1.Shape();

    }
}
//结果是：Rectangle

工厂方法模式

结构:
工厂模式主要包含一下几个主要角色：
抽象产品：定义产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了该产品对象的共同方法。
具体产品：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂：声明了创建产品的抽象方法，可以是接口或者抽象类，它可以有多个方法用于创建不同类型的产品。
具体工厂：实现了抽象工厂接口，定义了创建具体产品的方法，并返回具体产品对象。

抽象工厂:

public interface CoffeeFactory{
    //创建Coffee对象的方法
    Coffee createCoffee();
       
}

具体工厂:

public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
        return new AmericanCoffee();
    }

}

public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
        return new LatteCoffee();
    }
}

抽象产品:

public abstract class Coffee{
        // 抽象方法声明
    public abstract String getName();
    public void addMilk(){
        System.out.println("加奶");
    }
    public  void addSugar(){
        System.out.println("加糖");
    }

}

具体产品:

public class AmericanCoffee extends Coffee{
    
    public String getName(){
        return "AmericanCoffee";                    
    }
}

public class LatteCoffee extends Coffee{
    
    public String getName(){
        return "LatteCoffee";                    
    }
}

中间依赖类:

public class CoffeeStore{

    private CoffeeFactory factory;

    public void SetFactory(CoffeeFactory factory){
        this.factory=factory;
    }
    //实现点Coffee功能
    public Coffee OrderCoffee(){
        Coffee coffee=factory.CreateCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}

Client 测试类

public class Client{
    public static void main(String[] args){
        //创建咖啡店对象
        CoffeeStore store=new CoffeeStore();
        //创建咖啡工厂对象
        CoffeeFactory factory=new AmericanCoffeeFactory();
        //设置咖啡工厂对象
        store.SetFactory(factory);
        //点咖啡
        Coffee coffee=store.OrderCoffee();

        System.out.println(coffee.getName());
    }
}
//结果是：加奶 加糖 AmericanCoffee

工厂方法模式优势：

解耦：客户端与具体产品类解耦，调用者只需要知道对象的名称即可创建对象。
扩展性：添加新产品只需新增具体工厂和产品类
单一职责：每个工厂只负责创建一种产品
开闭原则：对扩展开放，对修改关闭

工厂方法模式缺点：

每次增加一个产品时，都需要增加一个具体类和对应的工厂，使系统中类的数量成倍增加，增加了系统的复杂度和具体类的依赖。

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

抽象工厂模式通常涉及一族相关的产品，每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象，而不需要直接使用具体产品的实现类。

结构：
抽象工厂模式的主要角色如下：
抽象工厂：提供了创建产品的接口，它包含了多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
优点：
确保同一产品族的对象一起工作。
客户端不需要知道每个对象的具体类，简化了代码。
缺点：
扩展产品族非常困难。增加一个新的产品族需要修改抽象工厂和所有具体工厂的代码。
适用场景:
1.当系统需要创建多个相关或依赖的对象，而不需要指定具体类时。
2.当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、电冰箱、空调等。
3.系统中有多个产品族，而系统只消费其中的一族产品。
4.当一个产品族中的多个对象被设计成一起工作时，需要确保客户端代码不会依赖于具体的产品类。

抽象工厂：

      
        public interface DessertFactory {
            //生产咖啡的功能
            Coffee createCoffee();
            //生产甜品的功能
            Dessert createDessert();
}

具体工厂:

//抽象工厂模式 美式风味的甜品工厂：美式咖啡、抹茶慕斯
public class AmerricanDessertFactory implements DessertFactory {


    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new MatchMousse();
    }
}

//意大利风味甜品工厂：创建意大利风味的咖啡和甜品
public class ItalyDessertFactory implements DessertFactory{

    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Trimisu();
    }
}

抽象产品:

public abstract class Dessert {
    public abstract void show();
}

public abstract class Coffee{
        // 抽象方法声明
    public abstract String getName();
    public void addMilk(){
        System.out.println("加奶");
    }
    public  void addSugar(){
        System.out.println("加糖");
    }

}

具体产品：

public class Trimisu extends Dessert{
    @Override
    public void show() {
        System.out.println("Trimisu");
    }
}

public class MatchMousse extends Dessert{
@Override
    public void show() {
    System.out.println("MatchMousse");
    }
}

public class AmericanCoffee extends Coffee{
    
    public String getName(){
        return "AmericanCoffee";                    
    }
}

public class LatteCoffee extends Coffee{
    
    public String getName(){
        return "LatteCoffee";                    
    }
}

测试类：

public class Client {
    public static void main(String[] args) {
        //创建的是意大利风味甜品工厂对象
        ItalyDessertFactory factory=new ItalyDessertFactory();
        //再从工厂里面获取所需要的产品
        Coffee  coffee=factory.createCoffee();
        Dessert dessert=factory.createDessert();

        System.out.println(coffee.getName());
        dessert.show();

    }
}

//结果为：LatteCoffee Trimisu

模式扩展：

简单工厂+配置文件接触耦合：
可以通过工厂模式+配置文件的方式可解除工厂对象和产品对象的耦合，在工厂类中加载配置文件的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。

第一步：定义配置文件
创建一个配置文件，将产品类全限定名保存在文件中，文件名任意，如：bean.properties
<bean.properties>
coffee=com.liuyue.factorymethod.Coffee
dessert=com.liuyue.factorymethod.Dessert
american=com.liuyue.factorymethod.AmericanCoffee
latte=com.liuyue.factorymethod.LatteCoffee
match=com.liuyue.factorymethod.MatchMousse
trimisu=com.liuyue.factorymethod.Trimisu
<bean.properties>
第二部：改进工厂类：

        public class DessertFactory {
            public static Dessert createDessert(String type){
                try {
                    //加载配置文件
                    Properties properties=new Properties();
                    properties.load(new FileInputStream("bean.properties"));
                    //获取type全限定类名
                    String className=properties.getProperty(type);
                    //通过反射创建对象
                    return (Dessert) Class.forName(className).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
            public static Coffee createCoffee(String type){
                try {
                    //加载配置文件
                    Properties properties=new Properties();
                    properties.load(new FileInputStream("bean.properties"));
                    //获取type全限定类名
                    String className=properties.getProperty(type);
                    //通过反射创建对象
                    return (Coffee) Class.forName(className).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
        }
        //测试类
        public class Client {
            public static void main(String[] args) {
                //创建的是意大利风味甜品工厂对象
                ItalyDessertFactory factory=new ItalyDessertFactory();
                //再从工厂里面获取所需要的产品
                Coffee  coffee=factory.createCoffee();
                Dessert dessert=factory.createDessert();

                System.out.println(coffee.getName());
                dessert.show();
                //通过简单工厂+配置文件的方式创建对象
                Coffee coffee1=DessertFactory.createCoffee("latte");
                Dessert dessert1=DessertFactory.createDessert("trimisu");
                System.out.println(coffee1.getName());
                dessert1.show();
            }
        }