java学习笔记：设计模式

一、设计模式的概述和分类

    1、设计模式概述
        设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
        使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.
   2、设计模式分类
        创建型模式(创建对象的):    单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
        行为型模式(对象的功能):    适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
        结构型模式(对象的组成):    模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

二、简单工厂模式概述和使用

    1、概述：又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
    2、优点：使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。明确了类的职责。
    3、缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

       
三、工厂方法模式的概述和使用

  1、概述：工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
  2、优点：客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
  3、缺点:    需要额外的编写代码，增加了工作量
  4、案例演示
    

四、单例模式

   1、分类：懒汉式和饿汉式
   2、饿汉式和懒汉式的区别

单例模式之饿汉式
public class Student {
    private static Student student=new Student();
    //1.私有化构造
    private Student() {
    }
    //2.提供一个公共的静态方法，让外界通过这个方法，来获取一个该类的对象
    public static Student getStudent(){
        return student;
    }
}

测试类
public class MyTest {
    public static void main(String[] args) {
        Student student = Student.getStudent();
        Student student1 = Student.getStudent();
        System.out.println(student==student1);
    }
}

单例模式之懒汉式
public class Teacher {
    private static Teacher teacher=null;
    //1.私有化构造
    private Teacher() {
    }
    //2.提供公共的静态方法，让外界获取该类的一个对象
    //t1 t2
    public synchronized static Teacher getTeacher(){
        if(teacher==null){
            teacher=new Teacher();
        }
        return teacher;
    }
}

测试类
public class Test {
    public static void main(String[] args) {
        //懒汉式：体现的是一种延迟加载，当需要用的时候，我再帮你去创建这个对象
        //实际开发中 常用饿汉式
        Teacher teacher = Teacher.getTeacher();
        Teacher teacher1 = Teacher.getTeacher();
        System.out.println(teacher==teacher1);
    }
}

3、单例模式的两种思想:
             a: 线程安全思想
             b: 延迟加载思想
4、单例模式的Java代码体现Runtime类

   a、Runtime类概述：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时对象。 应用程序不能创建自己的 Runtime 类实例。 
   b、案例演示:    public Process  exec(String command)  //执行Dos 命令

public class Demo {
    public static void main(String[] args) throws IOException {
        //这个类，采用的是单例模式之饿汉式
        Runtime runtime = Runtime.getRuntime();
        //Process exec (String command)
        //在单独的进程中执行指定的字符串命令。
        //runtime.exec("calc");//打开计算机
        //runtime.exec("mspaint");//打开画图
        //runtime.exec("notepad");//打开记事本
        //定时关机
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                    runtime.exec("shutdown -s -t 0");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }, 1000 * 60 * 1);
    }
}

五、模版设计模式概述和使用

    1、概述：模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现    
    2、 需求: 计算一个for循环执行的时间 
    3、优点:    使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求   
    4、缺点:    如果算法骨架有修改的话，则需要修改抽象类    
    5、案例演示:    模版设计模式的使用

public abstract class CalcTime {
    public long testTime() throws IOException {
        long start = System.currentTimeMillis();
        testTimer();
        long end = System.currentTimeMillis();
        return  end-start;
    }
    public abstract void testTimer() throws IOException;
}

public class TestFor extends CalcTime{
    @Override
    public void testTimer() {
        for (int i = 0; i < 1000; i++) {
                   System.out.println(i);
                }
    }
}

public class MyTest {
    public static void main(String[] args) throws IOException {
        CalcTime testFor = new TestFor();
        long l = testFor.testTime();
        System.out.println("耗时" + l + "毫秒");
    }
}

 

六、装饰模式概述和使用

   1、概述:    装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案
   2、优点：使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能。
   3、缺点:    正因为可以随意组合，所以就可能出现一些不合理的逻辑。

七、观察者模式概述和使用

 1: 案例: 找猎头找工作
 2: 观察者 = 订阅者 + 发布者
         岗位类  求职者  猎头(注册方法,注销方法,发布方法)

public class HeaderHunt { //猎头
    //定义两个集合，来装求职者，和工作岗位
    private ArrayList mans=new ArrayList<>();
    private ArrayList jobs = new ArrayList<>();
    //提供注册的方法
    public void addMan(Worker man){
        mans.add(man);
    }
    //提供注销的方法
    public void removeMan(Worker man){
        mans.remove(man);
    }
    //添加岗位
    public void addJob(Job job){
        jobs.add(job);
        //岗位一旦有了之后，我就得通知每一个求职着
        noticeToMan(job);
    }
    //通知的方法
    private void noticeToMan(Job job) {
        for (Worker man : mans) {
            System.out.println(man.getName()+"你好! 有一份"+job.getName()+"月薪"+job.getMoney()+"诚邀你前去面试");
        }
    }
}

public class Job {
    private String name;
    private double money;

    public Job() {
    }

    public Job(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

public class Worker {
    private String name;

    public Worker() {
    }

    public Worker(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试类
public class Test {
    public static void main(String[] args) {
        Worker man1 = new Worker("张三");
        Worker man2 = new Worker("李四");
        Worker man3 = new Worker("王五");
        Worker man4 = new Worker("赵六");
        //把每个人的信息注册到猎头那里
        HeaderHunt headerHunt = new HeaderHunt();
        headerHunt.addMan(man1);
        headerHunt.addMan(man2);
        headerHunt.addMan(man3);
        headerHunt.addMan(man4);
        //猎头一旦工作岗位更新后 ，就会通知每一个求职者
        headerHunt.addJob(new Job("软件开发工程师",25000));
        headerHunt.removeMan(man3); //移除求职着
        System.out.println("----------------------------");
        headerHunt.addJob(new Job("大数据工程师", 35000));
    }
}