本文主要是介绍单例模式_装饰模式_模板模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
1、 为了避免其他程序过多建立该类对象，先禁止其他对象建立该类对象。
2、 为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、 为了让其他程序对自定义对象进行访问，可以对外提供一些访问方式。
4，实现：
1） 私有化构造函数，使得外界不可以通过这个建立对象
2） 类中自定义一个对象，也进行私有化
3） 提供一个公共访问方式，可以获取到这个对象。
饿汉式：
代码：
（饿汉式实现方式）：
class Single{private Single(){}private static Single s = new Single();public static Single getInstance(){return s;}
}
public class SingleDemo {
public static void main(String[] args) {Single s = Single.getInstance();}
}
只有一个对象的原理是：
内存加载原理：
当类加载时，就会把静态变量s和静态方法getInstance加入方法区，同时在堆内存中建立对象，静态变量s指向堆内存中的对象，我们在调用的时，主函数在栈内存中有一个值ss，这个只是把静态变量s的值赋给了ss，是得ss指向对象。所以，即是再调用一次静态方法，其结果只是把s的值赋给了另一个变量，那个变量依旧指向原来的对象，所以这个就是单例，就是对象的唯一。
懒汉式：
实现方式：
class Single2{private Single2(){}private static Single2 s2 = null;public static Single2 getInstance2(){if(s2==null)s2=new Single2();return s2;}
}
class singledemo{public static void main（String[] args）{//要想获得single的对象，调用getInstance方法，既然无法通过对象调用，只能用类名调用，所以这个方法必须是static修饰的。single ss = single.getInstance();single ss2 = single.getInstance();//下列方法也可以实现调用，加入访问来获得就是为了对对象可控。
// single ss = single.s;
// single ss2 = single.s;}
}5，区别与选择：
饿汉式，当类一进内存就会创建好对象。而懒汉式，类一进内存，对象时没有建立的，只有调用了getInstance()方法时，才会建立对象，所以相对于饿汉式就是延迟加载。
饿汉式和懒汉式的选择：
1、 我们使用这两个单例设计模式时，其实是要用这个唯一的对象，进而使用其中的属性和方法，依照我们需要来说，一般用饿汉式。而且，饿汉式在线程方面来说，安全；编程方面来说，简单。
2、 懒汉式有线程安全问题，比如两个线程停顿到if语句之后，创建对象之前。然后，线程A执行s2=newSingle2()语句，然后线程B也执行这个语句，那么内存中就有了两个对象，这样对象就不唯一了。
1）常用，安全，定义单例模式时，一般是饿汉式。
2）但懒汉式考试比较多。
6，解决线程安全问题：
//第一种方式：
public static synchronized Single2 getInstance2(){
if(s2==null)
s2=new Single2();
}
//这样建立同步函数是可以的，但是每个使用者调用的时候，都要判断一次，效率较低。
//第二种方式：
public static Single2 getInstance2(){
if(s2==null){synchronized（Single.class）{
if（s==null）
s2=new Single2();
}}
}
二，装饰设计模式：
1，装饰设计模式：当相对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有功能，并提供加强功能。那么自定的该类就成为装饰类。
2，装饰设计模式和继承的区别：
先说继承：
继承就是子类B继承父类A和其功能，如果我们想在原有父类A功能进行改动，那么就要子类B覆盖父类的方法，写入我们的方法功能。在这之后，如果想在进一步在这个子类B上进行功能增强，办法是在这个子类B之下建立这个B的子类C，在子类C上复写B的功能然后写入改进功能。但如果A的子类不断增多，那么显而易见的结果是，系统庞大臃肿。
而装饰模式，是把对象传入进来，在对象已有功能的基础上进行增强，具备的功能和已有的功能是相同的，只不过提供了更强的功能。所以，装饰模式比继承要灵活，避免了体系的臃肿，而且降低了类与类之间的关系，而且装饰类和被装饰类通常在一个体系中。定义装饰类要注意一点：因为要传入原有体系对象，而且原有体系可能之后会有新子类，所以，传入对象时要使用多态，提高拓展性。
装饰设计模式代码：
//模拟一下readLIne方法：
class BufferedReadLine{//在构造函数中传入原有对象，要在原有对象功能基础上进行增强FileReader fr;BufferedReadLine(FileReader fr){this.fr = fr;}//自定义实现readLine功能public String MyReadLine() throws IOException{int ch =0;//建立StringBuilder，用于接收整行的数据StringBuilder sb = new StringBuilder();while((ch=fr.read())!=-1){/*一行的末尾是换行符，window系统是\r\n，处理\r\n，进行判断因为换行符有两个，所以当读到第一个时，继续循环，读到第二个时就意味着一行的结束*/if(ch=='\r')continue;if(ch=='\n')return sb.toString();//每读一次便把数据加入StringBuilder中sb.append((char)ch);}
<span style="white-space:pre"> /*这里注意，如果最后一行没有换行符，这是应判断一下Stringbuilder中是否有数据，有的话就返回*/if(sb.length()!=0)return sb.toString();return null;}
//这个自定义读一行的方法中，我们就把原有的FileReader对象传进来，运用原有的方法，//在原有的放上上改进，进行功能加强，实现了readLine方法。这就是装饰设计模式。
注意细节：
1、 在开发程序时，增强原有功能或改变原有功能，最好不好改动原代码。
2、 是将已有对象传入
3、 是基于原有程序功能，在这之上进行改进或增加新功能
三，模板设计模式：
1，代码实例：
/*GetTime类中getTime方法是为了获取某个程序运行的时间，因为不知道会运行什么程序，所以把程序封装进一个抽象类中，当我们引用这个方法时，就必须得复写其中的抽象方法runcode，同时继承了getTime这个方法，从而达到检测不同程序运行时间的效果。这就是模板设计模式。*/
abstract class GetTime
{public final void getTime(){long start = System.currentTimeMillis();runcode();long end = System.currentTimeMillis();System.out.print("程序运行时间（毫秒）:"+(end-start));public abstract void runcode();}
}
class SubTime extends GetTime
{public void runcode(){for (int x =0;x<100 ;x++ ){System.out.println(x);}}
}
2，模板设计模式，定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么就把这不确定的部分暴露出去，有该类的子类完成。
注意：不确定的部分不是非得是抽象的，因为原有类中可能有默认的方法，我们在使用时，只需把它覆盖即可，写我们需要的内容即可。所以，不确定部分，可以是抽象的，也可以不是抽象的。
这篇关于单例模式_装饰模式_模板模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
