23设计模式学习

最新推荐文章于 2023-08-01 17:42:04 发布

利剑 -~

最新推荐文章于 2023-08-01 17:42:04 发布

阅读量214

点赞数

分类专栏：设计模式文章标签： 23设计模式

本文链接：https://blog.csdn.net/JHON07/article/details/82858505

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.什么设计模式

1.1模式是解决相似问题的核心
1.2设计模式软件设计过程中解决一类问题的方案
总结来说：设计模式：软件设计过程中解决一类问题的一种方案；

2.什么是面向对象的设计模式

面向对象设计模式描述了面向对象设计过程中、特定场景下、类与相互通信的对象之间常见的组织关系、

面向对象的实现过程如下：

2.1 首先是抽象出类
2.2 然后设计出对象之间的关系

3.设计原则:

3.1 针对接口（抽象）编程，而不是针对实现编程；

3.2 优先使用组合而不是使用类的继承

3.3封装变化点

3.4 使用重构得到模式

4.模式

4.1 单例模式

单例模式分为：懒汉模式和饥汉模式

区别：懒汉模式是使用时才创建

饥汉模式是类初始化时加载

使用双检验模式

package com.asiainfo.test;

import java.util.HashMap;

public class Singleton {

    private static volatile Singleton singleton=null;
    
    private Singleton() {}//防止在其他类中创建实例

    public static Singleton getInstance() {
    	 HashMap<String, String> hashMap = new  HashMap<String,String>();
        if (singleton == null) {   //防止已经创建实例，线程进来，有枷锁和释放锁过程，造成cup 资源的浪费
            synchronized (Singleton.class) {//枷锁，两个线程同时进来，其中一个线程能获得锁，另一个线程只能等待
                if (singleton == null) {    //若两个线程都到synchronized ()这块，这个判空就能防止，后面的那个线程在次创建一个实例
                    singleton = new Singleton();
                System.out.println("进来了");
                }
            }
        }
        return singleton;
    }
}

静态加载这种方式:

package com.asiainfo.test;

public class SingletonStatic {
	
	public static int a=10;
	public static volatile SingletonStatic singleton=null;
	
	static {
		singleton=new SingletonStatic();//利用静态代码块实例化类
		System.out.println("this  si a static {}");
	}
	private  SingletonStatic(){ //防止其他类 实例化单例模式
		System.out.println("this is singletonStatic");
	}
	
	private static SingletonStatic getSingleton(){//获取单例
		System.out.println( "this is a static method");
		return singleton;
	}
		

	public static void main(String[] args) {
		System.out.println(a);
		getSingleton();
		SingletonStatic singletonStatic = new SingletonStatic();
	}
	

}

运行结果:

this is singletonStatic
this  si a static {}
10
this is a static method
this is singletonStatic

总结：

概括的说：静态代码块在类加载时调用，并且只调用一次。
静态代码块最常用的作用就是：给一个对象的属性初始化。

具体的说：

1.当调用一个类的静态变量时，这个类中的静态代码块会执行。【只有静态代码块会执行】
2.当调用一个类的静态方法时，这个类中的静态代码块会执行。【只有静态代码块会执行】
3.当创建一个类的一个实例时，这个类中的静态代码块、非静态代码块（也叫构造代码块）、创建实例的相应的构造方法都会执行。

具体类的执行顺序参考:https://mp.csdn.net/postedit/81100790

由于使用静态加载staic{} 方式，只要调用单例的静态变量，或者方法就会执行静态代码块，不是最优的方式

建议使用延迟加载：

该方法中Singleton 有一个静态内部类SingletonHolder，内部类在外部加载的时候并不会加载，在有在调用getInstance才会加载

package com.asiainfo.test;

public class InternalSingleton {


    private InternalSingleton() {
    }

    private static class SingletonHolder {//该方法中Singleton 有一个静态内部类SingletonHolder，内部类在外部加载的时候并不会加载，在有在调用getInstance才回加载
        private static final InternalSingleton inst = new InternalSingleton();
        static {
        	System.out.println("this internal static ");
        }
    }

    public static InternalSingleton getInstance() {
        return SingletonHolder.inst;
    }
    public static void sayHello(){
    	System.out.println("this  is  hello");
    }
    public static void main(String[] args) {
    	InternalSingleton.sayHello();
    	getInstance();
    	
	}
}

运行结果：