抽象工厂模式

1.概述

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2.适用性

1）一个系统要独立于它的产品的创建、组合和表示时

2）一个系统要由多个产品系列中的一个来配置时

3）当你要强调一系列相关的产品对象的设计以便进行联合使用时，

4）当你使用一个产品类库，而只想显示它们的接口而不是实现时，

3.参与者

1）AbstractFactory

声明一个创建抽象产品对象的操作接口

2）CreateFactory

实现创建具体产品对象的操作

3）AbstractProduct

为一类产品对象声明一个接口

4）CreateProduct

定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct

5)Client

仅使用由AbstractFactory和AbstractProduct类声明的接口

代码如下：

AbstractFactory包：

package abstractfactory;

import abstractproduct.ICat;
import abstractproduct.IDog;

public interface IAnimalFactory {
    ICat createCat();
    IDog createDog();
}

CreateFactory包：

package createfactory;

import createproduct.BlackCat;
import createproduct.BlackDog;
import abstractfactory.IAnimalFactory;
import abstractproduct.ICat;
import abstractproduct.IDog;

public class BlackAnimalFactory implements IAnimalFactory {

    @Override
    public ICat createCat() {
        // TODO Auto-generated method stub
        return new BlackCat();
    }

    @Override
    public IDog createDog() {
        // TODO Auto-generated method stub
        return new BlackDog();
    }

}



package createfactory;

import createproduct.whileDog;
import createproduct.whiteCat;
import abstractfactory.IAnimalFactory;
import abstractproduct.ICat;
import abstractproduct.IDog;

public class WhiteAnimalFactory implements IAnimalFactory {

    @Override
    public ICat createCat() {
        // TODO Auto-generated method stub
        return new whiteCat();
    }

    @Override
    public IDog createDog() {
        // TODO Auto-generated method stub
        return new whileDog();
    }

}

AbstractProduct包：

package abstractproduct;

public interface ICat {
    void eat();
}



package abstractproduct;

public interface IDog {
    void eat();
}

CreateProduct包：

package createproduct;

import abstractproduct.ICat;

public class BlackCat implements ICat {
    public void eat(){
        System.out.println("the black cat is eating");
    }
}



package createproduct;

import abstractproduct.IDog;

public class BlackDog implements IDog {
    public void eat(){
        System.out.println("the black dog is eating");
    }
}



package createproduct;

import abstractproduct.IDog;

public class whileDog implements IDog {
    public void eat(){
        System.out.println("the white dog is eating");
    }
}



package createproduct;

import abstractproduct.ICat;

public class whiteCat implements ICat {
    public void eat(){
        System.out.println("the white cat is eating");
    }
}

Client包：

package client;

import createfactory.BlackAnimalFactory;
import createfactory.WhiteAnimalFactory;
import abstractfactory.IAnimalFactory;
import abstractproduct.ICat;
import abstractproduct.IDog;

public class Client {
    
    public static void main(String args[]){
        IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
        ICat blackCat = blackAnimalFactory.createCat();
        blackCat.eat();
        IDog blackDog = blackAnimalFactory.createDog();
        blackDog.eat();
        
        IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
        ICat whiteCat = whiteAnimalFactory.createCat();
        whiteCat.eat();
        IDog whiteDog = whiteAnimalFactory.createDog();
        whiteDog.eat();
    }
}