Java _模式

模式
    装饰设计模式
            当想要对已有的对象进行功能增强时，
            可以定义类，将已有对象传入，基于已有的功能，提供加强功能，
            那么自定义的该类称为装饰类
            装饰类通常会通过构造方法，接收被装饰的对象
            并基于对象的功能，提供更强的功能
        装饰模式比继承要灵活,避免了继承体系的臃肿，降低了类与类之间的关系
        例子
            MyReader
            |--MyTextReader
            |--MyDataReader
            -----------------------------
            使用继承增强：
            MyReader
                |--MyTextReader
                    |--MyBufferTextReader
                |--MyDataReader
                    |--MyBufferDataReader
            ------------------------------
            使用装饰增强：
            class MyBuffer extents MyReader{
                MyBufferReader(MyReader){}}        //可以传入MyReader的所有子类
            MyReader
                |--MyTextReader
                |--MyDataReader
                |--MyBufferReader

-------------------------------------------2014-11-12

　　在java之装饰设计模式和继承的简单区别 看到了更好的解释   

　　例子:  人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了增强了吃饭的功能

//穷的时候吃饭简简单单的吃饭
class Person
{
    public void chiFan(){
    
        System.out.println("吃饭");
    }
}

//富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭
class SuperPerson
{
    private Person p;
    public SuperPerson(Person p){
    
        this.p=p;
    }

    public void superChiFan(){
        //吃饭前来杯开胃酒增加食量
        System.out.println("开胃酒");
        p.chiFan();
        //吃完饭后来根烟
        System.out.println("来根烟");
    }

}
public class PersonDemo
{    public static void main(String args[]){
    Person p=new Person();

    SuperPerson sp= new SuperPerson(p);

    sp.superChiFan();
    }
}

有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？

装饰是构造函数参数传递进行增强

如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的

 

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

 

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

-------------------------------------------------------

单例模式Singleton
a. 只能有一个实例
b. 实例必须由单例类自己创建,自己new
c. 所有对象共享这一个实例

    饿汉式
    class Single
    {
        private Single(){}           //构造函数私有化
        private static Single s =new Single();       //创建私有化,静态类
        public static Single getInstance(){           //公开静态类返回函数
            return s;
        }
    }
    懒汉式
　　基础的:

     private static Student student = null；  //不建立对象
     Student getInstance(){
             if(student == null) {        //先判断是否为空
                student = new Student();  //懒汉式做法 
             }
             return student；
     }

　　加强后的:
    class Single{
        private Single(){}
        private static Single s = null;
        public static Single getInstance(){
            if(s==null){
                synchronized(Single.class){
                    if(s==null)
                        s == new Single();    
                }
            }
            return s;
        }
    }

 

比较:

　　 　饿汉式在虚拟机启动的时候就会创建对象,而懒汉式是在类加载的时候创建对象,
         饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
         懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
         推荐使用第一种