java饿汉式的小程序

"饿汉式"是指在加载 Java 程序时就预先初始化单例类的方式，这种方式的优点在于线程安全，因为一旦实例化完成，就不会再有新的实例创建，所以在多线程环境中不会出现问题。下面是一个简单的饿汉式 Singleton（单例）模式的示例：

public class Singleton {
    // 创建 Singleton 类型的对象并赋值给 static 变量
    private static Singleton instance = new Singleton();

    // 将构造函数设为 private，防止外部直接创建对象
    private Singleton() {}

    // 获取唯一实例的方法
    public static Singleton getInstance() {
        return instance;
    }
}

在这个例子中，`instance` 初始化在类加载时就已经完成，这就是 "饿汉式" 的做法。当需要使用 Singleton 时，可以直接通过 `Singleton.getInstance()` 获得。

相关问题

请写一个懒汉式和饿汉式的单例程序

单例模式是一种常见的设计模式，其核心思想是保证一个类仅有一个实例，并且提供一个全局访问点。懒汉式和饿汉式是两种常见的单例实现方式。

懒汉式单例模式：

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造方法，避免外部new实例
    }

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

在懒汉式单例模式中，实例对象只有在第一次使用时才会被创建。这种实现方式的缺点是在多线程环境下，可能会创建多个实例，因此需要使用`synchronized`关键字保证线程安全。

饿汉式单例模式：

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
        // 私有构造方法，避免外部new实例
    }

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

在饿汉式单例模式中，实例对象在类加载时就会被创建，因此不存在线程安全问题。但这种实现方式的缺点是，即使实例没有被使用，也会被创建，可能会浪费一些内存空间。

需要根据具体情况选择懒汉式或饿汉式单例模式的实现方式。

二、实验内容 某软件公司开发人员要创建一个数据库连接池，将指定个数的(如3个)数据库连接对象存储在连接池中，客户端代码可以从池中随机取一个连接对象来连接数据库。试通过对单例类进行改造，设计一个能够自行指定个数实例对象的数据库连接类并Java代码编程实现（请分别用饿汉和懒汉单例模式实现）。 要求： 1、画出UML图； 2、给出程序代码，程序代码有恰当的注释。 3、文档格式正确，排版清晰。

本题不适用于AI智能作答，请参照以下答案。

1. UML图

饿汉单例模式：


懒汉单例模式：


2. 代码实现

饿汉单例模式：

public class EagerSingleton {
    private static final int POOL_SIZE = 3; // 连接池大小
    private static EagerSingleton instance = new EagerSingleton(); // 饿汉式单例
    private List<Connection> pool = new ArrayList<>(POOL_SIZE); // 连接池
    private int count = 0; // 记录连接池中连接对象的数量

    // 私有构造方法，初始化连接池
    private EagerSingleton() {
        for (int i = 0; i < POOL_SIZE; i++) {
            pool.add(new Connection());
        }
        count = POOL_SIZE;
    }

    // 获取连接对象
    public synchronized Connection getConnection() {
        if (count > 0) {
            Connection conn = pool.get(count - 1);
            count--;
            return conn;
        } else {
            return null;
        }
    }

    // 归还连接对象
    public synchronized void returnConnection(Connection conn) {
        pool.add(conn);
        count++;
    }

    // 获取单例对象
    public static EagerSingleton getInstance() {
        return instance;
    }
}

class Connection {
    // 省略连接数据库的操作
}

懒汉单例模式：

public class LazySingleton {
    private static int POOL_SIZE; // 连接池大小
    private static LazySingleton instance; // 懒汉式单例
    private List<Connection> pool; // 连接池
    private int count = 0; // 记录连接池中连接对象的数量

    // 私有构造方法，初始化连接池
    private LazySingleton() {}

    // 获取连接对象
    public synchronized Connection getConnection() {
        if (count > 0) {
            Connection conn = pool.get(count - 1);
            count--;
            return conn;
        } else {
            return null;
        }
    }

    // 归还连接对象
    public synchronized void returnConnection(Connection conn) {
        pool.add(conn);
        count++;
    }

    // 获取单例对象
    public static LazySingleton getInstance(int poolSize) {
        POOL_SIZE = poolSize;
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                    instance.pool = new ArrayList<>(POOL_SIZE);
                    for (int i = 0; i < POOL_SIZE; i++) {
                        instance.pool.add(new Connection());
                    }
                    instance.count = POOL_SIZE;
                }
            }
        }
        return instance;
    }
}

class Connection {
    // 省略连接数据库的操作
}

3. 文档说明

参考文献：无

注：本文档由AI自动生成，如有错误请及时联系我们。