【无标题】

Java：简单性 可移植性 安全性 并发性 

一. Java基础语法

1）基本数据类型：

数据类型	默认值	大小	类型
byte	0	1字节	数值型|字节型
short	0	2字节	数值型|整型
int	0	4字节	数值型|整型
long	0L	8字节	数值型|整型
float	0.0F	4字节	数值型|浮点型
double	0.0D	8字节	数值型|浮点型
boolean	false	1比特	布尔型
char	'\u0000'	2字节	字符型

        精确的数值使用BigDecimal进行处理 表示一个任意大小且精度完全准确的浮点数

2）引用数据类型：除了基本数据类型 都是引用数据类型 （ 数组  接口  类）

二者差别：

         a) 变量名指向具体的数值 存储在栈上

         b) 变量名指向存储对象 指向的对象存储在堆上

3）流程控制

        a) if(布尔表达式){}else{}

        b) 三元表达式 ：布尔表达式？表达式1：表达式2

        c) switch-case 枚举类作为语句的变量也很常见 使用break防止穿透现象

        d) for循环 for(初始变量；条件；自增/自减){循环体} 循环的次数固定

             foreach循环  for(元素类型 元素：数组或集合)

        e) While循环 while(条件){循环体} 循环的次数不固定

        f) do-while do{循环体}while(条件) 循环的次数不固定 并且至少执行一次循环

        g) break用于中断循环 

二. 数组

1）增：add    删: remove   改: set    查: get

2）ArrayList

               get() 时间复杂度为$O(1)$ 直接从底层数组根据下标获取 和数组长度无关

                add() 默认添加到数组末尾 不扩容 时间复杂度为$O(1)$ 扩容复杂度$O(n)$

                remove() 删除指定位置上的元素删除 复制底层数组 复杂度为$O(n)$

3）LinkedList

                get() 复杂度为$O(n)$ 遍历整个链表 first和last直接存储的 时间复杂度为$O(1)$

                add() 默认将元素添加到链接尾末 时间复杂度为$O(1)$ add(index,元素) 新元素插入指定位置 先遍历 进行插入 时间复杂度$O(n)$

                remove() 指定位置删除 node(index) 查找元素 时间复杂度$O(n)$

4）数组的循环方式

   for循环   迭代器   for-each

注意：不要在for-each循环中进行元素的remove/add元素 remove元素 使用Iterator 并发操作 对Iterator对象加锁

正确删除元素：使用iterator.remove

                        使用foreach remove后break(没有重复元素时)

5）continue 循环时 立即结束本次循环 进入下次循环 

三.运算符

1.关系运算符  + - * / %(取余)  (前自增)++ --(后自减)  

        1）整型和整形运算结果是整型 不会出现浮点型

        2）Infinity 无穷大 NAN 这不是一个数字

2.关系运算符 ==  !=  >  <  >=  <=

3.位运算符 &   |   ^(相对应位置相同)   ~(按位取反 0 -> 1  1 -> 0)    <<(按位左移)   >>(按位左移) 

        >>>(按位右移补零)  integer.tobinaryString(二进制)

        10 >> 2 / 10 * 2 ^ 2

4.逻辑运算符

&&  ||  !

5.赋值运算符  注意类型

6. 三元运算符  a > b ? a : b

四.注释

单行：//

多行：/**/

文档注释：类 字段 方法

注释规约：1）类 字段 方法 必须使用文档注释 

                  2） 方法上要有 返回值 参数 异常 方法做了什么 实现什么功能 

                  3）类 需添加 创作者和日期 

                  4）枚举类的字段需有注释 说明每个数据项的用途

五.面向对象

1.类：定义物体 可以包含字段 方法 构造方法

        1）抽象类：关键字abstract修饰 不能实例化 通过子类继承抽象类

        ·a) 可以定义普通方法 必须实现继承抽象类中的抽象方法

        ·b) 场景：通用功能被多个子类复用时  子类扩展实现

 2.变量

        1）成员变量：类中 方法体外 对象创建时创建 对象销毁时销毁 由默认值 实例变量 编译时不占用内存空间 运行时获取内存 对象实例化后 字段存内存 

        2）局部变量：方法 构造方法 语句块中  被执行时创建 执行完 销毁 栈上分配 没有默认值 声明后需要初始化

        3）静态变量：static 关键字声明的变量 成为静态变量 被类直接访问 类名.变量名 存储在静态区 随着类的加载而加载 只加载一次 

        4）常量：final修饰的成员变量 数据的值不会发生改变  常量名必须大写

3.方法：实现代码的复用性 被调用时才会执行 

        ·a）访问权限：指定方法的可见性 public private protected(同一个包的类 不同包的子类) default(同一个包中类可见)

        ·b）返回类型：基本数据类型 对象 集合 void(不返回数据)

        ·c）方法名(参数){方法体}：驼峰命名法  重载(同名方法 不同参数) 

        ·d）参数：参数类型+参数名 可以为空

        ·e）方法签名：每一个方法都有方法签名 方法名+参数

       · f）方法体：存放执行代码

        1）实例方法：不用static修饰 调用实例方法 需创建类的对象 有两种特殊类型(getter()、setter()) 

        2）抽象方法：在抽象类中声明 另一个类继承抽象类后需要实现抽象方法 

        3）构造方法：类被实例化时 会调用构造方法 此时 才会被分配内存空间 每次new对象时 构造方法至少会被调用一次

        ·a) 有两种类型：无参构造方法 有参构造方法

        ·b) 构造方法名字必须和类名一样 没有返回类型 不能被 abstract static final synchronized修饰

        ·c) 默认构造方法：构造方法中没参数 也称无参构造方法 主要是为对象的字段提供默认值

        ·d) 有参构造方法：参数可以一个或多个 为不同对象提供值 

4.代码初始化：用于初始化一些成员变量  类实例化时执行 实际上是在构造方法中执行 只是很靠前   默认情况下 子类的构造方法在执行时会主动去调父类的构造方法 

5.接口：interface关键字修饰 包含常量和方法(抽象、静态、默认)

        1）接口定义的方法或者常量会自动添加public关键字

        2）定义变量时会在编译的时候自动加上public static final 实际就是定义一个常量

        3）没有使用private、default、static修饰的方法是隐式抽象的 编译时会自动加上public abstarct 也就是一个抽象方法

        4）定义的静态方法需要通过接口名调用 

        5）接口允许定义变量 抽象方法 静态方法 默认方法 

        6）不允许实例化 可以是空的 不可以使用final关键字修饰接口 不可以使用private、protected、final修饰抽象方法 

        7）类是单继承 接口多实现 实现多态(同一事件不同结果)

6.关键字：

        1）static 静态

        ·a) 静态变量(存放在静态区) 随着类的加载而加载 并且只加载一次 任何对象对其修改都会得到保存 

        ·b) 静态方法 属于这个类而不是这个类的对象 静态方法可以访问静态变量

        ·c) 静态方法不能访问非静态变量和调用非静态方法

        ·d) 静态代码块:static{} 初始集合时用的比较多 

        ·e) 静态内部类:静态内部类不能访问外部类的所有成员变量 静态内部类可以访问外部类的所有静态变量 包含私有静态变量 外部类不能声明为static

        2) this

        ·a) 调用当前类的构造方法 作为参数在方法、构造方法中传递 

        ·b) 作为方法的返回值 返回当前类的对象

        ·c) 必须放在方法第一行

        3) super

       ·a) 指向父类方法

        ·b) 调用父类的方法

        ·c) super() 可以调用父类的构造方法

        3) final

        ·a) 修饰的变量 不可更改 声明的成员变量必须有默认值 和static修饰的变量叫做常量名字需要大写 

        ·b) 修饰的方法 不能被重写 

        ·c) 修饰的类 不能被继承 （String）

 六.方法重写和重载

1.重载：改变参数类型 传递的参数没有找到匹配的方法时 会发生隐式的类型转换

         两同一不同：同一个类 方法名相同 参数不同

2.重写：子类和父类的方法名相同 参数相同 继承关系 

        两同两小一大：方法名相同 参数相同 子类声明异常小于等于父类 返回值小于等于父类 子类的访问权限大于父类

七.值传递和引用传递

1）参数按照值的方式在两个方法之间传递时 调用者和被调用者其实是用的两个不同的变量 改变不会相互影响 java是按照值传递

 2）参数按照引用传递的方式在两个方法之间传递时 被调用者和调用者使用的是同一个变量 变量被修改 双方都会发生改变 

3）对于基本类型 赋值会直接改变变量的值 原来的值被覆盖 对于引用类型 赋值运算符会改变对象引用中保存的地址 地址被覆盖 但原来的对象没有被覆盖 

. HashMap

Hash方法就是为了增加随机性 让元素更加均衡的分布 减少碰撞

HashMap是线程不安全：多线程下扩容会死循环 多线程下put会导致元素丢弃 put和get并发时会导致get到null

.异常处理 Throwable

error 错误 致命错误 不容易修复 例如：内存溢出 OutOfMemoryError

exception 异常 在可控范围内 ：

        1）checked异常 检查型异常 编译时异常

        2）unchecked异常 非检查型异常 运行时异常

try-catch-finally：

        finally必须有try块 不可以单独使用 但不是必选项

throw和throws

throw：主动抛出异常  throw new + 参数（"报错信息"） 方法体里  只能抛出一个异常

throws：声明异常  throws+异常的名字 方法上 可以多个 ","隔开

尽量使用try-with-resource来关闭资源

.常用工具类

1.创建数组：copyOf 复制指定的数组 截取或用null填充

                     copyOfRange 复制指定范围内的数组到一个新的数组

                     fill 数组进行填充

2.数组转list：Arrays.toList 转化后的数组长度是固定的 五饭删除或添加

3.SetAll()：数组的元素进行填充 

4.(object) instanceOf (type) 判断兑现是否符合指定的类型 boolean类型