设计模式之工厂模式

简单工厂：又称静态工厂模式，

缺点：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。
		
优点：我们可以对创建的对象进行一些 “加工” ，而且客户端并不知道，因为工厂隐藏了这些细节。如果，没有工厂的话，那我们是不是就得自己在客户端上写这些代码，这就好比本来可以在工厂里生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护。

package cn.myproject.hzq.designpattern.factory;

/**
 * 抽象动物接口
 */
public interface Animal {

    /**
     * 颜色
     */
    void color();

    /**
     * 名称
     */
    void name();
}

package cn.myproject.hzq.designpattern.factory;

/**
 * 抽象的动物类
 * @author hzq
 **/
public abstract class AbstractAnimal implements Animal{
    public String color;
    AbstractAnimal(String color){
       this.color = color;
   }

}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class Cat extends AbstractAnimal {
    Cat(String color) {
        super(color);
    }

    @Override
    public void color() {
        System.out.println("this is a "+this.color+" cat");
    }

    @Override
    public void name() {
        System.out.println("this animal is a cat");
    }
}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class Dog extends AbstractAnimal {
    Dog(String color) {
        super(color);
    }

    @Override
    public void color() {
        System.out.println("this is a "+this.color+" dog");
    }

    @Override
    public void name() {
        System.out.println("this animal is  a dog");
    }
}

package cn.myproject.hzq.designpattern.factory;

/**
 * 静态工厂方法
 * 样做的优点：我们可以对创建的对象进行一些 “加工” ，而且客户端并不知道，因为工厂隐藏了这些细节。如果，没有工厂的话，那我们是不是就得自己在客户端上写这些代码，这就好比本来可以在工厂里生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护。
 * 但是缺点也很明显：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。
 * @author hzq
 **/
public class StaticFactory {
    /**
     * 静态工厂
     * @param name 动物名称
     * @param color 颜色
     * @return 动物接口
     */
    public static Animal animalFactory(String name,String color){
        if(null == name){
            return null;
        }
        if(name.contains("cat")){
            return new Cat(color);
        }else if(name.contains("dog")){
            return new Dog(color);
        }else{
            return null;
        }
    }
}

测试：

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class TestFactory {

        public static void main(String[] args){
            Animal animal = StaticFactory.animalFactory("cat", "blue");
            animal.name();
            animal.color();
        }
}

工厂方法：
工厂模式中，要增加产品类时也要相应地增加工厂类，客户端的代码也增加了不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。
你想要加功能，本来是改工厂类的，而现在是修改客户端。而且各个不同功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开-闭原则的缺点，又保持了封装对象创建过程的优点。
但工厂方法模式的缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

package cn.myproject.hzq.designpattern.factory;

/**
 * 工厂接口实现工厂方法
 */
interface IFactory {

    Animal getAnimal(String color);
}

package cn.myproject.hzq.designpattern.factory;

/**
 * 猫工厂
 * @author hzq
 **/
public class CatFactory  implements IFactory{
    @Override
    public Animal getAnimal(String color) {
        return new Cat(color);
    }


}

package cn.myproject.hzq.designpattern.factory;

/**
 * 狗工厂
 * @author hzq
 **/
public class DogFactory  extends AbstractFactory implements IFactory{
    @Override
    public Animal getAnimal(String color) {
        return new Dog(color);
    }

    @Override
    public AnimalSize createSize() {
        return new DogSize();
    }

    @Override
    public AnimalAge createAge() {
        return new DogAge();
    }
}

测试：

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class TestFactory {

        public static void main(String[] args){
            //使用工厂方法
            IFactory factory = new DogFactory();
            Animal yellow = factory.getAnimal("yellow");
            yellow.name();
            yellow.color();
        }
}

抽象工厂：

package cn.myproject.hzq.designpattern.factory;

/**
 * 抽象工厂
 * 抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类
 * @author hzq
 **/
public abstract class AbstractFactory {

    public abstract  AnimalSize createSize();
    public abstract  AnimalAge createAge();
}

创建一些属性：

package cn.myproject.hzq.designpattern.factory;

/**
 * 创建动物的一个属性
 */
public interface AnimalAge {
    /**
     * 例子不行
     */
     void setAge();
}

package cn.myproject.hzq.designpattern.factory;

/**
 * 动物大小
 * @author hzq
 **/
public interface AnimalSize {

    void saySize();
}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class DogAge implements AnimalAge {
    @Override
    public void setAge() {
        System.out.println("狗的年龄");
    }
}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class DogSize implements AnimalSize {
    @Override
    public void saySize() {
        System.out.println("狗的大小");
    }
}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class CatAge implements AnimalAge {
    @Override
    public void setAge() {
        System.out.println("猫的年龄");
    }
}

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class CatSize implements AnimalSize {
    @Override
    public void saySize() {
        System.out.println("猫的大小");
    }
}

省略点：直接给一个用的。

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class CatAttributeFactory extends AbstractFactory  {
    @Override
    public AnimalSize createSize() {
        return new CatSize();
    }

    @Override
    public AnimalAge createAge() {
        return new CatAge();
    }
}

测试：

package cn.myproject.hzq.designpattern.factory;

/**
 * @author hzq
 **/
public class TestFactory {

        public static void main(String[] args){
            //抽象工厂
            AbstractFactory catFactory = new CatAttributeFactory();
            catFactory.createAge().setAge();
            catFactory.createSize().saySize();
        }
}