设计模式

设计模式的几个要素
    名字      必须有一个简单，有意义的名字
    问题      描述在何时使用模式
    解决方案   描述设计的组成部分以及如何解决问题
    效果      描述模式的效果以及优缺点
设计模式的分类
    创建型模式   对象的创建
    结构型模式   对象的组成(结构)
    行为型模式   对象的行为

创建型模式：简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式。(6个)
结构型模式：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)
行为型模式：模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

简单工厂模式概述

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

优点
    客户端不需要在负责对象的创建，从而明确了各个类的职责
缺点
    这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

动物抽象类：public abstract Animal { public abstract void eat(); }
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
public class AnimalFactory {
    private AnimalFactory(){}

    //public static Dog createDog() {return new Dog();}
    //public static Cat createCat() {return new Cat();}

    //改进
    public static Animal createAnimal(String animalName) {
        if(“dog”.equals(animalName)) {}
        else if(“cat”.equals(animale)) {

        }else {
            return null;
        }
    }
} 

工厂方法模式概述

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点
    客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
缺点
    需要额外的编写代码，增加了工作量

动物抽象类：public abstract Animal { public abstract void eat(); }
工厂接口：public interface Factory {public abstract Animal createAnimal();}
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}

开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。

狗工厂：public class DogFactory implements Factory {
    public Animal createAnimal() {…}
        }
猫工厂：public class CatFactory implements Factory {
    public Animal createAnimal() {…}
        }

单例设计模式概述

单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
优点
    在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
缺点
    没有抽象层，因此扩展很难。
    职责过重，在一定程序上违背了单一职责


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

  如何保证类在内存中只有一个对象呢?
        A：把构造方法私有
        B:在成员位置自己创建一个对象
        C:通过一个公共的方法提供访问

  单例模式：
        饿汉式：类一加载就创建对象
        懒汉式：用的时候，才去创建对象

  面试题：单例模式的思想是什么?请写一个代码体现。

        开发：饿汉式(是不会出问题的单例模式)
        面试：懒汉式(可能会出问题的单例模式)
            A:懒加载(延迟加载) 
            B:线程安全问题
                a:是否多线程环境   是
                b:是否有共享数据   是
                c:是否有多条语句操作共享数据     是

饿汉式

package cn.itcast_03;

public class Student {
    // 构造私有
    private Student() {
    }

    // 自己造一个
    // 静态方法只能访问静态成员变量，加静态
    // 为了不让外界直接访问修改这个值，加private
    private static Student s = new Student();

    // 提供公共的访问方式
    // 为了保证外界能够直接使用该方法，加静态
    public static Student getStudent() {
        return s;
    }
}

package cn.itcast_03;

public class StudentDemo {
    public static void main(String[] args) {
        // Student s1 = new Student();
        // Student s2 = new Student();
        // System.out.println(s1 == s2); // false

        // 通过单例如何得到对象呢?

        // Student.s = null;

        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1 == s2);

        System.out.println(s1); // null，cn.itcast_03.Student@175078b
        System.out.println(s2);// null，cn.itcast_03.Student@175078b
    }
}

懒汉式

package cn.itcast_03;

public class Teacher {
    private Teacher() {
    }

    private static Teacher t = null;

    public synchronized static Teacher getTeacher() {
        // t1,t2,t3
        if (t == null) {
            //t1,t2,t3
            t = new Teacher();
        }
        return t;
    }
}

package cn.itcast_03;

public class TeacherDemo {
    public static void main(String[] args) {
        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();
        System.out.println(t1 == t2);
        System.out.println(t1); // cn.itcast_03.Teacher@175078b
        System.out.println(t2);// cn.itcast_03.Teacher@175078b
    }
}

Rnutime

package cn.itcast_03;

import java.io.IOException;

/*
 * Runtime:每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
 * exec(String command)
 */
public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();
//      r.exec("winmine");
        // r.exec("notepad");
        // r.exec("calc");
//      r.exec("shutdown -s -t 10000");
        r.exec("shutdown -a");
    }
}

/*
 * class Runtime {
 *      private Runtime() {}
 *      private static Runtime currentRuntime = new Runtime();
 *      public static Runtime getRuntime() {
 *          return currentRuntime;
 *      }
 * }
 */

模版设计模式概述

模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

    优点
        使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
    缺点
        如果算法骨架有修改的话，则需要修改抽象类

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public abstract class GetTime {
    // 需求：请给我计算出一段代码的运行时间
    public long getTime() {
        long start = System.currentTimeMillis();

        code();

        long end = System.currentTimeMillis();

        return end - start;
    }

    public abstract void code();
}

package cn.itcast_01;

public class ForDemo extends GetTime {

    @Override
    public void code() {
        for (int x = 0; x < 100000; x++) {
            System.out.println(x);
        }
    }

}

装饰设计模式概述

装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案

    优点
        使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能
    缺点
        正因为可以随意组合，所以就可能出现一些不合理的逻辑

package cn.itcast_02;

public interface Phone {
    public abstract void call();
}

package cn.itcast_02;

public class IPhone implements Phone {

    @Override
    public void call() {
        System.out.println("手机可以打电话了");
    }

}

package cn.itcast_02;

public abstract class PhoneDecorate implements Phone {

    private Phone p;

    public PhoneDecorate(Phone p) {
        this.p = p;
    }

    @Override
    public void call() {
        this.p.call();
    }
}

package cn.itcast_02;

public class RingPhoneDecorate extends PhoneDecorate {

    public RingPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        System.out.println("手机可以听彩铃");
        super.call();
    }
}

package cn.itcast_02;

public class MusicPhoneDecorate extends PhoneDecorate {

    public MusicPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        super.call();
        System.out.println("手机可以听音乐");
    }
}

package cn.itcast_02;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;

public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new IPhone();
        p.call();
        System.out.println("------------");

        // 需求：我想在接电话前，听彩铃
        PhoneDecorate pd = new RingPhoneDecorate(p);
        pd.call();
        System.out.println("------------");

        // 需求：我想在接电话后，听音乐
        pd = new MusicPhoneDecorate(p);
        pd.call();
        System.out.println("------------");

        // 需求：我要想手机在接前听彩铃，接后听音乐
        // 自己提供装饰类，在打电话前听彩铃，打电话后听音乐
        pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
        pd.call();
        System.out.println("----------");
        // 想想我们在IO流中的使用
        // InputStream is = System.in;
        // InputStreamReader isr = new InputStreamReader(is);
        // BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(
                System.out)));

        Scanner sc = new Scanner(System.in);
    }
}

适配器设计模式概述

将一个类的接口转换成另外一个客户希望的接口。从而使原来不能直接调用的接口变的可以调用。
    优点
        让本来不适合使用的接口变得适合使用
    缺点
        一次只能适配一个类，使用有一定的局限性