Java初阶知识总结

一、语法部分

1. java技术结构
   
   1. J2SE ： 表示JAVA标准版
   2. J2EE ： java企业版
   3. J2ME ： 移动版
2. java跨平台
   
   1. 基于JVM
   2. java是跨平台的 ， JVM不是 。
3. 入门程序
   
   1. 每一个java类在编译之后都会产生一个class文件
   2. class文件明 与 类名对应
   3. javac -d 文件存放路径 要编译的java文件
   4. java -cp class文件的存放目录 要运行的类名
   5. 一个java文件中可以有多个类 ， 但是只能有一个公共类
4. 关键字
   
   1. java中有特殊含义的单词 。 53个 goto 、 const — 保留字
   2. 所有关键字都是小写的
5. 标识符
   
   1. 由数字、字母、_ 、组成，不能以数字开头，尽量不要用
   2. 不能使用关键字
   3. 驼峰命名法：
      
      1. 类名、接口名 ： 首字母大小写
      2. 变量名、方法名 ： 排第一个首字母小写、 其余单词的首字母大小写
      3. 包名： 所有单词全部小写 ， 之间用”.”隔开
      4. 常量名 ： 所有单词用大写 ， 之间用”_”隔开
6. 注释
   
   1. 单行注释 ： //
   2. 多张注释 ： /**/
   3. 文档注释 ： /*/ 文档注释中的文字可以提取出来形成文档 。 javadoc -d 存放目录 要提取的文件 注： 只能提取公共类 。
   4. 注释的作用：
      
      1. 解释说明程序
      2. 排错
7. 常量
   
   1. 计算机中不可改变的量
   2. 分类： 整数 、 小数 、 字符、 字符串 、 布尔 、 空常量
8. 进制
   
   1. 一种计数方式
   2. 二进制 ： 0~1 以0b开头 — 从JDK1.7开始
   3. 八进制 ： 0~7 以0开头
   4. 十进制 ： 0~9 程序默认十进制
   5. 十六进制 ： 0~f 以0X开头
   6. 掌握进制之间的转换
9. 变量
   
   1. 存储数据的容器 — 需要指明数据类型
   2. 必须先定义 后使用 先赋值 ， 后使用
   3. 在哪定义在哪使用 。
10. 数据类型及其转换
    
    1. 基本数据类型
       
       1. byte ： 占一个字节 -128 ~ 127
       2. short ： 占两个字节 -32768 ~ 32767
       3. int ： 占四个字节
       4. long : 占8个字节
       5. float ： 占四个字节 但表示的范围比long还要大
       6. double ： 8个字节
       7. char ： 占两个字节 0~65535
       8. boolean ： true\false
    2. 引用数据类型 – 类 、 接口 、 数组
    3. 在java中整数默认int 小数默认double
    4. 如果一个正式超过了int的取值范围 ， 需要加上L 表示long类型的数据
    5. float类型的数据结尾加f
    6. 注意科学计数法 ： double d = 5e5 ; 科学计算法都是用double类型表示的 。
    7. 数据类型的转换 ：
       
       1. 隐式转换 ： 整转小 ， 小转大
       2. 显示转换 ： 大转小 小数转整数
       3. short char ： 转换 注意
11. 运算符
    
    1. 算术运算符
       
       1. 整数运算完成之后结果是整数 。
       2. byte\short 参与运算的时候， 自动提升为int
       3. 整数/0 ： ArithmeticException
       4. 小数/0 ： 结果为正无穷或负无穷 。 infinite
       5. 0|0.0/0.0 0.0/0|0.0： NaN
       6. % ： 结果的符号考表达式左边数字的符号 。 可以对小数进行取余
       7. ++/– ： 注意运算顺序 。 byte\short可以参与自增\自减运算 结果依然是原来的类型 。
    2. 赋值运算符
       
       1. = += 、 -+ 、 *= 、 /= 、 。。。
       2. 除了 = ， 其他的符号要求先有值才能使用 。
       3. 可以用于byte\short
    3. 比较
       
       1. == 、 ！= 、<、> 、<=、>=
       2. 运算结构 是一个boolean值
    4. 逻辑
       
       1. & | ！ ^ || &&
       2. ^ : 相同为假， 不同为真
       3. && 与|| 的短路特性
    5. 位
       
       1. & | ^ << >> <<< >>> ~
       2. 操作的是整数 ， 而且是整数的补码 。
       3. 可以利用&运算判断是否是奇偶数 。
       4. &运算 1 3 7 15 31 注意
       5. 交换两个数的值 a^a = 0 ;
       6. << : 最低位补0
       7. >> : 正数补0 ， 负数补 1
    6. 三元
       
       1. 在运算完成之后 ， 必须有一个结果 ， 运算的结果前后要相容 。
    7. 优先级： () 、 ! 、~ 、++– 、 算数运算符(* \ % + -) 、 比较运算符 、 逻辑运算符( | &)、位运算( << >> <<< & | ^) 、三元运算 、 赋值运算符。
12. 流程控制
13. 数组
    
    1. 本质上是存储一组数据的容器 。 要求数据类型要一致 ， 且数组大小是固定的 。
    2. 数组的内存 ： 数组存储在堆内存中 。 在堆内存中会自动赋予默认值 。
    3. 数组的应用 ：
       
       1. 数组的排序 ： 冒泡 、 选择
       2. 数组元素的查找 ： 循环遍历、 折半查找（要求数组有序 ， 时间复杂度O(log2n)）
       3. 数组的反转 ： 头尾交换
       4. 数组的扩容 ： 本质上是数组的复制 — 实际上是产生了一个新的数组 。
14. 二维数组 ：
    
    1. 存储的元素是数组 。
    2. 定义格式
    3. 二维数组的应用
       
       1. 遍历
15. 方法
    
    1. 为了实现某段代码的复用 ， 将这段代码进行了封装 。 —- 方法
    2. 方法在定义好之后 ， 必须明确返回值类型 。 如果一个方法有明确的返回值类型 ， 则必须确保这个方法有返回值 。
    3. 方法的重载 ： 发生在一个类中 ， 方法名一致 ， 参数列表不同 。 和修饰符 、 返回值类型 、 异常等没有关系 。 本身是一种编译时多态 。
    4. 方法的重写 ： 发生在父子类中 ， 存在了方法签名完全一致的非静态方法 ， 则发生了重写 。 要遵循两等两小一大原则 。
    5. 方法的递归： 是方法调用自己本身 。 — 本质上调用方法 。 如果递归层数太深， 会出现栈溢出StackOverFlowError 。 — 方法在栈中执行 。
    6. 方法的优势：
       
       1. 提高代码的复用性
       2. 使代码结构清晰
       3. 便于模块化开发

二、面向对象

1. 面向对象与面向过程
   
   1. 面向过程 ： 强调的是动作 ， 注重的是过程
   2. 面向对象 ： 寻找的是对象 ， 只要找到了这个对象就自然的拥有了这个对象身上的一切功能
2. 类与对象的关系
   
   1. 类是对象的概括\抽取
   2. 对象是类的具体化
3. 成员变量与局部变量
   
   1. 不同点：
      
      1. 定义位置 ： 成员变量定义在类内方法外 ， 局部变量定义在方法或语句内
      2. 作用域 ： 成员变量作用于整个类 ， 局部变量作用于方法或语句内
      3. 内存位置 ： 成员变量存储在堆内存中 ， 局部变量存储在栈中
      4. 生命周期 ： 成员变量随着对象的创建而产生 ， 并且在堆内存中自动获取一个默认值， 随着对象的回收被解析 。 局部变量在方法或语句执行的时候被创建 ， 方法执行完之后立即被回收 。
4. 构造函数
   
   1. 与类同名 ， 没有返回值类型
   2. 构造函数可以被重载 。
   3. 构造函数中可以写return ， 用于规避不合理的数据 。
   4. 作用 : 标志对象创建的开始和结束 。 创建父类对象 构造代码块 对象创建的最后一步才是调用构造函数 。
5. this
   
   1. 代表当前对象的引用
   2. 在本类中用this调用非静态方法和属性
   3. this语句表示在本类的构造函数中调用本类的其他构造函数
6. 代码块
   
   1. 局部代码块
      
      1. 定义在方法或代码块中
      2. 限制变量的声明周期和适用范围 ， 提高内存的利用率 。
   2. 构造代码块
      
      1. 定义在类内 。
      2. 在创建对象时先于构造方法执行 ，
      3. 作用： 用于完成一些对象初始化的操作 。
7. 面向对象的特征
   
   1. 封装 、 继承 、 多态 、（抽象）
8. 封装
   
   1. 体现形式 ： 方法 、 属性私有化 、内部类
   2. 优点 ：
      
      1. 复用性
      2. 安全性
      3. 使代码结构更加紧密（高内聚） 。
9. 继承
   
   1. 使用 extends 关键字 — java中类支持的是单继承 、 多实现
   2. 单继承和多继承的优劣比较
      
      1. 多继承能更好的提高代码的复用性 ， 但是会存在方法调用的混乱 ； 单继承能避免方法调用的混乱 ， 但是提高复用性上不如多继承 。
   3. 优点 ： 复用性 ， 安全性 ， 同一继承结构 。
10. 多态
    
    1. 编译时多态 ： 方法的重载
    2. 运行时多态 ： 向上造型 、 方法的重写 —- 基于继承 。
    3. 对象的多态（向上造型） 行为的多态（方法的重载和重写）
    4. 多态针对的是对象的行为而不是对象的属性 。
    5. 优点：
       
       1. 提高了代码的灵活性
       2. 配合反射实现解耦
11. 权限修饰福
    
    1. public protected 默认 private
12. super
    
    1. 代表父类对象的引用 ， 可以用于在子类中调用父类中的方法或属性
    2. super() : super语句 表示在子类构造函数中调用父类对应形式的构造函数 ， 必须写在构造函数的第一行
    3. 每个子类的构造函数都直接或间接的有super()
13. static
    
    1. 静态变量
       
       1. 在类加载的时候被加载到方法区中的静态区 ， 并且被自动 赋予初始值
       2. 先于对象存在 ， 可以直接通过类名调用 。
       3. 对象中存储的是该变量在静态区中的地址 ， 所以静态表变量是被该类的所有对象共享的。
    2. 静态方法
       
       1. 随着类的加载被加载到方法区中的静态区 ， 但只是存储在静态区 ， 没有执行 方法被调用时是到栈内存中执行 ， 由于静态方法是先于对象存在的 。 所以静态方法中不能调用非静态的属性或方法 。
       2. 静态方法不能被重写
    3. 静态代码块
       
       1. 在类被加载的时候执行一次 ，
       2. 代码执行顺序 ： 先父后子 ， 先静后动 。
14. final
    
    1. 常量
       
       1. 值不可变 — 值得是直接值 ， 对应引用类型来说是地址不可变 。 如果常量是一个成员属性 ， 要求在对象创建完成之前第一次给值 ； 如果该常量是静态的 ， 要求在类加载完成之前给值 。
    2. 最终方法 ； 不能被重写， 可以被重载 ， 可以被继承
    3. 最终类 ： 不能被继承
15. adstract
    
    1. 抽象类 : 不能实例化 ， 但是有构造函数 ； 抽象类一定不是最终类 ， 抽响雷中可以有一切的属性和方法 。 抽象类中不一定有抽象方法 ， 但抽象方法所在的类一定是抽象类 。 一个类如果继承了抽象类 ， 则必须重写其中的抽象方法 ， 或者也声明为抽象类
    2. 抽象方法 ： 可以被重载 必须被重写 — 所以不能用static 、 final 、 private
    3. 修饰 ， 如果一个抽象方法使用默认修饰符修饰 ， 则要求子类 必须和父类 同包 。
16. 接口
    
    1. 类 用implements 实现接口 ， 必须实现这个接口中所有方法
    2. java中接口支持多实现
    3. 接口与 接口之间时多继承
    4. 在JDK1.7及之前 ， 接口中只允许存在抽象方法
    5. 接口中的方法默认是用public abstract修饰
    6. 接口中属性默认 public static final修饰
    7. 作用 ： 统一代码结构
17. 内部类
    
    1. 方法内部类
    2. 成员内部类
    3. 静态内部类
    4. 匿名内部类
    5. 除了静态内部类 ， 其余内部类均不允许 定义静态属性或方法 ， 但是可以定义静态常量
    6. 方法内部类使用当前类中的数据时 ， 要求这个数据是一个常量 。
    7. 注意成员内部类以及静态内部类在类外创建对象的方式 。
    8. 除了 静态内部类 ， 都可以使用外部类的属性和方法， 但是静态内部类只能使用外部类的静态属性或方法 。
18. 包
    
    1. package 声明
    2. import 导入
    3. package 只能放在java文件中首行 ， 一个java文件中只能存在一个package语句
    4. • 表示通配符 ， 表示导入包下的所有类 ， 但是不包括子包下的类
    5. 注意java中常用的包 。
    6. 如果用的是同包类 ， 或者是java.lang.*在得类 ， 可以不用写导包语句
19. 垃圾分带回收
    
    1. 针对的是堆内存
    2. 将堆内存分为新生代和老生代 新生代又分为伊甸园区和幸存区
    3. 初代回收 、 完全回收 。

三、Api

1. Object
   
   1. java中顶级父类 — java中所有类都默认直接 或间接的继承了Object 。
   2. 掌握Object中的重点方法
      
      1. getClass() : 获取对象的实际类型
      2. equals(): 默认比较的是对象的地址 ， 要求手写
      3. hashCode() : 获取32位二进制的哈希码 哈希码可以认为是唯一的
      4. toString() : 默认返回对象的地址
2. String
   
   1. 字符串是一个常量 ， 可以被共享
   2. 注意不同的方式创建字符串对象的个数
   3. 如果需要拼接多个字符串的时候 ， 建议使用StringBuilder .如果拼接较少的字符串的时候 ， 可以使用+
   4. StringBuilder 本身是一个线程不安全的类 ， 而 StringBuffer是一个线程安全的类
   5. String是一个最终类 。
3. Pattern
   
   1. 一个代表正则的类
   2. 正则表达式就是用于指定规则的一系列形式 。
   3. 每个字符在匹配的时候 ， 只能跟一个数量词 。
4. 包装类
   
   1. 每种基本类型都有对应的包装类 。 int – Integer char – Character
   2. 自动封箱 : 将基本类型直接赋值给对应引用类型 调用了valusOf()
   3. 自动拆箱 ： 将引用类型直接赋值给对饮的基本类型 JDK1.5特性 实际上是调用了 ***value()
   4. 如果在-128~127之间 则判断的是实际值 ， 否则判断的是地址 。
5. 数学类
   
   1. Math类 ，最终类 构造函数被私有化 提供好了一系列基本类型的初等运算 。
   2. BigDecimal ： 可以精确运算的一个类 。 — 在使用的时候需要将参数一字符串的形式传递 。
6. 日期类
   
   1. Date|Calendar — 掌握字符串与日期格式的转换 。
7. 异常
   
   1. 顶级父类 Throwable
   2. Error : 合理的应用程序出现的例外 — 无法处理
   3. Execption ： 合理的应用视图捕获的问题 。
      
      1. 编译时异常（已检查异常） ： 编译时期就已经出现 ， 要求必须处理
      2. 运行时异常（未检查异常） ： 在编译时期不出现， 运行时出现 ， 出现之后可以处理也可以不处理 。 所有运行时异常的父类RuntimeException
   4. 异常的捕获方式：
      
      1. 多个catch 分别捕获 ， 分别处理
      2. 捕获一个父类异常 统一处理
      3. 将多个异常用 | 隔开 分组处理
   5. try{} catch(){} finally{}
8. 集合
   
   1. 顶级接口 collection ： list set queue
   2. list ：
      
      1. 列表 元素有序 ， 可重复
      2. ArrayList : 初始容量为10 每次扩容一半 ， 是一个线程不安全的集合 ， 便于查询， 不便于增删
      3. LinkedList : 基于链表 ， 内存空间不连续 是一个线程不安全的集合
      4. Vector ： 基于数组 。 内存空间连续 默认初始容量为10 每次扩容一倍 线程安全
      5. Stack ： 先进后出 继承了Vector
   3. Set : 散列 集合 ， 元素 无序不可重复
      
      1. HashSet ： 默认初始容量 16 加载因子0.75 每次扩容一倍 ， 线程不安全
   4. Queuue 队列 先进先出
9. 泛型
   
   1. 参数化类型 JDK1.5
   2. 泛型 的擦除 — 编译期
   3. 看懂泛型的继承

四、内存

1. 栈内存 ：
   
   1. 作用 ： 执行代码块 存储局部变量 — 执行代码块 。 — 计算
2. 堆内存 ： 存储对象 ， 对象在用完之后被GC回收
   
   1. 新生代
      
      1. 伊甸园区
      2. 幸存区
   2. 老生代
3. 方法区 ：
   
   1. 静态常量池 ： 存储类的成员属性和成员方法
   2. 静态区 ： 存储的是静态属性和静态方法 ， 静态属性存在静态区中后会自动赋予默认值
   3. 运行时常量池 ： 存储的是计算机常量 ， 以及final修饰的常量的副本 。
   4. 方法区存储类的信息 。 一旦存入就不再移除 。 一旦满了再存放元素时就会报错OutMemoryError
4. 本地方法栈 ： 存储本地方法
5. 寄存器 ： 负责程序的计数 和任务的调度