浅谈java24模式之观察者模式、工厂模式以及建造者模式

1，观察者模式：观察者模式一般是多对一的，即多个观察者同时监测一个对象。被监视对象一旦发生变动就会引起观察者的变动。比如各个电商平台需要监视商品列表中的商品变动情况以实时更新商品展示页面。那么这里的各个电商平台就是观察者，而商品列表就是被监视的对象。加入现在电商平台只有淘宝和京东，哪如何用java语言实现它呢？在利用代码的实现中，最重要的是编写产品列表类（ProductList，被监视的对象）。这个类要继承Observable类(表示这是一个可观察的类)。这个类需要用单例模式来获取对象，并且要定义两个方法，第一个是增加商品的方法，第二个是增加观察者的方法，其中增加观察者的方法父类也有，所以可以不用重写也能在使用时直接调用。如果重写，那么实现代码也只有一句，就是直接调用父类添加观察者的方法而已。即public void addProductListObserver(Observer observer){this.addObserver(observer);//这是继承的父类的方法}。再看添加产品的方法，首先我们需要声明一个私有的List集合，在单例模式创建对象时为其创建对象。然后在添加产品的方法中将产品add进此集合中。然后实现一些添加后的逻辑。最后再调用父类的setChanged()方法 设置被观察对象已发生了改变，再调用父类的notifyObservers()方法通知观察者对象。这就写好了一个可以添加观察者和产品并且添加完产品后会通知观察者的产品集合类。代码如下：

	public class ProductList extends Observable{
		private List<String> productList = null;//私有的属性，存储产品列表
		//利用单例模式来创建实例
		private static ProductList instance; //类唯一的实例对象
		
		public static ProductList getInstance() {
			if(instance == null) {
				instance = new ProductList();
				instance.productList = new ArrayList<String>();
			}
			return instance;
		}
		
		//增加观察者（电商接口）的方法，这个方法可以不重写，直接利用本类的实例调用addObserver()方法也可以实现增加观察者的目的
		public void addProductListObserver(Observer observer) {
			this.addObserver(observer);//这是继承的父类的方法
		}
		
		//增加产品到产品列表
		public void addProduct(String newProduct) {
			productList.add(newProduct);//新增新产品到产品集合
			System.out.println("产品列表新增了【"+newProduct+"】产品！");//给出新增产品提示
			this.setChanged();//设置被观察对象发生了变化
			this.notifyObservers(newProduct);//通知观察者对象并传递新产品
	
			}
			/**
			 * 这里已经有了被观察者对象，还要定义观察者对象，假设现在的观察者对象是淘宝和京东,观察者应该实现Observer接口，并且实现它的update()方法
			 */
	}

我们再来看观察者类应该怎么定义呢？其实也很简单，比如现在有一个淘宝观察者，那就先定义一个类TaoBaoObserver，然后要实现一个接口Observer，并且实现它的update方法，在这个update()方法中实现添加产品到商城的逻辑代码就可以了。代码如下：

public class TaoBaoObserver implements Observer{
	@Override
	public void update(Observable o, Object arg) {
		//这里的逻辑代码意思是将产品发布到淘宝网，为了演示方便，我们只写出一条打印语句即可
		//首先将arg强转成为String类型，然后输出
		String newProduct = (String) arg;
		System.out.println("发送了新产品【"+newProduct+"】同步到淘宝商城");
		
	}
}

在使用时要分别创建观察者对象和产品列表对象，然后将观察者对象添加进产品列表类里去，在添加产品。这样就会执行观察者类里面的update方法了。测试类如下：

public class TestObserver {
	public static void main(String[] args) {
		/**
		 * 测试观察者模式，首先根据单例模式获取一个被观察者对象实例
		 */
		ProductList observable = ProductList.getInstance();
		//创建两个观察者实例对象
		TaoBaoObserver  t = new TaoBaoObserver();
		JingDongObserver j = new JingDongObserver();
		//给被观察者对象增加观察对象，即t和j
		observable.addObserver(t);
		observable.addObserver(j);
		//像产品列表中添加产品
		observable.addProduct("皮鞋");
		observable.addProduct("风衣");
		observable.addProduct("红酒");
	}
}

2，再来看工厂模式：
简单工厂模式很简单，我们需要定义一个产品接口来规范所有的产品，然后所有的产品都来实现这个接口即可，然后在编写一个工厂类，这个工厂类有一个生产方法，并且这个方法返回类型应该用产品接口来声明，然后利用switch(productNo){case “No”:return new ProductNo();}结构即可，具体代码如下：

public class ProductFactory {
	public static IProduct creatProduct(String productNo) {
		switch(productNo) {
			case "1":return new Product1();
			case "2":return new Product2();
			case "3":return new Product3();
			default : return null;
		}
	}
}

测试类代码如下：

public class TestSimpleFactory {
	public static void main(String[] args) {
		ProductFactory.creatProduct("4");
	}
}

我们再来看抽象工厂模式。同样需要有一个规范产品的产品接口IProduct。由于一个工厂生产多种产品会是代码十分复杂且不易扩展，不符合，低耦合可扩展的设计理念。所以我们需要将工厂分为具体工厂，即一个工厂生产一种产品，为了规范工厂，我们同时也是需要定义一个工厂接口，这个工厂接口要有一个生产产品的方法，返回一个产品，即一个IProduct。所有实现这个工厂接口的工厂都要实现这个方法，例如工厂1生产产品1。但是在使用的时候使用者不可能记住所有的工厂，故我们需要提供一个抽象工厂来给使用者，这个抽象工厂会根据使用者提供的参数去选择对应的工厂生产对应的产品。具体代码如下：

public class ProductFactory implements IProductFactory{

	@Override
	public IProduct creatProduct(String productNo) {
		if(productNo.equals("BMW")) {
			return new ProductFactory1().creatProduct(productNo);
		}
		if(productNo.equals("benz")) {
			return new ProductFactory2().creatProduct(productNo);
		}
		return null;
	}
}

测试类代码如下：

public class Test {
	public static void main(String[] args) {
		ProductFactory p = new ProductFactory();
		p.creatProduct("benz");
	}

}

这就是抽象工厂的设计理念和简单实现。
我们再看看建造者模式。建造者模式属于对象的创建模式。它可以将一个产品的内部属性与产品的生成过程分割开来。从而使一个建造过程生成具有不同的内部属性的产品对象。我们平时创建对象的时候，可以使用new关键字和工厂模式，单例模式等来创建一个对象，但是有时候在创建对象时，由于所需要的参数太多，所以创建一个对象变得不那么容易，这个时候，我们就需要建造者模式了。
首先创建一个类，这个类用来表示分布构建对象的过程。实现代码如下：

public class TicketHelper {
	/**
	 * 构建成年人票的逻辑方法，构建每一种票有一个逻辑方法
	 * @param info
	 */
	public void buildAdult(String info) {
		System.out.println("构建成年人票的逻辑，成年人的基本信息为："+info);
	}
	
	public void buildChildrenForSeat(String info) {
		System.out.println("构建小孩有座票的逻辑，小孩有座的基本信息为："+info);
	}
	
	public void biuldChildrenNoSeat(String info) {
		System.out.println("构建了小孩无座票的逻辑，小孩无做的座的基本信息为："+info);
	}
	public void buildElderly(String info) {
		System.out.println("构建老人票的逻辑，老人的基本信息为："+info);
	}
	
	public void buildSoldier(String info) {
		System.out.println("构建军人票的逻辑，军人的基本信息为："+info);
	}
}

其次定义已构建类：

public class TicketBuilder {
	public static Object builder(TicketHelper helper) {
		System.out.println("通过helper构建了套票");
		return null;
	}
}

测试类代码如下：

public class Test {
	public static void main(String[] args) {
		TicketHelper helper = new TicketHelper();
		helper.buildAdult("zhangsan");
		helper.buildChildrenForSeat("lisi");
		helper.biuldChildrenNoSeat("waanger");
		helper.buildElderly("laoren");
		helper.buildSoldier("soldier");
		TicketBuilder.builder(helper);
	}
}

测试结果如下：

构建成年人票的逻辑，成年人的基本信息为：zhangsan
构建小孩有座票的逻辑，小孩有座的基本信息为：lisi
构建了小孩无座票的逻辑，小孩无做的座的基本信息为：waanger
构建老人票的逻辑，老人的基本信息为：laoren
构建军人票的逻辑，军人的基本信息为：soldier
通过helper构建了套票

以上就是简单实现的三种设计模式，写之目的仅当本人笔记。