废话不多说，破坏普通自定义类单例模式以下方法：

1. 反射
2. 序列化

代码如下：

首先，我们自定义一个单例模式的类Earth。

地球是独一无二的吗。

class Earth implements Serializable{
    
    //序列化标识
    private static final long serialVersionUID = -348273948432427L;

    private static Earth earth = new Earth();

    private Earth() {
    }

    public static Earth getInstance() {
        return earth;
    }

    public void speak() {
        out.println("i am earth , No : " + this.toString());
    }
}

尝试使用反射破单例模式

main函数代码如下：

//利用反射调用私有构造方法
        try {
            for (int i = 0; i < 3; i++) {
                Class classes = Class.forName(Earth.class.getName());
                Constructor[] declaredConstructors = classes.getDeclaredConstructors();
                for (Constructor declaredConstructor : declaredConstructors) {
                    declaredConstructor.setAccessible(true);
                    Earth earth = (Earth) declaredConstructor.newInstance();
                    earth.speak();
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

Run代码之后，日志如下：

i am earth , No : Earth@5e2de80c
i am earth , No : Earth@1d44bcfa
i am earth , No : Earth@266474c2

看，类的内存地址是不同的。利用反射机制成功破坏了已经封装的单例模式

尝试使用序列化和反序列化破坏单例模式

直接贴

                   .-' _..`.
                  /  .'_.'.'
                 | .' (.)`.
                 ;'   ,_   `.
 .--.__________.'    ;  `.;-'
|  ./               /
|  |               / 
`..'`-._  _____, ..'
     / | |     | |\ \
    / /| |     | | \ \
   / / | |     | |  \ \
  /_/  |_|     |_|   \_\
 |__\  |__\    |__\  |__\

//利用反序列化破坏单利模式
Earth earth = Earth.getInstance() ;
try {
        File file = new File("temp") ;
        if (!file.exists()){
                file.createNewFile() ;
                out.println("文件路径"+file.getAbsolutePath());
        }

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file)) ;
        oos.writeObject(earth);
        oos.close();

        for (int i = 0 ; i < 3 ; i ++){
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)) ;
                Earth tempEarth = (Earth) ois.readObject();
                tempEarth.speak();
                ois.close();
        }
        if (file.delete()) {
                out.println("---删除成功");
        }

} catch (IOException e) {
        e.printStackTrace();
} catch (ClassNotFoundException e) {
        e.printStackTrace();
}

代码运行结果如下：

文件路径/XXX/XXX/IdeaProjects/Test/temp
i am earth , No : Earth@10f87f48
i am earth , No : Earth@b4c966a
i am earth , No : Earth@2f4d3709
---删除成功

内存地址是不同的，这证明序列化和反序列化也可以破坏单例模式的封装。

总结

以上两种方法证，明了单例模式是可破坏的，但是在编程的浩瀚海洋里，据不知这两种方法。与之相对，肯定也有形形色色对应得保护机制，这也是下一篇文章的内容。