访问者模式

是我没有理解正确仍是？这个模式为何要单独出来。不就是状态模式的广度增长版而已嘛？

我的感受很是少的合适的场景。看状态模式就行了。同样的思想。

多个状态的状态模式 =》多个元素须要分别处理状态=》多个元素须要有各自的操做=》访问者模式。

//又是一个貌似看懂结构，但没法理解的模式。
//根据以前的经验，例子很是重要，状态模式也是没法理解，作一个合适的例子，立刻理解。恩。看定义，搞清正确场合，制定正确例子。
//Represent an operation to be performed on the elements of an object structure.
//Visitor lets you define a new operation without changing the classes of the elements on which it operates.
//表示做用于某结构全部元素的一个操做，它能够在不改变数据结构的前提下定义做用于这些元素的新的操做。
//fk,不能理解英文，中文本身感受确定是直译。会对本质含义存在点不破的可能。再找一个解释吧。
//将做用于某种数据结构中的各元素的操做分离出来封装成独立的类，使其在不改变数据结构的前提下能够添加做用于这些元素的新的操做，
//为数据结构中的每一个元素提供多种访问方式。它将对数据的操做与数据结构进行分离，是行为类模式中最复杂的一种模式。
//意思是说，某类的数据不变，可是须要增长新的操做，做用于这些数据。请设计出一个模式。
//忽然想到以前作的我的基因检测，一我的的基因数据是基本不变，稳定的。可是给不一样的团队，不一样的研究方向，会得出各自领域的数据和结论。
//预感这个例子会失败。
//失败，没有理解访问者模式的定义。中文翻译，竟然也看不懂。作完了例子。一点不像访问者模式。并且没有发现有任何须要改进的地方。
//若是须要增长新的研究机构，直接新设立类就能够啊。没问题啊。。。
//看了一个解释。原来改变的不是研究所。而是研究所的研究方法。。。。
//这里：if(item.minfo1==1)若是研究方法须要改变。那么analyze,就须要改变了。感受有戏。
//命令模式，也是这样，把方法踢出来，并包含一个执行方法的主体。组成一个类，就变成了命令模式。
//状态模式，一样，把判断的分支，加上执行主体，组成一个类，就变成了状态模式。
//莫非这里，把判断的分支，加上执行的主体，组成一个类。就变成了访问者模式？
//比较无言的一种模式，
// 1.首先被访问者的数据是固定的，一个或多个均可以，不必定要是集合。我的感受若是只有一个元素，那就是状态模式啊。
//2.数据固定，可是对数据的的信息的处理会常常变更。因此if else ，违法了开闭原则，要像状态模式同样，放到一个类里面。
//3.由于是有多个元素，每一个元素，都有至少一个处理类，我的感受就是 多个状态下的的状态模式。
//绝对是很是少的合适的场景。并且也没有必要去看。看状态模式就行了。同样的思想。
public class Visister
{

    public void Run()
    {
        GeneLibrary linson=new GeneLibrary(Linsongene());


        SkinColorStudio skinColorStudio=new SkinColorStudio();
        HairStudio hairStudio=new HairStudio();

        LSComponentsHelper.LS_Log.Log_INFO(skinColorStudio.analyze(linson));
        LSComponentsHelper.LS_Log.Log_INFO(hairStudio.analyze(linson));
    }

    public void Run2()
    {
        GeneLibrary linson=new GeneLibrary(Linsongene());


        SkinColorStudioV2 skinColorStudioV2=new SkinColorStudioV2();

        LSComponentsHelper.LS_Log.Log_INFO(skinColorStudioV2.analyze(linson));
    }


    //region  初版，开始没看出来须要升级的地方。后来看解释，变化的是访问元素的方法，会常常变更。
    public List<GeneItem> Linsongene()
    {
        List<GeneItem> ret=new LinkedList<>();
        GeneItem temp=new GeneItem(1, 3, "ok");
        GeneItem temp2=new GeneItem(1, -2, "ok");
        GeneItem temp3=new GeneItem(2, 2, "ok");
        GeneItem temp4=new GeneItem(2, 1, "ok");

        ret.add(temp);
        ret.add(temp2);
        ret.add(temp3);
        ret.add(temp4);

        return  ret;
    }

    public class GeneItem
    {
        public int minfo1;
        public int minfo2;
        public String minfo3;
        public GeneItem (int i,int i2,String i3)
        {
            minfo1=i;
            minfo2=i2;
            minfo3=i3;
        }
    }
    public class GeneLibrary
    {
        public List<GeneItem> mGeneItems;
        public GeneLibrary(List<GeneItem> geneItems)
        {
            mGeneItems=geneItems;
        }
    }

    public interface IStuido
    {
        public String analyze(GeneLibrary geneLibrary);
    }

    public class SkinColorStudio implements IStuido
    {
        @Override
        public String analyze(GeneLibrary geneLibrary)
        {
            int res=0;
            for(GeneItem item :geneLibrary.mGeneItems)
            {
                if(item.minfo1==1)
                {
                    //LSComponentsHelper.LS_Log.Log_INFO(item.minfo2+"");
                    res+=item.minfo2;
                }
                else
                {
                    //LSComponentsHelper.LS_Log.Log_INFO(item.minfo2+"");
                    res-=item.minfo2;
                }
            }
            if(res<=0)
            {
                return  "your sikn is yellow"+res;
            }
            else
            {
                return "your skin is black"+res;
            }
        }
    }

    public class HairStudio implements IStuido
    {
        @Override
        public String analyze(GeneLibrary geneLibrary)
        {
            int res=0;
            for(GeneItem item :geneLibrary.mGeneItems)
            {
                if(item.minfo1==2)
                {
                    res+=item.minfo2;
                }
                else
                {
                    res-=item.minfo2;
                }
            }
            if(res>=0)
            {
                return  "your will be drop you hair in middle"+res;
            }
            else
            {
                return "congratulation ,you will have a good hair in your life!"+res;
            }
        }
    }

    //endregion
    public abstract class AnlyzeItem
    {
        protected GeneItem mGeneItem;
        public AnlyzeItem(GeneItem geneItem)
        {
            mGeneItem=geneItem;
        }
        public abstract int checkME();
    }
    public class SkinAnlyzeItem1v1 extends AnlyzeItem
    {
        public SkinAnlyzeItem1v1(GeneItem geneItem)
        {
            super(geneItem);
        }

        @Override
        public int checkME()
        {
            if(mGeneItem.minfo1==1)
            {
                return mGeneItem.minfo2;
            }
            else
            {
                return -mGeneItem.minfo2;
            }
        }
    }

    public class SkinAnlyzeItem2v1 extends AnlyzeItem
    {
        public SkinAnlyzeItem2v1(GeneItem geneItem)
        {
            super(geneItem);
        }

        @Override
        public int checkME()
        {
            if(mGeneItem.minfo1==1)
            {
                return mGeneItem.minfo2;
            }
            else
            {
                return -mGeneItem.minfo2;
            }
        }
    }

    public class SkinAnlyzeItem3v1 extends AnlyzeItem
    {
        public SkinAnlyzeItem3v1(GeneItem geneItem)
        {
            super(geneItem);
        }

        @Override
        public int checkME()
        {
            if(mGeneItem.minfo1==1)
            {
                return mGeneItem.minfo2;
            }
            else
            {
                return -mGeneItem.minfo2;
            }
        }
    }

    public class SkinAnlyzeItem4v1 extends AnlyzeItem
    {
        public SkinAnlyzeItem4v1(GeneItem geneItem)
        {
            super(geneItem);
        }

        @Override
        public int checkME()
        {
            if(mGeneItem.minfo1==1)
            {
                return mGeneItem.minfo2;
            }
            else
            {
                return -mGeneItem.minfo2;
            }
        }
    }



    public class SkinColorStudioV2 implements IStuido
    {
        @Override
        public String analyze(GeneLibrary geneLibrary)
        {
            int res=0;
            int index=0;
            //这里仍是有if，可是注意假设，访问者模式是假设数据不变的。因此这里的if结构是不会在变的。就4个元素。
            //变化的是具体方法。因此把方法踢倒一个类里面。而且把元素也给他。
            for(GeneItem item :geneLibrary.mGeneItems)
            {
                if(index==0)
                {
                    SkinAnlyzeItem1v1 skinAnlyzeItem1v1=new SkinAnlyzeItem1v1(item);
                    res+=skinAnlyzeItem1v1.checkME();
                }
                else if(index==1)
                {
                    SkinAnlyzeItem2v1 skinAnlyzeItem2v1=new SkinAnlyzeItem2v1(item);
                    res+=skinAnlyzeItem2v1.checkME();
                }
                else if(index==2)
                {
                    SkinAnlyzeItem3v1 skinAnlyzeItem3v1=new SkinAnlyzeItem3v1(item);
                    res+=skinAnlyzeItem3v1.checkME();
                }
                else if(index==3)
                {
                    SkinAnlyzeItem4v1 skinAnlyzeItem4v1=new SkinAnlyzeItem4v1(item);
                    res+=skinAnlyzeItem4v1.checkME();
                }
                index++;
            }
            if(res<=0)
            {
                return  "your sikn is yellow:"+res;
            }
            else
            {
                return "your skin is black"+res;
            }
        }
    }
    //region

    //endregion
}