设计模式的混合使用

设计模式的混合使用

一、 抽象工厂、建造者模式结合

参考
抽象工厂：这时我们可以把多个工厂方法组合到一个类，这就是抽象工厂模式，它就是专门用来创建多个产品，也可以说是创建产品家族的。
抽象工厂模式包含如下角色：
AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
Product：具体产品

建造者模式：面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
包含如下角色：
建造者（Builder）
具体建造者（ConcreteBuilder）
指挥者（Director）
产品（Product）

结合实例：
以开奶茶店为例，奶茶的原料可以由多个厂提供，使用抽象工厂来统一供应原料。假如配制奶茶只需要奶类和茶类，这些配件是稳定的，配制过程也是稳定的，但是搭配方式是多样的，比如牛奶红茶，牛奶绿茶等。

类图：

抽象工厂部分：

public interface Factory {
	
    public Milk CreateMilk();

    public Tea CreateTea();
    
}



 class AFactory implements Factory {
	//A厂
	    public Milk CreateMilk(){
	    	Milk milk = new PureMilk();
	    	System.out.println("(产地：A厂)");
	        return milk;
	    }

	    public Tea CreateTea(){
	    	Tea tea = new GreenTea();
	    	System.out.println("(产地：A厂)");
	        return tea;
	    }
	}

 class BFactory implements Factory {
	//B厂
	    public Milk CreateMilk(){
	    	Milk milk = new Yogurt();
	    	System.out.println("(产地：B厂)");
	        return milk;
	    }

	    public Tea CreateTea(){
	    	Tea tea = new RedTea();
	    	System.out.println("(产地：B厂)");
	        return tea;
	    }
	}


 interface Milk {

}

 interface Tea {

}
 
class PureMilk implements Milk {
	PureMilk(){
		System.out.print("加纯牛奶");
	}
}

class Yogurt implements Milk {
	public Yogurt(){
		System.out.print("加酸奶");
	}
}


class GreenTea implements Tea {
	public GreenTea(){
    	System.out.print("加绿茶");
	}
}


class RedTea implements Tea {
	public RedTea()	{
		System.out.print("加红茶");
	}
}

建造者模式部分：

public abstract class MilkTeaBuilder {
	
	public String name;
	
	public Milk milk;
	
	public Tea tea;
	
	public abstract void buildMilk();
	
	public abstract void buildTea();
	
	public abstract void create();
}



 class GreenMilkConBuilder extends MilkTeaBuilder{
	@Override
	public void buildMilk() {
		Factory factory;		
		factory=new AFactory();
		milk=factory.CreateMilk();
	}
	@Override
	public void buildTea() {
		Factory factory;		
		factory=new AFactory();
		tea=factory.CreateTea();
	}
	@Override
	public void create() {
		System.out.print("正在准备牛奶绿茶中......");		
	}
}

 class GreenYogurtConBuilder extends MilkTeaBuilder{
	@Override
	public void buildMilk() {
		Factory factoryB;
		factoryB=new BFactory();
		milk=factoryB.CreateMilk();
	}
	@Override
	public void buildTea() {
		Factory factoryA;
		factoryA=new AFactory();
		tea=factoryA.CreateTea();
	}
	@Override
	public void create() {
		System.out.print("正在开始准备酸奶绿茶中......");	
	}
}

 class RedMilkConBuilder extends MilkTeaBuilder{
	Factory factoryA;
	Factory factoryB;
	public RedMilkConBuilder() {
		factoryA=new AFactory();	
		factoryB=new BFactory();	
	}
	@Override
	public void buildMilk() {
		milk=factoryA.CreateMilk();
	}
	@Override
	public void buildTea() {
		tea=factoryB.CreateTea();
	}
	@Override
	public void create() {	
		System.out.println("正在准备牛奶红茶中......");
	}
}

 class RedYogurtConBuilder extends MilkTeaBuilder{
	@Override
	public void buildMilk() {
		Factory factoryB;
		factoryB=new BFactory();
		milk=factoryB.CreateMilk();
	}
	@Override
	public void buildTea() {
		Factory factoryB;
		factoryB=new AFactory();
		tea=factoryB.CreateTea();
	}
	@Override
	public void create() {
		System.out.print("正在开始准备酸奶红茶中......");	
	}
}



import java.util.Scanner;

public class MilkTeashop {
  
	public void menu() {
		System.out.println("************MENU************");
		System.out.println("1.RedMilk               2.GreenMilk");
		System.out.println("3.RedYogurt           4.GreenYogurt");
		System.out.println("*************END*************");
	}
	
	public void making(MilkTeaBuilder milkTea) {
		milkTea.create();
		milkTea.buildMilk();
		milkTea.buildTea();
	}
	
	public MilkTeaBuilder selectMilkTea() {
		MilkTeaBuilder milkTea=null;	
		Scanner number =new Scanner(System.in);
		System.out.print("请选择你的饮料");
		int num=number.nextInt();
		switch (num) {
		case 1:
			milkTea=new RedMilkConBuilder();
			break;
		case 2:
			milkTea=new GreenMilkConBuilder();
			break;
		case 3:
			milkTea=new RedYogurtConBuilder();
			break;
		case 4:
			milkTea=new GreenYogurtConBuilder();
			break;
		default:
			System.out.println("输入错误！");
			break;
		}
		making(milkTea);
		return milkTea;
	}
}

测试：

public class Client {
	public static void main(String[] args) {
		MilkTeashop coco = new MilkTeashop();
		coco.menu();
		coco.selectMilkTea();
	}
}

结果：

二、工厂方法设计模式和单例设计模式结合

工厂方法设计模式：

public interface AnimalFactory {
    public Animal createAnimal();
}


public class DogFactory implements AnimalFactory {
    //实现接口中的抽象方法.
public Animal createAnimal() {
        return Dog.getDog();
    }
}


public abstract class Animal {
    public abstract void eat();
    public abstract void sleep();
}

单例设计模式：

import java.io.Serializable;

public class Dog extends Animal implements Serializable {
// 利用单例设计模式,保证在内存中有一条机器狗对象
    private Dog(){
    }
    private static Dog dog = new Dog();
    public static Dog getDog(){
        return dog;
    }
   
    public void eat() {
        System.out.println("狗喷火");
    }
    public void sleep() {
        System.out.println("狗打雷");
    }
}

测试：

import org.junit.Test;

public class FactoryMethodTest {
    @Test
    public void factoryMethodTest(){
        AnimalFactory animalFactory = new DogFactory();   
        Animal animal = animalFactory.createAnimal();
        animal.eat();
        animal.sleep();
    }
}