详细介绍：【Java】设计模式——单例、工厂、代理模式

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

【Preface】

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

文章目录：

• 一、单例模式
• • 1.饿汉式
  • 2.懒汉式
• 二、工厂模式
• 三、代理模式

一、单例模式

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

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");
}

【总结】

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