Java设计模式

此篇博客目前只涉及到了本人所接触到的几种设计模式，以后会持续更新。

一.设计模式

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

二.常见设计模式

1.单例设计模式

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

　　1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

　　2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

　　3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

懒汉式:

class Single
{
    private static Single s = null;//内部创建本类引用
    private Single(){}//私有化构造方法，外部不可以创建实例对象


    public static  Single getInstance()//提供获取对象的方法
    {
        if(s==null)//首先判断对象是否创建
        {
            synchronized(Single.class)//同步线程，因为懒汉式是延迟加载的所以线程是不安全的
            {
                if(s==null)
                    s = new Single();
            }
        }
        return s;
    }
}

饿汉式:

class Single
{
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }
}

2.模板设计模式

模板设计模式是指一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。通过抽象类对所需要固定功能进行封装，通过子类对可变元素进行封装。

abstract class GetTime
{
    public final void getTime()
    {
        long start = System.currentTimeMillis();

        runcode();//此处调用方法，方法内部封装所需要测试的代码

        long end = System.currentTimeMillis();

        System.out.println("毫秒："+(end-start));
    }
    public abstract void runcode();//因为事先不明确方法体，所以定义为抽象由子类继承复写进行扩展

}


class SubTime extends GetTime
{
　　//覆盖runcode方法，将所需要测试的代码进行封装
    public void runcode()
    {
        
        for(int x=0; x<4000; x++)
        {
            System.out.print(x);
        }
    }
}


class  TemplateDemo
{
    public static void main(String[] args) 
    {
        SubTime gt = new SubTime();
        gt.getTime();
    }
}

3.装饰设计模式

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象通过接口持有被装饰对象的实例。

public interface Sourceable {  
    public void method();  
}  
public class Source implements Sourceable {  
   
    public void method() {  
        System.out.println("the original method!");  
    }  
}  
public class Decorator implements Sourceable {  
  
    private Sourceable source;  
      
    public Decorator(Sourceable source){  
        super();  
        this.source = source;  
    }  
    public void method() {  
        System.out.println("before decorator!");  
        source.method();  
        System.out.println("after decorator!");  
    }  
}
 public class DecoratorTest {  
  
    public static void main(String[] args) {  
        Sourceable source = new Source();  
        Sourceable obj = new Decorator(source);  
        obj.method();  
    }  
}

装饰模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错！