对象统一由工厂返回一个抽象接口。子类通过实现工厂的抽象接口，实现具体的代码逻辑。 作用：将对象的创建和使用分离解耦。

简单工厂模式

通过一个工厂类的静态方法来创建不同类型的对象。违反了开闭原则，每增加一个对象类就要修改工厂类的代码。

代码实现：

public interface Button {  
    void click();  
}

public class HtmlButton implements Button{  
    @Override  
     public void click() {  
        System.out.println("click html");  
     }  
}

创建工厂：

public class ButtonFactory {  
    public Button createButton(String button){  
        if(Objects.equals(button, "html")){  
            return new HtmlButton();  
         }  
        return null;  
     }  
}

客户端调用：

public class ClientDemo {  
    public static void main(String[] args) {  
        ButtonFactory buttonFactory=new ButtonFactory();  
         Button button=buttonFactory.createButton("html");  
         button.click();  
     }  
}

工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 一个抽象工厂类提供一个创建对象的抽象方法，具体的创建过程由子类实现。遵循了开闭原则。 代码实现：

// 抽象工厂
public interface ButtonFactory {  
    Button createButton();  
}  

// 具体工厂
public class HtmlButtonFactory implements ButtonFactory{  

    @Override  
    public Button createButton() {  
        return new HtmlButton();  
    }  
}

// 客户端代码
public Button createButton(ButtonFactory buttonFactory){  
    return buttonFactory.createButton();  
}  

@Test  
public void testHtml(){  
    Button button=createButton(new HtmlButtonFactory());  
}

使用反射和枚举优化代码：

public interface Button {  
    void click();  
}

public class HtmlButton implements Button {  
    @Override  
    public void click() {  
        System.out.println("click html");  
    }  
}

// 枚举类
enum ButtonType {  
    HTML(HtmlButton.class);  
    private Class<? extends Button> clazz;  

    ButtonType(Class<? extends Button> clazz) {  
        this.clazz = clazz;  
    }  

    public Class<? extends Button> getClazz() {  
        return clazz;  
    }  
}

//抽象工厂
public interface AbstractButtonFactory<T extends Button> {  
    T createButton(ButtonType buttonType);  
}

//具体工厂
public class ButtonFactory<T extends Button> implements AbstractButtonFactory<T> {  

    private static Map<ButtonType, Class<?>> map = new ConcurrentHashMap<>();  

    static {  
        for (ButtonType buttonType : ButtonType.values()) {  
            Class<?> clazz = buttonType.getClazz();  
            map.put(buttonType, clazz);  
        }  
    }  

    @Override  
    public T createButton(ButtonType buttonType) {  
        try {  
            Class<T> clazz = (Class<T>) map.get(buttonType);  
            if (clazz == null) {  
                return null;  
            }  
            return clazz.getDeclaredConstructor().newInstance();  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
}

// 客户端代码
AbstractButtonFactory<Button> factory = new ButtonFactory<>();  
Button button = factory.createButton(ButtonType.HTML);  
button.click();

抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而无需指定它们的具体类。

工厂方法模式 抽象工厂模式
一个抽象产品类 多个抽象产品类
具体工厂只能创建一个具体产品 具体工厂可以创建多个具体产品
工厂方法只有一个参数 工厂方法有多个参数