设计模式

设计模式

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

简单工厂模式概述和使用

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

优点: 使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。明确了类的职责

但是如果有新的对象增加，或者对象的创建方式不同，就需要对工厂类进行修改，不利于后期维护。

//工厂类:主要负责创建各种动物实例的创建
public class AniamlFactory {
    private AniamlFactory() {
    }

    public static Animal getAnimal(String name){
        if("cat".equals(name)){
            return new Cat();
        }else if("dog".equals(name)){
            return new Dog();
        }else if("tiger".equals(name)){
            return new Tiger();
        }else{
            return null;
        }
    }
}



public abstract class Animal {
    public abstract void eat();
}


public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}


public class Tiger extends Animal{
    @Override
    public void eat() {
        System.out.println("老虎吃鸡");
    }
}




public class MyTest {
    public static void main(String[] args) {
     
        Animal an = AniamlFactory.getAnimal("cat");
        an.eat();
        an=AniamlFactory.getAnimal("dog");
        an.eat();
        an=AniamlFactory.getAnimal("tiger");
        an.eat();
    }
}

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

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

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

public abstract class Animal {
    public abstract void eat();
}

public interface BigFactory {
    //创建产品的方法
    Animal createAnimal();
}

//创建猫的工厂
public class CatFactroy implements BigFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class DogFactory implements BigFactory{
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

单例模式之懒汉式

单列：保证一个类的对象，在内存中只有一个
单例模式存在懒汉式写法，饿汉式写法
1.把该类的构造私有，不让他在外界直接new对象。
Student student = new Student();

懒汉式写法:你要用这个对象的时候，再去创建

 private static Student student = null;
    //1.私有构造
    private Student() {
    }

    //2.提供静态方法，返回一个该类的实例，共外界使用
    //多线程环境下能保证这个方法的一定是创建一个对象吗？
    //加上synchronized保证多线程环境下的使用也是单列的
    //th1 th2
    public synchronized static Student getStudent() {
        if (student == null) {
            //th1 th2
            student = new Student();
        }
        return student;
    }
}

饿汉式，这个类一加载，我就创建一个该类的对象

  private static Teacher teacher=new Teacher();
    //私有构造
    private Teacher() {
    }
    public static Teacher getTeacher(){
        return teacher;
    }
}


public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = Teacher.getTeacher();
        Teacher teacher1 = Teacher.getTeacher();
        System.out.println(teacher);
        System.out.println(teacher1);
        System.out.println(teacher==teacher1);

单例模式的Java代码体现Runtime类

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。

Runtime的源码是单例模式的应用。

public class MyTest {
    public static void main(String[] args) throws IOException {
       // Runtime 这个类Java就采用的是单列模式的饿汉式
        Runtime runtime = Runtime.getRuntime();
        //可以执行一些DOS命令
        runtime.exec("calc");
        runtime.exec("mspaint");
        //定时关机

    }
}

模版设计模式概述和使用

public void calc(){
        //算法骨架
        long start = System.currentTimeMillis();
        calcMethod();
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start)+"毫秒");
    }

 
    public abstract void calcMethod();
}

public class CalcFor extends CalcClass {
    @Override
    public void calcMethod() {
        for (int i = 0; i < 5000; i++) {
            System.out.println("abc");
        }
    }
}

public class CopyFile extends CalcClass{

    @Override
    public void calcMethod() {
        System.out.println("复制文件");
    }
}


public class MyTest {
    public static void main(String[] args) {
        //单例设计模式
        //计算for循环的耗时
       // new CalcClass().calcFor();
        CalcClass js = new CalcFor();
        js.calc();
        js=new CopyFile();
        js.calc();
    }
}

观察者模式概述和使用

public class Hunter {
    //定义两个集合，用来装求职者，和工作岗位
    private ArrayList jobSeekers=new ArrayList<>();
    private ArrayList jobs = new ArrayList<>();
    //注册求助者
    public void addJobSeeker(JobSeeker jobSeeker){
        jobSeekers.add(jobSeeker);
    }

    //注册工作岗位
    public void addJob(Job job){
        jobs.add(job);
        //工作岗位过来之后，通知求职者
        notifyJobSeeker(job);
    }

    private void notifyJobSeeker(Job job) {
        for (JobSeeker jobSeeker : jobSeekers) {
            System.out.println(jobSeeker.getName()+"你好！有一份工作:"+job.getJobName()+"薪资:"+job.getSal()+"欢迎你前去面试");
        }
    }

    //注销
    public void removeJobSeeker(JobSeeker jobSeeker){
        jobSeekers.remove(jobSeeker);
    }

}


public class Job {
    private String jobName;
    private double sal;

    public Job() {
    }

    public Job(String jobName, double sal) {
        this.jobName = jobName;
        this.sal = sal;
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
}


public class JobSeeker {
    private String name;

    public JobSeeker() {
    }

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

    public String getName() {
        return name;
    }

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



public class MyTest {
    public static void main(String[] args) {
        //观察者 = 订阅者 + 发布者
        JobSeeker zs = new JobSeeker("张三");
        JobSeeker ls= new JobSeeker("李四");
        JobSeeker ww= new JobSeeker("王五");

        //在猎头出注册
        Hunter hunter = new Hunter();
        hunter.addJobSeeker(zs);
        hunter.addJobSeeker(ls);
        hunter.addJobSeeker(ww);

        Job job= new Job("Java开发工程师", 8000);
        hunter.addJob(job);
        System.out.println("=====================");
        Job job2 = new Job("前端开发工程师", 18000);
        hunter.addJob(job2);
        System.out.println("========================");
        //注销
        hunter.removeJobSeeker(ww);
        Job job3 = new Job("运维工程师", 5000);
        hunter.addJob(job3);
    }
}