抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的，抽象工厂模式可以向客户端提供一个接口，使得客户端再不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象

1. 模式中包含的角色及其职责

1.1 抽象工厂（Creator）

抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口

AnimalFactory

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public interface AnimalFactory {
    public Dog creatDog();

    public Cat createCat();
}

1.2 具体工厂（Concrete Creator）

具体工厂类是抽象工厂的一个实现，负责实例化某个产品族的产品对象

BluckAnimalFactory

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class BluckAnimalFactory implements AnimalFactory {

    @Override
    public Dog creatDog() {
        return new BluckDog();
    }

    @Override
    public Cat createCat() {
        return new BluckCat();
    }
}

WhiteAnimalFactory

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class WhiteAnimalFactory implements AnimalFactory {
    @Override
    public Dog creatDog() {
        return new WhiteDog();
    }

    @Override
    public Cat createCat() {
        return new WhiteCat();
    }
}

1.3 抽象（Product）

抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口

Animal

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public interface Animal {
    public void eat();
}

下面这两个不算是所有对象的父类，但是产品族的两个大类（大的结构）

Dog

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public abstract class Dog implements Animal {

    @Override
    public abstract void eat();
}

Cat

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public abstract class Cat implements Animal {
    @Override
    public abstract void eat();
}

1.4 具体产品（Concrete Product）

抽象模式所创建的具体实例对象

BluckCat

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class BluckCat extends Cat {
    @Override
    public void eat() {
        System.out.println("BluckCat eat");
    }
}

BluckDog

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class BluckDog extends Dog {
    @Override
    public void eat() {
        System.out.println("BluckDog eat");
    }
}

WhiteCat

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class WhiteCat extends Cat{
    @Override
    public void eat() {
        System.out.println("WhiteCat eat");
    }
}

WhiteDog

package com.liuyao;

/**
 * @author liuyao
 * @date 2018/07/29
 */
public class WhiteDog extends Dog {
    @Override
    public void eat() {
        System.out.println("WhiteDog eat");
    }
}

---

Main

package com.liuyao;

public class Main {

    public static void main(String[] args) {
        AnimalFactory factory=new BluckAnimalFactory();
        Dog dog=factory.creatDog();
        Cat cat=factory.createCat();
        dog.eat();
        cat.eat();

        AnimalFactory factory1=new WhiteAnimalFactory();
        Dog dog1=factory1.creatDog();
        Cat cat1=factory1.createCat();
        dog1.eat();
        cat1.eat();
    }
}

//    BluckDog eat
//    BluckCat eat
//    WhiteDog eat
//    WhiteCat eat

2. 总结

抽象工厂方法对应的是产品的大的结构，具体工厂对应的是产品族。