工厂模式分为三种：简单工厂模式 （Simple Factory） 、工厂方法模式(Factory Method)、抽象工厂模式(Abstract Factory)

//举例：发送邮件和短信的例子

/**
* @author Administrator
* 产品类
*/
interface Sender{
　　void send();
}
class MailSender implements Sender{
　　@Override
　　public void send() {
　　　　System.out.println("this is a mailsender !");

　　}
}
class SmsSender implements Sender{
　　@Override
　　public void send() {
　　　　System.out.println("this is a smssender !");

}
}
/**
* @author Administrator
* 工厂类
*/
class SenderFactory{
　　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;
　　　　}
　　}
}
/**
* @author Administrator
* 测试类
*/
public class SimpleFactoryTest{
　　public static void main(String[] args) {
　　　　SenderFactory factory = new SenderFactory();
　　　　Sender sender = factory.produce("mail");
　　　　sender.send();
　　}
}

//结果：

this is a mailsender !

对于简单工厂模式而言，如果传递的字符串出错，则不能正确创建对象，或者说如果要发送彩信，需要去改进SenderFactory方法，显然违背了设计的原则
这里多个共产方法模式是提供了多个工厂方法，分别创建对象

/**
* @author Administrator
* 工厂类
*/
//class SenderFactory2{
// //发短信
// 　　public Sender smsProduce(){
// 　　　　 return new SmsSender();
// 　　}
// //发邮件
//　　 public Sender mailProduce(){
// 　　　　 return new MailSender();
//　　 }
//}
//也可以将工厂方法类改为静态的,这样就可以不同通过创建工厂的实例去调用
class SenderFactory2{
//发短信
　　public static Sender smsProduce(){
　　　　return new SmsSender();
　　}
//发邮件
　　public static Sender mailProduce(){
　　　　return new MailSender();
　　}
}

/**
* @author Administrator
* 测试类
*/
public class FactoryMethodTest {

　　public static void main(String[] args) {
// 　　　　SenderFactory2 factory2= new SenderFactory2();
// 　　　　 factory2.smsProduce().send();
//　　　　 factory2.mailProduce().send();

　　　　//静态工厂方法模式
　　　　SenderFactory2.smsProduce().send();
　　　　SenderFactory2.mailProduce().send();
　　}

}

/**
* @author Administrator
* 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题。
* 解决：用抽象工厂模式，创建多个工厂，这样一旦需要增加新功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
*
* 抽象工厂模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需要做一个实现类，实现Sender接口，同时做一个工厂类，实现Factory接口，就OK了，无需改现成的代码。这样做，扩展性好。
*/

//工厂类，多个工厂类
interface Factory{
　　Sender produce();
}
class SmsFactory implements Factory{
　　@Override
　　public Sender produce() {
　　　　return new SmsSender();
　　}
}
class MailFactory implements Factory{
　　@Override
　　public Sender produce() {
　　　　return new MailSender();
　　}
}

/**
* @author Administrator
* 测试类
*/
public class AbstractFactoryTest {

　　public static void main(String[] args) {
　　　　Factory factory = new SmsFactory();
　　　　Sender sender = factory.produce();
　　　　sender.send();
　　}

}