这几天学习到的Java设计模式

这篇文章实在是简单，只是写给自己的。

1、单例模式

单例模式，简单就是说一个动作只能单个出现，一个类只能创建出一个对象，所有要使用都需要这一个对象，老师聚的例子就是，当你打开Windows下的任务管理器后，在打开状态下，你也就只能打开这一个窗口了，这个和你的文件管理中的窗口就截然不同了，文件管理中你可以重复打开一个路径下的窗口，这都是没有问题的。

我们知道，每次new 对象的时候，都会在堆内存中开辟一块内存，如果你直接打印这个类的话，你就会发现他们的地址是不同的，所以这样可以区分是否创建对个对象的。

关于单例模式有很多中创建方式，今天写一下最基本的方式，这种方式又分为两种方式创创建的，一种是“饿汉模式”，另外一种就是“懒汉模式”，他们的优势在与，如果采用懒汉的设计方式的话，优点就是减少内存的开拓，如果你不需要使用这个对象的时候，他就不会自己创建对象的，但是。。。。。是吧，就是当这种方式使用在线程中使用的时候，在高并发的情况下，不好确定到底是在需要使用对象之前创建还是在需要使用对象之后再创建，真的如果像后者这样的话，就JJ了。而饿汉模式就不同了，很直接就是耗内存，安全，弄清这个的话就可以让我们知道我们该在什么时候进行使用哪种了。如果没看懂，没关系，代码最清楚了。

package com.hejingzhou.single;

public class Single {
	private Single() {// 将构造方法进行封装，这样的话就不会随便的new对象了
	}

	// 既然类外部不能进行创建对象，那么就在类内创建一个对象，还是封装。
	private static Single single = new Single();// 饿汉式
	// private static Single single = null;// 懒汉式

	// 对外部提供一个通道都设成静态的，这样就可以直接通过类名点出来了
	public static Single getIntance() {
		// if (single == null) {
		// single = new Single();// 懒汉式
		// }
		return single;
	}
}

测试打印结果：

package com.hejingzhou.single;

public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Single.getIntance());
		System.out.println(Single.getIntance());
	}
}

com.hejingzhou.single.Single@1db9742
com.hejingzhou.single.Single@1db9742

这样的话就足以可以说明他们获取到的是一个对象。

2、工厂模式

试想有一天你的软件上线了，把软件交付给第三方使用，那么问题来了，第三方怎么进行维护和更新这些问题啊，他们不会聘请一个高级工程师来使用这个系统吧，所以你的这个软件系统必须造的简单到傻子都能操作，这些东西，都是设计之前需要考虑进去的，如果可以，列举创建对象这事，你让第三方简简单单的new一个对象，他都有可能出错，或者根本不知道干啥呢，那么你让他输入一个字符串，就可以使用，岂不更好。

这就可以用到工厂模式了，这里举的例子只是学习这个理论而已，如果配合上反射在使用工厂模式就更完美了，有兴趣的话看看我的这篇基础的Java中的反射基础知识，看看代码吧，这个例子就是当第三方输入一个字符串就可以查到这个类的全部信息，很简单。

被操作类父类：

package com.hejingzhou.factry;

public class Car {
	
	public Car() {
		super();
	}

	private String brand;
	private int price;

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public Car(String brand, int price) {
		super();
		this.brand = brand;
		this.price = price;
	}

	void show() {

	}
}

被操作类：

package com.hejingzhou.factry;

public class Bmw extends Car {
	public Bmw(String brand, int price) {
		super(brand, price);
	}

	public void show() {
		System.out.println("品牌：" + this.getBrand() + "\t" + "价格" + this.getPrice());
	}
}

----------------------------------------------------------------------------优雅分割线-------------------------------------------------------------------------------------

package com.hejingzhou.factry;

public class Mercedes extends Car {
	public Mercedes(String brand, int price) {
		super(brand, price);
	}

	public void show() {
		System.out.println("品牌：" + this.getBrand() + "\t" + "价格" + this.getPrice());
	}
}

工厂类：

package com.hejingzhou.factry;

public class Factry {
	public void serach(String brand) {
		if (brand.equals("宝马")) {
			new Bmw("宝马", 900000).show();
		} else if (brand.equals("奔驰")) {
			new Mercedes("奔驰", 1000000).show();
		}
	}
}

测试类：

package com.hejingzhou.factry;

public class Test {
	public static void main(String[] args) {
		Factry factry = new Factry();
		// 使用者只需要填写一个宝马或者奔驰就可以在内部创建对象做任何事情
		factry.serach("宝马");
		factry.serach("奔驰");
	}
}

看完代码应该很清楚吧。

3、观察者模式

观察者模式，就是将顾名思义就是将观察者和被观察者分离运行。可以是一对一，也可以是一对多，意思就是，当被观察者有所以改变，所有的属于该对象的观察者，根据被观察者的改变而做出相应的改变，这就好比一个明星和众多粉丝相似，当这位明星做一些事情或者改变一些事情的时候，他的脑残粉丝也就跟着盲目随从，各有千秋，我这里程序的例子举得是某个人比如我在家里说一声吃饭了，可能儿子就听到后赶紧赶过（虽然没有儿子），当夫人听到后，就会说着什么急，化完妆再去吃（虽然没有夫人），这就是一个团体就可以看成是一个观察者模式。

需要一个通知接口，所有观察者需要实现的。

package com.hejingzhou.weach;

public interface IUpdate {
	void update(String content);
}

儿子类和夫人类---就是观察者了。

package com.hejingzhou.weach;

public class Son implements IUpdate {

	@Override
	public void update(String content) {
		// TODO Auto-generated method stub
		System.out.println("收到爸爸消息"+content+"现在就去");
	}

}

package com.hejingzhou.weach;

public class Wife implements IUpdate {

	@Override
	public void update(String content) {
		// TODO Auto-generated method stub
		System.out.println("收到老公消息，着什么急，化完妆再去。");
	}

}

我：也就是那个被观察者的立场，我改变某些行为，他们都会跟着改变行为。

package com.hejingzhou.weach;

import java.util.ArrayList;

public class Me {
	private ArrayList<IUpdate> member = new ArrayList<IUpdate>();

	public void addWatcher(IUpdate update) {
		member.add(update);
	}

	public void deleteWatcher(IUpdate update) {
		member.remove(update);

	}

	public void notifyWatcher(String noty) {
		for (IUpdate iUpdate : member) {
			iUpdate.update(noty);
		}
	}

}

测试类：

package com.hejingzhou.weach;

public class Test {
	public static void main(String[] args) {
		Me me = new Me();
		IUpdate son = new Son();
		IUpdate wife = new Wife();
		me.addWatcher(son);
		me.addWatcher(wife);
		me.notifyWatcher("该吃饭了");
		System.out.println("--------------------------------");
		me.deleteWatcher(wife);// 不让妻子听见
		me.notifyWatcher("看电视了");
	}
}

结果：

收到爸爸消息该吃饭了现在就去
收到老公消息，着什么急，化完妆再去。
--------------------------------
收到爸爸消息看电视了现在就去

嗯，很简单，但我怕我老了。