Java 设计模式之享元模式详解 1. 定义享元模式（Flyweight Pattern）是一种结构型设计模式，其核心思想是通过共享对象来减少内存的使用和提高系统性能。享元模式通过将内部可共享的状态和外部独立的状态分离，从而减少对象的重复创建。2. 适用场景享元模式适用于以下情况：对象数量庞大，且大多数对象可以共享部分状态。内存消耗高，有必要通过对象复用来优化性能。外部状态可独立存储，共享的对象可以被多个外部对象同时使用。3. 模式结构享元模式主要由以下几个部分构成：Flyweight接口：定义享元对象的接口，包含需要实现的业务方法。ConcreteFlyweight（具体享元类）：实现 Flyweight 接口，提供共享的内部状态。UnsharedConcreteFlyweight（非共享享元类）：定义那些不被共享的对象。FlyweightFactory（享元工厂类）：用于管理享元对象，提供共享对象的缓存机制。Client（客户端）：负责存储和操作外部状态，并使用享元对象完成具体任务。4. 享元模式的核心：内部状态与外部状态内部状态：可以共享的部分，不会随外部变化。由享元对象内部维护。外部状态：不可共享的部分，会随环境改变。由客户端维护或传递给享元对象。5. 实例：JDK 中 Integer 的缓存机制在 Java 中，Integer 类为了提高性能和减少内存消耗，对 -128 到 127 之间的整数进行了缓存，这是享元模式的一个典型应用。5.1 Integer 缓存的工作原理当你对一个 Integer 对象进行自动装箱或通过 Integer.valueOf() 创建时，JVM 会检查数字是否在缓存范围（-128 到 127）内：如果在此范围内，返回缓存中的对象。如果超出该范围，创建新的 Integer 对象。Integer i1 = 127; // 自动装箱，相当于 Integer.valueOf(127) Integer i2 = 127; // 直接从缓存中获取 Integer i3 = 128; // 创建新的对象，因为超出缓存范围 Integer i4 = 128; // 再次创建新的对象5.2 Integer 缓存的源码Integer.valueOf() 方法通过内部的 IntegerCache 类来实现缓存机制：public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) { return IntegerCache.cache[i + (-IntegerCache.low)]; } return new Integer(i); } private static class IntegerCache { static final int low = -128; static final int high = 127; static final Integer cache[]; static { cache = new Integer[(high - low) + 1]; for (int i = 0, j = low; j <= high; i++, j++) { cache[i] = new Integer(j); } } }在此代码中，IntegerCache 类缓存了 -128 到 127 之间的 Integer 对象。调用 Integer.valueOf() 时，如果数字在缓存范围内，则返回缓存对象，避免创建新的对象。5.3 实例演示public class FlyweightExample { public static void main(String[] args) { Integer i1 = Integer.valueOf(127); Integer i2 = Integer.valueOf(127); Integer i3 = Integer.valueOf(128); Integer i4 = Integer.valueOf(128); System.out.println(i1 == i2); // true, 127在缓存范围内，共享对象 System.out.println(i3 == i4); // false, 128不在缓存范围内，不同对象 } }输出结果：true false5.4 内部状态与外部状态的应用内部状态：在 -128 到 127 之间的整数是共享的，表示可重复使用的部分（享元模式中的共享对象）。外部状态：超出此范围的整数需要每次新建，是不可共享的部分。6. 享元模式总结优点：减少内存开销：通过共享相同的对象，减少了重复对象的创建，尤其在大量小对象场景中非常有效。提高性能：减少了对象的创建和销毁过程，尤其在大量使用相似对象时性能提升显著。缺点：增加代码复杂度：需要区分内部状态和外部状态，额外的状态管理会增加代码复杂度。适用场景有限：仅在对象可共享且变化不大时效果显著，不适用于复杂对象或场景。7. 适用案例JDK 中 Integer 的缓存机制：Integer 类缓存了 -128 到 127 之间的整数，避免重复创建相同数值的对象，节省内存。文本编辑器中的字符对象：同样字符的对象可以共享字体、大小等属性，只需根据不同位置设定外部状态（坐标）。游戏中的精灵对象：相同的精灵图片资源可以共享，不同精灵的位置和行为通过外部状态来控制。8. 模式应用要点享元模式的核心是通过分离共享的内部状态和不可共享的外部状态来实现对象的重用。在实际开发中，常见的场景如缓存、池化资源管理等，都可以通过享元模式来实现内存优化。

java浅拷贝深拷贝 在Java中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两个常见的对象拷贝方式。它们的主要区别在于它们处理对象中的引用类型字段的方式。1. 浅拷贝（Shallow Copy）浅拷贝仅拷贝对象本身以及对象中所有的基本数据类型字段，对于引用类型字段（如对象、数组等），仅复制其引用（即指针），而不复制实际的对象。这意味着原对象和拷贝对象中的引用类型字段指向同一个内存地址，因此改变一个对象中的引用类型字段可能会影响到另一个对象。实现方式：实现Cloneable接口并重写clone()方法。代码示例：class Address { String city; public Address(String city) { this.city = city; } } class Person implements Cloneable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); // 浅拷贝 } } public class ShallowCopyExample { public static void main(String[] args) throws CloneNotSupportedException { Address address = new Address("New York"); Person person1 = new Person("John", address); Person person2 (Person) person1.clone(); System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // New York person2.address.city = "San Francisco"; System.out.println(person1.address.city); // San Francisco System.out.println(person2.address.city); // San Francisco } }应用场景：浅拷贝适用于对象结构简单且不包含复杂的嵌套对象的情况。因为浅拷贝的速度较快，适合对性能有较高要求但不涉及深层嵌套结构的场景。2. 深拷贝（Deep Copy）深拷贝不仅拷贝对象本身，还会递归地拷贝对象中所有引用类型字段所指向的对象。这意味着原对象和拷贝对象中的引用类型字段互不影响，修改一个对象中的引用类型字段不会影响到另一个对象。实现方式：重写clone()方法，手动拷贝所有的引用类型字段。使用序列化和反序列化实现深拷贝。代码示例：class Address implements Cloneable { String city; public Address(String city) { this.city = city; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } class Person implements Cloneable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { Person clonedPerson = (Person) super.clone(); clonedPerson.address = (Address) address.clone(); // 深拷贝 return clonedPerson; } } public class DeepCopyExample { public static void main(String[] args) throws CloneNotSupportedException { Address address = new Address("New York"); Person person1 = new Person("John", address); Person person2 = (Person) person1.clone(); System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // New York person2.address.city = "San Francisco"; System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // San Francisco } }应用场景：深拷贝适用于对象结构复杂且包含多个嵌套引用类型字段的场景，尤其是在这些引用类型字段是可变对象时。深拷贝确保拷贝后的对象与原对象完全独立，不会互相影响。总结浅拷贝：仅复制对象及其基本数据类型字段，引用类型字段只复制引用。适用于简单的对象结构。深拷贝：复制对象及其所有引用类型字段所指向的对象。适用于复杂对象结构，确保深层次的独立性。根据具体需求选择合适的拷贝方式可以有效地避免不必要的副作用并提高程序的性能。

代理模式 代理模式（Proxy Pattern）是设计模式中的一种结构型模式。它为其他对象提供一种代理以控制对这个对象的访问。在 Java 中，代理模式有多种实现方式，主要分为静态代理和动态代理。1. 代理模式的基本概念意图：代理模式通过创建一个代理对象来代替实际对象，并且可以控制对实际对象的访问。代理对象和实际对象通常实现相同的接口或继承相同的类。结构：Subject（抽象主题接口/类）：定义了真实对象和代理对象的公共接口或父类。RealSubject（真实主题类）：实现了抽象主题接口，是代理对象所代表的真实对象。Proxy（代理类）：持有一个对真实对象的引用，实现了抽象主题接口，并在调用时对真实对象进行操作。适用场景：需要对原对象的功能进行扩展或控制，而不改变原对象的代码。需要对某个类的访问进行控制，比如延迟加载、安全代理、远程代理等。2. 静态代理特点：预先定义：代理类在编译时就已经创建好了，代理类和真实类需要实现相同的接口。代理行为固定：代理类的行为是静态的，不能在运行时改变。优缺点：优点：实现简单，容易理解，能够在编译时进行类型检查。缺点：代理类与真实类高度耦合，代理类过多会导致代码冗余，不适合扩展性需求高的场景。示例代码：// 定义接口 public interface Subject { void request(); } // 真实主题类 public class RealSubject implements Subject { @Override public void request() { System.out.println("真实主题处理请求"); } } // 代理类 public class Proxy implements Subject { private RealSubject realSubject; public Proxy(RealSubject realSubject) { this.realSubject = realSubject; } @Override public void request() { System.out.println("代理开始处理"); realSubject.request(); System.out.println("代理完成处理"); } } // 测试代码 public class Main { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); Proxy proxy = new Proxy(realSubject); proxy.request(); } }3. 动态代理特点：动态生成：动态代理类在运行时由 JVM 动态生成，不需要事先定义代理类。灵活性高：可以在运行时灵活地决定代理行为。实现方式：JDK 动态代理：基于反射机制，只能代理实现了接口的类。CGLIB 动态代理：基于字节码生成，可以代理没有实现接口的类，常用于 Spring 框架。优缺点：优点：减少了静态代理的冗余代码，增强了扩展性，可以动态地为多个对象创建代理。缺点：性能略低于静态代理，调试较为复杂，尤其是对生成的动态代理类进行调试。JDK 动态代理示例代码：import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; // 定义接口 public interface Subject { void request(); } // 真实主题类 public class RealSubject implements Subject { @Override public void request() { System.out.println("真实主题处理请求"); } } // 动态代理处理器 public class DynamicProxyHandler implements InvocationHandler { private Object target; public DynamicProxyHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理开始处理"); Object result = method.invoke(target, args); // 调用真实对象的方法 System.out.println("代理完成处理"); return result; } } // 测试代码 public class Main { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); Subject proxyInstance = (Subject) Proxy.newProxyInstance( realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), new DynamicProxyHandler(realSubject) ); proxyInstance.request(); } }4. 代理模式的常见应用安全代理：控制对原始对象的访问，确保安全性。延迟加载：在需要时才创建或加载实际对象，以提高性能。远程代理：为远程对象提供本地代理，使远程调用看起来像本地调用。虚拟代理：控制对象的访问以延迟实际对象的创建和初始化。保护代理：通过代理来控制对象的访问权限。5. 总结代理模式是一种非常有用的设计模式，它通过引入代理对象来控制对实际对象的访问。静态代理适合简单和固定的场景，而动态代理则提供了更强的灵活性和扩展性。理解代理模式的使用场景和实现方式，可以帮助开发者编写更灵活、更易维护的代码。

封装和抽象 Java 的构建者模式 创建一个通用的 Builder 接口或抽象类，并将具体的构建过程委托给子类或具体实现类。这样做可以复用构建逻辑，并且提高代码的可扩展性和维护性。1. 抽象 Builder 类首先，我们可以定义一个抽象的 Builder 类，这个类会定义一个通用的构建流程，并且要求子类去实现具体的构建步骤。public abstract class Builder<T> { protected T instance; // 提供创建对象的通用方法 protected abstract T createInstance(); // 每个具体的构建步骤由子类实现 public Builder<T> with(Consumer<T> setter) { setter.accept(instance); return this; } // 返回最终构建的对象 public T build() { return instance; } }2. 具体实现 UserBuilder继承上面的抽象 Builder 类，针对具体的 User 对象，我们可以实现一个 UserBuilder：public class User { private String firstName; private String lastName; private int age; private String phone; private String address; // 公开构造函数或私有构造函数 public User() { } // getter和setter public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } public class UserBuilder extends Builder<User> { @Override protected User createInstance() { return new User(); } public UserBuilder() { this.instance = createInstance(); } public UserBuilder firstName(String firstName) { return this.with(user -> user.setFirstName(firstName)); } public UserBuilder lastName(String lastName) { return this.with(user -> user.setLastName(lastName)); } public UserBuilder age(int age) { return this.with(user -> user.setAge(age)); } public UserBuilder phone(String phone) { return this.with(user -> user.setPhone(phone)); } public UserBuilder address(String address) { return this.with(user -> user.setAddress(address)); } }3. 使用方式使用抽象后的 Builder 类构建 User 对象：public class Main { public static void main(String[] args) { User user = new UserBuilder() .firstName("John") .lastName("Doe") .age(30) .phone("123456789") .address("123 Main St") .build(); System.out.println(user.getFirstName()); System.out.println(user.getLastName()); System.out.println(user.getAge()); System.out.println(user.getPhone()); System.out.println(user.getAddress()); } }4. 优势通过这种方式：通用性：Builder 类可以复用，也可以通过创建不同的具体构建器（如 UserBuilder）来构建不同的对象。可扩展性：如果以后有其他复杂对象需要使用构建者模式，只需要继承 Builder 类，提供具体的实现即可。简化构建流程：with 方法的引入使得构建过程更加简洁和灵活。这个模式让你的代码不仅易于维护，而且能很好地应对未来的扩展需求。