Uno de los patrones estructurales tiene como objetivo reducir el uso de memoria compartiendo la mayor cantidad de datos posible con objetos similares.
Es particularmente útil cuando se trata de una gran cantidad de objetos similares, donde crear una nueva instancia para cada objeto sería costoso en términos de consumo de memoria.
conceptos clave:
Estado intrínseco: el estado que comparten varios objetos es independiente del contexto y permanece igual en diferentes objetos.
Estado extrínseco: el estado que es único para cada objeto y se pasa desde el cliente. Este estado puede variar y no se almacena en el objeto Flyweight

Participantes clave:

Flyweight: Interfaz que el objeto Flyweight recibe el estado extrínseco y lo utiliza.
ConcreteFlyweight: implementa Flyweight y almacena el estado intrínseco.
FlyweightFactory: gestiona los objetos Flyweight y garantiza el intercambio de interfaces; devuelve un Flyweight existente si ya existe.

Cliente (como la clase principal): mantiene una referencia a Flyweight y proporciona un estado extrínseco cuando necesita interactuar con el objeto Flyweight.

Tomemos un ejemplo de un objeto Flyweight de carácter
Supongamos que tenemos un editor de texto que necesita representar una gran cantidad de texto. Cada personaje se puede representar como un objeto, pero tener un objeto separado para cada personaje desperdiciaría mucha memoria. En su lugar, podemos usar Flyweights para compartir los objetos de carácter que representan cada letra y almacenar el estado extrínseco como la posición o el formato externo

Peso mosca

public interface Flyweight {
    public void display(int x, int y);//x, y are the extrinsic state of the Flyweight object
}

Peso mosca concreto

public class CharacterFlyweight implements Flyweight {
    private char ch;
    public CharacterFlyweight(char c){
        this.ch  = c;
    }
    @Override
    public void display(int x ,int y){
        System.out.println("[drawing character: " this.ch " at co-ordinates:(" x "," y ")]");
    }

}

Fábrica de peso mosca

public class FlyweightFactory {
    private static HashMap flyweights = new HashMap();
    public static Flyweight getFlyweight(char c){
        Flyweight flyweight = flyweights.getOrDefault(c,null);
        if(null==flyweight){
            flyweight = new CharacterFlyweight(c);
            flyweights.put(c,flyweight);
        }
        return flyweight;
    }
}

Principal

public class Main {
    public static void main(String args[]){
        Flyweight flyweight1 = FlyweightFactory.getFlyweight('a');
        Flyweight flyweight2 = FlyweightFactory.getFlyweight('b');
        Flyweight flyweight3 = FlyweightFactory.getFlyweight('a');// will use the same object that is referenced by flyweight1

        flyweight1.display(1, 2);//'a' displayed at 1,2
        flyweight2.display(3, 4);//'b' displayed at 3,4
        flyweight3.display(5, 7); // 'a'(shared) displayed at 5,7
    }
}

Producción:

[drawing character: a at co-ordinates:(1,2)]
[drawing character: b at co-ordinates:(3,4)]
[drawing character: a at co-ordinates:(5,7)]

Puntos clave

• Eficiencia de la memoria: reduce el uso de memoria al compartir objetos, especialmente cuando el estado intrínseco es grande o hay muchos objetos.
• Mejora del rendimiento: al reducir la cantidad de objetos creados, se puede mejorar el rendimiento de la aplicación al administrar una gran cantidad de objetos.

Desventajas
Complejidad: El patrón puede agregar complejidad al código, especialmente en la gestión de los estados extrínsecos e intrínsecos por separado.
General: si hay pocos objetos para compartir, el patrón Flyweight podría introducir una complejidad innecesaria sin ahorros significativos de memoria.