java基础部分回顾（2）

1. 范型
   
   1. Demo d = new Demo(“Df”);
   2. Demo d1 = new Demo(120);
   3. System.out.println(d.getClass());
   4. System.out.println(d1.getClass());
   5. 范型只起到约束作用，但是并没有被编译进去 在编译的时候jvm将范型类型擦出
   6. 缺点
      
      1. 如果遇到了不同类型，那么就约束了自己的代码
2. IO
3. 设计模式
   
   1. java中一共有23种基本设计模式
   2. 装饰者模式
      
      1. 创建一个私有化对象（被添加）
      2. 构造器带有该对象
      3. 定义一个与目标相同的方法
      4. 特点
         
         1. 可以对原有目标的功能进行拓展
      5. 为什么要
         
         1. 因为随着软件的需求的改变，原有的功能已经不能够满足现在的业务需求，所以必须在原有的功能上进行功能拓展
         2. 与此同时，还不能改变原有的功能功能，因为原来的功能还在继续使用。
         3. 继承也可以实现该模式的效果，如果使用了继承，那么程序就会过于臃肿
   3. 什么时候用什么流
      
      1. 明确源和目的
         
         1. 源
            
            1. InputStream Reader
            2. OutPutStream Writer
         2. 明确数据是否是纯文本
            
            1. 源
               
               1. 纯文本：reader
               2. 否：inputStream
            2. 目的
               
               1. 是纯文本
                  
                  1. Writer
               2. 否
                  
                  1. OutPutStream
            3. 明确具体的设备
               
               1. 源设备
                  
                  1. 硬盘：file
                  2. 键盘:System.in
                  3. 内存：数组
                  4. 网络：Socked流
               2. 目的设备
                  
                  1. 硬盘：file
                  2. 控制台：System。out
                  3. 内存：数组
                  4. 网络：Socket流
            4. 是否需要额外的其他功能：
               
               1. 是否需要高效（缓冲区）：
                  
                  1. 如果需要：buffer
               2. 转换流
                  
                  1. 如果需要：
                     
                     1. InputStreamReader OutPutStreamWriter

4. 线程

   1. 实现方式
      
      1. 继承Thread类
      2. 实现Runnable接口
      3. 调用通过start()方法
   2. 进程是指一种“自包容”的运行程序，有自己的地址空间;
   3. 线程是进程内部单一的一个顺序控制流 基于进程的特点是允许计算机同时运行两个或更多的程序。
   4. 基于线程的多任务处理环境中，线程是最小的处理单位。
   5. 基于线程的多任务处理的优点
      
      1. 在多任务中，各个进程需要分配它们自己独立的地址空间
      2. 多个线程可共享相同的地址空间并且共同分享同一个进程
      3. 线程之间切换成本低
      4. 进程之间调用涉及的开销比线程间通信多
   6. 线程的状态
      
      1. 新建 (Born) : 新建的线程处于新建状态
      2. 就绪 (Ready) : 在创建线程后，它将处于就绪状态，等待 start() 方法被调用
      3. 运行 (Running) : 线程在开始执行时进入运行状态
      4. 睡眠 (Sleeping) : 线程的执行可通过使用 sleep() 方法来暂时中止。在睡眠后，线程将进入就绪状态
      5. 等待 (Waiting) : 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。
      6. 挂起 (Suspended) : 在临时停止或中断线程的执行时，线程就处于挂起状态。
      7. 恢复 (Resume) : 在挂起的线程被恢复执行时，可以说它已被恢复。
      8. 阻塞 (Blocked) – 在线程等待一个事件时（例如输入/输出操作），就称其处于阻塞状态。
      9. 死亡 (Dead) – 在 run() 方法已完成执行或其 stop() 方法被调用之后，线程就处于死亡状态。
   7. 可能使线程暂停执行的条件
      
      1. 线程优先级比较低，因此它不能获得 CPU 时间。使用 sleep( ) 方法使线程睡眠。
      2. 通过调用 wait( ) 方法，使线程等待。
      3. 通过调用 yield( ) 方法，线程已显式出让CPU控制权。
      4. 线程由于等待一个文件I/O事件被阻塞。
   8. 线程的优先级
      
      1. NORM_PRIORITY : 值为 5
      2. MAX_PRIORITY : 值为 10
      3. MIN_PRIORITY : 值为 1
      4. 缺省优先级为 NORM_PRIORITY
      5. final void setPriority(int newp) : 修改线程的当前优先级
      6. final int getPriority() : 返回线程的优先级
      7. final void setPriority(int newp) : 修改线程的当前优先级
      8. final int getPriority() : 返回线程的优先级
   9. 同步
      
      1. synchronized
         
         1. 数据安全
         2. 降低了代码逻辑的效率
   10. wait-notify 机制
       
       1. 为避免轮流检测，Java提供了一个精心设计的线程间通信机制，使用wait()、notify()和notifyAll()方法 。这些方法是作为 Object 类中的 final 方法实现的。这三个方法仅在 synchronized 方法中才能被调用。wait()方法告知被调用的线程退出监视器并进入等待状态，直到其他线程进入相同的监视器并调用 notify( ) 方法。 notify( ) 方法通知同一对象上第一个调用 wait( )线程。 notifyAll() 方法通知调用 wait() 的所有线程，具有最高优先级的线程将先运行。

   11. 几个方法

       1. Suspend()方法有死锁的倾向
          
          1. 使用的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁
       2. stop（）方法
          
          1. 不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们

       3. runnable只有run方法，start方法只属于thread

       4. join（）

          1. 相当于让出cpu