9、JavaSE总结

9、JavaSE总结

9.1 Java语言

9.1.1 MarkDown语法

9.1.2 简单的Dos命令

9.1.3计算机语言发展

9.1.4 Java的诞生

1995年诞生：JavaSE、JavaME、JavaEE

2006年Hadoop大数据系列

9.1.5 JDK、JRE

JDK：开发者工具包、配置环境变量（配置Javahome、编辑环境变量）

JRE：运行环境

9.2 HelloWorld

  public class Hello{
  	public static void main(String[] args){
  		System.out.print("Hello,World!");
  	}
  }
1
2
3
4
5

javac编译Java文件的，编译之后会生成一个class文件

java命令执行class文件

编译型语言和解释型语言

安装了IDEA的开发工具

9.3 基础语法

9.3.1 注释

行内注释

多行注释

文档注释，javadoc生成帮助文档

9.3.2 标识符

关键字

9.3.3 数据类型

基本数据类型：八大基本类型

整数：byte（1字节）、 short（2字节）、 int（4字节）、long（8字节）

1. 0b二进制
2. 0x16进制
3. 0 八进制

浮点数：float（4字节）、double（8字节）扩展了金融中使用了BigDecimal类型

字符：char（2字节）

扩展了

1. ASCII码
2. UTF-8
3. Unicode
4. 转义字符：\u0000、\b、\n、\r、\t

布尔值：boolean（1位）

引用数据类型

类

接口

数组

9.3.4 类型转换

1. 自动类型转换

   低转高（字节数、子类父类）

2. 强制类型转换

   高转低：（低）高

9.3.5 变量和常量

1. 变量

   1. 定义：type varName [=value];

   2. 作用域

      类变量

      实例变量

      局部变量

2. 常量

   1. 定义 final MAX_A =10

3. 命名规则

   1. 所有变量、方法、类名：见名知意
   2. 类成员变量：首字母小写和驼峰原则（除了第一个单词以外，后面的单词首字母大写）：monthSalary
   3. 局部变量：首字母小写和驼峰原则
   4. 常量：大写字母和下划线：MAX_VALUE
   5. 类名：首字母大写和驼峰原则：Man，GoodMan
   6. 方法名：首字母小写和驼峰原则：run()，runRun()

9.3.6 运算符

1. 算数运算符：+ - * / % ++ –
2. 赋值运算符：=
3. 关系运算符：> < >= <= == != instanceof
4. 逻辑运算符：&& || ！
5. 位运算符：& | ^ ~ >> << >>>
6. 条件运算符：？ :
7. 扩展运算符：+= -= *= /=

9.3.7 包机制

防止命名冲突

1. 域名倒写
2. package
3. import

9.3.8 JavaDoc

1. JDK帮助文档

2. javadoc

   参数信息
       @author 作者名
       @version 版本号
       @since 指明需要最早使用的JDK版本
       @param 参数名
       @return 返回值情况
       @throws 异常抛出情况
   1
   2
   3
   4
   5
   6
   7

3. 生成帮助文档

   javadoc -encoding UTF-8 -charset UTF-8 Doc.java
   # -encoding UTF-8设置编码为UTF-8这样可以正常显示中文
   # -charset UTF-8 设置字符集编码为UTF-8也是为了正常显示中文
   1
   2
   3

9.4 Java流程控制

9.4.1 顺序结构

1. 用户交互Scanner
2. 程序默认的顺序结构，自上而下的结构

9.4.2 选择结构

1. if单选择结构
2. if-else双选择结构
3. if-else多选择结构
4. switch（JDK7支持了Spring类型）、case穿透现象、default

9.4.3 循环结构

1. while：尽量避免死循环
2. do-while
3. for
4. 增强for循环

9.4.4 break、continue

1. break：跳出循环
2. continue：终止当次循环
3. return：结束方法的运行

9.5 方法

1. 什么是方法：语句块的集合

2. 方法的定义

   修饰符 返回值 方法名（参数名）{return 返回值}

3. 方法的调用

   1. 类名.方法
   2. 对象.方法

4. 方法重载：名字相同，参数列表不同

5. 命令行传参

6. 可变参数：…必须放在最后一个参数

7. 递归：自己调用自己，给自己一个出口

9.6 数组

1. 数组的定义

2. 数组的使用

   通过下标拿到值

   数组下标越界ArrayIndexoutofBounds

   增强for循环

3. 二维数组

4. Arrays类

5. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、堆排序、基数排序

9.7 面向对象

1. 什么是面向对象

2. 类与对象

   类是对象的抽象：类是模板class，所有的对象都是根据这个模板刻出来的。

   对象是类的具体

3. 构造器：new对象，每个类都有一个默认的无参构造，如果手动定义了无参构造就必须要手动添加一个无参构造，单例模式，需要构造器私有。

   栈存放引用

   堆存放具体的对象

4. 封装：该露的露，该藏的藏

   属性私有，提供相应的public的get、set方法。

5. 继承

   extends关键字

   object类是所有类的老祖宗

   子类拥有父类的全部特性

   方法重写

   this

   super

   Java是单继承只能继承一个父类，但是可以实现多个接口

6. 多态：父类的引用指向子类的对象，可以使用instanceof相互的转型

7. 修饰符

   public

   protected

   Private

   default

   static

   abstract

   final

8. 接口

   interface

   接口是一个约束，只能定义方法名

   子类实现接口，必须重写其中的方法

   只有一个方法的接口叫做函数式接口，可以使用lambda表达式简化

   接口比抽象类更抽象

9. 内部类

   局部内部类：方法里面的

   静态内部类：方法外面类里面的

   匿名内部类：方法里面的

9.8 异常

1. 异常机制：异常总接口：Throwable

   1. Exception，Exception捕获不到需要抛出到Throwable，Exception捕获不到Error，需要捕获Error就要到Error去捕获

      分为运行时异常和检查型异常

      1. 运行时异常
         1. 1/0
         2. ClassNotFound
         3. NullPoint:空指针异常
         4. 未知的类型转换：UnknownType
         5. 下标越界异常
      2. 检查型异常

   2. Error

      AWT错误

      JVM错误

      1. 栈溢出：StackOverFlow递归死的话就会报这个错误
      2. Java内存溢出：OutOfMemory：当计算的数大的时候就会报这个错误

2. 处理异常

   1. 五个关键字
      1. try{要捕获的异常代码块}
      2. catch（捕获异常）{}：先小后大
      3. finally{无论捕不捕获都执行的代码块}
      4. throw在方法内部手动抛出异常
      5. throws方法抛出异常
   2. 自定义异常：继承Exception类即可

9.9 Java常用类

1. Object类

   1. hashcode()
   2. toString()
   3. clone()
   4. getClass()
   5. notify()
   6. wait()
   7. equals()

2. String类

   不可变性，它是不可能被改变的，操作量较少的时候使用String

   1. StringBuffer：可变长，append()，当多线程数据量较大时使用
   2. StringBuilder：单线程数据量较大，效率高，不安全。

3. Math类

   常见的数学运算

4. Random类

   生成随机数：UUID

5. File类

   1. 创建文件
   2. 查看文件
   3. 修改文件
   4. 删除文件

6. 包装类

   1. 自动装箱
   2. 自动拆箱

7. Date类

   1. Date
   2. SimpleDateFormat：yyyy -MM-dd HH:mm:ss
   3. Calendar（建议使用）

9.10 集合框架

1. Collection
   1. List（有序可以重复）：建议使用iterator迭代器遍历
      1. ArrayList（常用）：add添加、remove删除、contains包含、size大小
      2. LinkedList链表：链表都有头跟尾
         1. getFirst()
         2. getLast()
         3. removeFirst()
         4. addFirst()
      3. Vector
      4. Stack
   2. Set（无序不可重复）
      1. HashSet（常用）
      2. TreeSet
2. Map
   1. HashMap（重点，常用）在项目中不用数据库存可以用HashMap存，在JDK1.7的数据结构是数组+链表，而在JDK1.8则变成了hash表=数组+链表+红黑树
   2. TreeMap
3. Collections工具类
4. 泛型：约束，避免类型转换之间的问题

9.11 IO流

一切的IO流就是进来和出去，进口和出口，input和output，按照字节说可以分为InputStream和OutputStream，按照字符流分可以分为Writer和Reader，有中文的时候不要用字节流要用字符流。

1. 字节流
   1. 输出：OutputStream
   2. 输入：InputStrem
2. 字符流
   1. Reader
   2. Writer写出
3. 处理流
   1. buffer
      1. bufferInputStrem
      2. bufferOutputStream
      3. bufferReader
      4. bufferWriter
   2. data：通信的时候必须要转换成这个，不转换的话就没办法传
      1. DataInputStrem
      2. DataOutputStream
   3. 转换流
      1. inputStreamReader
      2. OutputStreamWriter
   4. 过滤流：Filter
      1. FilterInputStrem
      2. FilterOutputStream
      3. FilterReader
      4. FilterWriter
   5. print：打印是无法写入的
      1. PrintWriter
      2. PrintStream
   6. Object流：也是四个
   7. 文件流File
4. 节点流
   1. CharArray
      1. CharArrayReader
      2. CharArrayWriter
      3. CharArrayInputStrem
      4. CharArrayOutputStream
   2. 管道流：pipe
      1. PipeOutputStream
   3. String
      1. StringReader
      2. StringWriter

使用这些流的时候要注意序列化

9.12 多线程

1. 进程和线程

2. run方法的调用和start方法的区别

3. 线程创建的方式

   1. Thread：实现了Runnable接口，start0，本地方法Java无权调用，交给底层C处理：Private native void start0()
   2. Runnable：函数式接口，可以被lambda表达式简化
   3. Callable：可以有返回值

4. 静态代理

5. lambda表达式

   函数式编程

   避免内部类定义过多不便于阅读

   手动把内部类推导成lambda表达式

6. 线程的状态

   新建、就绪、运行、阻塞、死亡

7. 常用方法

   1. sleep
   2. join
   3. yield
   4. isLive
   5. start
   6. setPriority
   7. interrupt

8. 线程同步

   1. 多个对象操作同一个资源：并发

   2. 为了处理并发要用到“锁”：队列+锁

   3. Synchronized解决线程同步问题

      1. 同步方法：有弊端的，锁太多了

      2. 同步代码块（常用）

      3. 第一个线程进来拿到锁，后面就要排队了，直到这个人释放锁，后面人拿到锁才能进去

      4. 两个人都抱着对方的锁就会产生死锁，死锁的四个条件

         1. 互斥：一个资源只能被一个资源使用不能被两个进程使用
         2. 请求与保持：一个进程因为一个资源被阻塞了，就不能抱着这个资源不放不然就彻底死了。
         3. 不剥夺条件：即进程已经获得了资源，在没有使用完这个资源之前不能强行的拿走。
         4. 循环等待条件：很多个线程形成了一个圈之后，相互有需求

         代码中出现了以上四种情况，代码一定会产生死锁。当然破坏其中任何一个条件这个死锁就被解开了。

      如果是同步方法的话，如果对方方法加锁的话，在方法中有代码块A，A是只读的，所有人都可以读取，而在方法中B代码块才是可写的，如果加锁的话，A和B都会被锁上，而实际上只用锁B就行了，最常用的还是同步代码块。同步代码块一般锁的是this

   4. Lock（优先级高）：也属于JUC下面的

      一般常用

      1. ReentrantLock常用方法
         1. Lock
         2. tryLock
         3. unLock

   5. 线程同步中的锁的使用顺序是

      优先使用Lock锁，然后是同步代码块，最后是同步方法

9. 线程通信

   线程与线程之间是相互隔离的，如何实现他们的通信，有两个方法

   1. 通过缓冲区：消息队列是它的原型，做一个缓冲让他妈呢存放数据，也就是两个线程都到缓冲区拿数据，从而实现线程的通信。
   2. 标志位（信号灯）：两个线程去读标志位，如果这个标志位发生了变化，两个线程就做相应的变化，也就是现实生活中的红绿灯，两辆车行驶的时候完全没有关系，但是因为有了红绿灯实现了井井有条的通信。

   这里面会用到object的两个方法

   1. wait（）
   2. notifyall（）

10. 线程池（Pool）

    线程每次创建都要消耗资源，如果我们提前准备好一些资源放在池子里，就解决了这个问题

    1. 池化技术，就像数据库的连接池一样，因为经常连接数据库是非常消耗资源的，不停的连接断开，因此就先准备一些连接，用的时候直接用就好了
    2. 池的大小
    3. 最大连接数
    4. 连接时间
    5. 保持时间

9.13 网络编程

1. URL

2. IP

3. 端口

4. Socket变成

5. TCP编程

   三次握手、四次挥手、面相连接

6. UDP编程

   无连接，以包Packet发送

7. 聊天通信

8. 文件上传下载

9. Tomcat

9.14 GUI（可选）

1. AWT

   1. frame
   2. 事件
      1. 鼠标监听事件
      2. 键盘监听事件
      3. 窗口事件
      4. 文本框监听事件
      5. 动作事件

2. Swing

   1. 文本框
   2. 标签
   3. 按钮
   4. 文本域
   5. 面板
   6. 布局方式
   7. 关闭窗口
   8. 列表

9.15 注解和反射

1. 注解
   1. 元注解
   2. 内置注解
   3. 自定义注解
   4. 反射读取注解
2. 反射
   1. Class
   2. 类加载机制
   3. Method
   4. Field
   5. Construct
   6. 破坏私有关键字
   7. 性能分析
   8. 反射获得注解、泛型
3. 单例模式的探究