Java基础部分回顾（1）

1. 基本数据类型
   
   1. byte（-128~127 ，一个字节八位），short(2)，int(4)，long(8)
   2. float(数字后面要带f)，double
   3. char
   4. boolean
2. 输入输出
   
   1. 1.
3. 多态的好处
   
   1. 为了后期软件需求的改变不至于修改早期过多的代码
4. ++I 和I++
   
   1. 原理
      
      1. java的编译器在遇到++i和i++的时候会重新为变量运算分配一块内存空间，以存放原始的值
      2. （注： i ++存放i，++i存放i + 1），参加运算的恰好是这块新的内存空间中的值。而在完成了运算之后，这块内存将自动释放掉。
   2. ++i先自增
   3. I++后自增

5. 运算符

   1. 逻辑运算符
      
      1. 逻辑非
         
         1. ！
      2. 逻辑与
         
         1. &&
      3. 逻辑或
         
         1. ||
      4. 短路
         
         1. &&和||中前面能够直接决定后面的结果时，后面都不运算了
   2. 位运算符
      
      1. 定义
         
         1. 主要对二进制进行运算
      2. ～
         
         1. 按位非
      3. &
         
         1. 按位与
      4. |
         
         1. 按位或
      5. ^
         
         1. 按位异或
         2. 相同为0
   3. 移位运算符
      
      1. <<
         
         1. 左移位运算符
         2. 将运算符左边的对象，向左移动运算符右边指定的位数，并且在低位补零（向左移 n 位，相当于乘以 2 的 n 次方
      2. >>>
         
         1. 右边移位运算符
         2. 将运算符左边的对象向右移动运算符右边指定的位数，并且在高位补 0（右移 n 位，就相当于除上 2 的 n 次方）
      3. >>
         
         1. 带符号的右移位运算符
         2. 将运算符左边的运算对象，向右移动运算符右边指定的位数。如果是正数，在高位补零，如果是负数，则在高位补 1
   4. 运算符优先级
      
      1. 1.

6. 数组

   1. 定义
      
      1. 是在内存中连续存放且类型相同的数据的集合，一个数组用于表示一组数据
      2. 数组必须经过申明和初始化之后才能够使用
   2. 数组分类
      
      1. 一维数组
      2. 二维数组
      3. 多维数组
   3. 初始化
      
      1. 默认初始化
      2. 动态初始化
         
         1. int[] a = new int[4];
            int a1[] = new int[4];
            a[0] = 1;
            // []int a1=new int[4];
      3. 静态初始化
         
         1. int[] a = { 1, 2, 3 };
   4. .length属性可以直接获取长度
   5. 对数组操作
      
      1. 1.
   6. 注意
      
      1. 数组是对象，注意使用时要new
      2. 数组的容量是固定的，注意开辟数组大小
   7. 基本排序
7. 方法
   
   1. 访问修饰符
   2. 返回值
   3. 方法名
   4. 参数列表
8. 类的加载方法
   
   1. 找到对应.class文件
   2. 把。class文件加载到内存，用new为对象分配空间，为引用分配栈空间
   3. 把对象的成员变量设置为默认值
   4. 调用构造方法初始化
9. this
   
   1. 指的是引用，也就是当前对象
10. 无参构造默认就有
11. 写了有参构造就没有无参构造了，要自己记得写
12. 作用域（同一包中的类是朋友，派生类是子女）
    
    1. public
       
       1. 所有用户都可以直接调用
    2. protected
       
       1. 只有子女和朋友可见
    3. default
       
       1. 只有朋友可见
    4. private
       
       1. 只有自己可见
    5. 5.
13. 封装
    
    1. 功能
       
       1. 隐藏具体细节
       2. 迫使用户通过方法访问数据
       3. 使代码更好回顾
    2. 方式
       
       1. 使属性私有化
       2. 提供公有方法访问属性
14. static
    
    1. 不能被继承
    2. 不能被重写
    3. 不能用来修饰构造方法
    4. 是大家共享的
15. static块
    
    1. 加载时机
       
       1. 在类加载到内存之后对象创建之前执行，比构造方法还早，因为此时对象还没有准备好，所以static块是不能调用非static成员的，只能调用类的static成员
16. 内部类
    
    1. Innter I = out.new Inner();
    2. Outer.Innter=out.new Innter();
17. final
    
    1. 修饰变量
       
       1. 表示这是常量
    2. 修饰方法
       
       1. 表示方法不能
    3. 引用不可变
    4. 常见的final类
       
       1. String
       2. math
       3. Scanner
18. 抽象类
    
    1. 特点
       
       1. abstract关键字
       2. 可以有抽象方法，也可以没有抽象方法
       3. 抽象类不能实例化
          
          1. 如果可以实例化那么可以调用抽象方法，但是抽象方法里面什么都没有
       4. 如果子类没有实现父类的抽象方法，那么子类也是个抽象类
       5. 访问修饰符不能是private
19. 接口
    
    1. 定义
       
       1. 也是一个类
       2. 但是类中的方法都是抽象方法
       3. 命名一般I开头
       4. 访问修饰符+ interface+接口名称
          
          1. 访问修饰符只能定义public常量和public方法
    2. 一般都是提供一种规范
    3. 成员属性默认都是public+static+final的
    4. 只能定义抽象方法
    5. 没有构造方法不能被初始化
    6. 接口可以继承多个接口
    7. 接口可以多继承
       
       1. 1.
    8. 实现接口
       
       1. implements方法
       2. 如果类中部分接口的方法没有实现，那么该类是抽象类
    9. 抽象类和接口的区别
       
       1. 抽象类可以为部分方法提供实现，避免了在子类中重复实现这些方法，提高了代码的可重用性，这是抽象类的优势；
       2. 而接口中只能包含抽象方法，不能包含任何实现。
       3. 一个类只能继承一个直接的父类（可能是抽象类），但一个类可以实现多个接口，这个就是接口的优势抽象类是is-a的关系，接口是has-a的关系
    10. 接口回调
20. 多态
    
    1. 不同类的对象对同一消息作出响应。同一消息可以根据对象的不同而产生不同的行为
    2. 动态绑定
    3. 是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法
    4. 基本要求
       
       1. 有重写
       2. 父类的引用指向子类的对象
       3. 有继承
    5. 好处
       
       1. 可替换性
       2. 可扩充性
       3. 接口性
       4. 灵活性
       5. 简化性
21. 类与类之间的关系
    
    1. 泛化
       
       1. 1.
    2. 实现
       
       1. 1.
    3. 关联
       
       1. 1.
    4. 依赖
       
       1. 1.
    5. 聚合
       
       1. 1.
    6. 组合
       
       1. 1.
22. 包装类
    
    1. 装箱
       
       1. 基本数据类型-》包装类
    2. 拆箱
    3. 包装类的好处
       
       1. 考试0分和缺考的区别
       2. 具有更多的功能
    4. 任意类型+String=String
    5. 
       Integer i1 = 128;
       Integer i2 = 128;
       System.out.println(i1 == i2);//false
       System.out.println(i1.equals(i2));//true
    6. Integer
23. String
    
    1. 本质是char数组
    2. final类不能被继承
    3. 字符串值 一旦被确定就不能被更改
    4. 常量池
    5. 是一个对象，具有方法
    6. 编译期间能够自动优化
    7. 比较字符串是否相同使用equals方法
       
       1. 使用注意空指针异常
    8. Stringbuffer／StringBuilder
       
       1. StringBuffer线程安全，效率高
       2. builder不安全，效率低
       3. StringBuffer操作字符串不会创建新的对象
24. 日期
    
    1. 
       
       1. 特征说明
       2. 年份 y 由整数 y - 1900 表示。
       3. 月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。
       4. 日期（一月中的某天）按通常方式由整数 1 至 31 表示。 小时由从 0 至 23 的整数表示。
       5. 因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。
       6. 分钟按通常方式由 0 至 59 的整数表示。
       7. 秒由 0 至 61 的整数表示（有闰秒，但极少发生）
    2. 比较时间的先后
       
       1. before
       2. after
       3. 日期的转化
          
          1. getTime（）
          2. long表示的毫秒数都可以转
    3. 区别
       
       1. java.util.Date
          
          1. 常用的日期类，但功能很少，可同时表示日期和时间
       2. java.sql.Date
          
          1. java.util.Date的子类，仅表示日期
       3. java.sql.Time
          
          1. java.util.Date的子类，仅表示时间
       4. java.sql.Timestamp
          
          1. java.util.Date的子类，可以表示日期和时间
    4. 日历类
       
       1. 是一个抽象类
       2. 获取 对象通过getInstance方法获取
       3. 常用方法
          
          1. 
             
             1. 格式化日期
             2. java.text.DateFormat是负责格式化日期的类
                
                1. 是一个抽象类
                2. 2.
25. 异常
    
    1. 定义
       
       1. 程序运行过程中出现的错误干扰了指令的正常指令流程
       2. 2.
    2. Throwable是异常类的父类
       
       1. Error
          
          1. 程序无法处理的错误
          2. OutOfMemoryError、ThreadDeath
          3. Jvm一般会选择线程终止
       2. Exception
          
          1. 程序本身可以处理的异常
          2. 分类
             
             1. checkedException
                
                1. 继承自Exception
             2. uncheckedException
                
                1. 继承自runtimeException
       3. 异常捕获处理机制
          
          1. try，catch，finally
             
             1. 都不能单独使用
             2. try-catch
             3. try-finally
             4. try-catch-finally
          2. 当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行
       4. Throw
          
          1. 如果一个方法可能会出现异常，但没有能力处理这种异常，可以将异常通过throw向方法的调用者抛出，由他来处理异常
       5. Throws
          
          1. 对于Exception及子类，必须强制性处理可抛出
          2. 对于RuntimeException及子类，可以不处理不抛出，但一旦产生异常，将由系统抛出
    3. 自定义异常
26. 集合
    
    1. Collection
       
       1. public interface Collection extends Iterable
    2. Iterable
       
       1. 
          
          1. foreach由iterable接口提供
    3. Iterator
       
       1. default void forEachRemaining(Consumer