1.单例设计模式
对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。
1.1 饿汉式
- 构造器私有化 --> 防止直接new
- 类的内部创建对象
- 提供一个static的public方法 getInstance
class GirlFriend {
private String name;
private static GirlFriend gf = new GirlFriend("小红红");
private GirlFriend(String name) {
System.out.println("構造器被調用.");
this.name = name;
}
public static GirlFriend getInstance() {
return gf;
}
public class SingleTon01 {
public static void main(String[] args) {
//通过方法可以获取对象
GirlFriend instance = GirlFriend.getInstance();
System.out.println(instance);
GirlFriend instance2 = GirlFriend.getInstance();
System.out.println(instance2);
System.out.println(instance == instance2); //T
}
}
1.2 懒汉式
- 构造器私有化 --> 防止直接new
- 类的内部定义一个static对象
- 提供一个static的public方法 getInstance
- 只有当用户使用 getInstance 时,才返回对象, 再次调用时,会返回上次创建的对象
class Cat {
private String name;
private static Cat cat ; //默認是 null
private Cat(String name) {
System.out.println("構造器調用...");
this.name = name;
}
public static Cat getInstance() {
if(cat == null) {//如果還沒有創建 cat 對象
cat = new Cat("小可愛");
}
return cat;
}
public class SingleTon02 {
public static void main(String[] args) {
Cat instance = Cat.getInstance();
System.out.println(instance);
//再次調用 getInstance
Cat instance2 = Cat.getInstance();
System.out.println(instance2);
System.out.println(instance == instance2); //T
}
}
饿汉式和懒汉式的区别:
- 创建对象的时机不同。饿汉式在类加载时就创建了对象实例,懒汉式在使用时才创建。
- 线程安全问题。饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
- 浪费资源。饿汉式存在浪费资源的可能,如果程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费。懒汉式是使用才创建,就不存在这个问题。
2.模板设计模式
// 抽象类-模板设计模式
abstract public class Template {
// 抽象方法
public abstract void job();
// 实现方法,调用 job 方法
public void calculateTime() {
long start = System.currentTimeMillis(); //得到开始的时间
//动态绑定机制
job();
long end = System.currentTimeMillis(); //得的结束的时间
System.out.println("任务执行时间 " + (end - start));
}
}
public class AA extends Template {
//计算任务 1+....+ 800000
//实现 Template 的抽象方法 job
@Override
public void job() {
long num = 0;
for (long i = 1; i <= 800000; i++) {
num += i;
}
}
}
public class BB extends Template{
//这里也去,重写了 Template 的 job 方法
public void job() {
long num = 0;
for (long i = 1; i <= 80000; i++) {
num *= i;
}
}
}
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
// 根据动态绑定机制,按各自的运行类型调用方法
aa.calculateTime(); //这里还是需要有良好的 OOP 基础,对多态
BB bb = new BB();
bb.calculateTime();
}
}