由一个工厂对象决定创建出哪一种产品类的实例，属于创建型模式。

定义发送接口

public interface Sender {
     public void Send(); 
}

以及实现的两个发送短信 和发送邮件

public class MailSender implements Sender {
@Override
    public void Send() {
        System.out.println("this is mail  sender!");
    }
}

发送短信

public class SmsSender implements Sender {
@Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

建造工厂， 一般写法：

public class NormalFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmsSender();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}

在测试入口测试

public class FactoryTest {
public static void main(String[] args) {
    normalFactory();
//  multiFactory();
//  staticFactory();
    }

// 一般写法
private static void normalFactory() {
    NormalFactory factory = new NormalFactory();
    Sender sender = factory.produce("sms");
    sender.Send();
    }

// 多个工厂方法模式
private static void multiFactory() {
    MultiFactory factory = new MultiFactory();
    Sender sender = factory.produceMail();
    sender.Send();
    }

// 静态 工厂
private static void staticFactory() {
    Sender sender = StaticFactory.produceMail();
    sender.Send();
    }
}

当然，产品多了这样写没效率，使用 多个工厂方法模式

public class MultiFactory {
public Sender produceMail() {
    return new MailSender();
    }

public Sender produceSms() {
    return new SmsSender();
    }
}

或者 使用 静态方式

 public class StaticFactory {
        public static Sender produceMail() {
            return new MailSender();
            }

            public static Sender produceSms() {
            return new SmsSender();
        }
}

调用方法在测试类，使用场景的理解：
比如不同模块对网络请求，可以把 使用静态方式创造不同模块的 网络请求实现 。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改。