设计模式（单例模式，工厂模式，装饰者设计模式，适配器模式）

问个问题：什么是模式？
模式：模式就是解决 一类 问题的固定步骤 。

单例设计模式：保证一个类在内存中只有一个对象。

单例设计模式的步骤：

饿汉单例设计模式
1. 私有化构造函数。
2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
3. 提供一个公共静态的方法获取本类的对象。

懒汉单例设计模式：
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象，
3. 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象
，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
然后再返回。

推荐使用： 饿汉单例设计模式。 因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。

*/
//饿汉单例设计模式 ----> 保证Single在内存中只有一个对象。
class Single{

    //声明本类的引用类型变量，并且使用该变量指向本类对象
    private static  Single s = new Single();

    //私有化构造函数
    private Single(){}

    //提供一个公共静态的方法获取本类的对象
    public  static  Single getInstance(){
        return s;
    }
}

//懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。

class Single2{

    //声明本类的引用类型变量，不创建本类的对象
    private static Single2 s;

    //私有化了构造函数
    private Single2(){}

    //
    public static Single2 getInstance(){
        if(s==null){
            s = new Single2();
        }
        return s;
    }
}

再举一个 栗子：

Runtime r = Runtime.getRuntime();
        r.exec("shutdown -s -t 300");//五分钟后关闭计算机
        r.exec("shutdown -a");//取消操作

总结：
Runtime是可以在一个进程里执行 字符串操作 即 cmd命令

设计模式之工厂模式：
工厂模式又叫静态工厂方法模式
专门定义的一个类用来创造其他实例类 创建的实例类基本拥有一个公共的父类或者接口
**1. 抽象产品
2. 具体产品
3. 工厂角色 负责创建所有类的内部逻辑**

举个例子：

interface Animal {
public abstract void print();
}
class Dog implements Animal {

@Override
public void print() {
    System.out.println("Dog汪汪汪");
}

}

class Cat implements Animal {

@Override
public void print() {
    System.out.println("Cat喵喵");
}

}

class Petfactory {
public static Animal createPet(String name) {
    if ("Cat".equals(name)) {
        return new Cat();
    } else if ("Dog".equals(name)) {
        return new Dog();
    } else {
        return null;
    }
}
}
public class FatherSonMather {

public static void main(String[] args) {
    String name1="Cat";
    String name2="Dog";
    Animal animal1=Petfactory.createPet(name1);
    Animal animal2=Petfactory.createPet(name2);
    animal1.print();
    animal2.print();
}
}

装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰。

BufferedReader 是拓展了FileReader的功能。
BuferedWriter 也是拓展了FileWriter的功能。

需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。

需求2：编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号。

需求3： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号。

增强一个类的单个功能

class BufferedLineNum extends BufferedReader{
    //行号
    int count = 1 ;

    public BufferedLineNum(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line = super.readLine(); 
        if(line ==null){
            return null;
        }
        line = count+" "+ line;
        count++;
        return line;
    }   
}


//带分号的缓冲输入字符流
class BufferedSemi extends BufferedReader{

    public BufferedSemi(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line =  super.readLine();
        if(line==null){
            return null;
        }
        line = line+";";
        return line;
    }
}


//带双引号的缓冲输入字符流
class  BufferedQuto extends BufferedReader{

    public BufferedQuto(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line = super.readLine();
        if(line==null){
            return null;
        }
        line = "\""+line+"\"";
        return line;
    }
}





public class Demo1 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\Demo1.java");
        //建立数据的输入通道
        FileReader fileReader = new FileReader(file);
        //建立带行号的缓冲输入字符流
        BufferedLineNum bufferedLineNum = new BufferedLineNum(fileReader);

        //带有分号的缓冲输入字符流
        BufferedSemi bufferedSemi = new BufferedSemi(fileReader);

        //带有双引号的缓冲输入字符流
        BufferedQuto bufferedQuto = new BufferedQuto(fileReader);


        String line = null;
        while((line = bufferedQuto.readLine())!=null){
            System.out.println(line);
        }

    }

}

装饰类互相装饰
继承实现的增强类：
优点：代码结构清晰，而且实现简单.
缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。

修饰模式实现的增强类：
优点：内部可以通过多态技术对多个需要增强的类进行增强， 可以是这些装饰类达到互相装饰的效果。使用比较灵活。

    缺点：需要内部通过多态技术维护需要被增强的类的实例。进而使得代码稍微复杂。

1. 在装饰类的内部维护一个被装饰类的引用。
2. 让装饰类有一个共同的父类或者是父接口。

//带行号的缓冲输入字符流
class BufferedLineNum2  extends BufferedReader{  

    //在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;

    int count = 1;

    public BufferedLineNum2(BufferedReader bufferedReader){
        super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
        this.bufferedReader = bufferedReader;
    }


    public String readLine() throws IOException{
        String line = bufferedReader.readLine();
        if(line==null){
            return null;
        }
        line = count+" "+line;
        count++;
        return line;
    }
} 


//带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader{  //为什么要继承?  是为了让这些装饰类的对象可以作为参数进行传递，达到互相装饰 的效果。

    //在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;


    public BufferedSemi2(BufferedReader bufferedReader){ // new BuffereLineNum();
        super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException{
        String line = bufferedReader.readLine();  //如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
        if(line==null){
            return null;
        }
        line = line +";";
        return line;
    }

}

//缓冲类带双引号
class BufferedQuto2 extends BufferedReader{

    //在内部维护一个被装饰的类
    BufferedReader bufferedReader;

    public BufferedQuto2(BufferedReader bufferedReader){  //new  BufferedSemi2();
        super(bufferedReader) ; //只是为了让代码不报错..
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException{
        String line = bufferedReader.readLine();  //如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
        if(line==null){
            return null;
        }
        line = "\""+line +"\"";
        return line;
    }


}



public class Demo2 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\Demo1.java");
        FileReader fileReader = new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //建立带行号的缓冲输入字符流
        BufferedLineNum2 bufferedLineNum = new BufferedLineNum2(bufferedReader);

        //带分号的缓冲输入字符流
        BufferedSemi2 bufferedSemi2 = new BufferedSemi2(bufferedLineNum);

        //带双引号的缓冲输入字符流
        BufferedQuto2 bufferedQuto2 = new  BufferedQuto2(bufferedSemi2);

        String line = null;
        while((line = bufferedQuto2.readLine())!=null){
            System.out.println(line);
        }




    }

}

再来个练习：

package other;

/*练习：
    一家三口每个人都会工作，儿子的工作就是画画，母亲的工作就是在儿子的基础上做一个增强，不单止可以画画，还可以上涂料。
    爸爸的工作就是在妈妈基础上做了增强，就是上画框。
*/

interface Work{

    public void work();
}

class Son implements Work{

    @Override
    public void work() {
        System.out.println("画画...");
    }
}


class Mather implements Work{

    //需要被增强的类。
    Work worker;

    public Mather(Work worker){
        this.worker = worker;
    }

    @Override
    public void work() {
        worker.work();
        System.out.println("给画上颜色..");
    }
}


class Father implements Work{

    //需要被增强的类的引用
    Work worker;

    public Father(Work worker){
        this.worker = worker;
    }


    @Override
    public void work() {
        worker.work();
        System.out.println("上画框...");
    }

}


public class Demo3 {

    public static void main(String[] args) {
        Son s = new Son();
//      s.work();
        Mather m = new Mather(s);
//      m.work();
        Father f = new Father(s);
        f.work();


    }
}

适配器模式：
要实现某些接口 但是要实现的方法太多 只用到了一部分 繁琐了 就定义一个中间抽象层 继承实现 接口方法 但是 没有具体代码 再定义一个具体的类 继承抽象层 只需要重写需要的方法就行

public class Demo1_Adapter {
    public static void main(String[] args) {

    }

}

interface 和尚 {
    public void 打坐();
    public void 念经();
    public void 撞钟();
    public void 习武();
}

abstract class 天罡星 implements 和尚 {      //声明成抽象的原因是,不想让其他类创建本类对象,因为创建也没有意义,方法都是空的

    @Override
    public void 打坐() {
    }

    @Override
    public void 念经() {
    }

    @Override
    public void 撞钟() {
    }

    @Override
    public void 习武() {
    }

}

class 鲁智深 extends 天罡星 {
    public void 习武() {
        System.out.println("倒拔垂杨柳");
        System.out.println("拳打镇关西");
        System.out.println("大闹野猪林");
        System.out.println("......");
    }
}