0

当需要打包大量特定类型的对象时，我们使用享元。因为它们共享一个公共数据（内在状态），所以有助于减少内存消耗，并且还拥有自己的状态（外在状态），所有其他对象都不共享。这是一个示例代码

public abstract class Shape {

    private String color;
    private int x;
    private int y;

    public Shape(String color) {
        super();
        this.color = color;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public abstract String draw();

    @Override
    public String toString() {
        return "[color=" + color + ", x=" + x + ", y=" + y + "]";
    }


}


public class Circle extends Shape {

    public Circle(String color) {
        super(color);
    }

    @Override
    public String draw() {
        // TODO Auto-generated method stub
        return "Circle " + toString();
    }

}

import java.util.HashMap;

public class ShapeFactory {

    private static HashMap<String, Shape> circle_map = new HashMap<>();

    public static Shape getCircle(String size){
        if(!circle_map.containsKey(size))
            circle_map.put(size, new Circle(size));

        return circle_map.get(size);
    }

}

和司机

public class ShapeDriver {

    public static void main(String[] args) {

        Shape first_circle = ShapeFactory.getCircle("small");
        first_circle.setX(45);
        first_circle.setY(12);
        Shape second_circle = ShapeFactory.getCircle("small");

        System.out.println("First circle" + first_circle);
        System.out.println("Second circle" + second_circle);

        second_circle.setX(62);
        second_circle.setY(23);

        System.out.println("First circle" + first_circle);
        System.out.println("Second circle" + second_circle);
    }

}

在这个例子中，我希望大小是内在的，坐标（x，y）是外在的，但是当我改变它的坐标时，first_circle它也反映了变化，second_circle因为它们共享一个完整的对象而不仅仅是一个状态。输出如下

First circle[color=small, x=45, y=12]
Second circle[color=small, x=45, y=12]
First circle[color=small, x=62, y=23]
Second circle[color=small, x=62, y=23]

它相当于创建一个对象并将其存储在不同的对象中，但是它们都具有相同的状态或数据，那么它们如何拥有自己的数据（外部状态）？

4

1 回答 1

2

享元对象应该是不可变的。

在您的示例中，您可以在一个单独的类中绝望地重用部分（颜色/大小，您的示例冲突）并将其用作享元。

然后，您将为每个位置实例化一个新 Circle，但重用颜色对象。

public class Color {
     String color;
     public (String color) {
         this.color = color;
     }
     ...
}    

public abstract class Shape {

        private Color color;
        private int x;
        private int y;

        public Shape(Color color) {
            super();
            this.color = color;
        }
        ...    
    }


    public class Circle extends Shape {

        public Circle(Color color) {
            super(Color);
        }

         ...    
    }


    public class ShapeFactory {

        private static HashMap<String, Color> color_map = new HashMap<>();

        public static Shape getCircle(String color){
            if(!color_map.containsKey(color))
                color_map .put(color, new Color(color));

            return new Circle(color_map.get(size));
        }

    }
于 2016-05-04T09:29:10.360 回答