装饰设计模式，以及和继承的区别？

  装饰模式(Decorator)的定义：又名包装(Wrapper)模式，装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。  装饰模式以对客户端透明的方式动态的给一个对象附加上更多的责任。换言之客户端并不会觉的对象在装饰前和装饰后有什么区别。
装饰模式与类继承的区别：

1)    装饰模式是一种动态行为，对已经存在类进行随意组合，而类的继承是一种静态的行为，一个类定义成什么样的，该类的对象便具有什么样的功能，无法动态的改变。

2)    装饰模式扩展的是对象的功能，不需要增加类的数量，而类继承扩展是类的功能，在继承的关系中，如果我们想增加一个对象的功能，我们只能通过继承关系，在子类中增加两个方法。

3)    装饰与继承比较图：

4)    装饰模式是在不改变原类文件和使用继承的情况下，动态的扩展一个对象的功能，它是通过创建一个包装对象，也就是装饰来包裹真是的对象。

5.    装饰模式把对客户端的调用委派给被装饰的类，装饰模式的关键在于这种扩展完全透明的。

装饰设计模式就是对已有的对象的功能进行增强
如一个简单的demo 人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了,增强了吃饭的功能

1. class Person
   
2. {
   
3.         void chifan()
   
4.         {
   
5.                 System.out.println("chifan");
   
6.         }
   
7. }
   
8. 
   
9. /*
   
10. 为了不随便改变原有的代码。
    
11. 还要增强chifan功能。
    
12. 那么就定义一个类，对原有对象进行装饰。
    
13. */
    
14. class NewPerson
    
15. {
    
16.         private Person p;
    
17.         NewPerson(Person p)
    
18.         {
    
19.                 this.p = p;
    
20.         }
    
21.         public void newChifan()
    
22.         {       
    
23.                 System.out.println("来一杯");
    
24.                 p.chifan();
    
25.                 System.out.println("来一根");
    
26.         }
    
27. }
    
28. 
    
29. class  PersonDemo
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 Person p = new Person();
    
34.                
    
35.                 //NewPerson np = new NewPerson(p);
    
36.                 //np.newChifan();
    
37. 
    
38.                 p.chifan();
    
39.         }
    
40. }

复制代码

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

你应该学习过IO吧，我结合IO来说明一下
装饰模式角色对比：
抽象构件角色（Component）相当于 IntputStream;
具体构件角色（Concretor ）相当于 字节流 FileInputStream
装饰角色     （Decorator）相当于  FilterIntputStream 包装（只是为具体装饰角色提供实现条件）
具体装饰角色  （Concretor Decorator）相当于 BufferedInputStream DateInputStream
装饰模式其实就是为原有的对象赋予更多的功能，而如果使用继承的话，就不知道你要写多少个子类了，这样就会显得很繁琐。

装饰类：
装饰类是对已有对象进行功能的增强，将已有对象作为参数传入，基于已有的功能，并提供加强的功能。装饰类是一种组合结构，和被装饰的类同属一个体系。装饰模式比继承更灵活，避免了继承体系的臃肿，且降低了类与类之间的关系

1. class MyBufferReader extends MyReader
   
2. {
   
3.         private MyReader r;
   
4.         MyBufferReader(MyReader r)
   
5.         {}
   
6. }
   

复制代码

区别：
装饰类是对已有对象进行功能的增强，将已有对象作为参数传入，基于已有的功能，并提供加强的功能。装饰类是一种组合结构，和被装饰的类同属一个体系。装饰模式比继承更灵活，避免了继承体系的臃肿，且降低了类与类之间的关系
继承是当两个事物之间存在一定的所属关系时，可以使用继承，继承的类可以使用被继承类中的功能和属性，提高代码的复用性。让类与类之间产生了关系。但不能为了使用一个类的方法，就任意继承。
联系：
可以说装饰类和被装饰类同继承一个类，是被继承类体系下的子类。

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

1. //穷的时候吃饭简简单单的吃饭
   
2. class Person
   
3. {
   
4.         public void chiFan(){
   
5.        
   
6.                 System.out.println("吃饭");
   
7.         }
   
8. }
   
9. 
   
10. //富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭
    
11. class SuperPerson
    
12. {
    
13.         private Person p;
    
14.         public SuperPerson(Person p){
    
15.        
    
16.                 this.p=p;
    
17.         }
    
18. 
    
19.         public void superChiFan(){
    
20.                 //吃饭前来杯开胃酒增加食量
    
21.                 System.out.println("开胃酒");
    
22.                 p.chiFan();
    
23.                 //吃完饭后来根烟
    
24.                 System.out.println("来根烟");
    
25.         }
    
26. 
    
27. }
    
28. public class PersonDemo
    
29. {        public static void main(String args[]){
    
30.         Person p=new Person();
    
31. 
    
32.         SuperPerson sp= new SuperPerson(p);
    
33. 
    
34.         sp.superChiFan();
    
35.         }
    
36. }

复制代码

上只是简单说明一下，在JAVA IO中用了很多增强 如：FileRead中read()方法 只是一个一个字节去读，为了读得更快在BufferedReader就增强了read()方法而产生了reandLine()一行一行的去读



有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？
装饰是构造函数参数传递进行增强
如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的

例如：你有个对象有个功能 是在N年前建立的，如今你觉得功能不够用了 写个类把对象传进来就可以解决问题了 如果这个功能写错了 我就把自己写的功能去掉又不影响以前的功能灵活性相当强的。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。