工厂模式

1、工厂模式的作用

工厂模式是用来创建对象的。但是，创建可以用new创建对象，为什么要用工厂模式呢？比如说我们创建一个Sample对象

Phone s=new Phone ();

看上去并没有什么不妥的地方啊，平常也一直这样写代码的。但是我们想想工作中如果Phone创建的时候要传入一个对象
那么代码可以写成这样

Phone s=new Phone (context);

如果再加一个呢？

Phone s=new Phone (context，tag1...);

如果这样说，并不麻烦啊，构造参数加就可以了。但是这只是一个简单的问题。如果我们在new的时候做一些操作呢比如加上赋值，查询操作，甚至是调用比较复杂的代码。那么我们就得把每一个new的地方都得修改。这样话，工作量是很大的。况且我们不能预测将来还会有什么改变。因此把new对象交给别人是非常重要的事情。另外，使用new 来创建对象本身也是一种耦合的代码，一处的变动可以影响到多个模块的使用（构造方法变动，调用的变动）。代码设计的规范一定要减少耦合度，这样才容易维护。

工厂模式的主要作用：
1、创建对象
2、代码解耦，模块化。
3、减少对象变动时带来的工作量，容易维护。

2、简单工厂模式

产品类

abstract class Phone {
    public Phone(){

    }
}

public class Androidphone extends Phone {
    public Androidphone() {
        System.out.println("安卓手机");
    }
}

public class Iosphone extends Phone {
    public Iosphone() {
        System.out.println("苹果手机");
    }
}

工厂类，工厂中根据不同的类型，生产不同的手机

public class Factory {
    public Phone creatPhone(int type) {
        switch (type) {

            case 1:
                return new Iosphone();

            case 2:
                return new Androidphone();

            default:
                break;
        }
        return null;
    }
}

测试类

public class SimpleFactivityTest {

    public static void main(String[] args) {
        Factory factory=new Factory();
        factory.creatPhone(1);
        factory.creatPhone(2);
    }
}

3、工厂模式

1、产品类

//抽象产品类
abstract class Phone {
    public Phone(){

    }
}

//具体产品：安卓手机
public class Androidphone extends Phone {
    public Androidphone() {
        System.out.println("im android phone");
    }
}

//具体产品：苹果手机
public class Iosphone extends Phone {
    public Iosphone() {
        System.out.println("im ios phone");
    }
}

2、工厂类

//抽象工厂类
public interface FactoryPhone {
    Phone createPhone();
}

//具体的工厂类：安卓手机
public class FactoryAndroid implements FactoryPhone {
    @Override
    public Phone createPhone() {
        return new Androidphone();
    }
}

//具体工厂类：苹果手机
public class FactoryIos implements FactoryPhone {
    @Override
    public Phone createPhone() {
        return new Iosphone();
    }
}

测试类

public class FactivityTest {

    public static void main(String[] args) {
    //生产安卓手机
        FactoryAndroid android=new FactoryAndroid();
        android.createPhone();
    //生产苹果手机
        FactoryIos ios=new FactoryIos();
        ios.createPhone();
    }
}

4、抽象工厂模式

1、产品类

产品类与上面一样

abstract class Phone {
    public Phone(){

    }
}

public class Androidphone extends Phone {
    public Androidphone() {
        System.out.println("abstract android phone");
    }
}

public class Iosphone extends Phone {
    public Iosphone() {
        System.out.println("abstract ios phone");
    }
}

2、工厂类

抽象工厂，抽象出所创建的对象

 abstract class AbstractFactory {
     abstract Androidphone getAndroid();
     abstract Iosphone getIos();
}

具体工厂，抽象工厂的具体实现

public class PhoneFactory extends AbstractFactory {
    @Override
    public Androidphone getAndroid() {
        return new Androidphone();
    }

    @Override
    public Iosphone getIos() {
        return new Iosphone();
    }
}

测试

public class AbstractFactivityTest {

    public static void main(String[] args) {
        PhoneFactory phoneFactory=new PhoneFactory();
        phoneFactory.getAndroid();
        phoneFactory.getIos();
    }
}

总结

简单工厂模式：在简单工厂中直接根据所有创建的产品类型不同，来new不同的对象，从同一个工厂中可以生产出android,ios类型的手机。

工厂模式：把简单工厂模式中的工厂职能分离，android工厂创建android类型手机，ios工厂创建ios类型的手机。

抽象工厂：把所要创建的手机抽象到工厂中，产生一个抽象工厂，在这个工厂的实现中，创建所需求的手机。

看了上面的解释，这三种工厂在什么情况下使用呢？
在一般情况下：简单工厂和工厂模式都可以满足我们的使用需求，工厂模式其实是简单工厂模式的一种更加解耦的方式。在实际中比较适合这种创建不同对象的工厂：比如说，这个工厂生产手机：一种类型的苹果手机，一种类型的安卓手机（注意是一种类型手机）

抽象工厂是用来给我们更复杂的场景使用的，这个对象创建可能比较复杂，工厂中创建的可能只是这一系列的产品，而不具体的产品，比如
这个工厂生产手机，生产苹果和安卓手机，但苹果（iphone6,7）android(华为，小米…)