设计模式

设计模式：解决某一类问题行之有效的方法（思想）。

学习设计模式必须先弄清楚它是解决什么问题的。

单例（singleton）设计模式：可以保证一个类的对象唯一性。

场景：比如多个程序都要使用一个配置文件中的数据，而且要实现数据的共享和交换，必须要将多个数据封装到一个对象中，而且多个程序操作的是同一个对象，所以要保证配置文件对象的唯一性。

1、怎么保证对象的唯一性？

1、一个类只要提供了构造函数，就可以产生多个对象。完全无法保证唯一。既然数量不可控，那么不让其他程序建立对象。

2、不让其他程序创建对象，对象何在？ 自己在本类中创建一个对象，这样好处是什么？可控！

3、创建完成后，是否要给其他程序提供访问的方式。

2、怎么实现这个步骤？

1、直接私有化构造函数，可以不让其他程序创建对象初始化。

2、直接在本类中new一个本类对象。

3、定义一个功能，其他程序可以通过这个功能可以获取到本类的这个对象。

3、代码体现（饿汉式单例模式）

/*
单例模式的代码体现
 */
class single{
    //1、私有化构造函数
    private single(){
    }
    //2、创建一个本类对象
    private static single s = new single();
    //3、定义一个方法，返回对象
    public static single getInstance(){
        return s;
    }
}
public class singlton {
    public static void main(String[] args) {
        //要想获取single对象。无法通过对象调用，只能通过静态调用.
        single ss = single.getInstance();
        single ss2 = single.getInstance();
    }
}

 直接single ss = single.s也可以，所以定义返回对象的方法可以去掉吗？

 不行，要将属性进行安全性的可控。所以步骤2需要进行private修饰。

4、另一种代码体现（懒汉式单例模式）

class single2{
    private static single2 s2 = null;
    private single2(){
        
    }
    public static single2 getInstance(){
        if(s2 == null){
            s2 = new single2();
            return s2;
        }
    }
}

好处，当调用方法的时候才产生对象，不调用方法，则初始化时为空。

懒汉式单例设计模式有线程同步的问题。

在判断类中对象是否为空的时候，有可能会切换到其他线程中，导致new好几个对象出来。饿汉式没有这个问题。

解决方式：

class single{
    private static single s = null;
    private singel(){}
    public static synchronized single getInstance(){
         if(s = null){
            s = new single();
        }   
        return s;
    }
}

但是这样，效率会变低，所以通过双重判断的方式解决效率的问题，减少判断锁的次数。

class single{
    private static single s = null;
    private singel(){}
    public static  single getInstance(){
       if(s == null){
            synchronized(single.class){ 
                if(s = null){
                    s = new single();
                }   
            }
        }
        return s;
    }
}

一个字，屌！！！！ 

 

5、单例模式的加载方式

内部类的加载方式、集合的加载方式。

6、练习

package single;
class Superman{
    private String name;
    private static Superman s = new Superman("leo");
    private Superman(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public static Superman getInstance(){
        return s;
    }
    public void fly(){
        System.out.println("fly");
    }
}
public class test {
    public static void main(String[] args) {
        Superman man = Superman.getInstance();
        man.fly();
        Superman man2 = Superman.getInstance();
        man2.setName("don");
        System.out.println(man.getName());
    }
}

2、装饰设计模式

解决问题：给一组类增加功能，避免继承的臃肿，提高灵活性。 

注意：装饰类和被装饰类必须所属于同一个体系，通常装饰类都会提供构造函数接收被装饰类对象。

装饰类通常不单独存在。

举例：

房子居住（）；

       |--毛坯楼房  居住(){简陋}

       |--毛坯平房

       |--田园风光房子

class 田园风光房子 extends 房子{
    田园风光房(房子){
        
    }
    居住(){
        田园风光的居住，惬意！
    }
}

class 欧式 extends 房子{
    欧式(房子){
        
    }
    居住(){
        欧式的居住，华丽！
    }
}



毛坯楼房 x = new 毛坯楼房（）；
x.居住（）；   //简陋
田园风光房 y = new 田园风光房（x）；
y.居住（）；   //简陋+惬意

欧式 z = new 欧式（y）；
z.居住（）；   //简陋+惬意+华丽

田园风光房对象的出现，仅仅是提升了功能。