单例+反射模式

啊_宇

已于 2023-08-24 15:12:56 修改

阅读量98

点赞数

文章标签：单例模式

于 2023-08-24 15:00:35 首次发布

本文链接：https://blog.csdn.net/m0_75280915/article/details/132473869

版权

单例+反射模式

1.什么是单例模式
- 1.1单例模式的优点与缺点
- 1.2单例模式步骤
2.单例模式的几种实现方式
3 反射模式

1.什么是单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

1.1单例模式的优点与缺点

优点:在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
避免对资源的多重占用。
缺点:没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1.2单例模式步骤

步骤 1
创建一个 Singleton 类。

public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
 
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
 
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

步骤 2
从 singleton 类获取唯一的对象。

SingletonPatternDemo.java


public class SingletonPatternDemo {
   public static void main(String[] args) {
 
      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      //显示消息
      object.showMessage();
   }
}

测试结果

Hello World!

2.单例模式的几种实现方式

2.1懒汉式，线程不安全

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

2.2 懒汉式，线程安全

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

2.3饿汉式

优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

2.4双检锁/双重校验锁

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

2.5 登记式/静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

3 反射模式

3.1什么是反射模式

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射，体现了Java的动态性。
优点：

1、反射提高了程序的灵活性和扩展性。
2、降低耦合性，提高自适应能力。
3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
缺点：

1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。

3.2怎么使用反射

第一步：首先要有一个目标类（用来验证反射）

//在类中有私有变量和共有变量 私有构造和共有构造
public class User {
 
    public String address;
    private int id;
    private String name;
 
 
    public User() {
        System.out.println("无参构造");
    }
 
    public User(int id, String name) {
        System.out.println("全部参数构造");
        this.id = id;
        this.name = name;
    }
 
    private User(int id) {
        System.out.println("私有id的构造函数");
        this.id = id;
    }
 
    private int add(int a){
        System.out.println("私有方法");
        int i=10;
        return a+i;
    }
 
 
    public int add1(int a){
        System.out.println("共有方法");
        int i=10;
        return a+i;
    }
 
    public static int add2(int a){
        System.out.println("静态方法");
        int i=10;
        return a+i;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "address='" + address + '\'' +
                ", id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

第二步：我们使用反射得到类（反射得到类有三种方式，第三种实用性强）

@org.junit.Test
    public void t1() throws ClassNotFoundException {
        System.out.println("第一种获取反射类 new 对象,对象.class");
        User user = new User();
        Class c1 = user.getClass();
        System.out.println(c1);
 
        System.out.println("第二种获取反射类 类.class");
        Class c2 = User.class;
        System.out.println(c2);
 
        System.out.println("第三种获取反射类 Class.forName(全限定名字)");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
        System.out.println(c3);
 
        System.out.println("反射类只有一个 所以都相等 但是创建的对象不相等");
        System.out.println(c1 == c2);//true
        System.out.println(c2 == c3);//true
 
 
    }

第三步：通过得到类获取构造函数创建对象、获取字段、获取方法

/**
     * 反射获取类 类通过构造得到对象
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取所有的public的方法
        System.out.println("=============getConstructors获取所有public构造=================");
        Constructor[] constructors = c3.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("所有的public构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的public的方法
        System.out.println("=============getConstructor获取指定public构造=================");
        Constructor<User> constructorsP = c3.getConstructor(null);
        Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);
 
        //实例化对象 无参构造不能写参数constructorsP.newInstance(1,"22");
        User user = constructorsP.newInstance();
        System.out.println(user);//输出对对象
        System.out.println(user.add1(2));//调用方法
 
        User user1 = constructorsP1.newInstance(1, "郑州");
        System.out.println(user1);
        System.out.println(user1.add1(3));
 
 
        System.out.println("公有无参构造：" + constructorsP);
        System.out.println("公有两个参数构造：" + constructorsP1);
 
        System.out.println();
 
 
        //获取所有的public,private的方法
        System.out.println("=============getDeclaredConstructors获取所有public，private构造=================");
        Constructor[] constructors1 = c3.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println("所有的public、peivate构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的的private的方法
        System.out.println("=============getDeclaredConstructor获取private构造=================");
        Constructor constructors11 = c3.getDeclaredConstructor(int.class);
        System.out.println("私有一个参数构造：" + constructors11);
 
        System.out.println();
 
        System.out.println(c3);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到字段
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取无参构造 并且创建对象
        Constructor<User> userConstructor = c3.getConstructor(null);
        User user = userConstructor.newInstance();
 
        System.out.println("");
        System.out.println("===========getFields获取所有的共有字段===========");
        Field[] fields = c3.getFields();
        for (Field field : fields) {
            field.set(user, "北京");
            System.out.println(field);
        }
        System.out.println("私有属性的User:" + user);
 
 
        System.out.println();
        System.out.println("===========getDeclaredFields获取所有的字段(public private)===========");
        Field[] fields1 = c3.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
 
        System.out.println();
        System.out.println("===========getDeclaredField获取私有和共有  getField获取共有的指定字段===========");
 
        Field field = c3.getDeclaredField("id");
        field.setAccessible(true);
        field.set(user, 1);
        field = c3.getDeclaredField("name");//获取私有
        field.setAccessible(true);//设置true 才能这设置值
        field.set(user, "麻子");
 
        field = c3.getDeclaredField("address");//获取共有
        field.set(user, "天津");
 
        System.out.println(user);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到方法
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        System.out.println("============反射构造函数，然后实例化对象============");
        User user = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
        User user1 = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
 
        System.out.println(user == user1);
 
        System.out.println();
        System.out.println("============getMethods反射获取public方法，包含父类object的方法===========");
        Method[] methods = c3.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
 
        System.out.println();
        System.out.println("============getMethod反射获取指定的public方法，包含父类object的方法===========");
        Method m1 = c3.getMethod("add2", int.class);
        System.out.println("方法返回值+10："+m1.invoke(user, 3));
 
 
        System.out.println();
        System.out.println("============getDeclaredMethods反射获取public和private方法 只有自己的============");
        Method[] methods1 = c3.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
 
 
        System.out.println();
        System.out.println("============getDeclaredMethod反射获取public和private方法 只有自己的============");
        Method m2 = c3.getDeclaredMethod("add",int.class);
        m2.setAccessible(true);
        System.out.println("方法返回值+10："+m2.invoke(user1,5));
 
        m2=c3.getDeclaredMethod("add1",int.class);
        System.out.println("方法返回值+10："+m2.invoke(user1,11));
 
    }