设计模式介绍:
- 创建型:简单工厂模式(并不是23种设计模式之一)、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式
- 结构型:适配器模式adapter、桥接模式bridge、组合器模式component、装饰器模式decorator、门面模式、亨元模式flyweight和代理模式proxy
- 行为型:命令模式command、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式state、策略模式、模板模式和访问者模式
常用的几种设计模式介绍
1、单例模式
如果一个类始终只能创建一个实例,则这个类被称为单例类,这种模式就被称为单例模式。一般建议单例模式的方法命名为:getInstance(),这个方法的返回类型肯定是单例类的类型了。getInstance方法可以有参数,这些参数可能是创建类实例所需要的参数,当然,大多数情况下是不需要的。实现单例模式的简单例子:
- public class Singleton {
- public static void main(String[] args)
- {
-
- Singleton s1 = Singleton.getInstance();
- Singleton s2 = Singleton.getInstance();
-
- System.out.println(s1 == s2);
- }
-
- private static Singleton instance;
-
- private Singleton(){
- System.out.println("Singleton被构造!");
- }
-
-
- public static Singleton getInstance()
- {
-
-
- if (instance == null)
- {
-
- instance = new Singleton();
- }
- return instance;
- }
- }
2、工厂模式
简单工厂模式的核心思想就是:有一个专门的类来负责创建实例的过程。 具体来说,把产品看着是一系列的类的集合,这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑,那么我们就可以使用接口来扮演抽象产品的角色;如果具体产品之间有功能的逻辑或,我们就必须把这些共同的东西提取出来,放在一个抽象类中,然后让具体产品继承抽象类。为实现更好复用的目的,共同的东西总是应该抽象出来的。
-
-
-
- public interface Food {
-
-
-
- public void get();
- }
-
-
-
- public class McChicken implements Food{
-
-
-
- public void get(){
- System.out.println("我要一份麦香鸡");
- }
- }
- public class FoodFactory {
-
- public static Food getFood(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
- if(type.equalsIgnoreCase("mcchicken")) {
- return McChicken.class.newInstance();
-
- } else if(type.equalsIgnoreCase("chips")) {
- return Chips.class.newInstance();
- } else {
- System.out.println("哎呀!找不到相应的实例化类啦!");
- return null;
- }
-
-
- }
- }
-
-
-
- public class SimpleFactoryTest {
- public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
-
-
- Food mcChicken = FoodFactory.getFood("McChicken");
- Food chips = FoodFactory.getFood("Chips");
- Food eggs = FoodFactory.getFood("Eggs");
-
-
- if(mcChicken!=null){
- mcChicken.get();
- }
- if(chips!=null){
- chips.get();
- }
- if(eggs!=null){
- eggs.get();
- }
-
-
- }
- }
输出的结果如下:
哎呀!找不到相应的实例化类啦! 我要一份麦香鸡 我要一份薯条 |
3、代理模式
代理模式是一种应用非常广泛的设计模式,当客户端代码需要调用某个对象时,客户端实际上不关心是否准确得到该对象,它只要一个能提供该功能的对象即可,此时我们就可返回该对象的代理(Proxy)。
代理就是一个Java对象代表另一个Java对象来采取行动。如:
- public class ImageProxy implements Image
- {
-
- private Image image;
-
- public ImageProxy(Image image)
- {
- this.image = image;
- }
-
-
-
-
-
- public void show()
- {
-
- if (image == null)
- {
- image = new BigImage();
- }
- image.show();
- }
- }
调用时,先不创建:
Image image = new ImageProxy(null);
|
Hibernate默认启用延迟加载,当系统加载A实体时,A实体关联的B实体并未被加载出来,A实体所关联的B实体全部是代理对象——只有等到A实体真正需要访问B实体时,系统才会去数据库里抓取B实体所对应的记录。
借助于Java提供的Proxy和InvocationHandler,可以实现在运行时生成动态代理的功能,而动态代理对象就可以作为目标对象使用,而且增强了目标对象的功能。如:
- public interface Panther
- {
-
- public void info();
-
- public void run();
- }
- public class GunPanther implements Panther
- {
-
- public void info()
- {
- System.out.println("我是一只猎豹!");
- }
-
- public void run()
- {
- System.out.println("我奔跑迅速");
- }
- }
- public class MyProxyFactory
- {
-
- public static Object getProxy(Object target)
- throws Exception
- {
-
- MyInvokationHandler handler =
- new MyInvokationHandler();
-
- handler.setTarget(target);
-
- return Proxy.newProxyInstance(target.getClass().getClassLoader()
- , target.getClass().getInterfaces(), handler);
- }
- }
- public class MyInvokationHandler implements InvocationHandler
- {
-
- private Object target;
- public void setTarget(Object target)
- {
- this.target = target;
- }
-
- public Object invoke(Object proxy, Method method, Object[] args)
- throws Exception
- {
- TxUtil tx = new TxUtil();
-
- tx.beginTx();
-
- Object result = method.invoke(target , args);
-
- tx.endTx();
- return result;
- }
- }
- public class TxUtil
- {
-
- public void beginTx()
- {
- System.out.println("=====模拟开始事务=====");
- }
-
- public void endTx()
- {
- System.out.println("=====模拟结束事务=====");
- }
- }
测试:
- public static void main(String[] args)
- throws Exception
- {
-
- Panther target = new GunPanther();
-
- Panther panther = (Panther)MyProxyFactory.getProxy(target);
-
- panther.info();
- panther.run();
- }
4、观测者模式
观察者模式结构中包括四种角色:
一、主题:主题是一个接口,该接口规定了具体主题需要实现的方法,比如添加、删除观察者以及通知观察者更新数据的方法。
二、观察者:观察者也是一个接口,该接口规定了具体观察者用来更新数据的方法。
三、具体主题:具体主题是一个实现主题接口的类,该类包含了会经常发生变化的数据。而且还有一个集合,该集合存放的是观察者的引用。
四:具体观察者:具体观察者是实现了观察者接口的一个类。具体观察者包含有可以存放具体主题引用的主题接口变量,以便具体观察者让具体主题将自己的引用添加到具体主题的集合中,让自己成为它的观察者,或者让这个具体主题将自己从具体主题的集合中删除,使自己不在时它的观察者。
观察者模式定义了对象间的一对多依赖关系,让一个或多个观察者对象观察一个主题对象。当主题对象的状态发生变化时,系统能通知所有的依赖于此对象的观察者对象,从而使得观察者对象能够自动更新。
在观察者模式中,被观察的对象常常也被称为目标或主题(Subject),依赖的对象被称为观察者(Observer)。
Observer,观察者接口:
观察者:观察者也是一个接口,该接口规定了具体观察者用来更新数据的方法
- public interface Observer {
- void update(Observable o, Object arg);
- }
Observable,目标或主题:
主题:主题是一个接口,该接口规定了具体主题需要实现的方法,比如添加、删除观察者以及通知观察者更新数据的方法
- import java.util.ArrayList;
- import java.util.List;
- import java.util.Iterator;
-
- public abstract class Observable {
-
- List<Observer> observers = new ArrayList<Observer>();
-
-
- public void registObserver(Observer o) {
- observers.add(o);
- }
-
-
- public void removeObserver(Observer o) {
- observers.add(o);
- }
-
-
- public void notifyObservers(Object value) {
-
- for (Iterator it = observers.iterator(); it.hasNext();) {
- Observer o = (Observer) it.next();
-
- o.update(this, value);
- }
- }
- }
Product被观察类:
具体主题:具体主题是一个实现主题接口的类,该类包含了会经常发生变化的数据。而且还有一个集合,该集合存放的是观察者的引用。
- public class Product extends Observable {
-
- private String name;
- private double price;
-
-
- public Product() {
- }
-
- public Product(String name, double price) {
- this.name = name;
- this.price = price;
- }
-
- public String getName() {
- return name;
- }
-
-
-
- public void setName(String name) {
- this.name = name;
- notifyObservers(name);
- }
-
- public double getPrice() {
- return price;
- }
-
-
-
- public void setPrice(double price) {
- this.price = price;
- notifyObservers(price);
- }
- }
具体观察者:具体观察者是实现了观察者接口的一个类。具体观察者包含有可以存放具体主题引用的主题接口变量,以便具体观察者让具体主题将自己的引用添加到具体主题的集合中,让自己成为它的观察者,或者让这个具体主题将自己从具体主题的集合中删除,使自己不在时它的观察者。
NameObserver名称观察者:
- import javax.swing.JFrame;
- import javax.swing.JLabel;
-
- public class NameObserver implements Observer {
-
- public void update(Observable o, Object arg) {
- if (arg instanceof String) {
-
- String name = (String) arg;
-
- JFrame f = new JFrame("观察者");
- JLabel l = new JLabel("名称改变为:" + name);
- f.add(l);
- f.pack();
- f.setVisible(true);
- System.out.println("名称观察者:" + o + "物品名称已经改变为: " + name);
- }
- }
- }
PriceObserver
价格观察者:
- public class PriceObserver implements Observer {
-
- public void update(Observable o, Object arg) {
- if (arg instanceof Double) {
- System.out.println("价格观察者:" + o + "物品价格已经改变为: " + arg);
- }
- }
- }
测试:
- public class Test {
- public static void main(String[] args) {
-
- Product p = new Product("电视机", 176);
-
- NameObserver no = new NameObserver();
- PriceObserver po = new PriceObserver();
-
- p.registObserver(no);
- p.registObserver(po);
-
- p.setName("书桌");
- p.setPrice(345f);
- }
- }
其中
Java
工具类提供了被观察者抽象基类:
java.util.Observable
。观察者接口:
java.util.Observe