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

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();
   }
  }