黑马程序员_ 三种设计模式：单例、模板、装饰

               ------- android培训、java培训、期待与您交流！ ----------                                 

一、单例设计模式：懒汉式和饿汉式

1.      目的：解决一个类在内存中只存在一个对象，保证对象的唯一性

(1)将构造函数私有化

(2)在类中创建一个本类对象

(3)提供一个方法可以获取到该对象

2.饿汉式：先初始化对象

class Single{

    private static final Single s=new Single();

    private Single();

    public static Single getInstance(){

       returns;

    }

}

2.    懒汉式：对象是方法被调用时才初始化，也叫做对象的延时加载

class Single{

    private static Single s=null;

    private Single();

    public static Single getInstance(){

       if(s==null)

           s=new Single();

       returns;

    }

}

3.懒汉式用于对象的延时加载，在多线程访问时会有安全问题（开发一般用恶汉式，安全）

class Single{

    private static Single s=null;

    private Single();

    public static Single getInstance(){

       if(s==null)

           -->A  

           -->B

//A、B中都用到了Single对象s,线程A执行到这，停止，执行B,B进来，线程B停止，线程A执行，创建了一个Single对象，线程B醒了，向下执行又创建了一个Single对象。

           s=new Single();

       returns;

    }

}

解决方法1，加同步synchronized,效率低

最优解决方法2，加同步代码块，稍微提升一点效率，使用的锁是该类所属的的字节码文件对象

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();

           }

       }

       returns;

    }

}

二、模板方法设计模式：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去实现

package code;

abstract class GetTime{

    public final void getTime(){

       //获取系统的当前时间作为开始时间

       long start=System.currentTimeMillis();

       //不确定的功能代码块

       runcode();

       //获取系统的当前时间作为开始时间

       long end=System.currentTimeMillis();

       //输出代码块的执行时间，并打印

       System.out.println("代码执行时间（毫秒）："+(end-start));

    }

    //定义一个抽象的runcode()方法

    public abstract void runcode();

}

class SubTimeextends GetTime{

    //实现父类的runcode()方法

    public void runcode(){

       for(int x=0;x<10;x++){

           System.out.print(x+" ");

       }

    }

}

public class Test{

    public static void main(String[] args) {

       SubTime s=new SubTime();

       s.getTime();

    }

}

如上代码，runcode()中封装的不确定的功能代码块，它由确定功能的getTime()方法所使用，就将runcode()定义成抽象方法暴露出去，由其子类SubTime实现runcode()的具体功能。

三、装饰设计模式：

    当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类成为装饰类

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

class Person{

    public void eat(){

       System.out.println("吃饭！");

    }

}

class SuperPerson{

    private Personp;

    SuperPerson(Person p){

       this.p=p;

    }

    public void eat(){

       System.out.println("开胃酒！");

       p.eat();

       System.out.println("甜点！");

       System.out.println("抽根烟！");

    }

}

class Test{

    public static void main(String[] args) {

       Person p=new Person();

       p.eat();

       SuperPerson sp=new SuperPerson(p);

       sp.eat();

    }

}

如上代码，Person p的eat()方法只有吃饭！一个功能，将Person p 传入SuperPerson中基于Person p的eat()方法,创建了一个SuperPerson sp的eat()方法，不仅具有吃饭！功能，还有开胃酒！甜点！抽根烟等功能。