设计模式概念
1.设计模式是静态方法和属性的经典使用
2.设计模式是大量时间中总结和理论化后优选的代码结构、编程风格、以及解决问题的思考方式
3.我们可以这样理解，设计模式就像是一个棋谱，遇到不同的棋局，我们就用不同的棋谱，免去我们自己的思考。
单例设计模式
单例模式的概念
单例就是单个实例
1.类的单例设计模式，就是采取一定的方法，保证在整个的软件系统中，对应某一个类来说，它只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
比如说在软件开发中，有一个类是核心类，它很耗费资源，而且我们只需要一个，这个时候，就可以单例设计模式
2.单例模式有两种方式: 饿汉式 和 懒汉式
饿汉式
只要类加载，就会创建对象
我们可能还没有用到这个对象，但是这个时候对象已经创建好了(饿汉式)
比如说我们调用一个静态属性，这个时候类就会加载，静态属性的初始化就会被执行，但是此时我们还没有用到这个实例，就有可能导致对象创建，但是我们没有用，就会导致资源的浪费
步骤:
1.构造器私有化，防止直接new对象 (构造器如果不私有化，那么我们就可以new多个对象，构造器私有化，可以保证我们只能创建一个对象，因为私有的方法只能在本类中调用)
2.类的内部创建对象(静态的)3.向外暴露静态的公共方法，来获取这个实例
思考：为什么内部创建的对象要是静态的呢？
就算这个对象不是静态的，我们也可以保证这个类只能有一个对象，但是main方法是静态的，静态方法只能调用静态方法和静态属性，如果说这个对象不是静态的，那么获取这个对象的方法就不能是静态的’，如果想要在main方法中调用这个方法来获取实例，是不行的，我们就需要在外面创建对象，然后才可以调用这个方法，这样就矛盾了，所以说内部创建的对象必须是静态的
public class SingleInstance {
public static void main(String[] args) {
GirlFriend g1 = GirlFriend.getInstance();
GirlFriend g2 = GirlFriend.getInstance();
System.out.println(g1);
System.out.println(g2);
System.out.println(g1 == g2);
}
}
//饿汉式
class GirlFriend{
//保证这个类只有一个对象
//所以要保证不能随意创建对象，因此构造器要私有化
//在类的内部创建好对象
private static GirlFriend girlFriend=new GirlFriend("lucy");
private String name;
private GirlFriend(){
}
private GirlFriend(String name){
this.name=name;
}
public static GirlFriend getInstance(){
return girlFriend;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}输出结果:
GirlFriend{name='lucy'}
GirlFriend{name='lucy'}
true这样可以说明，g1和g2其实是同一个对象
懒汉式
我们在使用这个实例的时候，才会创建这个实例
步骤:
1.构造器私有化，防止直接new对象 (构造器如果不私有化，那么我们就可以new多个对象，构造器私有化，可以保证我们只能创建一个对象，因为私有的方法只能在本类中调用)
2.定义一个静态属性对象3.向外暴露静态的公共方法，可以返回一个对象，如果对象还没有创建，我们就创建一个对象，否则，直接返回一个对象
public class SingleInstance1 {
public static void main(String[] args) {
Cat cat=Cat.getInstance();
Cat cat1=Cat.getInstance();
System.out.println(cat);
System.out.println(cat1);
}
}
class Cat{
private String name;
private static Cat instance;
private Cat(){}
private Cat(String name){this.name=name;}
public static Cat getInstance(){
if (instance == null){
instance=new Cat("小猫");
}
return instance;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
运行结果
Cat{name='小猫'}
Cat{name='小猫'}
true两者的区别
1.二者主要的区别在于创建对象的时机不同；饿汉式是在类加载就创建了对象实例，而懒汉式是在使用的时候才创建的
2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题
3.饿汉式在类加载的时候就创建了，存在浪费资源的可能，因为如果我们一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用的时候创建，就不会存在这个问题
4.javase中，Java.lang.Runtime就算经典的单例模式,饿汉式
public class Runtime {
private static Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class <code>Runtime</code> are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the <code>Runtime</code> object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
