小白学java日记day22--单例实例
定义
一个类只允许有一个对象 , 建立一个全局的访问点 , 提供出去供大家使用 .
分析 :
1. 我们肯定要建立一个单例类来描述
2. 只允许有一个对象
3. 全局的访问点 : 说的就是当前的 s ---- 通过 static 实现的
4. 提供出去
5. 给大家使用
总括 :1. 传值 . 作为全局的访问点 .
解决一个全局使用的类，频繁创建和销毁。拥有对象的唯一性，并保证内存中对象的唯一。
可以节省内存，因为单例共用一个实例，有利于 Java 的垃圾回收机制。也就是控制资源使
用，通过线程同步来控制资源的并发访问；
控制实例产生的数量，达到节约资源的目的；
使用场景
1. 统计当前在线人数（网站计数器）：用一个全局对象来记录。
2. 打印机（设备管理器）：当有两台打印机，在输出同一个文件的时候只一台打印机进行输
出。
3. 数据库连接池（控制资源）：一般是采用单例模式，因为数据库连接是一种连接数据库资
源，不易频繁创建和销毁。
数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损
耗，这种效率的损耗还是非常昂贵的，因此用单例模式来维护，就可以大大降低这种损耗。
4. 应用程序的日志（资源共享）：一般日志内容是共享操作，需要在后面不断写入内容所以通
常单例设计。
示例代码：
/*
1.我们肯定要建立一个单例类来描述
2.只允许有一个对象
3.全局的访问点:说的就是当前的s----通过static实现的
4.提供出去
5.给大家使用
*/
public class Demo {
public static void main(String[] args) {
// SingleInstance singleInstance1=new SingleInstance();
// SingleInstance singleInstance2=new SingleInstance();
// System.out.println(singleInstance1==singleInstance2);//false
//通过公共方法找单例对象
SingleInstance singleInstance1 = SingleInstance.getSingleInstance();
SingleInstance singleInstance2 = SingleInstance.getSingleInstance();
System.out.println(singleInstance1 == singleInstance2);//true
//实现功能：有A，B类
//在A类中有属性num1 B类中有属性num2
//num1的值是4，
//
A a=new A();
a.num1=4;
}
static class A{
int num1;
}
static class B{
int num2;
}
}
//饿汉式：在声明SingleInstance变量时直接赋值
class SingleInstance {
//2.生成一个静态的私有的SingleInstance(私有保证有唯一的对象)
//不加final，引用后面的地址可以改变，加final后singleInstance的引用变成了常量，地址不能改变了
//private 目的是为了外界不能访问，改变singleInstance地址（加上final后可以去掉一般习惯性写上）
private final static SingleInstance singleInstance = new SingleInstance();
//1.将构造方法私有化
private SingleInstance() {
}
//3.静态的公共的方法
public static SingleInstance getSingleInstance() {
return singleInstance;
}
//4.重写clone方法，让这个方法也返回当前的单例类的唯一对象
//注意：这个方法一般可以不写
@Override
protected Object clone() throws CloneNotSupportedException {
return singleInstance;
}
}
//懒汉式：在声明SingleInstance1变量时先不进行赋值，等到实际使用的时候在完成赋值
class SingleInstance1 {
//2.生成一个静态的私有的SingleInstance(私有保证有唯一的对象)
private static SingleInstance1 singleInstance1 = null;
//1.将构造方法私有化
private SingleInstance1() {
}
//3.静态的公共的方法
public static SingleInstance1 getSingleInstance1() {
//外层if 减少了synchronized判断的次数，在保证同步的前提下，提高了到哪里使用的效率
if (singleInstance1 == null){//控制不了同步，减少同步判断的次数
synchronized (SingleInstance.class) {//用当前类的字节码文件对象作为锁
if (singleInstance1 == null) {
singleInstance1 = new SingleInstance1();
}
}
}
return singleInstance1;
}
//4.重写clone方法，让这个方法也返回当前的单例类的唯一对象
//注意：这个方法一般可以不写
@Override
protected Object clone() throws CloneNotSupportedException {
return singleInstance1;
}
}
案例：
有一个订单文件order.txt
orderid:20 ordername:shoes orderprice:1000 orderday:1990-10-10
orderid:21 ordername:phones orderprice:1100 orderday:1990-11-10
orderid:17 ordername:computers orderprice:1300 orderday:1990-12-11
1.需要将数据存入List
2.将list存入单例对象,使其在全局可见
3.对list所在的单例进行序列化操作,并反序列化测试
/*
有一个订单文件order.txt
orderid:20 ordername:shoes orderprice:1000 orderday:1990-10-10
orderid:21 ordername:phones orderprice:1100 orderday:1990-11-10
orderid:17 ordername:computers orderprice:1300 orderday:1990-12-11
1.需要将数据存入List
2.将list存入单例对象,使其在全局可见
3.对list所在的单例进行序列化操作,并反序列化测试
分析：
IO流
NIO流
集合
面向对象
单例设计模式
序列化/反序列化
*/
public class test {
public static void main(String[] args) {
//1.需要将数据存入List
List list=getDate();
System.out.println(list);
//2.将list存入单例对象,使其在全局可见
SinleInstance s=SinleInstance.getInstance();
s.list=list;
test();
//3.对list所在的单例进行序列化操作,并反序列化测试
//writeToFile();
readFromFile();
}
//1.需要将数据存入List
public static List getDate(){
List list1=new ArrayList<>();
try {
List list = Files.readAllLines(Paths.get("C:\\Desktop\\order.txt"));
//将数据转存到Order
for (String s: list) {
list1.add(new Order(s));
}
} catch (IOException e) {
e.printStackTrace();
}
return list1;
}
static public class Order implements Serializable{
private String orderid;
private String ordername;
private double orderprice;
private Date orderday;
public String getOrderid() {
return orderid;
}
public void setOrderid(String orderid) {
this.orderid = orderid;
}
public String getOrdername() {
return ordername;
}
public void setOrdername(String ordername) {
this.ordername = ordername;
}
public double getOrderprice() {
return orderprice;
}
public void setOrderprice(double orderprice) {
this.orderprice = orderprice;
}
public Date getOrderday() {
return orderday;
}
public void setOrderday(Date orderday) {
this.orderday = orderday;
}
public Order(){}
public Order(String orderid, String ordername, double orderprice, Date orderday) {
this.orderid = orderid;
this.ordername = ordername;
this.orderprice = orderprice;
this.orderday = orderday;
}
@Override
public String toString() {
return "Order{" +
"orderid=" + orderid +
", ordername='" + ordername + '\'' +
", orderprice=" + orderprice +
", orderday='" + orderday + '\'' +
'}';
}
//完成数据切割
public Order(String src){
String[] srcs=src.split("\t");
for (String s : srcs) {
String[] pair=s.split(":");
//去空格
String key=pair[0].trim();
String value=pair[1].trim();
//正则表达式
if (key.equals("orderid")){
this.orderid=value;
}else if (key.equals("ordername")){
this.ordername=value;
}else if (key.equals("orderprice")){
this.orderprice= Double.parseDouble(value);
}else if (key.equals("orderday")){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
this.orderday = simpleDateFormat.parse(value);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
}
}
//2.将list存入单例对象,使其在全局可见
public static void test(){
SinleInstance s=SinleInstance.getInstance();
System.out.println("单例对象中的list"+s.list);
}
//3.对list所在的单例进行序列化操作,并反序列化测试
public static void writeToFile(){
try(ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("0609--单例\\danli.txt"))){
objectOutputStream.writeObject(SinleInstance.getInstance());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void readFromFile(){
try(ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("0609--单例\\danli.txt"))) {
try {
SinleInstance s=(SinleInstance)objectInputStream.readObject();
System.out.println("逆序列化后的list："+s.list);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//单例类
class SinleInstance implements Serializable {
private static final long serialVersionUID=-2848937489372589732L;
private static SinleInstance s=null;
private SinleInstance(){}
public static SinleInstance getInstance(){
if (s==null){
synchronized (SinleInstance.class){
if (s==null){
s=new SinleInstance();
}
}
}
return s;
}
//功能区
List list=new ArrayList<>();
} 注意：要把单例单独一写一个类出来，不要写在类里。
例如：
/阿里总裁到广州,北京,上海访问
//总裁属性:姓名,年龄,性别
//要求:使用单例实现//阿里总裁到广州,北京,上海访问
//总裁属性:姓名,年龄,性别
//要求:使用单例实现
public class homework {
public static void main(String[] args) {
visitBeijing();
visitGuangzhou();
visitShanghai();
}
public static void visitGuangzhou(){
SingleInstance singleInstance = SingleInstance.getS();
System.out.println("总裁"+singleInstance.president.getName()+"到广州开会");
}
public static void visitBeijing(){
SingleInstance singleInstance = SingleInstance.getS();
System.out.println("总裁"+singleInstance.president.getName()+"到北京开会");
}
public static void visitShanghai(){
SingleInstance singleInstance = SingleInstance.getS();
System.out.println("总裁"+singleInstance.president.getName()+"到上海开会");
}
}
enum Gender{
Male,FeMale
}
class President{
private String name;
private int age;
private Gender gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
public President(String name, int age, Gender gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
}
class SingleInstance{
private static SingleInstance s = null; private SingleInstance(){}
public static SingleInstance getS() {
if (s == null){
synchronized (SingleInstance.class){
if (s == null){ s = new SingleInstance();
}
}
}
return s;
}
President president = new President("云云",40,Gender.Male);
}