Javaのフライウェイトパターンでメモリ使用量を最適化する方法

// Flyweightインターフェース
interface Flyweight {
    void operation(String extrinsicState);
}

// ConcreteFlyweightクラス
class ConcreteFlyweight implements Flyweight {
    private final String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println("Intrinsic State: " + intrinsicState + ", Extrinsic State: " + extrinsicState);
    }
}

// FlyweightFactoryクラス
class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();

    public Flyweight getFlyweight(String key) {
        if (!flyweights.containsKey(key)) {
            flyweights.put(key, new ConcreteFlyweight(key));
        }
        return flyweights.get(key);
    }
}

// クライアントコード
public class FlyweightPatternDemo {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();

        Flyweight flyweight1 = factory.getFlyweight("A");
        flyweight1.operation("First Call");

        Flyweight flyweight2 = factory.getFlyweight("B");
        flyweight2.operation("Second Call");

        Flyweight flyweight3 = factory.getFlyweight("A");
        flyweight3.operation("Third Call");
    }
}

class Character {
    String appearance; // キャラクターの外見
    int x, y; // 座標

    public Character(String appearance, int x, int y) {
        this.appearance = appearance;
        this.x = x;
        this.y = y;
    }
}

// 1000体のキャラクターを個別に作成
Character[] characters = new Character[1000];
for (int i = 0; i < 1000; i++) {
    characters[i] = new Character("warrior", i, i);
}

class CharacterFlyweight {
    String appearance; // 共有される外見情報

    public CharacterFlyweight(String appearance) {
        this.appearance = appearance;
    }

    public void display(int x, int y) {
        System.out.println("Appearance: " + appearance + " at (" + x + ", " + y + ")");
    }
}

class CharacterFactory {
    private Map<String, CharacterFlyweight> flyweights = new HashMap<>();

    public CharacterFlyweight getFlyweight(String appearance) {
        if (!flyweights.containsKey(appearance)) {
            flyweights.put(appearance, new CharacterFlyweight(appearance));
        }
        return flyweights.get(appearance);
    }
}

// フライウェイトパターンを使用して1000体のキャラクターを作成
CharacterFactory factory = new CharacterFactory();
for (int i = 0; i < 1000; i++) {
    CharacterFlyweight character = factory.getFlyweight("warrior");
    character.display(i, i);
}

// Flyweightインターフェース
interface CharacterFlyweight {
    void display(int x, int y);
}

// ConcreteFlyweightクラス（共有オブジェクト）
class ConcreteCharacterFlyweight implements CharacterFlyweight {
    private final String appearance;  // 共有される外見情報

    public ConcreteCharacterFlyweight(String appearance) {
        this.appearance = appearance;
    }

    @Override
    public void display(int x, int y) {
        System.out.println("Character: " + appearance + " at (" + x + ", " + y + ")");
    }
}

// FlyweightFactoryクラス（Flyweightオブジェクトの管理）
class CharacterFlyweightFactory {
    private Map<String, CharacterFlyweight> flyweights = new HashMap<>();

    // Flyweightオブジェクトを取得
    public CharacterFlyweight getFlyweight(String appearance) {
        if (!flyweights.containsKey(appearance)) {
            flyweights.put(appearance, new ConcreteCharacterFlyweight(appearance));
            System.out.println("New Flyweight created for appearance: " + appearance);
        }
        return flyweights.get(appearance);
    }
}

// クライアントコード
public class FlyweightPatternExample {
    public static void main(String[] args) {
        CharacterFlyweightFactory factory = new CharacterFlyweightFactory();

        // 同じ外見のキャラクターを再利用
        CharacterFlyweight warrior1 = factory.getFlyweight("Warrior");
        warrior1.display(10, 20);

        CharacterFlyweight warrior2 = factory.getFlyweight("Warrior");
        warrior2.display(15, 25);

        CharacterFlyweight mage = factory.getFlyweight("Mage");
        mage.display(30, 40);
    }
}

// フライウェイトオブジェクトとしての画像クラス
class TreeFlyweight {
    private final String treeImage;

    public TreeFlyweight(String image) {
        this.treeImage = image; // 木の画像データ
    }

    public void display(int x, int y, int size) {
        System.out.println("Drawing tree at (" + x + ", " + y + ") with size " + size);
    }
}

// 工場クラスで画像オブジェクトを管理
class TreeFactory {
    private Map<String, TreeFlyweight> treeMap = new HashMap<>();

    public TreeFlyweight getTree(String image) {
        if (!treeMap.containsKey(image)) {
            treeMap.put(image, new TreeFlyweight(image));
            System.out.println("Creating new TreeFlyweight with image: " + image);
        }
        return treeMap.get(image);
    }
}

// クライアント側での使用
public class FlyweightGraphicsExample {
    public static void main(String[] args) {
        TreeFactory factory = new TreeFactory();

        // 同じ木の画像を使って異なる場所に木を描画
        TreeFlyweight tree1 = factory.getTree("oak_tree.png");
        tree1.display(10, 20, 5);

        TreeFlyweight tree2 = factory.getTree("oak_tree.png");
        tree2.display(50, 80, 6);
    }
}

// フライウェイトオブジェクトとしての文字クラス
class CharacterFlyweight {
    private final char character;

    public CharacterFlyweight(char character) {
        this.character = character;
    }

    public void display(int fontSize, String color) {
        System.out.println("Displaying character '" + character + "' in size " + fontSize + " and color " + color);
    }
}

// 工場クラスで文字オブジェクトを管理
class CharacterFactory {
    private Map<Character, CharacterFlyweight> characterMap = new HashMap<>();

    public CharacterFlyweight getCharacter(char character) {
        if (!characterMap.containsKey(character)) {
            characterMap.put(character, new CharacterFlyweight(character));
            System.out.println("Creating new CharacterFlyweight for character: " + character);
        }
        return characterMap.get(character);
    }
}

// クライアント側での使用
public class FlyweightTextExample {
    public static void main(String[] args) {
        CharacterFactory factory = new CharacterFactory();

        // 'A'という文字を異なるフォントサイズや色で表示
        CharacterFlyweight charA1 = factory.getCharacter('A');
        charA1.display(12, "red");

        CharacterFlyweight charA2 = factory.getCharacter('A');
        charA2.display(16, "blue");
    }
}

// 1. CircleFlyweightインターフェースを作成
interface CircleFlyweight {
    void draw(int x, int y); // 座標は非共有
}

// 2. ConcreteCircleFlyweightクラスを作成（色とサイズは共有）
class ConcreteCircleFlyweight implements CircleFlyweight {
    private final String color;   // 共有部分
    private final int radius;     // 共有部分

    public ConcreteCircleFlyweight(String color, int radius) {
        this.color = color;
        this.radius = radius;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("Drawing circle of color " + color + " and radius " + radius + " at (" + x + ", " + y + ")");
    }
}

// 3. CircleFactoryクラスを作成
class CircleFactory {
    private Map<String, CircleFlyweight> circleMap = new HashMap<>();

    public CircleFlyweight getCircle(String color, int radius) {
        String key = color + radius;
        if (!circleMap.containsKey(key)) {
            circleMap.put(key, new ConcreteCircleFlyweight(color, radius));
            System.out.println("Creating new circle with color " + color + " and radius " + radius);
        }
        return circleMap.get(key);
    }
}

// 4. クライアントコードでフライウェイトパターンを使用して円を描画
public class FlyweightCircleExample {
    public static void main(String[] args) {
        CircleFactory factory = new CircleFactory();

        // フライウェイトを利用して円を描画
        CircleFlyweight circle1 = factory.getCircle("red", 10);
        circle1.draw(5, 5);

        CircleFlyweight circle2 = factory.getCircle("red", 10);
        circle2.draw(15, 25);

        CircleFlyweight circle3 = factory.getCircle("blue", 15);
        circle3.draw(30, 40);
    }
}

// 1. CharacterFlyweightインターフェースを作成
interface CharacterFlyweight {
    void display(int x, int y); // 座標は非共有部分
}

// 2. ConcreteCharacterFlyweightクラスを作成（フォント、サイズ、色は共有）
class ConcreteCharacterFlyweight implements CharacterFlyweight {
    private final String font;
    private final int size;
    private final String color;

    public ConcreteCharacterFlyweight(String font, int size, String color) {
        this.font = font;
        this.size = size;
        this.color = color;
    }

    @Override
    public void display(int x, int y) {
        System.out.println("Displaying character with font " + font + ", size " + size + ", color " + color + " at (" + x + ", " + y + ")");
    }
}

// 3. CharacterFactoryクラスを作成
class CharacterFactory {
    private Map<String, CharacterFlyweight> characterMap = new HashMap<>();

    public CharacterFlyweight getCharacter(String font, int size, String color) {
        String key = font + size + color;
        if (!characterMap.containsKey(key)) {
            characterMap.put(key, new ConcreteCharacterFlyweight(font, size, color));
            System.out.println("Creating new character with font " + font + ", size " + size + ", color " + color);
        }
        return characterMap.get(key);
    }
}

// 4. クライアントコードでフライウェイトパターンを使用して文字を描画
public class FlyweightTextExample {
    public static void main(String[] args) {
        CharacterFactory factory = new CharacterFactory();

        // フライウェイトを利用して文字を表示
        CharacterFlyweight charA = factory.getCharacter("Arial", 12, "black");
        charA.display(10, 20);

        CharacterFlyweight charB = factory.getCharacter("Arial", 12, "black");
        charB.display(30, 40);

        CharacterFlyweight charC = factory.getCharacter("Courier", 14, "blue");
        charC.display(50, 60);
    }
}