Java 工厂模式

第一种：简单工厂

                   建立一个工厂，对实现了同一个接口的类，进行实例的创建，同时又因为创建实例的方法是静态的，所以简单工厂又被称为静态工厂。

               简单工厂的角色：

                   抽象产品角色：具体产品要继承的父类或者要实现的接口。 

                   具体产品角色：在工厂类所创建的对象就是此对象的实例。 

//抽象的产品角色
public interface Phone {

    void PhoneName();
}

//具体的产品的角色
public class HuaWeiP20 implements Phone {
    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为P20");
    }
}

//具体的产品的角色
public class HuaWeiNova4 implements Phone {

    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为Nova4");
    }
}

//具体的产品的角色
public class HuaWeiMate20 implements Phone {
    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为Mate20");
    }
}

//简单工厂它是一个类
public class HuaWeiPhoneFactory {
    public static final int TYPE_P20 = 0;
    public static final int TYPE_NOVA4 = 1;
    public static final int TYPE_MATE20 = 2;

    public static Phone CreatePhone(int type) { //创建对象的方法，因为这里创建对象的方法是静态的，所以也叫静态工厂
        switch (type) {
            case TYPE_P20:
                 return new HuaWeiP20();
            case TYPE_NOVA4:
                return new HuaWeiNova4();
            case TYPE_MATE20:
                return new HuaWeiMate20();
        }
        return  null;
    }
}

//现在在简单工厂模式里创建产品实例
HuaWeiPhoneFactory.CreatePhone(HuaWeiPhoneFactory.TYPE_P20).PhoneName();
HuaWeiPhoneFactory.CreatePhone(HuaWeiPhoneFactory.TYPE_NOVA4).PhoneName();
HuaWeiPhoneFactory.CreatePhone(HuaWeiPhoneFactory.TYPE_MATE20).PhoneName();

结果：

      

 

   第二种：工厂模式

          因为上面的的简单工厂的类的创建依赖于工厂，所以如果我们要扩展程序，必须对工厂类进行修改，这样就违背了面向对象设计的开闭原则（就是对扩展开放，对修改关闭），那么此时我们可以用到工厂模式，我们创建抽象一个工厂接口，创建具体化抽象接口的工厂类，产品的实例由某个具体工厂类来创建。

        工厂模式的角色：

             抽象工厂角色：具体工厂类要继承的父类或者接口

             具体工厂角色：具体化抽象工厂的抽象方法，并且创建具体产品的实例

             抽象产品角色：具体产品类要继承的父类或者接口

             具体产品角色：具体工厂要创建的对象就是此产品的实例

     工厂模式的特点：

            多个具体的工厂类继承具体工厂类或者实现接口，代替简单工厂里“全能”的工厂类，相比较简单工厂，工厂方法减轻了“全能”工厂类的压力，并且结构能能加灵活，但是类数量是大大的增加。

//抽象的产品角色
public interface Phone {

    void PhoneName();
}

//具体的产品角色（HuaWeiNova4 ）
public class HuaWeiNova4 implements Phone {

    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为Nova4");
    }
}

//具体的产品角色（HuaWeiP20）
public class HuaWeiP20 implements Phone {
    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为P20");
    }
}

//具体的产品角色（HuaWeiMate20）
public class HuaWeiMate20 implements Phone {
    @Override
    public void PhoneName() {
        Log.d("HuaWei","我是华为Mate20");
    }
}

     

//抽象工厂角色 具体工厂要实现的接口
public interface PhoneFactory {

    Phone CreatePhone();
}

//具体的工厂角色（HuaWeiNova4Factory ）
public class HuaWeiNova4Factory implements PhoneFactory {

    @Override
    public Phone CreatePhone() {
        return new HuaWeiNova4();
    }
}

//具体的工厂角色（HuaWeiP20Factory ）
public class HuaWeiP20Factory implements PhoneFactory {

    @Override
    public Phone CreatePhone() {
        return new HuaWeiP20();
    }
}

//具体的工厂角色（HuaWeiMate20Factory ）
public class HuaWeiMate20Factory  implements PhoneFactory{

    @Override
    public Phone CreatePhone() {
       return new HuaWeiMate20();
    }
}

各个具体的工厂创建自己产品实例

//创建HuaWeiNova4
new HuaWeiNova4Factory().CreatePhone().PhoneName();
//创建HuaWeiP20
new HuaWeiP20Factory().CreatePhone().PhoneName();
//创建HuaWeiMate20
new HuaWeiMate20Factory().CreatePhone().PhoneName();

结果：

 

第三种：抽象工厂

             先说下两个概念：

                   1.产品等级结构：如一个抽象类是华为手机，其子类有HuaWeiP20，HuaWeiNova4，HuaWeiMate20等，则抽象华为手机与具体的华为手机型号之间构成了一个产品等级结构。

                   2.产品族：产品族是指同一工厂生产的，位于不同产品等级结构中的一组产品。比如华为电子厂生产华为华为手机，华为平板，华为电脑，则可以看出华为手机位于手机产品等级结构中，华为平板位于平板产品等级结构中，华为电脑位于电脑产品等级结构中，最终,华为手机，华为平板，华为电脑构成一个产品族的。

          抽象工厂的角色：

                  1.抽象工厂：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。

                  2.具体工厂：具体化抽象工厂创建产品的方法，这一组方法创建的产品，形成一个产品族，每个产品都位于某个产品等级结构中。

                3.抽象产品：抽象化产品，它声明了产品所具有的业务方法

                4.具体产品：继承或者实现抽象产品，具体化抽象产品所声明的业务方法。

           抽象工厂与工厂模式的区别：

                   工厂模式对应的是一种产品等级结构，抽象工厂对应的则是多个产品等级结构。 

           

//抽象的产品角色（摄像头）
public interface Camera {

    public void Create();
}

//抽象的产品角色（处理器）
public interface Processor {
    void Create();
}

//具体的产品角色（手机摄像头）
public class PhoneCamera implements Camera {
    @Override
    public void Create() {
        Log.d("HuaWei","手机摄像头");
    }
}

//具体的产品角色（平板摄像头）
public class PadCamera implements Camera {
    @Override
    public void Create() {
        Log.d("HuaWei","平板摄像头");
    }
}

//具体的产品角色（手机处理器）
public class PhoneProcessor implements Processor {
    @Override
    public void Create() {
        Log.d("HuaWei","手机处理器");
    }
}

//具体的产品角色（平板处理器）
public class PadProcessor implements Processor {
    @Override
    public void Create() {
        Log.d("HuaWei","平板处理器");
    }
}

//抽象工厂角色
public interface Factory {

    public Camera CreateCmaera();
    public Processor CreateProcessor();
}

//具体的产品工厂角色（手机工厂）
public class PhoneFactory implements Factory {
    @Override
    public Camera CreateCmaera() {
        return new PhoneCamera();
    }

    @Override
    public Processor CreateProcessor() {
        return new PhoneProcessor();
    }
}

//具体的产品工厂角色（平板工厂）
public class PadFactory implements Factory{
    @Override
    public Camera CreateCmaera() {
        return new PadCamera();
    }

    @Override
    public Processor CreateProcessor() {
        return new PadProcessor();
    }
}

//手机工厂，创建手机摄像头，手机处理器，构成手机产品
Factory phoneFactory=new PhoneFactory();
phoneFactory.CreateCmaera().Create();
phoneFactory.CreateProcessor().Create();

//平板工厂，创建平板摄像头，平板处理器，构成平板产品
Factory padFactory=new PadFactory();
padFactory.CreateCmaera().Create();
padFactory.CreateProcessor().Create();

结果：