设计模式初阶_01

单例模式

package com.songlin.designpattern.lazysingleton;

/**
 * @Author Joe
 * com.songlin.designpattern.lazysingleton
 * @Date 2021-12-13 22:54
 */
public class LazySingletonTest {
    public static void main(String[] args) {
//        LazySingleton instance = LazySingleton.getInstance();
//        LazySingleton instancel = LazySingleton.getInstance();
//        System.out.println(instancel == instance);


        new Thread( () ->{
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }

        ).start();

        new Thread( () ->{
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
    }

}


class LazySingleton{
    private static LazySingleton instance;
    private LazySingleton(){

    }
    public synchronized static LazySingleton getInstance(){
        if (instance == null){
            synchronized (LazySingleton.class){
                if (instance == null){
                    instance  = new LazySingleton();
                }
            }

        }
        return instance;

    }
}

饿汉加载

package com.songlin.designpattern.hungrysingleton;

/**
 * @Author Joe
 * com.songlin.designpattern.hungrysingleton
 * @Date 2021-12-13 23:53
 */
public class HungerySingletonTest {
    public static void main(String[] args) {
        HungerySingleton instance = HungerySingleton.getInstance();
        HungerySingleton instancel = HungerySingleton.getInstance();
        System.out.println(instance == instancel);
    }
}
//饿汉模式的编写
class HungerySingleton{
    private static HungerySingleton instance = new HungerySingleton();
    private HungerySingleton(){

    }
    public static HungerySingleton getInstance(){
        return instance;
    }
}

反射

package com.songlin.designpattern.innerclasssingleton;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Author Joe
 * com.songlin.designpattern.innerclasssingleton
 * @Date 2021-12-14 0:09
 */
public class InnerSingletonTest {
    @Test
    public void test1 () {
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        InnerClassSingleton internal = InnerClassSingleton.getInstance();
        System.out.println(instance == internal);
        System.out.println("---------------------------");
        new Thread(() -> {
            InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
            System.out.println(instance2.hashCode());
        }).start();

        new Thread(() -> {
            InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
            System.out.println(instance2.hashCode());
        }).start();
    }


    /**
     * 反射的含义：
     *  反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括包括其modifiers(修饰符)，fields(属性)，methods(方法)等，
     *  并可于运行时改变fields内容或调用methods。
     *  那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；
     *  还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！
     *
     * 常用的反射的方法
     * getName()：获得类的完整名字。
　　  * getFields()：获得类的public类型的属性。
　　  * getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类
　　  * getMethods()：获得类的public类型的方法。
　　  * getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类
　　  * getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
　　  * getConstructors()：获得类的public类型的构造方法。
　　  * getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
　　  * newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
     */
    @Test
    public void test2() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(instance == innerClassSingleton);
    }
}
class InnerClassSingleton{
    private static class InnerClassHolder{
        private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }
    private InnerClassSingleton(){

    }
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.innerClassSingleton;
    }


}

enum

package com.songlin.designpattern.enumsingleton;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Author Joe
 * com.songlin.designpattern.enumsingleton
 * @Date 2021-12-14 0:49
 */
public enum EnumSingleton {
    INSTANCE;
    public void print(){
        System.out.println(INSTANCE.hashCode());
    }
}

class EnumTest{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//        EnumSingleton instance = EnumSingleton.INSTANCE;
//        EnumSingleton instance1 = EnumSingleton.INSTANCE;
//        System.out.println(instance == instance1);
        /**
         * 下面的代码会报错，原因是因为对于enum类中的参数是不支持通过反射去获取和修改其属性值的
         * 所以enum是一个线程安全的
         * 运行后的报错信息如下：
         *    Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
         * 	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
         */
        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        declaredConstructor.newInstance("INSTANCE",0);

    }
}

通过流的读取

package com.songlin.designpattern.innerclasssingleton;

import org.junit.Test;

import javax.sound.midi.Synthesizer;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Author Joe
 * com.songlin.designpattern.innerclasssingleton
 * @Date 2021-12-14 0:09
 */
public class InnerSingletonTest {
    @Test
    public void test1 () {
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        InnerClassSingleton internal = InnerClassSingleton.getInstance();
        System.out.println(instance == internal);
        System.out.println("---------------------------");
        new Thread(() -> {
            InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
            System.out.println(instance2.hashCode());
        }).start();

        new Thread(() -> {
            InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
            System.out.println(instance2.hashCode());
        }).start();
    }


    /**
     * 反射的含义：
     *  反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括包括其modifiers(修饰符)，fields(属性)，methods(方法)等，
     *  并可于运行时改变fields内容或调用methods。
     *  那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；
     *  还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！
     *
     * 常用的反射的方法
     * getName()：获得类的完整名字。
　　  * getFields()：获得类的public类型的属性。
　　  * getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类
　　  * getMethods()：获得类的public类型的方法。
　　  * getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类
　　  * getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
　　  * getConstructors()：获得类的public类型的构造方法。
　　  * getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
　　  * newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
     */
    @Test
    public void test2() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(instance == innerClassSingleton);
    }


    /**
     * 此处是使用了InnerClassSingleton的类，这个里面是继承了一个Serializable接口
     * @throws IOException
     */
    @Test
    public void test3() throws IOException, ClassNotFoundException {
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
//        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("testSerializable"));
//        os.writeObject(instance);
//        os.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testSerializable"));
        InnerClassSingleton o = (InnerClassSingleton) ois.readObject();
        System.out.println(instance == o);

    }
}
class InnerClassSingleton implements Serializable {
    private static class InnerClassHolder{
        private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }
    private InnerClassSingleton(){

    }
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.innerClassSingleton;
    }


}