JAVA模板 单例

模板
模板就是一种设计模式 而程序由不确定和确定的部分组成
这时我们可以把不确定的部分 抽象出来
对外界只开放访问的模式
再使用的时候 由其子类继承父类
通过子类重写抽象方法 来完成不确定的部分

来看一下具体的实现
计算一个程序的运行时间

abstract class GetTime{
    public void getTime() {
    long startTime = System .currentTimeMillis();
        for（int i = 0; i < 30000; i++）{
        System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("程序执行:" + (endTime - startTime) + "毫秒");
    }

其中long startTime = System .currentTimeMillis();代表的是获取系统当前时间 long endTime = System.currentTimeMillis();代表的是获取程序执行结束的时间 最后打印执行的时间就好了
我们可以把方法中的实现部分抽取出来 定义成抽象方法
强制子类重写

public class Demo {
    public static void main(String[] args) {
    GetTime g=new GetTime();
    g.getTime();


        GetTime g = new SubTime();
        g.getTime();
    }
}

abstract class GetTime{
    public void getTime() {
        long startTime = System .currentTimeMillis();
        fun();
        long endTime = System.currentTimeMillis();
        System.out.println("程序执行:" + (endTime - startTime) + "毫秒");
    }
    abstract public void fun();
}

class SubTime extends GetTime{
    @Override
    public void fun() {
        for (int i = 0; i < 20000; i++) {
            System.out.println(i);
        }
    }
}

这样就是模板 把不确定的部分抽取出来
我们可以随时更改想要测试的数据 而不用修改源代码

单例
也是一种设计模式(重在思想)
整个程序执行期间 不管创建这个类的对象多少个
整个程序有且只有一个该类的对象 –单例对象

怎么写
1.构造方法私有化
2.写一个创建对象自定义方法
3.只提供get方法

饿汉式单例

class Single{
    private static Single single = new Single();
    private Single() {
    }
    public static Single getInstace() {
        return single;
    }
}

懒汉式单例

class SingleLan{
    private static SingleLan singleLan = null;
    private SingleLan() {
    }
    public static SingleLan getInstence() {
        if (singleLan == null) {
            singleLan = new SingleLan();
        }
        return singleLan;
    }
}

饿汉式汉懒汉式单例不同之处
饿汉式的创建对象随着类的加载而加载
懒汉式只有调用单例方法时才会创建
而且懒汉式单例对象只会创建一次