java几种常用设计模式简单示例

1.单例设计模式

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

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

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

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

示例代码如下：

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

单例模式的实现

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

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

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

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

2.工厂设计模式

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

示例代码如下：

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

 3.代理设计模式

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

示例代码如下：

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

4.观察者设计模式

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

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

示例代码如下：

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

 5.适配器模式

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

示例代码如下：

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

装饰者模式

/*
    装饰设计模式:
    当想要对已有的对象进行功能增强时,
    可以定义类,将已有对象传入,基于已有的功能,并提供加强功能
    那么自定义的该类称为装饰类

例子:
BufferedReader和FileReader    BufferedReader(FileReader)
readline   和 read,这两个方法

    装饰类通常会通过构造方法接收被装饰的对象
    并基于被装饰的对象的功能,提供更强的功能

*/

import java.io.*;

public class PersonDemo
{
    public static void main(String args[])
    {
        Person p = new Person();
        SuperPerson sp = new SuperPerson(p);
        sp.superChifan();
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }

}

class SuperPerson
{
    private Person p ;
    SuperPerson(Person p)
    {
        this.p = p;
    }
    public void superChifan()
    {
        System.out.println("开胃菜");
        p.chifan();
        System.out.println("甜点");
    }
}

装饰设计模式
package pack;

import java.io.*;

public class Demo {
    public static void main(String args[]) throws IOException {
        FileReader fr = new FileReader("ltp.txt");
        MyBufferedReader myBuf = new MyBufferedReader(fr);
        String line = null;
        while ((line = myBuf.myReadLine()) != null) {
            System.out.println(line);
        }
        myBuf.myClose();
    }

    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

class MyBufferedReader {
    private FileReader r;

    MyBufferedReader(FileReader r) {
        this.r = r;
    }

    // 可以一次读一行数组
    public String myReadLine() throws IOException {
        // 用StringBuilder容器
        StringBuilder sb = new StringBuilder();
        int ch = ;
        while ((ch = r.read()) != -) {
            if (ch == '\r')
                continue;
            if (ch == '\n')// 这里的东西都是临时的,不用在这里把sb 设置成空.
                return sb.toString();
            else
                sb.append((char) ch);
        }

        //当到最后一行的时候,r.read()返回-1,StringBuilder没有toString.要在外面toString
        if (sb.length() != )
            return sb.toString();

        return null;
    }

    public void myClose() throws IOException {
        r.close();
    }

}

http://blog.csdn.net/haoxingfeng/article/details/9191619