工厂模式

工厂模式分为三种：
1、简单工厂模式
2、工厂方法模式
3、抽象工厂模式
下面具体介绍着三种工作模式：
首先是简单工作模式:
1、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
就是首先创建一个手机的接口，定义构造方法，然后创建小米跟苹果两个实现类来实现接口，在实现类里面重写手机接口里面的构造方法。然后定义一个工厂Foxconn来实现对于不同的输入字符串来创建不同的对象以实现调用不同的构造方法实现。简单来说就是我不知道工厂能干什么，这个模式需要告诉工厂我需要生产什么东西，我只管给工厂说我需要什么，工厂有的就生产，没有就不生产。

package FactoryModel;

import java.util.Scanner;

public class Foxconn {
    public Phone creatPhoneByCondition(){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入需要生产的手机类型:");
        String next = scanner.next();
        if (next.equals("小米")){
            return new Mi();
        }else if (next.equals("苹果")){
            return new Iphone();
        }else {
            System.out.println("无法生产该产品");
        }
        return null;
    }
}
interface Phone{
    void creat();
}
class Iphone implements Phone{

    @Override
    public void creat() {
        System.out.println("创造了一部Iphone x max ");
    }
}
class Mi implements Phone{

    @Override
    public void creat() {
        System.out.println("创造了一部小米10 Pro");
    }

}
class FactoryFoxconn {
    public static void main(String[] args) {
        while (true){
            Foxconn foxconn=new Foxconn();
            Phone phone = foxconn.creatPhoneByCondition();
            if (phone!=null){
                phone.creat();
             }

        }
    }
    }
---------------------------------------
下面是运行结果
---------------------------------------
请输入需要生产的手机类型:
小米
创造了一部小米10 Pro

2、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
简单来说就是，工厂已经定义好自己能干什么，我知道工厂能干什么，我只需要调用生产方法就行。而简单工厂模式下我不知道工厂能干什么，而且需要传参数去对应相应的生产方法。

package FactoryModel;

import java.util.Scanner;

public class Foxconn {
    public Phone creatPhoneByCondition(){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入需要生产的手机类型:");
        String next = scanner.next();
        if (next.equals("小米")){
            return new Mi();
        }else if (next.equals("苹果")){
            return new Iphone();
        }else {
            System.out.println("无法生产该产品");
        }
        return null;
    }
}
interface Phone{
    void creat();
}
class Iphone implements Phone{

    @Override
    public void creat() {
        System.out.println("创造了一部Iphone x max ");
    }
}
class Mi implements Phone{

    @Override
    public void creat() {
        System.out.println("创造了一部小米10 Pro");
    }

}
class FactoryFoxconn {
    public static void main(String[] args) {
        while (true){
            Foxconn foxconn=new Foxconn();
            Phone phone = foxconn.creatPhoneByCondition();
            if (phone!=null){
                phone.creat();
             }

        }
    }
    }

运行结果
-----------------------
创造了一部Iphone x max 

/静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
简单来说就相当于工厂工作模式加了一个static修饰符而已，目的是为了不用再去创建新的实例化对象，静态方法直接调用即可/

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，而静态跟非静态相比，不需要实例化工厂类，所以，大多数情况下，我们会选用静态工厂方法模式。

4、抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
下面用发送消息的例子来说明。

package FactoryModel;
public interface Sender {
    public void Send();
}
class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("发送mail消息!");
    }
}
class SmsSender implements Sender {

    @Override
    public void Send() {
        System.out.println("发送sms消息!");
    }
}
class SendMailFactory implements Provider {

    @Override
    public Sender produce(){
        return new MailSender();
    }
}
class SendSmsFactory implements Provider{

    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

interface Provider {
    public Sender produce();
}
class Test {

    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.Send();
    }
}

运行结果
----------------------------
发送mail消息!

简单来说就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！