目录
1、JDK、JRE和JVM
2、程序运行过程：
3、Java程序的四种基本控制结构：
4、Java范围控制符作用范围：
5、标识符定义要求：
6、Java中对变量常量声明的内存位置
7、运算符
8、数组声明初始化方式：
9、输入输出：
10、三大特性：
11、类的定义：
12、重写和重载的区别：
13、this关键字的使用：
14、super关键字的使用：
15、static关键字的使用：
16、final关键字的使用：
17、抽象类与接口：
18、Java中的异常：
19、Java中的常用包和类库：
20、自动装箱与拆箱：
21、instanceof 关键字的作用：
22、集合：
23、其他补充（不做重点）：
1、JDK、JRE和JVM
JDK
：
Java
标准开发包，它提供了编译、运⾏
Java
程序所需的各种⼯具和资源，包括
Java
编译器、
Java
运⾏时环境，以及常⽤的Java
类库等。
JRE
：
Java
运⾏环境，⽤于解释执⾏
Java
的字节码⽂件。
JVM：
Java
虚拟机，是
JRE
的⼀部分。负责解释执⾏字节码⽂件，是可运⾏
java
字节码⽂件的虚拟计算机。
三者区别与联系
：
JDk
包含
JRE；
JDK
和
JRE
中都包含
JVM；
JDK除了包含 JRE 还包含⼀些常⽤开发⼯具和基础类库；
JDK
⽤于开发，
JRE
⽤于运⾏
java程序，JVM
是
java
编程语⾔的核⼼并且具有平台独⽴性。
2、程序运行过程：
编写源⽂件—（javac）—> 编译源⽂件⽣成class字节码—（java）—> 加载运⾏class字节码
3、Java程序的四种基本控制结构：
顺序结构、选择结构（if—else if —else、switch—case—default）、循环结构（while、for、do—while、for each）、异常处理逻辑结构。
4、Java范围控制符作用范围：
编写源⽂件—（javac）—> 编译源⽂件⽣成class字节码—（java）—> 加载运⾏class字节码
3、Java程序的四种基本控制结构：
顺序结构、选择结构（if—else if —else、switch—case—default）、循环结构（while、for、do—while、for each）、异常处理逻辑结构。
4、Java范围控制符作用范围：
| 类内部 | 本包 | 子类 | 外部包 | |
|---|---|---|---|---|
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | × |
| default | √ | √ | × | × |
| private | √ | × | × | × |
5、标识符定义要求：
1）由字母、数字、下划线和$组成。
2）不能以数字开头。
3）不能是Java中的关键字。
6、Java中对变量常量声明的内存位置
堆区：通过new关键字生成的对象
栈区：对象引用、8种基本数据类型（byte、short、int、long、float、double、boolean、char ）
方法区：class文件、static标识的变量和方法
7、运算符
算术运算符：+ - * / % ++ --
赋值运算符：=
关系运算符：> < = >= <= !=
逻辑运算符：& | ！ ^ && ||
条件运算符：XX? X：X
位运算符：>> <<
8、数组声明初始化方式：
int
[][]
arr
=
new
int
[
3
][3];
int
arr1
[][]
=
new
int
[
3
][
2
];
int
arr2
[][]
=
new
int
[
][
]{{1,,2},{1,2}};
9、输入输出：
输⼊：
Scanner s
=
new
Scanner
(
System
.
in
);
s
.
nextInt
()
s
.
nextLine
()
s
.
nextFloat
()
scanner
.
next
()
输出：
System
.
out
.
println
(
"XX"
);
10、三大特性：
封装、多态、继承
封装好处：
1实现数据项和⽅法的隐藏
2实现隐藏隔离，允许外部对类做有限的访问,开发者可以⾃由的改变类的内部实现
3提⾼了代码的重⽤性
继承好处：
1.代码重⽤了
2. 通过继承 实现对现实世界更加准确的建模
多态好处：
提⾼了代码的维护性（继承保证）；提⾼了代码的扩展性
Java中多态的实现⽅式：接⼝实现，继承⽗类进⾏⽅法重写，同一个类中进⾏⽅法重载。⽗类引⽤指向⼦类对象
多态的
三个必要条件
：
继承、⽅法的重写、⽗类⼸
|
⽤指向⼦类对象
11、类的定义：
[
修饰符
]
class
类名
[
extends
⽗类名
] [
implements
接⼝名
] {
//
类体，包括类的成员变量和成员⽅法
}
12、重写和重载的区别：
⽅法的重载: 在同⼀个类中,出现多个同名的⽅法,参数列表不同,与返回值类型,修饰符⽆关
⽅法的重写: ⼦类中出现和⽗类中⼀模⼀样的⽅法(包括返回值类型,⽅法名,参数列表)
13、this关键字的使用：
Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤：
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
14、super关键字的使用：
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
堆区：通过new关键字生成的对象 栈区：对象引用、8种基本数据类型（byte、short、int、long、float、double、boolean、char ） 方法区：class文件、static标识的变量和方法
7、运算符
算术运算符：+ - * / % ++ --
赋值运算符：=
关系运算符：> < = >= <= !=
逻辑运算符：& | ！ ^ && ||
条件运算符：XX? X：X
位运算符：>> <<
8、数组声明初始化方式：
int
[][]
arr
=
new
int
[
3
][3];
int
arr1
[][]
=
new
int
[
3
][
2
];
int
arr2
[][]
=
new
int
[
][
]{{1,,2},{1,2}};
9、输入输出：
输⼊：
Scanner s
=
new
Scanner
(
System
.
in
);
s
.
nextInt
()
s
.
nextLine
()
s
.
nextFloat
()
scanner
.
next
()
输出：
System
.
out
.
println
(
"XX"
);
10、三大特性：
封装、多态、继承
封装好处：
1实现数据项和⽅法的隐藏
2实现隐藏隔离，允许外部对类做有限的访问,开发者可以⾃由的改变类的内部实现
3提⾼了代码的重⽤性
继承好处：
1.代码重⽤了
2. 通过继承 实现对现实世界更加准确的建模
多态好处：
提⾼了代码的维护性（继承保证）；提⾼了代码的扩展性
Java中多态的实现⽅式：接⼝实现，继承⽗类进⾏⽅法重写，同一个类中进⾏⽅法重载。⽗类引⽤指向⼦类对象
多态的
三个必要条件
：
继承、⽅法的重写、⽗类⼸
|
⽤指向⼦类对象
11、类的定义：
[
修饰符
]
class
类名
[
extends
⽗类名
] [
implements
接⼝名
] {
//
类体，包括类的成员变量和成员⽅法
}
12、重写和重载的区别：
⽅法的重载: 在同⼀个类中,出现多个同名的⽅法,参数列表不同,与返回值类型,修饰符⽆关
⽅法的重写: ⼦类中出现和⽗类中⼀模⼀样的⽅法(包括返回值类型,⽅法名,参数列表)
13、this关键字的使用：
Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤：
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
14、super关键字的使用：
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
int [][] arr = new int [ 3 ][3]; int arr1 [][] = new int [ 3 ][ 2 ]; int arr2 [][] = new int [ ][ ]{{1,,2},{1,2}};
9、输入输出：
输⼊：
Scanner s
=
new
Scanner
(
System
.
in
);
s
.
nextInt
()
s
.
nextLine
()
s
.
nextFloat
()
scanner
.
next
()
输出：
System
.
out
.
println
(
"XX"
);
10、三大特性：
封装、多态、继承
封装好处：
1实现数据项和⽅法的隐藏
2实现隐藏隔离，允许外部对类做有限的访问,开发者可以⾃由的改变类的内部实现
3提⾼了代码的重⽤性
继承好处：
1.代码重⽤了
2. 通过继承 实现对现实世界更加准确的建模
多态好处：
提⾼了代码的维护性（继承保证）；提⾼了代码的扩展性
Java中多态的实现⽅式：接⼝实现，继承⽗类进⾏⽅法重写，同一个类中进⾏⽅法重载。⽗类引⽤指向⼦类对象
多态的
三个必要条件
：
继承、⽅法的重写、⽗类⼸
|
⽤指向⼦类对象
11、类的定义：
[
修饰符
]
class
类名
[
extends
⽗类名
] [
implements
接⼝名
] {
//
类体，包括类的成员变量和成员⽅法
}
12、重写和重载的区别：
⽅法的重载: 在同⼀个类中,出现多个同名的⽅法,参数列表不同,与返回值类型,修饰符⽆关
⽅法的重写: ⼦类中出现和⽗类中⼀模⼀样的⽅法(包括返回值类型,⽅法名,参数列表)
13、this关键字的使用：
Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤：
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
14、super关键字的使用：
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
封装、多态、继承封装好处：
1实现数据项和⽅法的隐藏
2实现隐藏隔离，允许外部对类做有限的访问,开发者可以⾃由的改变类的内部实现
3提⾼了代码的重⽤性
继承好处：
1.代码重⽤了
2. 通过继承 实现对现实世界更加准确的建模多态好处：
提⾼了代码的维护性（继承保证）；提⾼了代码的扩展性
Java中多态的实现⽅式：接⼝实现，继承⽗类进⾏⽅法重写，同一个类中进⾏⽅法重载。⽗类引⽤指向⼦类对象
多态的 三个必要条件 ： 继承、⽅法的重写、⽗类⼸ | ⽤指向⼦类对象
11、类的定义：
[
修饰符
]
class
类名
[
extends
⽗类名
] [
implements
接⼝名
] {
//
类体，包括类的成员变量和成员⽅法
}
12、重写和重载的区别：
⽅法的重载: 在同⼀个类中,出现多个同名的⽅法,参数列表不同,与返回值类型,修饰符⽆关
⽅法的重写: ⼦类中出现和⽗类中⼀模⼀样的⽅法(包括返回值类型,⽅法名,参数列表)
13、this关键字的使用：
Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤：
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
14、super关键字的使用：
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
⽅法的重载: 在同⼀个类中,出现多个同名的⽅法,参数列表不同,与返回值类型,修饰符⽆关
⽅法的重写: ⼦类中出现和⽗类中⼀模⼀样的⽅法(包括返回值类型,⽅法名,参数列表)
13、this关键字的使用：
Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤：
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
14、super关键字的使用：
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
1）构造⽅法中指该构造器所创建的新对象；
2）⽅法中指调⽤该⽅法的对象；
3) 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
注：this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this——>原因：static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。
⼀句话概括: super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属
性、函数以及构造函数。
2 ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键
字指定访问⽗类的成员；
3 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。
15、static关键字的使用：
作为静态变量修饰、作为静态方法修饰、作为静态代码块修饰
若被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类；被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类。
16、final关键字的使用：
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
修饰类时：不能被继承，但可以继承他人的。
修饰方法时：不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法。
修饰变量时：1 基本类型变量使⽤final修饰了就不可变了；
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
17、抽象类与接口：
//抽象类
public abstract class Action {
public abstract void doSomething(); //抽象⽅法
public void test(){
};
}
//接口
public interface UserService {
//接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
//变量只能为 public static final 类型的
//public abstract void add();
//等效于 void add();
int age = 99;
void add(String name);
}
二者区别：
1）接口要被子类实现，抽象类要被子类继承；
2）接口中变量全为公共静态常量，抽象类中可以有普通变量；
3）接口中全是方法的声明，抽象类中可以有方法的实现；
4）接口中不可以有构造函数，抽象类中可以有构造函数；
5）接口可以多实现，抽象类只能单继承；
6）接口中的方法全为抽象方法，抽象类中可以有非抽象方法。
18、Java中的异常：
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
Throwable： 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类， 异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。
其中Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)：
1）运⾏时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常) 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
2）⾮运⾏时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exceptiion异常。
//try-catch-finally
public static boolean catchFinallyTest1() {
try {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is : " + i);
return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
System.out.println(" -- Exception --");
return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情
况:
}
}
//throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
//throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
}
19、Java中的常用包和类库：
●java.lang包 .该包是Java语言的核心包,并且该包中的所有内容由Java虚拟机自动导入。 如: System类. String类、 ..
●java.util包 .该包是Java语言的工具包,里面提供了大量工具类以及集合类等。 如: Scanner类、Random类、 List集合、 ..
●java.IO包- 该包是Java语言中的输入输出包,里面提供了大量读写文件相关的类等。 如: FileInputStream类. FIleOutputStream类、 ..
●java.net包 .该包是Java语言中的网络包,里面提供了大量网络编程相关的类等。 如: ServerSocket类、Socket类.
●java.sql包.该包是ava语言中的数据包,里面提供了大显操作数据库的类和接口等。 如: DriverManager类、Connection接口、 ..
●Java程序员在编程时可以使用大量类库,因此ava编程时需要记的很多,对编程能力本身要求不是特别的高。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
20、自动装箱与拆箱：
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character
因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
String类、StringBuffer类和StringBuilder类：
String类不可变，而StringBuffer类和StringBuilder类可变长。
StringBuffffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
速度快慢：String类 < StringBuffer类 < StringBuilder类
System类：
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指 定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
源数组 源数组的起始位置 ⽬标数组 ⽬标数组的起始位置 要复制的数组元素的个数
currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机
gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性
Runtime类：
freeMemory()：返回java虚拟机中空闲内存
maxMemory()：虚拟机试图使⽤的最多空闲内存
totalMemory() ：返回 Java 虚拟机中的内存总量
byte、short、int、long、float、double、boolean、char——>Byte、Short、Integer、Long、Float、Double、Boolean、Character 因为通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变星进行打 包封装处理变成对象,而负责将这些变星声明为成员变星进行对象化处理的相关类，叫做包装类。
21、instanceof 关键字的作用：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
22、集合：
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
集合和数组既然都是容器，它们有啥区别呢？
数组的长度是固定的。集合的长度是可变的。数组中存储的是同⼀类型的元素，可以存储基本数据类型值。集合存储的都是对象。 ⽽且对象的类型可以不⼀致。在开发中⼀般当对象多的时候，使⽤集合进⾏存储。
Collection是所有单列集合的⽗接口,单列集合(List和Set)是Collection的⼦类，每次操作的时候都只能保存⼀个对象的数据。
ArrayList是线程不安全，有List和Collection的所有方法，默认数组大小10。
Vector 是线程安全。
23、其他补充（不做重点）：
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
面向对象和面向过程的区别：
面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调 用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是 为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以 易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
equal和==区别：
==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是 指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以 适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的 equals方法返回的却是==的判断。
Hashcode的作用：
java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中 插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法 就会比较满。 于是有人发明了哈希算法来提高集合中查找元素的效率。
ArrayList和linkedList的区别：
Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
HashMap和HashTable的区别：
1、两者父类不同
HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
2、对外提供的接口不同
Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。
contains()方法判断该Hashtable是否包含传入的value，它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
3、对null的支持不同
Hashtable：key和value都不能为null。
int[] a = new int[4];//推介使用int[] 这种方式初始化；
int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]。
HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
4、安全性不同
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。
Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
5、初始容量大小和每次扩充容量大小不同
6、计算hash值的方法不同
Java创建对象有几种方式：
java中提供了以下四种创建对象的方式: new创建新对象 、通过反射机制 、采用clone机制 、通过序列化机制。
类加载生命周期：
类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程：
加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象；
连接，连接又包含三块内容：验证、准备、初始化。
1）验证，文件格式、元数据、字节码、符号引用验证；
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用；
初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收。
