Um dos padrões estruturais visa reduzir o uso de memória compartilhando o máximo de dados possível com objetos semelhantes.
É particularmente útil ao lidar com um grande número de objetos semelhantes, onde criar uma nova instância para cada objeto seria caro em termos de consumo de memória.
conceitos-chave:
Estado intrínseco: o estado compartilhado entre vários objetos é independente do contexto e permanece o mesmo em diferentes objetos.
Estado extrínseco: O estado exclusivo de cada objeto e transmitido pelo cliente. Este estado pode variar e não é armazenado no objeto Flyweight

Principais participantes:

Flyweight: Interface para que o objeto Flyweight receba o estado Extrínseco e utilize-o.
ConcreteFlyweight: Implementa o Flyweight e armazena o estado intrínseco.
FlyweightFactory: Gerencia os objetos Flyweight e garante o compartilhamento de interfaces, retorna um Flyweight existente caso já exista.

Cliente (como a classe Principal): Mantém uma referência ao Flyweight e fornece o estado Extrínseco quando precisa interagir com o objeto Flyweight.

Vamos dar um exemplo de um objeto de personagem Flyweight
Suponha que temos um editor de texto que precisa renderizar uma grande quantidade de texto. Cada personagem pode ser representado como um objeto, mas ter um objeto separado para cada personagem desperdiçaria muita memória. Em vez disso, podemos usar Flyweights para compartilhar os objetos de caracteres que representam cada letra e armazenar o estado extrínseco como a posição ou formatação externa

Peso mosca

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

ConcreteFlyweight

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
    }
}

Saída:

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

Pontos-chave

• Eficiência de memória: reduz o uso de memória compartilhando objetos, especialmente quando o estado intrínseco é grande ou há muitos objetos.
• Melhoria de desempenho: Reduzindo o número de objetos criados, pode melhorar o desempenho do aplicativo ao gerenciar um grande número de objetos.

Desvantagens
Complexidade: O padrão pode adicionar complexidade ao código, especialmente no gerenciamento dos estados extrínseco e intrínseco separadamente.
Overhead: Se houver poucos objetos para compartilhar, o padrão Flyweight pode introduzir complexidade desnecessária sem economia significativa de memória.