设计模式

设计模式

单例模式

饿汉式VS懒汉式

1.二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，懒汉式是在使用时才创建对象实例。

2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题，

3.饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，但是在类加载时这个对象就已经被创建了，创建的对象就被浪费了，懒汉式是使用时才创建，不存在这个问题。

饿汉式代码实现：

package com.example.single;
 
 
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 15:29
 */
public class SingleTon01 {
    public static void main(String[] args) {
 
        girlFriend instance = girlFriend.getInstance(); //调用getInstance()方法
        System.out.println(instance);
 
        girlFriend instance1 = girlFriend.getInstance();
        System.out.println(instance1);
 
        girlFriend instance2 = girlFriend.getInstance();
        System.out.println(instance2);
 
        System.out.println(instance == instance1); //结果为true，因为上面三个都属于一个对象。
    }
}
 
class girlFriend {
 
    /**
     * 单例设计模式——饿汉式   保证只能创建一个对象
     * 步骤：　
     * 1.将构造器私有化,放止外面直接new
     * 2.在类的内部私有化的创建对象
     * 3.向外暴露一个静态的公共方法可以返回私有的对象实例
     */
 
    //为了能在下面的静态方法中返回这个对象，我们只能把这个设置为静态，因为静态方法只能调用静态成员
    private static girlFriend gf = new girlFriend("辛蕊小可爱"); //2.在类的内部私有化的创建对象
 
    private String name;
 
    private girlFriend(String name) {       //1.将构造器私有化
        System.out.println("构造器私有化");
        this.name = name;
    }
 
    public static girlFriend getInstance(){    //3.向外暴露一个静态的公共方法可以返回私有的对象实例
        return gf;
    }
    @Override
    public String toString() {
        return "girlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式代码实现：

 package com.example.single;
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 16:12
 */
public class SingleTon02 {
 
    public static void main(String[] args) {
        System.out.println(Cat.n1);
 
        Cat instance = Cat.getInstance();
        System.out.println(instance);
 
        Cat instance1 = Cat.getInstance();
        System.out.println(instance1);
 
        System.out.println(instance == instance1);
    }
}
 
class Cat {
    public static int n1 = 100;
    private static Cat cat;
    private String name;
 
    /**步骤
     * 1.仍然构造器私有化
     * 2.定义一个static静态属性对象
     * 3.提供一个public的static方法，可以返回一个对象
     * 4.懒汉式：只有当用户使用哪个public创建的static方法时，才返回创建的对象，
     * 后面再次调用public这个方法时会返回上次创建的cat对象，而不会重新创建对象
     */
 
    private  Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }
 
    public static Cat getInstance(){
 
        if(cat == null){
           cat = new Cat("辛蕊宝贝");
        }
        return cat;
    }
 
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

模板设计模式

抽象模板类：

package com.example.templatedesign;
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 21:00
 */
abstract public class Template {     //抽象类  模板设计模式
    public abstract void job(); //抽象方法
 
    public void calculateTime() {   //实现方法，调用job方法
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();	//如果调用到这里会触发动态绑定机制
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
 
    public void hi(){
        System.out.println("你好！");
    }
}

AA类：

package com.example.templatedesign;
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 21:01
 */
public class AA extends Template{
 
    public void job() {
        for (int i = 1; i < 800000; i++) {
            int num = 0;
            num += i;
        }
    }
}

BB类：

 package com.example.templatedesign;
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 21:01
 */
public class BB extends Template{
 
    public void job() {
        for (int i = 1; i < 200000; i++) {
            int num = 0;
            num += i;
        }
    }
}

执行类：

package com.example.templatedesign;
 
/**
 * @author gaoqinghui
 * @date 2022/4/27 21:12
 */
public class TestTeplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
 
        BB bb = new BB();
        bb.calculateTime();
 
 
    }
}