GOF23的一些总结（十二）

享元模式：相同或者相似对象，内存中只存一份。极大的节约资源，提高系统性能。
为了节省内存，共享内部状态，分离出了外部状态。用时间换取了空间。
享元模式的几个类
棋子类欲实现的功能类

    package com.baidu.co;
/**
 * 棋子（享元模式）
 * 
 * @author Administrator
 *
 */
public interface Chess {
    void setColor(String c);
    String getColor();
    void display(Coordinate c);
}

实现棋子的功能类

    class ConcreateChess implements Chess{

        private String color;

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

        @Override
        public void setColor(String c) {
            this.color=c;
        }

        @Override
        public String getColor() {
            return color;
        }

        @Override
        public void display(Coordinate c) {
            System.out.println("棋子颜色："+color);
            System.out.println("棋子位置："+c.getX()+"---"+c.getY());
        }
    }

外部状态

    package com.baidu.co;
    /**
     * 坐标类
     * @author Administrator
     *
     */
    public class Coordinate {
        private int x,y;

        public Coordinate(int x, int y) {
            super();
            this.x = x;
            this.y = y;
        }

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

享元池

    package com.baidu.co;

    import java.util.HashMap;
    import java.util.Map;

    /**
     * 享元工厂类
     * @author Administrator
     *
     */
    public class ChessFlyWeightFactory {
        //享元池
        private static Map<String,Chess> map =new HashMap<String,Chess>();

        public static Chess getChess(String color){
            if(null!=map.get(color)){
                return map.get(color);
            }else{
                Chess che=new ConcreateChess(color);
                map.put(color, che);
                return che;
            }
        }
    }

测试类

    package com.baidu.co;
    /**
     * 享元模式应用的场景
     * 内存属于稀缺资源，不要随便浪费。如果有很多个相同的或相似的对象，我们通过享元模式，节省内存。
     * 享元模式以共享的方式高效的支持大量细粒度对象的重用。
     * 享元对象能做到共享的关键是区分了内部状态或外部状态。
     * 内部状态：可以共享，不会随环境变化而改变。
     * 外部状态：不可以共享，会随着环境变化而改变。
     * @author Administrator
     */
    public class Client {

        /**
         * @param args
         */
        public static void main(String[] args) {
            Chess ch1=ChessFlyWeightFactory.getChess("black");
            Chess ch2=ChessFlyWeightFactory.getChess("black");
            Chess ch3=ChessFlyWeightFactory.getChess("black");
            System.out.println(ch1);
            System.out.println(ch2);
            System.out.println(ch3);
            System.out.println("增加外部处理状态+++++");
            ch1.display(new Coordinate(10,10));
            ch2.display(new Coordinate(20,20));
            ch3.display(new Coordinate(30,30));
        }
    }