单例模式: 保证类的实例只有一个。
构造函数私有化,提供一个可以获取到对象的静态公开方法。
优点
在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例
避免对资源的多重占用(比如写文件操作)。
单例也分为 懒汉模式(线程不安全)和饿汉模式(线程安全)
缺点
没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
方法1:懒汉模式 --第一次调用的时候才创建对象
//单例模式
public class Singleton {
private static Singleton s;
private Singleton(){};
public static synchronized Singleton getInstance(){
if(s==null){
s=new Singleton();
}
return s;
}
}
class TestSingleton{
public static void main(String[] args) {
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
System.out.println(s1==s2); //判断是否为同一个对象
}
}
方法2:饿汉模式--在类加载的时候就创建了对象
//单例模式
public class Singleton {
private static Singleton sa=new Singleton();
private Singleton(){};
//getInstance()方法中需要使用同步锁 synchronized (Single.class) 防止多线程同时进入造成 instance 被多次实例化。
public static synchronized Singleton getInstance(){
return sa;
}
}
class TestSingleton{
public static void main(String[] args) {
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
System.out.println(s1==s2); //判断是否为同一个对象
}
}
单例模式:一个类只有一个对象
非单例:一个类型可以创造出多个对象
单例模式写一个冒泡排序算法(面试题)
import java.util.Arrays;
public class SingletonSort {
private static SingletonSort s;
private SingletonSort(){};
public static synchronized SingletonSort getInstance(){
if(s==null){
s=new SingletonSort();
}
return s;
}
public int[] sort(int[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
}
class TestSingletonSort{
public static void main(String[] args) {
SingletonSort ss=SingletonSort.getInstance();
int[] a=ss.sort(new int[]{3,2,5,6,8,12,10,4});
System.out.println(Arrays.toString(a));
}
}