【Java】设计模式——单例、工厂、代理模式

🎁个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：【Java】内容概括

【Preface】

在 Java 编程世界里，设计模式是前辈们总结出的解决常见问题的优秀方案。今天，我们就来深入剖析单例模式、工厂模式和代理模式，带大家领略设计模式的魅力。

一、单例模式

单例模式确保一个类只有一个实例

1.饿汉式

• 程序启动时就进行单例对象的初始化，无论是否被使用
• 线程安全
• 浪费资源（一直未被使用）

static修饰的静态变量只能有一个

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

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

public class Test {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
    }
}

2.懒汉式

延迟加载，单例对象在首次访问时才初始化，节省了资源

ublic class Singleton2 {
    private static Singleton2 instance;//null
    private Singleton2(){

    }
    public static Singleton2 getSingleton(){
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

二、工厂模式

工厂模式定义一个创建对象的接口（只创建对象的工厂类），使创建对象的过程和使用对象的过程分离

• 创建工厂接口（抽象工程）

public interface UserFactory {
    User createUser(String name,int age);
}

• 实现具体工厂

public class AdminFactory implements UserFactory{
    @Override
    public User createUser(String name, int age) {
        return new AdminUser(name, age);
    }
}

public class NormalFactory implements UserFactory{
    @Override
    public User createUser(String name, int age) {
        return new AdminUser(name, age);
    }
}

• 使用方式

public class Test {
    public static void main(String[] args) {
        //管理员
        UserFactory adminFactory = new AdminFactory();
        User admin = adminFactory.createUser("baby",10);
        //用户
        UserFactory NormalFactory = new NormalFactory();
        User normal1 = NormalFactory.createUser("lisy",12);
        User normal2 = NormalFactory.createUser("long",14);

    }

• 在⼯⼚⽅法模式中，每种⽤⼾类型都有⾃⼰的⼯⼚类。要添加新的⽤⼾类型，只需创建新的⼯⼚ 类，⽆需修改现有代码。

• 代码不会重复，创建对象的过程，封装到了⼯⼚当中

• 更加解耦

三、代理模式

一个类代表另一个类的功能，通过代理对象来控制实际对象的访问，相当于“中介”

• User类

public abstract class User {
    protected String name;
    protected int age;

    //Alt+Inster
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public abstract void menu();
}

• NormalUser 和AdminUser 类的结构如下：

public class AdminUser extends User{
    public AdminUser(String name, int age) {
        super(name, age);
    }

    @Override
    public void menu() {
        System.out.println("管理员菜单");
    }
    public void addBook(String bookName){
        System.out.println("普通用户"+ name +"借阅了" + bookName);
    }
}

public class NormalUser extends User{
    public NormalUser(String name, int age) {
        super(name, age);
    }

    @Override
    public void menu() {
        System.out.println("普通用户的菜单");
    }
    public void borrowBook(String bookName){
        System.out.println("普通用户"+ name +"借阅了" + bookName);
    }
}

• 代理类结构

• 在该代理类中对borrowBook、returnBook⽅法提供了代理
• ProxyUser 为不同类型的User 提供代理

public class ProxyUser {
    private User realUser;
    public ProxyUser(User user){
        this.realUser = user;
    }
    public void menu(){
        this.realUser.menu();
    }
    public void borrowBook(String bookName) {
        System.out.println("检查用户权限");
        if (this.realUser instanceof NormalUser) {
            //User类里面不包含borrowBook,需要强转
            ((NormalUser) this.realUser).borrowBook(bookName);
        } else {
            System.out.println("没有权限借阅");
        }
    }
    public void addBook(String bookName){
        System.out.println("检查用户权限");
        if(this.realUser instanceof AdminUser){
            //User类里面不包含borrowBook,需要强转
            ((AdminUser) this.realUser).addBook(bookName);
        }else {
            System.out.println("没有权限上架");
        }
    }
}

 public static void main(String[] args) {
        UserFactory adminFactory = new AdminFactory();
        User admin = adminFactory.createUser("baby",10);

        UserFactory NormalFactory = new NormalFactory();
        User normal1 = NormalFactory.createUser("lisy",12);
        User normal2 = NormalFactory.createUser("long",14);
        //代理模式
        ProxyUser proxyAdminUser = new ProxyUser(admin);
        proxyAdminUser.borrowBook("图书1");

        ProxyUser proxyNormalUser = new ProxyUser(normal1);
        proxyNormalUser.addBook("图书1");
        proxyNormalUser.borrowBook("图书1");
        proxyNormalUser.borrowBook("图书2");
    }

【总结】

设计模式不是银弹，而是解决特定问题的优秀思路。在实际开发中，我们要根据具体场景选择合适的设计模式，让代码更加优雅、可维护。希望本文能帮助大家更好地理解和运用这三种设计模式！