标签：线程安全 instance final ati 两种 com 问控制 tin 实例化
对所有的Java开发者而言，所有项目中最为常见的三个设计模式：工厂设计模式、代理设计模式、单例设计模式。
单例设计模式：
如果一个类中定义有普通方法，那么这些普通方法一定要通过本类的实例化对象你才可以调用。
传统调用：
class Single{
public void print(){
System.out.println("单身");
}
}
class TestDemo{
public static void main(String arg[]){
Single single = new Single();
single.print();
}
}
运行结果：单身
在本程序中Single是一个普通的类，由于本类并没有进行任何构造方法的定义，所以这个类中会自动生成一个无参的、什么都不做的的构造方法，正是因为如此，我们可以在外部进行无参构造的调用。
但现在相对Single 类做一个修改：
class Single{
private Single(){}
public void print(){
System.out.println("单身");
}
}
class TestDemo{
public static void main(String arg[]){
Single single= null;
single = new Single();
single.print();
}
}
运行结果：java: Single() 在 com.hellojava.类与方法.JiChengTest.Single 中是 private 访问控制
如果构造方法被私有化了，那么类的外部将无法进行该构造方法的调用，那也就意味着这个类无法进行新的实例化对象的生成。于是我们需要在Single 类中通过一些新设计，让外部可以获取本类实例。
1、使用 private 进行私有化的结构中只允许在本类之中进行访问，所以此时Single 类中的无参构造方法只有Single 类自己调用，那就要找到一种结构既可以在内部调用Single 类构造，又可以不受到Single 类实例化对象的限制，那么自然可以想到 static 方法。
class Single{
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
return new Single();
}
}
class TestDemo{
public static void main(String arg[]){
Single single=Single.getInstance();
single.print();
}
}
运行结果：单身
以上的操作的确实现外部获取Single 类实例化对象的需求，但是这种实现有些荒唐，因为如果此时不在构造方法上加private，也可以实现功能。
2、构造方法的主要功能是获取一个类实例化对象，每调用一次构造方法都可以获取一个新的实例化对象，如果想限制一个类中实例化对象的产生，那么最好的控制就是将构造方法隐藏，
那么此时就需要进行程序结构的修改，让一个类中只能维持一个实例化对象；
3、类的构造方法被私有化后，就只能够在类中进行对象的实例化操作；
class Single{
private static final Single INSTANCE = new Single();
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
return INSTANCE;
}
}
class TestDemo{
public static void main(String arg[]){
Single instanceA = Single.getInstance();
Single instanceB = Single.getInstance();
Single instanceC = Single.getInstance();
Single instanceD = Single.getInstance();
}
}
以上就实现了一个最核心的单例设计模式，不管外部调用getInstance()方法，那么在整个系统内部只维持了唯一一个Single 类的实例。
对于单例设计模式，实际分为两种：饿汉式单例、懒汉式单例。上面就属于饿汉式单例，之所以称为饿汉，主要原因是Single 里面会始终维持一个 INSTANCE 的实例化对象，并不关心这个对象是否被使用。
而懒汉式单例设计的最大特点在于：第一次使用的时候才会进行实例化，而不使用不进行实例化。
懒汉式单例范例：
class Single{
private static Single INSTANCE;
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
if (INSTANCE == null){
INSTANCE = new Single();
}
return INSTANCE;
}
}
class TestDemo{
public static void main(String arg[]){
Single INSTANCE = Single.getInstance();
INSTANCE.print();
}
}
运行结果：单身
饿汉式的单例实现要比懒汉式的单例实现更简单。
单例模式
例--实例--对象
本类只有一个对象
当一个类只能有一个对象时，我们将这个类定义为单例模式
步骤：
01：将构造方法私有化
02:定义一个自己的对象引用，然后new一个对象
03:写一个public static方法，提供调用对象的入口
//懒汉式和饿汉式的区别
01：懒汉式只有在第一次调用的时候才new 对象 饿汉式 直接new一个对象
02：懒汉式省内存 饿汉式费内存
03：懒汉式有线程安全问题 饿汉式不存在
标签：线程安全 instance final ati 两种 com 问控制 tin 实例化
原文地址：https://www.cnblogs.com/Anjxasm/p/12000716.html
