javaSE的整体回顾

环境搭建

1. jdk：java的开发工具包
2. jre：java的运行环境
3. jvm：java虚拟机
   • jvm层内结构
     • 栈 stack：解决运行时的问题，程序的执行顺序
     • 堆 Heap：数据的存放
     • 元数据区：
   • GC机制：垃圾回收机制

语法基础

1. 标识符：任意大小写字母、数字、下划线和$符号，其中数字不能作为标识符的第一位
2. 包 package
3. 导入语句 import
4. 类的定义 public class类名{ }
5. 数据类型
   • 基本类型：boolean、byte、short、int、float、long、double、char
   • 对象类型：自定义对象，jre自带对象
   • 变量 数据类型 变量名 [=初始值]；
6. 变量、字面量、常量
   • 变量的语法 数据类型 变量名 [=初始值]；
   • 常量的语法： final 数据类型 常量名 = 值
   • 字面量 就是值
7. 运算符
8. 表达式 由变量、常量、字面量与运算符组成的合法语句
9. 条件分支
   • if语句
   • switch语句
10. 循环结构
    • for循环
    • while循环
    • do while循环
    • break语句和continue语句
11. 数组操作
    1. 一维数组：一段连续内存空间，并且一个数组只能放一种类型的数据 语法：数据结构 数组名 = new 数据结构[length]
    2. 二维数组：就相当于每一个一维数组中的每个类型都为一个数组

面向对象编程思想

1. top-down的理论
   • 自上而下的编程思想，将一个大的问题分解为一个个小问题，能解决就解决，不能解决就继续分
2. 与面向过程思想有什么不同？
   • 面向过程编程，是每一步都需要进行自己操作，没有太多的函数，只用最基本的操作解决问题。代码的执行效率略高
   • 面向对象编程，仅仅需要写的人对业务的流程清晰，并不需要对执行的细节很清晰，因为大部分通用的操作都是封装好的直接调用即可。对执行的效率略低，但开发效率较高。
3. 封装、继承、多态
   • 封装：通过权限修饰符对方法和属性进行修饰，使得不同的对象对本类的内容使用权限不相通
     • public 同一项目下可用
     • protected 不同包的子类可用
     • （缺省） 同一个包下可用
     • private 本类中可用
   • 继承：通过子类继承父类使得子类拥有父类结构的同时，还能进行拓展，并且对于父类中的方法还可以进行重写
   • 多态：父类的引用指向子类的对象，只能调用父类中的方法，但在执行时执行的是子类重写父类的方法。编译看左边，执行看右边
4. 什么是类？ 一种用户定义的数据引用类型
   • 构造器的定义
     • 在创建本类时，调用自身的方法
   • 构造器的作用
     • 定义类时进行初始化
   • getter/setter
     • 提供给使用本类时操作本类中属性的方法
5. 什么是对象？
   • 类的实例化
6. 属性和方法 类的基本组成
   • 方法的重载：方法名相同，返回类型和参数列表不同的同一个类中的方法
7. 对象和引用
   • 对象代表定义的一个对象类型的变量，而它执行的内容叫做对象的引用
8. 继承
   • java是单继承，多实现的一种语言
   • extends继承关键字
   • instanceof用来判断一个对象是不是另一个对象子类的关键字
9. 抽象类
   • abstract修饰符 用来定义这个类是一个抽象类
   • 不可被实例化
   • 可以有普通方法和抽象方法
10. 抽象方法
    • 在抽象类和接口中的只是被定义语句没有方法体的方法
11. 接口
    • 常量属性
      • 默认修饰为public static final
    • 抽象方法
      • 默认修饰符为public
    • 静态方法 - jdk8中
      • 默认修饰符 static
    • 默认方法 - jdk8中
      • 默认修饰符 default
12. static修饰符
    • 静态代码块 static {}
    • 静态属性 static 类型 属性名 [=属性值]
    • 静态方法 static 返回类型 方法名(参数列表) {方法体};
    • 静态内部类 class Person{ ststic class head{} }
      • 可以直接访问外部类中的静态方法和静态属性
      • 如果要访问外部类的非静态资源，需要通过对象调用
    • 单例模式
      • 饿汉式 使用static
13. final
    • 定义的类：不可继承
    • 定义的方法：不可重写
    • 定义的属性：值不可修改
14. 多态
    • 父类的引用指向子类的对象，只能调用父类中的方法，但在执行时执行的是子类重写父类的方法。编译看左边，执行看右边

异常处理机制

1. 异常的分类
   • 运行时异常 RuntimeException
     • NullPointerException 空指针异常
     • ArrayIndexOutOfBoundsException 数组越界
     • classCastException 类型转换异常
   • 非运行时异常
     • InterruptedException
     • IOException
     • SQLException
     • RemoteException
2. 积极处理方式
   • try{} catch {} finally{}
3. 消极的处理方式
   • throws 异常类型列表
   • throw 异常对象

数字、字符串、日期处理

1. Number相关的类型
   • Number
   • Integer
   • Long
   • BigInteger 大整数
   • BigDecimal 大浮点数
2. CharSequence相关得类型
   • String 不建议修改，数据放在常量池中，每次修改相当于重新获取对象
   • StringBuilder 可变长字符串 线程不安全
   • StringBuffer 可变长字符串 线程安全，效率较低
3. Date相关的类型
   • Date
     • java.util.Date 带时分秒
     • java.sql.Date 不带时分秒
   • Calender 一个日历工具类
   • SimpleDateFormat格式化日期对象
4. java.time包 - jdk
   • LocalDate 年月日
   • LocalDateTime 年月日时分秒
   • LocalTime时分秒
   • DateTimeFormatter 格式化

IO

1. 字节流
   1. 输入流
      • FileInputStream
      • ByteArrayInputStream
      • BufferedInputStream
      • DataInputStream
      • ObjectInputStream
   2. 输出流
      • FileOutputStream
      • ByteArrayOutputStream
      • BufferedOutStream
      • DataOutputStream
      • ObjectOutputStream
   3. 随机访问流
      • RandomAccessFile
2. 字符流
   • 输入流
     • FileReader
     • CharArrayReader
     • BufferedReader
     • InputStreamReader – 桥接器
   • 输出流
     • FileWriter
     • CharArrayWriter
     • BufferedWriter
     • PrintWriter
     • OutputStreamWriter – 输出桥接器
   • 桥接器：字节流到字符流的转换

内部类

1. 成员内部类：可以访问外部类的私有成员或属性
2. 静态内部类：可以使用外部类的静态属性和方法，其他方法需要通过对象调用
3. 局部内部类：
4. 匿名内部类 为lambda表达式的前身

集合框架

Iterable ->Collection

1. List:有序，可重复
   • ArrayList 低层为数组结构
   • LinkedList 低层为链表结构
   • Vector 低层为数组结构，线程安全，效率不高
2. Set：无序，不可重复。低层为Map结构，数据存放在key位置，value位置默认为PRESENT
   • HashSet，低层为hash表结构，无序，不可重复
   • SortedSet - >TreeSet :低层为树状结构，有序，不可重复
3. Queue 队列，先进先出
   • PriorityQueue 优先队列
   • Deque 低层为链表的双端队列
     • ArrayDeque 低层为数组的双端队列
   • BlockingQueue 阻塞队列
     • LinkedBlockingQueue 低层为链表的阻塞队列
     • ArrayBlockingQueue 低层为数组的阻塞队列

Map 键值映射关系

• jdk7及之前，每个节点是Entity<k,v>,jdk8后每个节点是Node<k,v>

1. HashMap 低层使用hash表
   • 初始大小为16，当使用率达到75%进行扩容，每次扩容为原来的二倍。当有8个hashCode值相同的数据放到集合中，该节点的链表结构会变为红黑树，当红黑树红数据的个数小于6时，红黑树会重新变回链表结构
   • 添加数据时，先比较数据的hashCode值，然后通过hashCode值在hash表中找到对应的位置。
     • 如果hash得这个位置没有数据，直接放入
     • 如果这个位置已经存在数据，则与这个位置链表中的所有数据数据进行equel比较
       • 如果有相同元素，则表示这是一个重复数据，不添加
       • 如果没有重复，则加入到这个位置的链表当中，添加规则遵循7上8下原则：jdk为头插法，jdk8中为尾插法
2. SortedMap ->TreeMap 有序
   • 低层存储结构为基于红黑树的树结构

枚举

1. 自动继承Enum类
2. 构造方法是私有的
3. 可以有抽象方法
4. 也可以有属性

泛型

1. 泛型类
2. 泛型方法
3. 泛型字母通配
4. 本质：类型参数化
5. 限定上限 <? extends 父类>
6. 限定下限 <? supper 子类>

反射机制

• 通过类的class对象，获取类中所有内容，并且可以打破封装setAccessible(true)
• Package 包
• Class 泛型类型，可以指泛型参数，也可以指泛型返回类型
• Modifiers 修饰符
• Constructor 构造器
• Method 方法
• Field 参数
• Array （？）

注解

1. 元注解：
   • @Target 限制注解的适用位置
   • @Retention 注解的保留策略
   • @Documented 是否可以被文档化
2. 自定义注解
3. APT程序
4. 自定义注解需要有相应的APT程序进行解释，不然定义的注解不能起作用

多线程

创建方式

1. 继承Thread类，重写run()方法，通过调用start()方法，开启线程
2. 创建Runable实现类，run()方法，通过调用start()方法，开启线程
3. 创建Callable实现类，call()方法，该方法有返回值，可以通过FutureTask类的get方法获取返回值。通过FutureTask对象作为Thread对象的target创建并启动新线程

线程的状态

1. 初始态
2. 可运行态
   • 有资源，没有时间片
3. 运行态
   • 有时间片
   • 有运行资源
4. 阻塞态
   • 缺少资源
   • 没有获取时间片
   • 没有锁
5. 终止态
   • 线程结束

sleep 和wite的区别

• 线程调用sleep，该线程处于阻塞状态，当休眠时间到，线程进入就绪状态等待时间片。如果该线程有锁。休眠期间并不会释放锁
• 线程调用wite方法，线程处于阻塞状态。如果该线程有锁，锁会自动释放。并且该线程不会自动解除阻塞状态，只有当其他线程调用notify()方法或notifyAll()方法，线程才能结束阻塞状态。并且notify每次只能唤醒一个线程。notifyAll()方法欢迎除自己外的所有线程。

网络编程

lambda表达式

• 使用条件：一个接口中只能有一个方法

1. 语法 (( 参数 ) - >{ 方法体 })
2. 方法引用
3. 流式编程
   1. java.util.function包
      • Predicate 谓词型接口 判断0或1
      • Consumer 消费型结构，只进不出
      • Supplier 供应型接口 给我一个特定类型对象，没有返回值
      • Function 功能性接口 你给我一个对象，我还你一个其他对象
   2. java.util.stream包
      • Stream
        • map方法
        • filter方法
        • reduce方法
        • sort方法
      • Collector类

可能会有些不对的地方，欢迎评论区指出，纯靠个人印象