1.单例设计模式

       所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

      (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

      (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

      (3) 定义一个静态方法返回该类的实例。

         示例代码如下：

Java代码  

1. class Singleton {   
2.     private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象  
3.   
4.     public static Singleton getInstance() { // 通过静态方法返回instance对象  
5.         return instance;   
6.     }   
7.   
8.     private Singleton() { // 将构造方法封装为私有化  
9.     }   
10.   
11.     public void print() {   
12.         System.out.println("Hello World!!!");   
13.     }   
14. }   
15.   
16. public class SingletonDemo {   
17.     public static void main(String args[]) {   
18.         Singleton s1 = null; // 声明对象  
19.         Singleton s2 = null; // 声明对象  
20.         Singleton s3 = null; // 声明对象  
21.         s1 = Singleton.getInstance(); // 取得实例化对象  
22.         s2 = Singleton.getInstance(); // 取得实例化对象  
23.         s3 = Singleton.getInstance(); // 取得实例化对象  
24.         s1.print(); // 调用方法   
25.         s2.print(); // 调用方法   
26.         s3.print(); // 调用方法   
27.     }   
28. }  

 一、单例模式的介绍 
     Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点 

二、单例模式的实现 

实现的方式有如下四种： 

Java代码  

1. /**  
2.  *   
3.  * 单例模式的实现：饿汉式,线程安全 但效率比较低  
4.  */  
5. public class SingletonTest {   
6.   
7.     private SingletonTest() {   
8.     }   
9.   
10.     private static final SingletonTest instance = new SingletonTest();   
11.   
12.     public static SingletonTest getInstancei() {   
13.         return instance;   
14.     }   
15.   
16. }  

Java代码  

1. /**  
2.  * 单例模式的实现：饱汉式,非线程安全   
3.  *   
4.  */  
5. public class SingletonTest {   
6.     private SingletonTest() {   
7.     }   
8.   
9.     private static SingletonTest instance;   
10.   
11.     public static SingletonTest getInstance() {   
12.         if (instance == null)   
13.             instance = new SingletonTest();   
14.         return instance;   
15.     }   
16. }  

Java代码  

1. /**  
2.  * 线程安全，但是效率非常低  
3.  * @author vanceinfo  
4.  *  
5.  */  
6. public class SingletonTest {   
7.     private SingletonTest() {   
8.     }   
9.   
10.     private static SingletonTest instance;   
11.   
12.     public static synchronized SingletonTest getInstance() {   
13.         if (instance == null)   
14.             instance = new SingletonTest();   
15.         return instance;   
16.     }   
17. }  

Java代码  

1. /**  
2.  * 线程安全  并且效率高  
3.  *  
4.  */  
5. public class SingletonTest {   
6.     private static SingletonTest instance;   
7.   
8.     private SingletonTest() {   
9.     }   
10.   
11.     public static SingletonTest getIstance() {   
12.         if (instance == null) {   
13.             synchronized (SingletonTest.class) {   
14.                 if (instance == null) {   
15.                     instance = new SingletonTest();   
16.                 }   
17.             }   
18.         }   
19.         return instance;   
20.     }   
21. }  

 2.工厂设计模式

       程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

      示例代码如下：

Java代码  

1. interface Animal { // 定义一个动物的接口  
2.     public void say(); // 说话方法  
3. }   
4.   
5. class Cat implements Animal { // 定义子类Cat  
6.     @Override  
7.     public void say() { // 覆写say()方法  
8.         System.out.println("我是猫咪，喵呜！");   
9.     }   
10. }   
11.   
12. class Dog implements Animal { // 定义子类Dog  
13.   
14.     @Override  
15.     public void say() { // 覆写say()方法  
16.         System.out.println("我是小狗，汪汪！");   
17.     }   
18. }   
19.   
20. class Factory { // 定义工厂类  
21.     public static Animal getInstance(String className) {   
22.         Animal a = null; // 定义接口对象  
23.         if ("Cat".equals(className)) { // 判断是哪个子类的标记  
24.             a = new Cat(); // 通过Cat子类实例化接口  
25.         }   
26.         if ("Dog".equals(className)) { // 判断是哪个子类的标记  
27.             a = new Dog(); // 通过Dog子类实例化接口  
28.         }   
29.         return a;   
30.     }   
31. }   
32.   
33. public class FactoryDemo {   
34.   
35.     public static void main(String[] args) {   
36.         Animal a = null; // 定义接口对象  
37.         a = Factory.getInstance(args[0]); // 通过工厂获取实例  
38.         if (a != null) { // 判断对象是否为空  
39.             a.say(); // 调用方法   
40.         }   
41.     }   
42. }  

 3.代理设计模式

       指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

      示例代码如下：

Java代码  

1. interface Network { // 定义Network接口  
2.     public void browse(); // 定义浏览的抽象方法  
3. }   
4.   
5. class Real implements Network { // 真实的上网操作  
6.     public void browse() { // 覆写抽象方法  
7.         System.out.println("上网浏览信息！");   
8.     }   
9. }   
10.   
11. class Proxy implements Network { // 代理上网  
12.     private Network network;   
13.   
14.     public Proxy(Network network) {// 设置代理的真实操作  
15.         this.network = network; // 设置代理的子类  
16.     }   
17.   
18.     public void check() { // 身份验证操作  
19.         System.out.println("检查用户是否合法！");   
20.     }   
21.   
22.     public void browse() {   
23.         this.check(); // 调用具体的代理业务操作  
24.         this.network.browse(); // 调用真实的上网操作  
25.     }   
26. }   
27.   
28. public class ProxyDemo {   
29.     public static void main(String args[]) {   
30.         Network net = null; // 定义接口对象  
31.         net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作  
32.         net.browse(); // 调用代理的上网操作   
33.     }   
34. }  

 4.观察者设计模式

       所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

       java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

       示例代码如下：

Java代码  

1. import java.util.Observable;   
2. import java.util.Observer;   
3.   
4. class House extends Observable {   
5.     private float price;   
6.   
7.     public void setPrice(float price) {   
8.         this.setChanged();// 设置变化点  
9.         this.notifyObservers(price);// 通知所有观察者价格改变  
10.         this.price = price;   
11.     }   
12.   
13.     public float getPrice() {   
14.         return this.price;   
15.     }   
16.   
17.     public House(float price) {   
18.         this.price = price;   
19.     }   
20.   
21.     public String toString() {   
22.         return "房子价格为: " + this.price;   
23.     }   
24. }   
25.   
26. class HousePriceObserver implements Observer {   
27.     private String name;   
28.   
29.     public HousePriceObserver(String name) {   
30.         super();   
31.         this.name = name;   
32.     }   
33.   
34.     @Override  
35.     public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法  
36.         if (arg instanceof Float) {   
37.             System.out.println(this.name + "观察的价格更改为:"  
38.                     + ((Float) arg).floatValue());   
39.         }   
40.   
41.     }   
42.   
43. }   
44.   
45. public class ObserDeom {   
46.     public static void main(String[] args) {   
47.         House h = new House(1000000);   
48.         HousePriceObserver hpo1 = new HousePriceObserver("购房者A");   
49.         HousePriceObserver hpo2 = new HousePriceObserver("购房者B");   
50.         HousePriceObserver hpo3 = new HousePriceObserver("购房者C");   
51.         h.addObserver(hpo1);// 给房子注册观察者   
52.         h.addObserver(hpo2);// 给房子注册观察者   
53.         h.addObserver(hpo3);// 给房子注册观察者   
54.         System.out.println(h);// 输出房子价格   
55.         // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息  
56.         h.setPrice(2222222);//   
57.         System.out.println(h);// 再次输出房子价格   
58.     }   
59. }  

 5.适配器模式

        如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

      示例代码如下：

Java代码  

1. interface Window {// 定义Window窗口接口，表示窗口操作  
2.     public void open();// 窗口打开  
3.   
4.     public void close();// 窗口关闭  
5.   
6.     public void iconified();// 窗口最小化  
7.   
8.     public void deiconified();// 窗口恢复  
9.   
10.     public void activated();// 窗口活动  
11. }   
12.   
13. // 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空   
14. abstract class WindowAdapter implements Window {   
15.     public void open() {   
16.     };// 窗口打开   
17.   
18.     public void close() {   
19.     };// 窗口关闭   
20.   
21.     public void iconified() {   
22.     };// 窗口最小化   
23.   
24.     public void deiconified() {   
25.     };// 窗口恢复   
26.   
27.     public void activated() {   
28.     };// 窗口活动   
29. }   
30.   
31. // 子类继承WindowAdapter抽象类，选择性实现需要的方法   
32. class WindowImpl extends WindowAdapter {   
33.     public void open() {   
34.         System.out.println("窗口打开");// 实现open()方法  
35.     }   
36.   
37.     public void close() {   
38.         System.out.println("窗口关闭");// 实现close()方法  
39.     }   
40. }   
41.   
42. public class AdapterDemo {   
43.     public static void main(String args[]) {   
44.         Window win = new WindowImpl(); // 实现接口对象  
45.         // 调用方法   
46.         win.open();   
47.         win.close();   
48.     }   
49. }  

 ----------------------------------------------------------------

初学水平有限，错误之处难免，览者勿讽！

参考资料：java开发实战经典。

------------------------------------------------------------------------------------

PART A：前言

平常我们都在敲代码，为了要实现一些我们希望看到的功能，敲一大堆一大堆。往往就会忽略了这样的一个问题。

你会问敲代码就让我们老老实实的敲代码吧，为什么要那么麻烦的去考虑那么多？当然了现在这样一说你肯定会回答我们肯定不可能就一心只会死头死脑的无脑敲代码啊。是吧？那么我们还要考虑一些什么事情呢？这么跟大家说吧，我们现在敲代码做项目就像做房子，现在我们做的事情是，一块一块的不断的垒砖块，无脑垒。而不管他垒的好不好看美不美观，也不管他消耗的砖块是否太多。是不是？再打个比方，从小学起我们就开始拿着笔写作文。刚刚开始那个时候，还记得自己是怎么写作文的么？是不是照着课本写？又或者就是写一些流水账似的东西？记得那个时候能够记两笔流水账已经能够让自己激动不已了是吧？呵呵。那你还记得是从什么时候开始，老师开始给你讲文章的结构文章的排篇布局，开始给你介绍各种诸如开门见山等等的文章写法的？今天就让我们回到那个时候。

接下来我们开始接触一些比较常用的java设计模式。

PART B：

         B-1工厂模式

你可以从网上找到许许多多关于这个（java设计模式）的文档与资料，如果你下载过看过不止四五份你就会发现，虽然他们的说法都有自己的一套，但是总是有千人一面的地方。而我要告诉你的是，这一面，就是你所需要的东西了。

对于工厂模式而言，每个人都会有自己的体会与看法。就比如有的人说他是将代码按照其功能模块化了，也有人说他就是一个分配机制，好比把不同的工作交给不同的人去做一样，将对象的功能的实现交给一些特制的类去完成，等等等等。只要是接触过的人，就可以说出一种他的立场上看到的工厂模式。

但是在这里我要告诉你的是，工厂模式他的关键是：将创建对象和使用对象分开。在这样的一个过程中不仅仅达到了理清编写者自己思路的作用，也使得代码脉络更加清晰明朗，简洁易懂。不知道大家还记不记得曾经讲哈夫曼树的时候那棵充斥我们一个多礼拜的哈夫曼树？我想说，现在这棵树是没了，但是重新出现了一座庞大的工厂……在这个工厂里边分工明确权责分明，他的每一个子工厂都只负责生产某一种特别的产品，而每一种产品也对应着每一个子工厂的生产线。现在只要想编写一个程序，就不知道绝的先考虑将它“工厂化”，将它的每一个步骤每一个功能先大卸八块的区分清楚，然后才开始代码的实际编写工作……

好了，闲话就不多说了，下面我们就通过实例来讲讲什么是创建对象和使用对象分开。

（例）

比如我想造一辆宝马车并让它跑起来，以前我们都是写一个宝马车的类然后直接在这个类里边实例化一个他的对象，完了以后紧接着在下边写宝马车的跑的方法，是吧？但是工厂模式不这么做，工厂模式怎么做呢？请看下面的步骤：

1.写一个车的接口，并在里边定义一个车的go()方法：

Java代码  

1. public interface Car {   
2.     public void go();   
3. }  

public interface Car {	public void go();}

 2.写一个宝马车的类，让他去继承上面这个车的总接口，并且实现里边的方法：

Java代码  

1. public class BMW implements Car{   
2.     public void go() {   
3.     }   
4. }  

public class BMW implements Car{	public void go() {	}}

 3.是不是少了什么？呵呵你有车的接口和实现类了当然得有造车工厂咯，是吧？于是我们同样给它定义一个造车工厂总接口以及一个继承并且实现它的宝马造车工厂：

Java代码  

1. public interface CarFactory {   
2.     public Car build(String name) ;   
3. }  

public interface CarFactory {	public Car build(String name) ;}

Java代码  

1. public class BMWFactory implements CarFactory{   
2.        
3.  private static  BMWFactory ins;   
4.         
5.      public static BMWFactory getIns(){   
6.          if(null==ins){   
7.              ins=new BMWFactory();   
8.          }   
9.          return ins;   
10.      }   
11.         
12.      BMWFactory(){}   
13.         
14.        
15.     public Car build(String name) {   
16.            
17.          if(name.equals("BMW")){   
18.                
19.              return new BMW();   
20.          }   
21.            
22.         return null;   
23.     }   
24.   
25. }  

public class BMWFactory implements CarFactory{	 private static  BMWFactory ins;	 	 public static BMWFactory getIns(){		 if(null==ins){			 ins=new BMWFactory();		 }		 return ins;	 }	 	 BMWFactory(){}	 		public Car build(String name) {				 if(name.equals("BMW")){						 return new BMW();		 }				return null;	}}

 4.有的人就会有点牢骚了，我不想老是自己跑工厂去，那样多麻烦！是吧？好，那么我们就给他写一个且车代理商：

Java代码  

1. public class AgentFactor {   
2.     private static AgentFactor ins;   
3.     public static AgentFactor getIns(){   
4.         if(ins==null){   
5.             ins=new AgentFactor();   
6.         }   
7.         return ins;   
8.     }   
9.        
10.     //取得制定品牌 的汽车   
11.     public CarFactory getCarFactor(String Name){   
12.         if(Name.equals("BMW")){   
13.             return new BMWFactory();   
14.         }   
15.         return null;   
16.     }   
17. }  

public class AgentFactor {	private static AgentFactor ins;	public static AgentFactor getIns(){		if(ins==null){			ins=new AgentFactor();		}		return ins;	}		//取得制定品牌 的汽车	public CarFactory getCarFactor(String Name){		if(Name.equals("BMW")){			return new BMWFactory();		}		return null;	}}

5.好了，车有了，造车工厂有了，连代理商都给你搞定了，那么就让我们来写个主函数让我们的宝马车跑起来吧！

Java代码  

1. public class CarTest {   
2.     public void driver(){   
3.            
4.         CarFactory ic=AgentFactor.getIns().getCarFactor("BMW");   
5.         Car mini=ic.build("MINI");   
6.         mini.go();   
7.     }   
8. }  

public class CarTest {	public void driver(){				CarFactory ic=AgentFactor.getIns().getCarFactor("BMW");		Car mini=ic.build("MINI");		mini.go();	}}

 当然了，也不是真的就让上面的代码跑起来，细心如你，肯定会发现上面的这几行代码是跑不起来的，是不是？具体是为什么呢，哈哈就留给你咯！

虽然上面给大家的几行代码不能够直接跑起来，但是通过他们，我想大家对于工厂模式这个概念应该会有一个比较清晰的把握了吧。再次说一遍：工厂模式，就是将对象的创建与使用分开。这样做的目的，自己开动脑经咯~

B-2 事件监听模式

相信大家接触java以来就一直在跟鼠标监听器等等各种事件监听器打交道，对于这些个零零总总的各式各样的监听器也并不陌生吧？但是对于这些鼠标监听器啊键盘监听器啊什么的，他的具体的实现方式是怎么样的你是否清楚呢？如果你是一个足够细心而好学的人，那么我接下来要说的东西对你来说可能是没什么必要的了，因为你肯定看过这些监听器它的源码，也必然知道他的运行机制与原理了。

下面让我们用代码实例来看一看这事件监听的原型吧！

（例）在做通信的时候我们曾经做过收到消息并且让他显示在一个JTEXTAREA上面，但是若我想要让他显示在JLABEL上的话就得对代码进行一些联动的改动，很是麻烦。我们且看事件监听模式怎么解决这个问题：

1.写一个消息的接口，在里边定义几项消息的基本属性：

Java代码  

1. //定义一个消息接口，所有的消息都是他的实现类   
2. public interface Msg {   
3.     public byte getType();//返回消息类型   
4.     public String getText();//返回消息内容   
5. }  

//定义一个消息接口，所有的消息都是他的实现类public interface Msg {	public byte getType();//返回消息类型	public String getText();//返回消息内容}

 2.写一个具体的消息类，继承消息接口：

Java代码  

1. public class TextMsg implements Msg{   
2.     private String text;   
3.     //具体的消息类，继承消息接口   
4.     public TextMsg(String text){   
5.         this.text=text;   
6.     }   
7.     public String getText() {   
8.            
9.         return this.text;   
10.     }   
11. public byte getType() {   
12.         return 2;   
13.     }   
14.   
15. }  

public class TextMsg implements Msg{	private String text;	//具体的消息类，继承消息接口	public TextMsg(String text){		this.text=text;	}	public String getText() {				return this.text;	}public byte getType() {		return 2;	}}

 3.第三布我们要做的是，编写一个监听器接口：

Java代码  

1. //处理器接口定义   
2. public interface MsgProcess {   
3.     //具体的处理器，所有的处理器实现类都必须实现这个方法   
4.      void processMsg(Msg msg);   
5. }  

//处理器接口定义public interface MsgProcess {	//具体的处理器，所有的处理器实现类都必须实现这个方法	 void processMsg(Msg msg);}

 4.编写你需要的监听器，比如你想让消息呈现在JLABEL上：

Java代码  

1. import javax.swing.JLabel;   
2.   
3. public class JLabelProcess extends JLabel implements MsgProcess{   
4.     public void processMsg(Msg msg) {   
5.         String t=msg.getText();   
6.   
7.         this.setText(t);   
8.            
9.         System.out.println(t);   
10.     }   
11. }  

import javax.swing.JLabel;public class JLabelProcess extends JLabel implements MsgProcess{	public void processMsg(Msg msg) {		String t=msg.getText();		this.setText(t);				System.out.println(t);	}}

如果你还想让消息显示在其他地方，比如，JBUTTON上，你可以另外写一个监听器的类继承上面的监听器接口： 

Java代码  

1. import javax.swing.JButton;   
2.   
3. public class JButtonProcess extends JButton implements MsgProcess{   
4.     public void processMsg(Msg msg) {   
5.         String t=msg.getText();   
6.         this.setText(t);   
7.     }   
8. }  

import javax.swing.JButton;public class JButtonProcess extends JButton implements MsgProcess{	public void processMsg(Msg msg) {		String t=msg.getText();		this.setText(t);	}}

 5.编写一个线程，我们将模拟生成消息（事件源）放在这个线程里边来做：

Java代码  

1. public class NetConn extends Thread{   
2.        
3.     //保存事件监听器的队列   
4.     ArrayList<MsgProcess>  ips=new ArrayList<MsgProcess>();   
5.        
6.     public void addMsgProcess(MsgProcess p){   
7.         ips.add(p);   
8.     }   
9.        
10.     public void run(){   
11.         //模拟事件源   
12.         int i=0;   
13.         while(true){   
14.                
15.             Msg s=new TextMsg("我收到的消息是："+i);   
16.             i++;   
17.             for(int t=0;t<ips.size();t++){   
18.                 MsgProcess pro=ips.get(t);   
19.                 pro.processMsg(s);   
20.             }   
21.             try {   
22.                 this.sleep(1000);   
23.             } catch (InterruptedException e) {e.printStackTrace();}   
24.         }   
25.     }   
26.        
27.        
28. }  

public class NetConn extends Thread{		//保存事件监听器的队列	ArrayList<MsgProcess>  ips=new ArrayList<MsgProcess>();		public void addMsgProcess(MsgProcess p){		ips.add(p);	}		public void run(){		//模拟事件源		int i=0;		while(true){						Msg s=new TextMsg("我收到的消息是："+i);			i++;			for(int t=0;t<ips.size();t++){				MsgProcess pro=ips.get(t);				pro.processMsg(s);			}			try {				this.sleep(1000);			} catch (InterruptedException e) {e.printStackTrace();}		}	}		}

 6.好的，做完了上面的这些工作，接下来就让我们来写一个主函数吧：

Java代码  

1. import java.awt.FlowLayout;   
2. import javax.swing.JFrame;   
3.   
4. public class Main {   
5.     public static void main(String srga[]){   
6.         NetConn nc=new NetConn();   
7.         nc.start();   
8.            
9.         JLabelProcess lp=new JLabelProcess();   
10.         nc.addMsgProcess(lp);   
11.         JButtonProcess tp=new JButtonProcess();   
12.         nc.addMsgProcess(tp);   
13.            
14.         JFrame jf=new JFrame("test");   
15.            
16.         jf.add(tp);   
17.            
18.         jf.setSize(300,300);   
19.         jf.setLayout(new FlowLayout());   
20.         jf.add(lp);   
21.         jf.setVisible(true);   
22.         jf.setDefaultCloseOperation(3);   
23.     }   
24. }  

import java.awt.FlowLayout;import javax.swing.JFrame;public class Main {	public static void main(String srga[]){		NetConn nc=new NetConn();		nc.start();				JLabelProcess lp=new JLabelProcess();		nc.addMsgProcess(lp);		JButtonProcess tp=new JButtonProcess();		nc.addMsgProcess(tp);				JFrame jf=new JFrame("test");				jf.add(tp);				jf.setSize(300,300);		jf.setLayout(new FlowLayout());		jf.add(lp);		jf.setVisible(true);		jf.setDefaultCloseOperation(3);	}}

 事件监听模式介绍到这里你是不是心里隐隐感觉，这个世界上的好多事情都变成了一个个事件源和一个个监听处理器了？如果对于事件监听模式还有一些不解或者困惑，请细心看上面提供的代码示例，慢慢体会它里边所蕴含的一些东西，相信你会获得意想不到的收获的！

B-3单例模式

好了，说完了两种比较罗嗦一点的工厂和事件监听模式，下面让我们来看看一种比较简单的java设计模式：单例模式。对于单例模式我想我不用说大家也能够说出这种模式就是实现单实例的，没错，就是如此！

单例就是：保证一个类仅有一个实例，仅提供一个访问它的全局访问点。

他的适用性在于：

 1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

 2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

话不多说，请君看我代码示例：

Java代码  

1. public class Singleton {   
2.        
3.     private static Singleton sing;   
4.   
5.     private Singleton() {   
6.            
7.     }   
8.        
9.     public static Singleton getInstance() {   
10.         if (sing == null) {   
11.             sing = new Singleton();   
12.         }   
13.         return sing;   
14.     }   
15. }  

public class Singleton {        private static Singleton sing;    private Singleton() {            }        public static Singleton getInstance() {        if (sing == null) {            sing = new Singleton();        }        return sing;    }}

 public class Test {

Java代码  

1.        
2.     public static void main(String[] args) {   
3.         Singleton sing = Singleton.getInstance();   
4.         Singleton sing2 = Singleton.getInstance();   
5.            
6.         System.out.println(sing);   
7.         System.out.println(sing2);   
8.     }   
9. }  

        public static void main(String[] args) {        Singleton sing = Singleton.getInstance();        Singleton sing2 = Singleton.getInstance();                System.out.println(sing);        System.out.println(sing2);    }}

ok，今天就介绍到这儿，这三种基本的java设计模式平时用的很多，当然，设计模式还有很多，由于时间关系我们在这里不便罗嗦太多，你可以自己去了解去学习去运用。但是要记住一点，不管是什么模式，他的实用性都体现在大型项目或者一些代码量很大的项目上。当你敲的代码足够多了，你就自然会对这些设计模式的作用和意义有一个深刻全面的体会。不管是工厂模式还是事件监听模式，又或者甚至是单例模式，他们的光芒都要在无数行代码之上才能够足够彰显足够耀眼。

常用设计模式 简单实例