Java基础第二十二天--设计模式-CSDN博客

本文链接：https://blog.csdn.net/u013905744/article/details/44936555

1. 设计模式（23种）

1）创建模式--造对象

简单工厂工厂方法抽象工厂原型模式单例模式等

2）结构模式--对象间的关系

适配器模式代理模式装饰模式

3）行为模式--功能

策略模式模板方法模式

2. 单例设计模式

确保类在内存中只有一个对象
举例：windows的打印机服务

如何保证？
1）外界不能造对象
  --把无参构造方法私有
2）类本身要造一个
  --调用构造方法即可
3）通过公共的方式对外提供
  --通过public修饰
  --又由于无参构造私有，所以要用static修饰符
  --为了保证静态方法只能访问静态成员，所以这个对象也要用static修饰
    如果这样...     static Student s = new Student();
    那么外界可以这样...   Student.s = null 使用为null的对象可能出现空指针异常错误
  --所以要加private修饰
  --也可以再加一个final修饰符修饰

C#与公共语言运行库提供了一种“静态初始化”方法，这种方法不需要开发人员显式地编写线程安全代码，即可解决多线程环境下的安全问题。
1）饿汉式--上来就造对象

  public sealed class Student{
   private Student(){}

   private static (final) Student s = new Student();
   public static Student getInstance(){
    return s;
   }
}

在多线程条件下，饿汉式没有多线程共享数据，并且没有多条语句操作共享数据,所以多线程下仍能正常工作

2）懒汉式--上来先不造对象，之后再造

  public class Teacher{
   private Teacher(){}
   private static (final) Teacher t = null;
   public synchronized static Teacher getInstance(){
    if(t==null){
     t = new Teacher();
    }
   }
}

  在多线程条件下，懒汉式有共享数据t，并且有多条语句操作t，所以多线程下可能出问题
  所以要在函数上加synchronized使之变成同步方法

  在框架里面有一个概念，叫做懒加载
  什么时候需要什么时候加载

  开发的时候显然用饿汉式更好，不需要考虑线程的问题
  面试的时候才会考懒汉式，考察你对多线程的理解
  案例：Runtime类也是单例模式的

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

3. 模板设计模式 -- 抽象类最典型的应用

要求：有一个抽象类，将所有共性的逻辑用一个具体方法来表达
然后将需要具体实现的逻辑用抽象方法来实现
继承此抽象类的不同子类可以以不同的方式实现这些抽象方法

举例：
我们想获得一段代码的运行时间

版本1：

  class Demo{
   public static void main(String[] args){
    long start = System.currentTimeMillis();
    // 被统计事件
    long end = System.currentTimeMillis();
    long time = end - start;
   }
  }

缺点：我们不在main()里面进行功能操作，基本上都是调用别人的方法

版本2：

 class GetTime{
   public void getTime(){
    long start = System.currentTimeMillis();
    // 被统计事件
    long end = System.currentTimeMillis();
    long time = end - start;
   }
  }
  class Demo{
   public static void main(String[] args){
    GetTime gt = new GetTime();
    gt.getTime();
   }
  }

缺点：因为被统计时间的代码，将来可能是多种形式的，如复制avi文件，一个模块执行时间等

版本3：

  class GetTime{
   public long getTime(){
    long start = System.currentTimeMillis();
    code();
    long end = System.currentTimeMillis();
    return end - start;
   }
   
   public void code(){
    //被统计时间的代码
   }
  }
  class Demo{
   public static void main(String[] args){
    GetTime gt = new GetTime();
    gt.getTime();
   }
  }

缺点：这个时候，这个code()里面的代码是不能写死的，也就是说，

在这一刻它是一个非具体方法-->抽象方法而抽象方法要放到抽象类中

版本4：

  abstract class GetTime{
   public long getTime(){
    long start = System.currentTimeMillis();
    code();
    long end = System.currentTimeMillis();
    return end - start;
   }
   
   public abstract void code(){};
  }
  
  public class ForDemo extends GetTime{
   @override
   public void code(){
    //具体实现
   }
  }
  
  public class AviDemo extends GetTime{
   @override
   public void code(){
    //具体实现
   }
  }
  
  class Demo{
   public static void main(String[] args){
    GetTime gt = new ForDemo();
    gt.getTime();
    gt = new AviDemo();
    gt.getTime();
   }
  }