AbstractFactory

 

 

 

 

 

AbstractFactory

Imagemap
 hideAbstractFactory
hideTest
/**
 * 抽象工厂模式
 * @author 
 *
 */
 public class Test {
 public static void main(String[] args) {
 // 定义出两个工厂
 AbstractCreator creator1 = new Creator1();
 AbstractCreator creator2 = new Creator2();
 
 // 产生A1对象
 AbstractProductA a1 = creator1.createProductA();
 // 产生2对象
 AbstractProductA a2 = creator2.createProductA();
 
 // 产生B1对象
 AbstractProductB b1 = creator1.createProductB();
 // 产生B2对象
 AbstractProductB b2 = creator2.createProductB();
 }
 }

hideAbstractCreator
/**
 * 抽象工厂
 * 
 * @author 
 * 
 */
 public abstract class AbstractCreator {
 /**
 * 创建A产品族
 * 
 * @return
 */
 public abstract AbstractProductA createProductA();
 
 /**
 * 创建B产品族
 * 
 * @return
 */
 public abstract AbstractProductB createProductB();
 }

hideCreator1
/**
 * 产品等级1的实现类
 * 
 * @author lyq
 * 
 */
 public class Creator1 extends AbstractCreator {
 
 /**
 * 只产生产品等级为1的A产品
 */
 public AbstractProductA createProductA() {
 return new ProductA1();
 }
 
 /**
 * 只产生产品等级为1的B产品
 */
 public AbstractProductB createProductB() {
 return new ProductB1();
 }
 
 }

hideAbstractProductA
/**
 * 抽象产品类
 *
 */
 public abstract class AbstractProductA {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductA1
/**
 * 产品A1的实现类
 * 
 */
 public class ProductA1 extends AbstractProductA {
 
 @Override
 public void doSomething() {
 System.out.println("产品A1的实现方法");
 
 }
 }

hideAbstractProductB
/**
 * 抽象产品类
 * 
 */
 public abstract class AbstractProductB {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductB1
/**
 * 产品B1的实现类
 * @author lyq
 *
 */
 public class ProductB1 extends AbstractProductB{
 
 @Override
 public void doSomething() {
 System.out.println("产品B1的实现方法");
 }
 
 }

hideCreator2
/**
 * 产品等级2的实现类
 * 
 * @author 
 * 
 */
 public class Creator2 extends AbstractCreator {
 
 /**
 * 只产生产品等级为2的A产品
 */
 public AbstractProductA createProductA() {
 return new ProductA2();
 }
 
 /**
 * 只产生产品等级为2的B产品
 */
 public AbstractProductB createProductB() {
 return new ProductB2();
 }
 
 }

hideAbstractProductA
/**
 * 抽象产品类
 *
 */
 public abstract class AbstractProductA {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductA2
/**
 * 产品A2的实现类
 * @author 
 *
 */
 public class ProductA2 extends AbstractProductA {
 
 @Override
 public void doSomething() {
 System.out.println("产品A2的实现方法");
 }
 
 }

hideAbstractProductB
/**
 * 抽象产品类
 * 
 */
 public abstract class AbstractProductB {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductB2
/**
 * 产品B2的实现类
 * @author 
 *
 */
 public class ProductB2 extends AbstractProductB {
 
 @Override
 public void doSomething() {
 System.out.println("产品B2的实现方法");
 }
 
 }

 

AbstractFactory
    Test
        AbstractCreator
            Creator1
                AbstractProductA
                    ProductA1
                AbstractProductB
                    ProductB1
            Creator2
                AbstractProductA
                    ProductA2
                AbstractProductB
                    ProductB2

 

 

AbstractFactory

Imagemap
 hideAbstractFactory
hideTest
/**
 * 抽象工厂模式
 * @author 
 *
 */
 public class Test {
 public static void main(String[] args) {
 // 定义出两个工厂
 AbstractCreator creator1 = new Creator1();
 AbstractCreator creator2 = new Creator2();
 
 // 产生A1对象
 AbstractProductA a1 = creator1.createProductA();
 // 产生2对象
 AbstractProductA a2 = creator2.createProductA();
 
 // 产生B1对象
 AbstractProductB b1 = creator1.createProductB();
 // 产生B2对象
 AbstractProductB b2 = creator2.createProductB();
 }
 }

hideAbstractCreator
/**
 * 抽象工厂
 * 
 * @author 
 * 
 */
 public abstract class AbstractCreator {
 /**
 * 创建A产品族
 * 
 * @return
 */
 public abstract AbstractProductA createProductA();
 
 /**
 * 创建B产品族
 * 
 * @return
 */
 public abstract AbstractProductB createProductB();
 }

hideCreator1
/**
 * 产品等级1的实现类
 * 
 * @author lyq
 * 
 */
 public class Creator1 extends AbstractCreator {
 
 /**
 * 只产生产品等级为1的A产品
 */
 public AbstractProductA createProductA() {
 return new ProductA1();
 }
 
 /**
 * 只产生产品等级为1的B产品
 */
 public AbstractProductB createProductB() {
 return new ProductB1();
 }
 
 }

hideAbstractProductA
/**
 * 抽象产品类
 *
 */
 public abstract class AbstractProductA {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductA1
/**
 * 产品A1的实现类
 * 
 */
 public class ProductA1 extends AbstractProductA {
 
 @Override
 public void doSomething() {
 System.out.println("产品A1的实现方法");
 
 }
 }

hideAbstractProductB
/**
 * 抽象产品类
 * 
 */
 public abstract class AbstractProductB {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductB1
/**
 * 产品B1的实现类
 * @author lyq
 *
 */
 public class ProductB1 extends AbstractProductB{
 
 @Override
 public void doSomething() {
 System.out.println("产品B1的实现方法");
 }
 
 }

hideCreator2
/**
 * 产品等级2的实现类
 * 
 * @author 
 * 
 */
 public class Creator2 extends AbstractCreator {
 
 /**
 * 只产生产品等级为2的A产品
 */
 public AbstractProductA createProductA() {
 return new ProductA2();
 }
 
 /**
 * 只产生产品等级为2的B产品
 */
 public AbstractProductB createProductB() {
 return new ProductB2();
 }
 
 }

hideAbstractProductA
/**
 * 抽象产品类
 *
 */
 public abstract class AbstractProductA {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductA2
/**
 * 产品A2的实现类
 * @author 
 *
 */
 public class ProductA2 extends AbstractProductA {
 
 @Override
 public void doSomething() {
 System.out.println("产品A2的实现方法");
 }
 
 }

hideAbstractProductB
/**
 * 抽象产品类
 * 
 */
 public abstract class AbstractProductB {
 /**
 * 每个产品共有的方法
 */
 public void shareMethod() {
 
 }
 
 /**
 * 每个产品相同的方法,不同的实现
 */
 public abstract void doSomething();
 }

leafProductB2
/**
 * 产品B2的实现类
 * @author 
 *
 */
 public class ProductB2 extends AbstractProductB {
 
 @Override
 public void doSomething() {
 System.out.println("产品B2的实现方法");
 }
 
 }