复习

复习：

1. 环境搭建： jdk - 》 dos 窗口，输入 javac 和 java 指令，

安装之后，配置环境： java_home 、 path 、 classpath

2. java 程序： class -> 类

3. 包： package ， 编译： javac -d . 文件名 .java

运行： java 包名 . 类名

4. 编码规范：变量 + 方法：第一个单词首字母小写，其余单词首字母大写

类：每个单词首字母大写

常量：全大写

包名：全小写

5. 分支结构： if 分支 + switch...case 分支 ( 了解 )

6. 循环结构： for 循环 [ 重点 ] 、 while 循环 |do..while 循环

7. 函数：被 方法 替换

8. 数组：应用底层设计，通常使用集合

9. 面向对象和三大特性 ( 封装、继承、多态：子类型的对象存储在父类型的引用中 )

10. 三个修饰符 (abstract 、 final 、 static)

11. 接口：关键字： interface

12. 内部类： lambda 表达式

第一章：常用类【实际开发重点 - 细节】

一、 Object 类

1. Object ：位于 java.lang 包中，是所有类的父类 ( 直接父类或是间接父类)

(1) Object 类型的引用可以 存储任意类型的对象，体现多态的应用

(2) Object 中定义的方法，所有类都可以使用 ( 访问权限允许 )

(1) getClass() ：返回引用中实际存储的对象类型

(2) int hashCode() ：返回哈希码值

注意：不同的对象返回不同的哈希码值

(3) boolean equals(Object obj) ：判断两个对象的内容是否相等，相等 -true; 不等 -false

(4) String toString()：返回对象的字符串形式

二、包装类

1. 包装类：基本数据类型对应的类成为包装类 ( 位于 java.lang 包中 )

2. 基本数据类型对应的包装类

基本数据类型 包装类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

// 基本数据类型 - 》 包装类型

int a = 36;

Integer i2 = new Integer(a);

System.out.println(i2);

Integer i3=Integer.valueOf(a);

System.out.println(i3);

/* public static Integer valueOf(int i) {

if (i >= -128 && i <= 127)

return IntegerCache.cache[i + (-IntegerCache.low)];

return new Integer(i);

} * */

// 包装类型 -> 基本数据类型

int n = i2.intValue();

System.out.println(n);

// int -> String

int a2 = 89;

String str1 = a2+"";

System.out.println(str1);

System.out.println(a2+1); // 90

System.out.println(str1+1); // 891

// String -> int

int n3 = Integer.parseInt("87a");

System.out.println(n3);

注意： String 转换为 int 类型，转换的 String 需要为纯数字内容，否则运行时报错，错误信息为：

java.lang.NumberFormatException( 数字格式转换异常)

4. 自动装箱和自动拆箱：基本数据类型和包装类型之间可以直接相互转换的

5. 包装类通常可以区分有效数据和无效数据，例如： 0 和 null

三、 String 类

1. 获取字符串的方式 【企业面试】

(1) String str1 = "hello";

这种获取字符串的方式，在串池中完成字符串对象的创建，有 - 不再创建

(2) String str2 = new String("world");

这种获取字符串的方式，先在堆空间中创建一个字符串对象，再查看字符串串池中是否存在该对象，存在 - 无需创

建，不存在 - 再次创建

字符串：由一个或是多个字符组成，用双引号引起来，底层为 字符数组进行存储 (char[] value) ，具有下标，默

认从 0 开始，依次为 1 、 2 、 3 、 .....

2. 常见的方法：【实际开发应用 + 计算机算法竞赛】

String str = "Hello";

// 根据下标获取对应字符

// 指定合理的下标范围，否则： java.lang.StringIndexOutOfBoundsException

char c = str.charAt(2);

System.out.println(c);

System.out.println(str.length());

// 遍历字符串

for(int i=0;i<str.length();i++){

System.out.println(str.charAt(i));

}

System.out.println(str.indexOf("elle"));// 获取字符在当前字符串出现的第一个字符下标，

没有，返回 -1

System.out.println(str.contains("ell"));// 判断指定字符串是否在当前字符串中存在

System.out.println(str.toLowerCase()); // 大写 - > 小写

System.out.println(str.toUpperCase()); // 小写 - 》大写

System.out.println(str.startsWith("he"));// 判断是否以 xx 开头

System.out.println(str.endsWith("o"));// 判断是否以 xx 结尾

String str2 = " he llo";

System.out.println(str2);

System.out.println(str2.trim()); // 去除前后空格

String str1 = new String("Hello");

String str2 = new String("hello");

System.out.println(str1 == str2);

System.out.println(str1.equals(str2));// 判断字符串内容

System.out.println(str1.equalsIgnoreCase(str2));// 判断字符串内容，忽略大小写

String str = "hello-world-java";

String[] strs = str.split("-");

for(int i=0;i<strs.length;i++){

System.out.println(strs[i]);

}

String str3 = "he89weHfyfs9gguFYFYFY";

// 统计以上字符串中大写字母的个数，并打印输出

int count = 0;

for(int i=0;i<str3.length();i++){

char c = str3.charAt(i);

if(c >='A' && c<='Z'){

count++; 3. 不可变性： String 字符串是常量，创建之后不可改变；字符串字面值存储在串池中，可以共享

4. 可变长的字符串：

第二章：集合 【开发应用重点 + 考试重点 + 面试重点 -> 底层】

一、理解

1. 概念：一种操作便利的对象容器，存储多个对象，多数情况下可替代数组。

2. 位置：所有集合的接口和相关实现类都是位于 java.util 包中

3. 学习集合从一下几个内容进行：

4. 集合的分类：

}

}

System.out.println(count);

StringBuffer ：可变长字符串， JDK1.0, 线程安全，运行效率慢。

StringBuilder ：可变长字符串， JDK5.0, 线程不安全，运行效率快。

(1) 集合的特点

(2) 集合的常用方法

(3) 集合的实现类

(4) 集合的遍历

(1) Collection 集合体系

-> List 集合

-> Set 集合

(2) Map集合体系

二、 Collection 集合体系

1. 父接口： Collection

2. 子接口： List

(1) Collection 接口的特点：存储多个对象，即存储数据类型 Object

(2) 方法：

boolean add(Object obj) ： 添加一个对象 【重点】

int size() ：返回此集合中的元素个数 【重点】

boolean contains(Object o) ： 检查此集合中是否包含 o 对象

boolean remove(Object o) ：在此集合中移除 o 对象

void clear() ：清空此集合中的所有对象。

boolean isEmpty() ：判断此集合是否为空

(3) 实现类：具体看子接口

(4) 遍历：具体看子接口

(1) List 接口的特点：存储 Object 类型的对象，有序、有下标，元素可以重复 ( 下标从 0 开始，依次为 1 、 2 、 ...)

(2) 方法： List 是 Collection 的子接口，所以 Collection 接口中定义的方法 List 都可以使用，同时自身也定义

了一些方法

Object get(int index) // 返回集合中指定位置的元素 【重点】

Object remove(int index) // 移除 index 位置上的元素

Object set(int index, Object element) // 替换 index 位置上的元素

(3) 实现类： ArrayList

(4) 遍历：

a. 下标遍历：

// 控制集合的下标：从 0 开始，到 size-1

for(int i=0;i<list.size();i++){

// 根据下标获取对应数据： get

System.out.println(list.get(i));

}

b. forEach 遍历：

for( 泛型类型 变量名 : 集合名 ){

// 利用变量名操作集合元素

(5) 泛型集合：强制约束集合中的元素类型统一

ArrayList< 数据类型 > 集合名 = new ArrayList< 数据类型 >();

ArrayList< 数据类型 > 集合名 = new ArrayList<>(); --> 数据类型可以省， <> 保留

注意： <> 前后的数据类型必须统一；

基本数据类型的泛型需要使用对应的包装类型

(6) 不同实现类区别：

ArrayList ：

底层用数组实现，查询快，增删慢

JDK1.2 提供，线程不安全，并发效率高。

Vector ：

底层用数组实现，查询快，增删慢

JDK1.0 提供，线程安全，并发效率低。

LinkedList ：

底层用链表实现，查询慢，增删快

JDK1.2提供，线程不安全，并发效率快。

(1) 特点：存储多个 Object 类型的对象，无序、无下标、元素不可以重复 ( 内容不允许重复 )

(2) 方法：继承于 父接口 Collection

(3) 实现类： HashSet

注意：为了保证存储在 HashSet 集合中对象内容不重复，需要覆盖 equals 和 hashCode 方法

LinkedHashSet ：存储多个 Object 类型的对象，按照添加顺序进行存储、无下标、元素不可以重复 ( 内容不允

许重复 )

(4) 遍历方式：

forEach 遍历：

for( 泛型类型 变量名 : 集合名 ){

// 利用变量名操作集合元素

}

三、 Map 集合体系

1. 特点：用于存储任意键值对 (Key-Value) ；键 (key) ：无序、无下标、不允许重复 ( 唯一 ) ; 值 (value) ：无序、无下

标、允许重复

2. 常见的方法：

}

(5) 泛型集合：强制约束集合中的元素类型统一

ArrayList< 数据类型 > 集合名 = new ArrayList< 数据类型 >();

ArrayList< 数据类型 > 集合名 = new ArrayList<>(); --> 数据类型可以省， <> 保留

注意： <> 前后的数据类型必须统一；

基本数据类型的泛型需要使用对应的包装类型

(6) 不同实现类区别：

ArrayList ：

底层用数组实现，查询快，增删慢

JDK1.2 提供，线程不安全，并发效率高。

Vector ：

底层用数组实现，查询快，增删慢

JDK1.0 提供，线程安全，并发效率低。

LinkedList ：

底层用链表实现，查询慢，增删快

JDK1.2 提供，线程不安全，并发效率快。

(1) 特点：存储多个 Object 类型的对象，无序、无下标、元素不可以重复 ( 内容不允许重复 )

(2) 方法：继承于 父接口 Collection

(3) 实现类： HashSet

注意：为了保证存储在 HashSet 集合中对象内容不重复，需要覆盖 equals 和 hashCode 方法

LinkedHashSet ：存储多个 Object 类型的对象，按照添加顺序进行存储、无下标、元素不可以重复 ( 内容不允

许重复 )

(4) 遍历方式：

forEach 遍历：

for( 泛型类型 变量名 : 集合名 ){

// 利用变量名操作集合元素

} V put(K key,V value) ：往 Map 中存储一个键值对，如果 key 在 map 中已经存在，则新值覆盖旧值；

如果 key 在 map 中不存在，则直接存储，返回值为 null 。

V remove(K key) ：根据键删除集合中对应的键值对，返回被删除的 value 。

V get(K key) ：根据 key 查询对应的 value 。

int size() ：获取集合中键值对的数量

boolean containsKey(K key) ：判断 map 集合中是否包含 key 的键，返回 true/false.

boolean containsValue(V value) ：判断 map 集合中是否包含 value 的值，返回 true/false

3. 常见的实现类： HashMap

4. 遍历方式：

// 1. 获取 map 中所有的键

Set<String> ks = map.keySet();

// 利用 forEach 遍历 Set 集合，获取每个键

for(String s:ks){

// 通过键 获取 对应的值 :get

System.out.println(s+"-"+map.get(s));

}

System.out.println("------- 值遍历 ----- 了解 ----");

// 2. 获取 map 集合中所有值

Collection<String> cs=map.values();

// 利用 forEach 遍历 集合获取每个值

for(String c:cs){

System.out.println(c);

}

System.out.println("------ 键值对 -----------");

// 3. 获取 map 集合中所有的键值对

Set<Map.Entry<String,String>> ks22=map.entrySet();

// 通过 遍历 集合 获取每个键值对

for(Map.Entry<String,String> keyValue:ks22){

// 获取 键

String key=keyValue.getKey();

// 获取 值

String value=keyValue.getValue();

System.out.println(key+"------"+value);

}

5. Map 其他的实现类：

HashMap 【重点】： JDK1.2 版本，线程不安全，运行效率快 ; 允许用 null 作为 key 或是 value 。

LinkedHashMap:HashMap 的子类，按照元素添加的顺序进行存储。

Hashtable ： JDK1.0 版本，线程安全，并发效率慢；不允许 null 作为 key 或是 value 。

Properties ： Hashtable 的子类，要求 key 和 value 都是 String 。通常用于配置文件的读取。

TreeMap ：实现了 SortedMap 接口 ( 是 Map 的子接口 ) ，可以对 key 自动排序。 第三章：异常

一、异常的理解

1. 异常：程序运行过程中出现的非正常的情况。

2. 异常的分类：

二、异常的分类：【企业面试重点 + 考试重点】

1. Throwable ： Throwable 类是 Java 语言中所有错误或异常的超类 ( 父类 )

2. 子类： Error ，代表错误

3. 子类： Exception ，代表异常

(1) 父类型： Throwable ，位于 java.lang 包中， Throwable 类是 Java 语言中所有错误或异常的超类 ( 父类 )

(2) 子类： Error ，代表错误

(3) 子类： Exception ，代表异常

(1) 提供的构造方法：

Throwable(): 无参数的构造方法

Throwable(String message) ：有参数的构造方法，参数代表异常信息

(2) 提供功能方法：

public void printStackTrace() ：打印输出异常的详细信息，用于开发人员调整程序应用

public String getMessage() ：获取字符串类型的异常信息，用于给用户展示提示信息

(1) Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题

(2) 案例：内存空间不足，或是 Java 虚拟机方法调用时栈溢出 java.lang.StackOverflowError( 栈溢出 ) 。

(3) 特点：遇到这样的错误，程序中无法处理。

(1) 运行时异常： RuntimeException 及其子类异常都为运行时异常

a. 特点：编译过程编译器不检测，运行过程中报错

b. 处理：这种异常可以避免，可以处理也可以不处理。

c. 常见的运行时异常：

java.lang.ArrayIndexOutOfBoundsException( 数组下标越界 )

java.lang.IndexOutOfBoundsException( 下标越界 -List 集合 )

java.lang.StringIndexOutOfBoundsException( 字符串下标越界 )

java.lang.ClassCastException( 类型转换异常 )

java.lang.NullPointerException( 空指针异常 )

java.lang.NumberFormatException( 数字格式转换异常 )

(2) 非运行时异常：和 RuntimeException 没有任何继承关系的异常类，称为非运行时异常 ( 已检查异常 )

a. 特点：编译过程编译器检测，编译过程中报错

b. 处理：必须处理，否则无法运行

c. 案例： Class.forName("hello");

d. 注意：编译报错可能出现的原因：

i. 语法错误 -> 修正 语法代码

ii. 出现非运行时异常 - 》需要异常处理才能解决 三、异常产生的原因

1. 自动产生异常：

2. 手动产生异常：

四、异常的传递

五、异常的处理【企业开发的重点】

1. 消极处理异常：声明异常

2. 积极处理异常：捕获异常

(1) 运行程序时 , 遇到错误的代码 , 自动产生异常 , 程序自动终止

(2) 结果：程序因为异常而被终止

(1) 关键字： throw

(2) 位置：必须应用方法内部

(3) 语法： throw new 异常类名();

(1) 位置：定义在方法的内部

(2) 语法：

try{

// 可能出现异常的语句

}catch(){

// 当异常出现时，执行的语句

}

(3) try 后面可以跟多个 catch 结构，从上往下依次匹配；借助多态的语法，利用父类型处理子类型的异常，但是子

类在前，父类在后

(4) finally ：应用在积极处理异常语法中

i. finally 中定义的语句：不管有没有都会执行 六、自定义异常类

1. 定义一个类继承 异常类

2. 提供 两个构造方法

七、方法的覆盖【终极版 -- 企业面试重点 + 企业级开发重点 - 细节处理 + 考试重点】

ii. try..catch...finally

try{

// 可能出现的异常语句

}catch( 异常类名 e){

// 异常处理语句

}finally{

// 在任何情况下都必须执行的代码

}

(1) 定义异常类如果为运行时异常，则需要继承 RuntimeException

class CheckedPasswordException extends RuntimeException{}

(2) 定义异常类如果为非运行时异常，则需要继承 Exception

class CheckedPasswordException extends Exception{}

(1) 一个无参数的构造方法

(2) 有参数的构造方法：带有字符串类型参数的构造方法

public CheckedPasswordException(String message){

super(message);

}

// 自定义异常类

class CheckedPasswordException extends Exception{

public CheckedPasswordException(){}

public CheckedPasswordException(String message){

super(message);

}

}

1. 子类的方法名、形参列表、返回值类型 和 父类相同

2. 子类的访问修饰符和父类相同或是比父类更宽

3. 子类不能抛出比父类更多、更宽的异常 第四章：多线程

一、进程理解

1. 进程：操作系统 (OS) 中，正在运行的一个应用程序。

2. 多进程的并发执行原理：微观上串行，宏观上并行

3. cpu 分配 cpu 时间片，哪个进程获取 cpu 时间片，那个进行执行自身任务

二、线程的理解

1. 线程：在一个进程中，可以同时执行多个任务，每一个任务就可以说是一个线程。线程是进程的执行单元，也

称为轻量级进程。

2. 主线程：从 main 方法开始执行，以 main 方法的退出作为结束，即 main 函数 是主线程的执行体。

3. 多线程并发原理：微观上串行，宏观上并行

4. 线程的组成部分：

三、代码实现多线程

1. 第一种方式：

2. 第二种方式：

四、线程的状态

(1) CPU ：操作系统 (OS) 分配时间片。

(2) 数据：堆空间共享，栈空间独立。

每一个线程都有自己的栈空间 ; 多个线程可以共享同一个堆空间

(3) 程序代码

(1) 定义一个线程的子类，定义一个继承 java.lang.Thread 类

(2) 覆盖 Thread 类中的 run 方法：定义线程的任务

(3) 创建线程对象

(4) 开启线程：利用线程对象调用 start ， jvm 默认调用 run 方法

(1) 定义一个目标类，继承 java.lang.Runnable 接口

(2) 覆盖 Runnable 接口中抽象 run 方法，用于定义线程任务

(3) 创建目标对象： target

(4) 创建线程对象，同时将目标对象传递给线程对象：

Thread t = new Thread(target);

(5) 开启线程： t.start()