抽象工厂模式
标签:设计模式

抽象工厂模式

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

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. 总结

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

  • 3 min read

CONTRIBUTORS


  • 3 min read