设计模式学习第十六天

public class Person {

    private String name;

    

    public Person() {}

    public Person(String name) {

      this.name = name;

    }

    

    public void show() {

      System.out.println("装扮的" + name);

    }

}

public  class Finery extends Person {

    

    protected Person component;

    public void decorate(Person component) {

     this.component = component;

    }

    

     public void show() {

       if(component != null) {

           component.show();

       }

     }  

}

public class LeatherShoes extends Finery {

    @Override

    public void show() {

         System.out.println("皮鞋");

         super.show();

    }

    

}

public class Sneakers extends Finery {

    @Override

    public void show() {

      System.out.println("破球鞋");

      super.show();

    }

    

}

public class Suit extends Finery {

    @Override

    public void show() {

      System.out.println("西装");

      super.show();

    }

    

}

public class Tie extends Finery {

    @Override

    public void show() {

        System.out.println("领带");

        super.show();

    }

    

}

public class Tshirt extends Finery {

    @Override

    public void show() {

       System.out.println("大T恤");

       super.show();

    }

    

}

public class Ttrouser extends Finery {

    @Override

    public void show() {

         System.out.println("垮裤");

         super.show();

    }

    

}

public class Customer {

    

    public static void main(String[] args) {

    Person ld = new Person("老大");

    System.out.println("装扮：");

    Finery dtk = new Tshirt();

    Finery kk = new Ttrouser();

    Finery pqx = new Sneakers();

    

    pqx.decorate(ld);

    kk.decorate(pqx);

    dtk.decorate(kk);

    dtk.show();

    }

}

装饰模式其实就是一种特殊情况的模拟，一种模式。装饰模式的要素一个就是共同的接口。只有共同的接口，那么在同一的装饰类中才可以有一个统一的引用，因为这个引用是最高接口，所以下面的所有子类都可以利用这个父类指向子类的方式来进行调用各个来自最顶端接口的各个子类，到达装饰的目的。装饰其实就是装配的过程。先执行自己的函数，再传过去另一个参数给父类，父类就是装配类，装饰类通过传过来的参数再装配下一个子类，一级一级装配下去，就所谓的装饰模式。这个模式适用于特定的情形。由于该装配函数调用的是最高接口，所以来自最高接口的所有子类都可以通过该装配类来一个一个所谓的添加职能。

装饰模式仅是一种模式，限于特定情况适用。

---------代理模式例子

public class SchoolGirl {

    

    private String name;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    } 

    

}

public  interface GiveGift {

    public void giveDolls();

    public void giveFlowers();

    public void giveChocolate();

}

public class Persuit implements GiveGift {

    

    private SchoolGirl mm;

    public Persuit(SchoolGirl mm) {

        this.mm = mm;

    }    

    

    @Override

    public void giveDolls() {

        System.out.println(mm.getName()+ "送你洋娃娃！");

    }

    @Override

    public void giveFlowers() {

        System.out.println(mm.getName() + "送你鲜花！");

    }

    @Override

    public void giveChocolate() {

        System.out.println(mm.getName() + "送你巧克力！");

    }

    

}

public class Proxy implements GiveGift {

    Persuit ld;

    

    public Proxy(SchoolGirl mm) {

      ld = new Persuit(mm);

    }

    

    @Override

    public void giveDolls() {

       ld.giveDolls();

    }

    @Override

    public void giveFlowers() {

      ld.giveFlowers();

    }

    @Override

    public void giveChocolate() {

       ld.giveChocolate();

    }

    

}

public class SchoolGirl {

    

    private String name;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    } 

    

}

public class Customer {

    public static void main(String[] args) {

     SchoolGirl mm = new SchoolGirl();

     mm.setName("红英");

     

     Proxy dl = new Proxy(mm);

     dl.giveChocolate();

     dl.giveDolls();

     dl.giveFlowers();

     

    }

}

代理模式其实是个很搞的模式，其实就是共同接口的两个类，一个为主类，就是被引用的类，也是被代理的类；一个为副类，也就是代理类。两个类都实现统一接口，但是主类是真正实现接口，是干活的；副类是吃干饭的，它偷工取巧，取了主类一个引用，各个方法的实现是利用主类的引用，调用主类的方法来实现各个接口。所以代理类就是保存了一个主类的引用。当代理类生成或者实例化的时候，其实代理类内部实例化了一个真正的被代理类。实例化代理类和实例化被代理类一样。