设计模式（一）------->工厂模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

一、设计模式的分类

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、
建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、
    桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、
        迭代器模式、责任链模式、命令模式、备忘录模式、
        状态模式、访问者模式、中介者模式、解释器模式。

正文

工厂方法模式（Factory Method）

工厂方法模式分为三种：普通工厂模式   多个工厂方法模式   静态工厂方法模式
1.1、普通工厂模式，就是建立一个工厂类，对实现了同一接口的产品类进行实例的创建.

例子:
//用手机打电话或者座机
public interface CallTelephone {  
    public void call();  
} 

//打电话实现类
public class Phone implements CallTelephone {  
    public void call() {  
        System.out.println("phone!");  
    }  
}  
//打电话实现类
public class Mobile implements CallTelephone {  
    public void call() {  
        System.out.println("mobile!");  
    }  
}  

//创建工厂类
public class CallFactory {  
    //工厂方法
    public CallTelephone produce(String type) {  
        if ("phone".equals(type)) {  
            return new Phone();  
        } else if ("mobile".equals(type)) {  
            return new Mobile();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}   

//测试类
public class FactoryTest {  

    public static void main(String[] args) {  
        CallFactory factory = new CallFactory();  
        CallTelephone callTelephone = factory.produce("phone");
        callTelephone.call();  
    }  
} 


1.2、多个工厂方法模式 是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错， 则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

//将上面的代码做下修改，改动下CallFactory类就行
//这个就不用根据用户传的字符串类创建对象了
public class CallFactory {  

    public CallTelephone producePhone(){  
        return new Phone();  
    }  

    public CallTelephone produceMobile(){  
        return new Mobile();  
    }  
}

//测试类
public class FactoryTest {  

    public static void main(String[] args) {  
        CallFactory factory = new CallFactory();  
        CallTelephone callTelephone = factory.producePhone();  
        callTelephone.call();  
    }  
}  


1.3、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class CallFactory {  

    public static CallTelephone producePhone(){  
        return new Phone();  
    }  

    public static CallTelephone produceMobile(){  
        return new Mobile();  
    }  
}  

//测试类
public class FactoryTest {  

    public static void main(String[] args) {      
        CallTelephone callTelephone = CallFactory.producePhone();  
        callTelephone.call();  
    }  
}   

抽象工厂模式（Abstract Factory）

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

例子:

    //打电话接口
public interface CallTelephone {  
    public void call();  
} 

//打电话的实现类
public class Phone implements CallTelephone {  
    public void call() {  
        System.out.println("phone!");  
    }  
}  
//打电话的实现类
public class Mobile implements CallTelephone {  
    public void call() {  
        System.out.println("mobile!");  
    }  
}  

//给工厂类一个接口
public interface Factory {  
    public CallTelephone produce();  
}  
//两个工厂的实现类
public class PhoneFactory implements Factory {  
    public CallTelephone produce(){  
        return new Phone();  
    }  
}  
public class MobileFactory implements Factory{  
    public CallTelephone produce() {  
        return new Mobile();  
    }  
}  

//测试类
public class Test {  

    public static void main(String[] args) {  
        MobileFactory mobile = new MobileFactory();  
        CallTelephone callTelephone = mobile.produce();  
        callTelephone.call();  
    }  
}  

注:这个模式的好处就是，如果你现在想增加一个功能：用其他方式打电话，则只需做一个实现类实现CallTelephone接口， 同时做一个工厂类，实现Factory接口，就OK了，无需去改动现成的代码。这样做，拓展性较好。

工厂模式另类

某些情况时，用反射是可以替代的，比如以上的功能，皆可用下面的方式替换。如果有新的功能方式打电话，比如电脑等，直接写computer implements CallTelephone接口即可， 并且不用再写新的工厂类.使用的时候，只需要向工厂方法传入一个类的class就可以。

测试