JAVA设计模式

在java代码中目前一共有26种设计模式，而设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。今天说说单例模式与代理模式。

代理模式

代理模式，举个例子说明吧，我们要创建一个线程，以下的创建方式就是一个代理模式

TestThread4  testThread4=new TestThread4();
new Thread(testThread4,"线程名1：小明").start();

那什么是代理模式呢，举个例子，比如你要结婚，但是需要婚庆公司来帮助你结婚，此刻婚庆公司就是一个代理商，而真正要结婚的人是你，你只是需要告诉婚庆公司说你要结婚，让它们来协助你结婚，布置场地等等，当然了既然是婚庆公司，那么可以代理的不仅仅是你要结婚，还有我也可以找它来代理我结婚
代码实现如下：

首先我们创建一个结婚的接口类，因为每个人都有可能会结婚，那么我们要结婚时去实现这个接口就行

interface  Marry{
    void HappyMarry();
}

比如我是真实要结婚的角色，那么我先去实现这个结婚的接口，因为真实要结婚的人是我

class  I implements  Marry{
    public void HappyMarry() {
        System.out.println("结婚了，，，");
    }
}

接下来我需要婚庆公司代理我结婚，因为靠我自己一个人无法完成婚礼的布置等等一切，那么创建一个婚庆公司，同样婚庆公司实现结婚接口（因为它代理的结婚嘛，当然也是可以实现别的接口做别的事情，或者其他业务不实现接口啥的，这里写了结婚接口就顺便用了），但是实现的内容是跟 谁要结婚 有关系的，目前这个例子中，这个谁要结婚就是 就是 I 的实例，I的实例就是我。

class  weddingcompany implements  Marry{
    //代理谁--》真实目标角色
    private  Marry target;
    public  weddingcompany(Marry target){
        this.target=target;
    }
    public void HappyMarry() {
        before();
        //target 是已经传入的对象   HappyMarry 是目标对象已实现的接口
        this.target.HappyMarry();  //传入的真实对象角色
        after();
    }
    private void after() {
        System.out.println("结婚之后，收尾款");
    }
    private void before() {
        System.out.println("结婚之前布置现场");

    }


}

接下来让我们测试一下这段代码

public static void main(String[] args) {
    //创建代理实例
    //传入目标对象我
    //婚庆公司代理我结婚
    I i=new I();//我结婚
    weddingcompany weddingcompany=new weddingcompany(i);
    weddingcompany.HappyMarry();
}

输出信息为：

1. 结婚之前布置现场
2. 结婚了，，，
3. 结婚之后，收尾款
   也就是说在婚庆公司的帮助下，我顺利的结婚了，如果是你结婚，也用这个逻辑，但是婚庆公司的代码不变。

单例模式

单例模式分为两种，一种是懒汉模式，一种是饿汉模式，首先简介一下什么是单例模式，所谓的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法，比如：一个人一生只能养一条狗子，不能是2个

饿汉模式

意思就是，在这个类被加载的时候就返回一个可爱的狗子小白，不管你需不需要这个可爱的狗子，都会给你一个，这有个问题就是会造成资源浪费，这个类每加载一次就会创建一个小白，因为这个饿汉模式是在类加载的时候就创建了这个对象（就类似于比较着急的，所以说称为饿汉模式）。那怎么创建这样的一个模式呢，首先
（1）构造器私有化（防止直接new在外面创建这个示例）
（2）类的内部创建对象
（3）向外暴露一个静态的公共方法。getinstance
（4）代码实现

public class ceshi {
    public static void main(String[] args) {
        Dog dog=Dog.getInstance();
        System.out.println(dog.toString());
        Dog dog1=Dog.getInstance();
        System.out.println(dog1.toString());
    }

}
class Dog {
    private  String name;
    //为了能够在静态方法中，返回Dog对象，需要将其修饰为static
    private  static Dog Dog=new Dog("得到Dog小白");
    private Dog( String name){
        this.name=name;
    }
    public static  Dog getInstance(){
        return Dog;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + ''' +
                '}';
    }
}

在上面的代码中能看出dog 与dog1 对象的输出都是得到Dog小白，也就是说这个Dog类的实例就是让每个人只能有一个Dog小白，可见第二次获取的时候输出的还是小白，但是这里 static Dog Dog=new Dog(“得到Dog小白”); 是类在加载一次就会被重复实例一次的，虽然得到的是相同对的值，但是被重复加载了导致程序性能不是很好，怎么解决这个问题呢？ 就出现了下面所要说的懒汉模式

2. 懒汉模式

修改上面饿汉模式的代码，将创建对象实例封装在方法体中，当第一次加载后Dog对象不再是空，因此第二次加载的时候不会再次创建new Dog(“得到Dog小白”); 就提高了代码的性能，也就是说只创建啊一次，后续在使用类中再次访问这个对象还是可以获取到这个对象

public class ceshi {
    public static void main(String[] args) {
        Dog dog=Dog.getInstance();
        System.out.println(dog.toString());
        Dog dog1=Dog.getInstance();
        System.out.println(dog1.toString());
    }

}
class Dog {
    private  String name;
    //为了能够在静态方法中，返回Dog对象，需要将其修饰为static
    private  static Dog Dog;
    private Dog( String name){
        this.name=name;
    }
    public static   Dog getInstance(){
        if(Dog==null){
            Dog =new Dog("得到Dog小白");
        }
        return Dog;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + ''' +
                '}';
    }
}

但有个问题是，这个懒汉模式会造成线程安全问题，比如说线程1，和线程2在同一时间线程1先访问，但还没有创建好空间，线程二又来访问了则又会被创建2次，就违背了 懒汉模式的设计理念，怎么解决这个问题呢 ，在得到对象的方法上加上 synchronized 同步则可解决 public static synchronized Dog getInstance()，synchronized 在后期说到线程上面会有详细的解说

工厂模式…

… 还有其他模式 持续更新中