大话设计模式-----(十一)享元模式、解释器模式、访问者模式

小鱼儿 2022-06-18 09:49 158阅读 0赞

## 享元模式 ##

运用共享技术有效地鸡翅大量细粒度的对象  
就是说有很多重复的东西，就一起用了。不要在单独创建了。不同的就传入参数就好了

抽象Flyweight类

//抽象Flyweight类
    
    abstract class Flyweight{
    
        public abstract void Operation(int extrinsicstate);
    }

两个继承实现

//继承Flyweight
    
    class ConcreteFlyweight extends Flyweight{ 
    
        @Override
        public void Operation(int extrinsicstate) {
            // TODO Auto-generated method stub
            System.out.println("具体Flyweight:"+extrinsicstate);
        }
    
    }
    
    class UnsharedConcreteFlyweight extends Flyweight{ 
    
        @Override
        public void Operation(int extrinsicstate) {
            // TODO Auto-generated method stub
            System.out.println("不共享的具体Flyweight:"+extrinsicstate);
        }
    
    }

工厂，用来创建的。没有就创建，有就返回

//FlyweightFactory工厂
    
    
    
    class FlyweightFactory{
        private Map<String, Flyweight> flyMap = new HashMap(); 
    
        public FlyweightFactory(){
            flyMap.put("x", new ConcreteFlyweight());
            flyMap.put("y", new ConcreteFlyweight());
            flyMap.put("z", new ConcreteFlyweight());
    
        }
        public Flyweight GetFlyweight(String key){
            return (Flyweight)flyMap.get(key);
        }
    
    
    }

客户端

public static void main(String[] args) {
        int extrinsicstate = 22;
        FlyweightFactory f = new FlyweightFactory();
    
        Flyweight fx = f.GetFlyweight("x");
        fx.Operation(--extrinsicstate);
    
        Flyweight fy = f.GetFlyweight("y");
        fx.Operation(--extrinsicstate);
    
    
        Flyweight fz = f.GetFlyweight("z");
        fx.Operation(--extrinsicstate); 
    
    
        Flyweight uFlyweight = new UnsharedConcreteFlyweight();
        uFlyweight.Operation(--extrinsicstate);
    
        }

![这里写图片描述][SouthEast]

实例

就是做网站的例子

//网站抽象类
    
    abstract class WebSite{ 
        public abstract void Use(User user);
    }

//具体网站类
    
    class ConcreteWebSite extends WebSite{ 
        public String nameString="";
        public ConcreteWebSite(String name){
            this.nameString = name;
        }
    
        @Override
        public void Use(User user) {
            // TODO Auto-generated method stub
            System.out.println("网站分类:"+nameString+"用户:"+user.nameString);
        }
    
    
    }

他们不同的是User

class User{
        public String nameString;
    
        public User(String nameString){
            this.nameString = nameString;
        }
    
    }

//网站工厂类
    
    class WebSiteFactory{
        private Map<String, WebSite> webMap = new HashMap<String, WebSite>();
    
        //获得网站分类
        public WebSite GetWebSiteCategory(String key){
            if(!webMap.containsKey(key)){
                //判断集合map是否有，没有就创建，有就直接返回
                webMap.put(key, new ConcreteWebSite(key));
            }
            return (WebSite)webMap.get(key);
        }
        //获得网站分类总数
    
        public int GetWebSiteCount(){
            return webMap.size();
        }
    
    
    }

客户端

public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            WebSiteFactory f = new WebSiteFactory();
    
            WebSite fx = f.GetWebSiteCategory("产品展示");
            fx.Use(new User("小菜"));
    
            WebSite fy = f.GetWebSiteCategory("产品展示");
            fx.Use(new User("大鸟"));
    
            WebSite fz = f.GetWebSiteCategory("产品展示");
            fx.Use(new User("妹子"));
    
            WebSite fl = f.GetWebSiteCategory("博客");
            fx.Use(new User("有大JJ的妹子"));
    
            WebSite fm = f.GetWebSiteCategory("博客");
            fx.Use(new User("Recar"));
            System.out.println("得到的网站总数为:"+f.GetWebSiteCount());
        }

![这里写图片描述][SouthEast 1]

实际上就创建了两个网站实例，不同的是传入的参数。

解释器模式用的比较少。我贴些参考（滑稽）  
应用实例 正则表达式  
[http://blog.csdn.net/chenhuade85/article/details/8147003][http_blog.csdn.net_chenhuade85_article_details_8147003]  
[http://www.cnblogs.com/itTeacher/archive/2012/12/12/2814437.html][http_www.cnblogs.com_itTeacher_archive_2012_12_12_2814437.html]  
[http://www.runoob.com/design-pattern/interpreter-pattern.html][http_www.runoob.com_design-pattern_interpreter-pattern.html]

## 访问者模式 ##

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

访问者的目的是要把处理从数据结构分离出来。  
优点：增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。  
缺点：使增加新的数据结构变得困难。  
嗯，用的也比较少

//抽象类，为该对象结构中ConcreteElement的每一个类声明一个访问者操作
    abstract class Visitor{
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    
    }

//具体访问者
    
    class ConcreteVistor1 extends Visitor{ 
    
        @Override
        public void VisitConcreteElementA(ConcreteElementA concreteElementA) {
            // TODO Auto-generated method stub
            System.out.println("A被1访问");
        }
    
        @Override
        public void VisitConcreteElementB(ConcreteElementB concreteElementB) {
            // TODO Auto-generated method stub
            System.out.println("B被1访问");
        }
    
    
    }
    
    class ConcreteVistor2 extends Visitor{ 
    
        @Override
        public void VisitConcreteElementA(ConcreteElementA concreteElementA) {
            // TODO Auto-generated method stub
            System.out.println("A被2访问");
        }
    
        @Override
        public void VisitConcreteElementB(ConcreteElementB concreteElementB) {
            // TODO Auto-generated method stub
            System.out.println("B被2访问");
        }   
    }

//Element类，定义一个Accept操作，它以一个访问者参数
    
    abstract class Element{
        public abstract void Accept(Visitor visitor);
    }

//具体元素
    
    class ConcreteElementA extends Element{ 
    
        @Override
        public void Accept(Visitor visitor) {
            // TODO Auto-generated method stub
            visitor.VisitConcreteElementA(this);
        }
        public void OperationA(){
            //其他方法}
        }
    
    }
    
    
    class ConcreteElementB extends Element{ 
    
        @Override
        public void Accept(Visitor visitor) {
            // TODO Auto-generated method stub
            visitor.VisitConcreteElementB(this);
        }
        public void OperationB(){
            //其他方法}
        }
    
    }

//ObjectStructure类，能枚举它的元素，可以提供一个高层的接口允许访问者访问他的元素
    
    class ObjectStructure{
        private ArrayList<Element> elements =  new ArrayList<Element>();
        public void Attach(Element element){
            elements.add(element);
        }
        public void Detach(Element element){
            elements.remove(element);
        }
    
        public void Accept(Visitor visitor){
            for(Element element :elements){
                element.Accept(visitor);
            }
        }
    
    }

public static void main(String[] args) {
            // TODO Auto-generated method stub
                ObjectStructure objectStructure = new ObjectStructure();
                objectStructure.Attach(new ConcreteElementA());
                objectStructure.Attach(new ConcreteElementB());
    
                ConcreteVistor1 vistor1 = new ConcreteVistor1();
                ConcreteVistor2 vistor2 = new ConcreteVistor2();
    
                objectStructure.Accept(vistor1);
                objectStructure.Accept(vistor2);
    
    
        }

![这里写图片描述][SouthEast 2]

初学设计模式，若有错误望指出来。

[SouthEast]: /images/20220618/88c895cb1a2f4f508da179010c67430b.png
[SouthEast 1]: /images/20220618/2acb721aa04b43b79e0531255030b2a8.png
[http_blog.csdn.net_chenhuade85_article_details_8147003]: http://blog.csdn.net/chenhuade85/article/details/8147003
[http_www.cnblogs.com_itTeacher_archive_2012_12_12_2814437.html]: http://www.cnblogs.com/itTeacher/archive/2012/12/12/2814437.html
[http_www.runoob.com_design-pattern_interpreter-pattern.html]: http://www.runoob.com/design-pattern/interpreter-pattern.html
[SouthEast 2]: /images/20220618/8ce7607160434d26992ecdd2dff5f3ef.png