设计模式 -- 工厂模式（Factory Pattern）

简单工厂模式（Simple Factory Pattern）

根据传入的参数决定实例化哪个对象。

• 优点：不直接在客户端创建具体产品的实例，降低了耦合性。

• 缺点：违反了开闭原则，（对扩展开放，对修改关闭），不容易形成高内聚松耦合结构。 每当我们增加一种产品的时候就要去修改工厂方法，这样会破坏其内聚性，给维护带来额外开支。

public class SimpleComputerFactory {
    public static Computer makeComputer(String brand) {
        Computer computer=null;
        switch (brand) {
            case "mac":
                computer=new MacComputer();
                break;
            case "mi":
                computer=new MiComputer();
                break;
            default:
                break;
        }
        return computer;
    }
}


// 或者 利用反射来生成对象
public class SimpleFactory {      
    public static <T extends AbstractProduct> T create(Class<T> clasz) {         
        AbstractProduct product = null;         
        try {             
            product = (AbstractProduct) Class.forName(clasz.getName()).newInstance();         
        } catch (InstantiationException e) {             
            e.printStackTrace();        
        } catch (IllegalAccessException e) {             
            e.printStackTrace();         
        } catch (ClassNotFoundException e) {             
            e.printStackTrace();         
        }         
        return (T) product;     
    } 
}


// 或者
public class SendFactory {  
    public static Sender produceMail(){  
        return new MailSender();  
    }  
    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}  

工厂方法模式（Factory Method Pattern）

工厂模式定义了一个创建对象的接口，由子类进行对象的初始化，即工厂模式将子类的初始化推迟到了子类里。

• 优点：不直接在客户端创建具体产品的实例，降低了耦合性。

• 缺点：每增加一种产品就要相应的增加一个工厂类，比较繁琐。

public abstract class Computer {
     public abstract void setOperationSystem(); 
}


public class MacComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("Mac笔记本安装Mac系统");
    }
}
public class MiComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("小米笔记本安装Win10系统");
    }
}


public interface ComputerFactory {
     Computer makeComputer();
}
public class MacComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new MacComputer();
    }
}
public class MiComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new MiComputer();
    }
}


public static void main(String[] args) {
    //生产Mac电脑
    ComputerFactory macFactory=new MacComputerFactory();
    macFactory.makeComputer().setOperationSystem();


    //生产小米电脑
    ComputerFactory miFactory=new MiComputerFactory();
    miFactory.makeComputer().setOperationSystem();
}

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式和工厂模式很相似，只是它利用接口或者抽象类定义了一个产品族。

此模式在日常开发中使用频率不高，但关键时刻是能起大作用的。

两个产品家族 小米公司 和 苹果公司 ，每个产品家族中包含 笔记本电脑与手机。

//电脑接口
public abstract class Computer {
    public abstract void setOperationSystem();
}
public class MacComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("Mac笔记本安装Mac系统");
    }
}
public class MiComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("小米笔记本安装Win10系统");
    }
}


//手机接口
public abstract class MobilePhoto {
    public abstract void setOperationSystem();
}
public class IPhoto extends MobilePhoto {
    @Override
    public void setOperationSystem() {
        System.out.println("苹果手机安装IOS系统");
    }
}
public class MiPhoto extends MobilePhoto {
    @Override
    public void setOperationSystem() {
        System.out.println("小米手机安装Android系统");
    }
}


//抽象工厂接口
public interface AbstractFactory {
     Computer makeComputer();
     MobilePhoto makeMobilePhoto();
}
public class AppleFactory implements AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new MacComputer();
    }


    @Override
    public MobilePhoto makeMobilePhoto() {
        return new IPhoto();
    }
}
public class XiaoMiFactory implements AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new MiComputer();
    }


    @Override
    public MobilePhoto makeMobilePhoto() {
        return new MiPhoto();
    }
}


    public static void main(String[] args) {
        //使用苹果工厂生产苹果公司的系列产品
        AbstractFactory appleFactory=new AppleFactory();
        appleFactory.makeComputer().setOperationSystem();
        appleFactory.makeMobilePhoto().setOperationSystem();


       //使用小米工厂生产小米公司的系列产品
        AbstractFactory miFactory=new XiaoMiFactory ();
        miFactory.makeComputer().setOperationSystem();
        miFactory.makeMobilePhoto().setOperationSystem();
    }

根据以下文章总结：

1. Java设计模式：23种设计模式全面解析（超级详细）HYPERLINK http://c.biancheng.net/design_pattern/ 

2. 3种设计模式详解 https://www.iteye.com/blog/zz563143188-1847029 

3. Android系统编程思想：设计模式https://github.com/sucese/android-open-source-project-analysis/blob/master/doc/Android%E7%B3%BB%E7%BB%9F%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1%E7%AF%87/02Android%E7%B3%BB%E7%BB%9F%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1%E7%AF%87%EF%BC%9A%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md#35-%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F

4. 设计模式 https://blog.csdn.net/shusheng0007/category_8638565.html

5. java设计模式 https://blog.csdn.net/qq_37909508/category_8976362.html

6. 设计模式 https://www.cnblogs.com/zuoxiaolong/category/509144.html 

7. 设计模式 在源码中的应用 https://blog.csdn.net/qq_36970993/category_10620886.html

8. Android系统设计中存在设计模式分析 https://www.2cto.com/kf/201208/150650.html

9. Android设计模式系列 - 基于android的各种代码分析各种设计模式 https://www.cnblogs.com/qianxudetianxia/category/312863.html