抽象工厂模式(Abstract Factory)

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

通常在run-time式创建一个ConcreateFactory类的单体实例。这个ConcreteFactory创建ConcreteProduct对象。为了创建不同的ConcreteProduct对象,clients需要使用不同的ConcreteFactory

AbstractFactoryContinentFactory

定义一个接口,用来创建抽象products

ConcreteFactoryAfrciaFactory,AmericaFactory

实现创建具体的Products

AbstractProductHerbivoreCarnivore

声明一个接口表示一种product类型

ProductWildebeestLionBisonWolf

定义被相关Concrete factory创建的product对象

实现AbstractProduct接口

ClientAnimalWorld

使用AbstractFactoryAbstractProduct

 

 

代码:

//AbstractFactory

public interface ContinentFactory{

            public Herbivore CreateHerbivore();

            public Carnivore CreateCarnivore();

}

 

 

//ConcreteFactory

public class AfricaFactory implements ContinentFactory{

            public Herbivore CreateHerbivore(){

                        return new Wildebeest();

            }

            public Carnivore CreateCarnivore(){

                        return new Lion();

            }

}

 

public class AmericaFactory implements ContinentFactory{

            public Herbivore CreateHerbivore(){

                        return new Bison();

            }

            public Carnivore CreateCarnivore(){

                        return new Wolf();

            }

}

 

//AbstractProduct

 

public interface Herbivore{

}

 

 

public interface Carnivore{

            public void Eat(Herbivore h);

}

 

 

//Product

public class Wildebeest implements Herbivore{

}

 

public class Lion implements Carnivore{

            public void Eat(Herbivore h){

                        System.out.println(“Lion eats “ +h.getName());

            }                     

}

 

public class Bison implements Herbivore{

}

 

public class Wolf implements Carnivore{

            public void Eat(Herbivore h){

                        System.out.println(“Wolf eats “ +h.getName());

            }

}

 

//Client

public class AnimalWorld{

            private Herbivore herbivore;

            private Carnivore carnivore;

            public AnimalWorld(ContinentFactory factory){

                        carnivore=factory. CreateCarnivore();

                        herbivore=factory. CreateHerbivore();

            }

            //Mehtods

            public void RunFoodChain(){

                        carnivore.Eat(herbivore);

            }

            public static void  main(String[] args){

                        AnimalWorld world=new AnimalWorld(new AfricaFactory());

                        world.RunFoodChain();

                       

                        world=new AnimalWorld(new AmericaFactory());

                        world.RunFoodChain();

}

 

Output

Lion eats Wildebeest
Wolf eats Bison

 

 

 

你可能感兴趣的:(抽象工厂模式(Abstract Factory))