Java基础

Java基本功

Java入门

Java语言有哪些特点？

1. 简单易学
2. 面向对象（封装，继承，多态）
3. 平台无关性（Java虚拟机将Java源文件编译后实现平台无关性）
4. 可靠性
5. 安全性
6. 支持多线程（C++语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而Java语言却提供了自身特有的多线程支持）
7. 支持网络编程并且方便使用（Java语言诞生本身就是为简化网络编程设计的，因此Java语言不仅支持网络编程，而且使用起来还很方便）
8. 编译与解释并存

关于JVM，JDK和JRE的通俗异动的解释

JVM

1. JVM：Java虚拟机，是用来运行Java字节码的虚拟机，JVM有针对不同系统的特定实现（Windows，Linux, MacOS），目的是使用相同的字节码，它们都会给出相同的结果。
2. 字节码：在Java中，JVM可以理解的代码就叫做字节码（既拓展为.class的文件），它不面向任何特定的处理器，只面向虚拟机。Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不针对一种 特定的机器，因此Java程序无须重新编译便可在多种不同的操作系统的计算机上运行。
3. Java运行通常有三个步骤：首先通过JDK中的javac编译.java文件，生成JVM可以理解的.class文件，最后通过JVM运行机器可执行的二进制机器码
4. 总结：Java虚拟机（JVM）是运行Java字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果，字节码不同的系统的JVM实现是Java语言“一次编译，随处可以运行”的关键所在。

JDK和JRE

1. JDK是Java Development Kit缩写，它是功能齐全的Java SDK，它拥有JRE所拥有的一切，还有编译器（javac）和工具（javadoc和jdb），它能够创建和编译程序。
2. JRE是Java运行时的环境，它是运行已编译Java程序所需的所有内容的集合，包括Java虚拟机（JVM），Java类库，Java命令和其他一些基础的构件，但是它不能用于创建新程序。
3. 如果只是要运行一下Java程序的话，就只需要安装JRE就可以了，如果需要进行Java编译方面的工作，就需要安装JDK了。但是这并不是绝对的，有时，即使不打算在计算机上进行任何Java开发，仍然需要安装JDK。例如：如果要将JSP部署到Web应用程序中，从技术上讲，这需要在应用程序服务器中运行Java程序，那为何还需要安装JDK呢？因为应用程序服务器会将JSP转换为Java Servlet，并且需要使用JDK来编译Servlet。

Java和C++的区别

1. 都是面向对象的语言，都支持封装、继承和多态
2. Java不提供指针来直接访问内存，程序内存更加安全
3. Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承。
4. Java有自动内存管理垃圾回收机制，不需要程序员手动释放无用的内存
5. 在C语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java语言中没有结束符这一概念

Import Java和Javax有什么区别

刚开始的时候JavaAPI所必需的包是Java开头的包，Javax当时只是拓展API包来使用的，然而随着时间的推移，Javax逐渐地扩展成为Java API的组成部分，但是将扩展从Javax包移动到Java包确实太麻烦了，最终会破坏一堆现有的代码，因此，最终决定Javax包将成为标准API的一部分。所以两者之间并没有区别，都是一个名字。

为什么说Java语言“编译与解释并存”

高级编程语言按照程序的执行方式分为编译型和解释型两种，简单来说，编译语言是指编译器针对特定的操作系统将源代码一次性翻译成可被该平台执行的机器码；解释型语言是指解释器对源程序逐行解释成特定平台的机器码并立即执行，例如：你想阅读一本英文名著，你可以找一个翻译人员帮助你阅读，有两种选择方式，你可以先等翻译人员将全本的英文名著（也就是源码）都翻译成汉语，然后再去阅读，也可以让翻译人员翻译一段，你在旁边阅读一段，慢慢把书看完。
Java语言既具有编译型语言的特征，也有解释型语言的特征，因为Java程序要经过先编译，后解释的两个步骤，由Java编写的程序需要先经过编译步骤，生成字节码（*.class文件），这种字节码必须有Java解释器来解释执行。因此，我们可以认为Java语言编译与解释并存。

Java语法

字符型常量和字符串常量的区别

1. 形式上：字符常量是单引号引起的一个字符；字符串常量是双引号引起的0个或若干个字符
2. 含义上：字符常量相当于一个整型值（ASCII值），可以参加表达式运算；字符串常量代表一个地址值（该字符串在内存中存放位置）
3. 占内存大小，字符常量只占2个字节；字符串常量占若干个字节（char在Java中占两个字节）
4. Java编程思想：Java要确定每种基本类型所占存储空间的大小，它们的大小并不像其他大多数语言那样随机器硬件架构变化而变化。这种所占存储空间大小的不变性是Java程序比用其他大多数语言编写的程序更具可移植性的原因之一。

关于注释

1. Java的注释有三种：单行注释，多行注释，文档注释
2. 代码的注释并不是越详细越好，实际上好的代码 本身就是注释，我们要尽量规范和美化自己的代码来减少不必要的注释。

标识符和关键字的区别是什么

在我们编写代码的时候，需要大量的为程序、类、变量、方法等取名字，于是就有了标识符，简单来说，标识符就是一个名字。但是有一些标识符，Java语言已经赋予了其特殊的含义，只能用于特定的地方，这种特殊的标识符就是关键字。因此，关键字是被赋予特殊含义的标识符。比如，在我们日常的生活中，“警察局”这个名字已经被赋予了特殊的含义，所以如果你开一家商店，店的名字不能叫“警察局”，“警察局”就是我们日常生活中的关键字。

Java中比较常见的关键字

1. 访问控制：private，protected，public
2. 类、方法和变量修饰符：abstract，class，extends，final，implements，interface，native
3. 程序控制：break，continue，return，do，while，if，else，for，instanceof，switch，case，default
4. 错误处理：try，catch，throw，throws，finally
5. 包相关：import，package
6. 基本类型：boolean，byte，char，double，float，int，long，short，null，true，false
7. 变量引用：super，this，void
8. 保留字：goto，const

自增自减运算符

在写代码的过程中，常见的一种情况是需要某个整数类型变量增加1或减少1，Java提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++）和自减运算符（–）
++和–运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时（前缀），先自增/减，再赋值；当运算符放在变量之后时（后缀），先赋值，再自增/减。例如，当b=++a时，先自增（自己增加1），再赋值（赋值给b）；当b=a++时，先赋值（赋值给b），再自增（自己增加1）.也就是，++a输出的是a+1的值，a++输出的是a的值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”

continue，break，return的区别是什么

在循环结构中，当循环条件不满足或者循环次数达到要求时，循环会正常结束，但是有时候可能需要在循环的过程中，当发生了某种条件后，提前终止循环，这就需要用到下面几个关键词：

1. continue：指跳出当前的这一次循环，继续下一次循环
2. break：指跳出整个循环体，继续执行循环下面的语句

return方法用于跳出所在的方法，结束该方法的运行，return一般有两种方法：

1. return;：直接使用return结束方法执行，用于没有返回值函数的方法
2. return value;：return一个特定值，用于有返回值函数的方法

Java泛型，类型擦除，介绍一下常用的通配符

Java泛型是JDK5中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
Java泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，这也就是通常所说的类型擦除。
泛型一般有三种使用方式：泛型类，泛型接口，泛型方法：

1. 泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
	private T key;
	public Generic(T key){
		this.key = key;
	}
	public T getkey(){
		return key;
	}
}

//如何实例化泛型
Generic<Integer> genericInteger = new Generic<Integer>(123456);

2. 泛型接口

public interface Generator<T> {
	public T method();
}

//实现泛型接口，不指定类型：
class Generator<T> implements Generator<T> {
	@Override
	public T method(){
		return null;
	}
}

//实现泛型接口，指定类型：
class GeneratorImpl<T> implements Generator<String> {
	@Override
	public String method(){
		return "hello";
	}
}

3. 泛型方法

public static <E> void printArray(E[] inputArray) {
	for(E element : inputArray){
		System.out.printf("%s",element);
	}
	System.out.println();
}

//创建不同类型数组：Integer，Double和Character
Integer[] intArray = {1,2,3};
String[] stringArray = {"Hello","Hello"};
printArray(intArray);
printArray(stringArray);

常用的通配符为：T，E，K，V，？

• ？表示不确定的Java类型
• T（type）表示具体的一个Java类型
• K V（key，value）分别代表Java键值中的key和value
• E（element）代表Element

==和equals的区别

==：它的作用是判断两个对象的地址是否相同，既判断两个对象是否是同一个对象。（基本数据类型 ：= =比较的是值，引用数据类型： = =比较的是内存地址）
因为Java只有值传递，所以对于= =来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

equals()：它的作用也是判断两个对象是否相等，它不能用于比较基本数据类型的变量，equals()方法存在于Object类中，而Object类是所有类的直接或间接父类。
Object类equals()方法：

public boolean equals(Object obj){
	return (this == obj);
}

equals()方法存在两种使用情况：

• 情况1：类没有覆盖equals()方法，则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是Object类equals()方法。
• 情况2：类覆盖了equals()方法。一般，我们都覆盖equals方法来两个对象的内容相等；若它们的内容相等，则返回true（既认为这两个对象相等）
• 举例：

public class test1{
	public static void main(String[] args){
		String a = new String("ab");//a为一个引用类型
		String b = new String("ab");//b为另一个引用，对象的内容都一样
		String aa = "ab"; //放在常量池中
		String bb = "ab"; //从常量池中查找
		if(aa == bb){//true
			System.out.println("aa==bb"); 
		}
		if(a == b){//false 比较的是a和b的地址
			System.out.println("a==b"); 
		}
		if(a.equals(b)){//true
			System.out.println("aEQb"); 
		}
		if(43 == 43.0){//true
			System.out.println("true"); 
		}
	}
}

说明：

• String中的equals方法是被重写过的，因为Object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
• 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用，如果没有就在常量池中重新创建一个String对象。

hashCode()与equals()

1. hashCode()介绍：
   hashCode()的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数，这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()定义在JDK的Object类中，这就意味着Java中的任何类都包含有hashCode()函数。另外需要注意的是：Object的hashCode()方法是本地方法，也就是用C语言或C++实现的，该方法通常用来将对象的内存地址转换为整数之后返回。散列表存储的是键值对（key-value），它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

public native int hashCode();

2. 为什么要有hashCode？
   我们以“HashSet如何检查重复”为例子来说明为什么要有hashCode：当你把对象加入HashSet中时，HashSet会先计算对象的hashCode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashCode值作比较，如果没有相符的hashCode，HashSet会假设对象没有重复出现，但是如果发现有相同的hashCode值的对象，这时会调用equals()方法来检查hashCode相等的对象是否真的相同。如果两者相同，HashSet就不会让其中加入操作成功，如果不同的话，就会重新散列到其他位置，这样就可以大大减少了equals的次数，相应的就大大提高了执行速度。

3. 为什么重写equals时必须重写hashCode方法？
   如果两个对象相等，则hashCode一定也相同，两个对象相等，对两个对象分别调用equals方法返回true。但是，两个对象有相同的hashCode值，它们也不一定是相等的。因此，equals方法被覆盖过，则hashCode方法也必须被覆盖。hashCode()的默认行为是对堆上的对象产生独特值。，如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

4. 为什么两个对象有相同的hashCode值，它们也不一定是相等的？
   因为hashCode(）所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值，越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的hashCode）。我们刚刚提到了HashSet，如果HashSet在对比的时候，同样的hashCode有多个对象，它会使用equals()来判断是否真的相同，也就是说hashCode(）只是用来缩小查找成本。

Java基本数据类型

Java中的几种基本数据类型是什么？对应的包装类型是什么？各自占用多少字节呢？

Java中有8种基本数据类型，分别为：

1. 6种数字类型：byte，short，int，long，float，double
2. 1种字符类型：char
3. 1种布尔型：boolean

这8种基本数据类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean

基本数据类型	位数	字节	默认值
int	32	4	0
short	16	2	0
long	64	8	0L
byte	8	1	0
char	16	2	‘u0000’
float	32	4	0f
double	64	8	0d
boolean	1		false

对于boolean，官方文档未明确定义，它依赖于JVM厂商的具体实现。逻辑上理解是占用1位，但是实际中会考虑计算机高效存储因素。
注意：Java里使用long类型的数据一定要在后面加上L，否则将作为整型解析；char a = ‘h’ char：单引号，String a = “hello”：双引号

自动装箱与拆箱

• 装箱：将基本数据类型用它们对应的引用类型包装起来
• 拆箱：将包装类型转换为基本数据类型

8种基本类型的包装类和常量池

Java基本类型的包装类的大部分都实现了常量池技术，即Byte，Short，Integer，Long，Character，Boolean；前4种包装类默认创建了数值[-128，127]的相应类型的缓存数据，Character创建了数值在[0,127]范围的缓存数据，Boolean直接返回True Or False。 如果超出了对应范围仍然会去创建新的对象。

public static Boolean valueOf(boolean b){
	return (b ? True : False);
}

private static class CharacterCache {
	private CharacterCache() {}
	static final Character cache[] = new Character[127 + 1];
	static{
		for (int i = 0; i < cache.length(); i++)
			cache[i] = new Character((char)i);	
	}
}

两种浮点数类型的包装类Float，Double并没有实现常量池技术：

	Integer i1 = 33;
	Integer i2 =33;
	System.out.println(i1 == i2); //输出true
	Integer i11 = 333;
	Integer i22 = 333;
	System.out.println(i11 == i22); //输出false
	Double i3 = 1.2;
	Double i4 = 1.2;
	System.out.println(i3 == i4); //输出false

Integer缓存源代码：

/*
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值
*/
public static Integer valueOf(int i) {
	if (i >= IntegerCache.low && i <= IntegerCache.high) {
		return IntegerCache.cache[i + (-IntegerCache.low)];
	}
	return new Integer(i);
}

应用场景：

1. Integer i1 = 40; Java在编译的时候会直接将代码封装成Integer i1 = Integer.valueOf(40)；从而使用常量池中的对象。
2. Integer i1 = new Integer(40); 这种情况下会创建新的对象。

	Integer i1 = 40;
	Integer i2 = new Integer(40);
	System.out.println(i1 == i2); //输出false

Integer比较丰富的一个例子

	Integer i1 = 40;
	Integer i2 = 40;
	Integer i3 = 0;
	Integer i4 = new Integer(40);
	Integer i5 = new Integer(40);
	Integer i6 = new Integer(0);

	System.out.println("i1=i2" + (i1 == i2));//i1=i2 true
	System.out.println("i1=i2+i3" + (i1 == i2 + i3));//i1=i2+i3 true
	System.out.println("i1=i4" + (i1 == i4));//i1=i4 false
	System.out.println("i4=i5" + (i4 == i5));//i4=i5 false
	System.out.println("i4=i5+i6" + (i4 == i5 + i6));//i4=i5+i6 true
	System.out.println("40=i5+i6" + (40 == i5 + i6));//40=i5+i6 true

解释：语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先 i5 和 i6 进行自动拆箱操作，进行数值相加，即i4 = = 40，然后Integer对象无法与数值进行直接比较，所以 i4 自动拆箱转为 int 值 40，最终这条语句转为40 = = 进行数值比较

函数

什么是方法的返回值？返回值在类的方法里的作用是什么？

方法的返回值是指我们获取到某个方法体中的代码执行后产生的结果（前提是该方法可能产生结果）。返回值的作用是接受出结果，使得它可以用于其他的操作。

为什么Java中只有值传递？

首先回顾一下在程序设计语言中有关参数传递给方法（或函数）的一些专业术语，按值调用（call by value）表示方法接受的是调用者提供的值，而按引用调用（call by reference）表示方法接受的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。它用来描述各种程序设计语言（不只是Java）中方法参数传递形式。
Java程序设计语言总是采用按值调用，也就是说，方法得到的是所有参数值的一个拷贝，方法不能修改传递给它的任何参数变量的内容。
下面举3个例子：

例子1：

public static void main(String[] args){
	int num1 = 10;
	int num2 = 20;
	swap(num1 , num2);
	System.out.println("num1 = " + num1); 
	System.out.println("num2 = " + num2);
}
public static void swap(int a,int b){
	int temp = a;
	a = b;
	b = temp;
	System.out.println("a = " + a); 
	System.out.println("b = " + b); 
}
//结果：
	a = 20
	b = 10
	num1 = 10
	num2 = 20

解析：在swap方法中，a、b的值进行交换，并不会影响到num1、num2.因为a、b中的值，只是从num1、num2的复制过来的，也就是说，a、b相当于num1、num2的副本，副本的内容无论怎么修改，都不会影响到原件本身。

通过上面的例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，如下：
例子2：

public static void main(String[] args){
	int[] arr = {1,2,3,4,5};
	System.out.println(arr[0]);
	change(arr);
	System.out.println(arr[0]);
}
public static void change(int[] array){
	//将数组的第一个元素变为0
	array[0] = 0;
}
//结果：
1
0

解析：array被初始化arr的拷贝也就是一个对象的引用，也就是说array和arr指向的是同一个数组对象，因此，外部对引用对象的改变会反映到所对应的对象上。
通过例2我们已经看到，实现一个改变对象参数状态的方法并不是一件难事，理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。

很多程序设计语言（特别是，C++和Pascal）提供了两种参数传递的方式：值调用和引用调用，大多数程序员都认为Java程序设计语言对对象采用的是引用调用，实际上这种理解是不正确的，由于这种误解具有一定的普遍性，所以下面给出一个反例来详细的阐述一下这个问题。

例3：

public class Test {
	public static void main(String[] args){
		Student s1 = new Student("小张");
		Student s2 = new Student("小李");
		Test.swap(s1,s2);
		System.out.println("s1:" + s1.getName());
		System.out.println("s2:" + s2.getName());
	}
	public static void swap(Student x,Student y) {
		Student temp = x;
		x = y;
		y = temp;
		System.out.println("x:" + x.getName());
		System.out.println("y:" + y.getName());
	}
}
//结果：
	x:小李
	y:小张
	s1:小张
	s2:小李

解析：方法并没有改变存储在变量s1和s2中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是两个拷贝。

总结

Java程序设计语言对对象采用的不是引用调用，实际上，对象引用的是按值传递的。
Java中方法参数的使用情况：

• 一个方法不能改变一个基本数据类型的参数（即数值型或布尔型）
• 一个方法可以改变一个对象参数的状态
• 一个方法不能让对象参数引用一个新的对象

重载和重写的区别

同名的函数，必须区别输入的形式参数类型就是重载。重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
重写就是当子类继承父类的相同方法，输入数据一样，但要做出有别于父类的相应时，就要覆盖父类的方法

重载：
发生在同一个类中（或者父类和子类之间），方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。注意：返回值类型不能作为重载函数的签名，也就是说，不能有两个名字相同、参数类型也相同却返回不同类型值的方法。
综上：重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。

重写：重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。

1. 返回值类型、方法名、参数列表必须相同，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
2. 如果父类方法访问修饰符为private/final/static则子类就不能重写该方法，但是被static修饰的方法能够再次声明。
3. 构造方法无法被重写
   综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变

方法的重写遵循“两同两小一大”：

• ”两同“即方法名相同、形参列表相同
• ”两小“指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等
• ”一大“指的是子类方法的访问权限应比父类方法的访问权限更大或相等

关于重写的返回值类型，如果方法的返回类型是void和基本数据类型，则返回值重写时不可修改，但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。

public class Hero {
	public String name(){
		return "超级英雄";
	}
}
public class SuperMan extends Hero {
	@Override
	public String name() {
		return "超人";
	}
	public Hero hero() {
		return new Hero();
	}
}
public class SuperSuperMan extends SuperMan {
	public String name() {
		return "超级超级英雄";
	}
	@Override
	public SuperMan hero() {
		return new SuperMan();
	}
}

深拷贝vs浅拷贝

1. 浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递搬的拷贝，此为浅拷贝。
2. 深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

方法的四种类型

1. 无参数无返回值的方法

//无参数无返回值的方法（如果方法没有返回值，不能不写，必须写void，表示没有返回值）
public void f1(){
	System.out.println("无参数无返回值的方法");
}

2. 有参数无返回值的方法

//有参数无返回值的方法
//参数列表由零组到多组”参数类型+形参名“组合而成，多组参数之间以英文逗号（，）隔开，形参类型和形参名之间以英文空格隔开
public void f2(int a, String b, int c){
	System.out.println(a + "-->" + b + "-->" + c);
}

3. 有返回值无参数的方法

//有返回值无参数的方法（返回值可以是任意的类型，在函数里面必须有return关键字返回对应的类型）
public int f3() {
	System.out.println("有返回值无参数的方法");
	return 2;
}

4. 有返回值有参数的方法

//有返回值有参数的方法
public int f4(int a, int b) {
	return a * b;
}

5. return在无返回值方法的特殊使用

//return在无返回值方法的特殊使用
public void f5(int a) {
	if(a > 10) {
		return; //表示结束所在方法（f5方法）的执行，下方的输出语句不会执行
	}
	System.out.println(a);
}

Java面向对象

类和对象

面向对象和面向过程的区别

1. 面向过程：面向过程性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，但是面向过程没有面向对象易维护、易复用、易拓展。
2. 面向对象：面向对象易维护、易复用、易拓展。因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护，但是，面向对象性能比面向过程低。
3. 面向过程性能比面向对象高？这个并不是根本原因，面向过程也需要分配内存，计算内存偏移量，Java性能差的主要原因并不是因为它是面向对象语言，而是Java是半编译语言，最终的执行代码并不是可以直接被CPU执行的二进制机械码。而面向过程语言大多都是直接编译成机械码在电脑上执行，并且其他一些面向过程的脚本语言性能也并不一定比Java好。

构造器Constructor是否可被override

Constructor不能被override（重写），但是可以overload（重载），所以你可以看到一个类中有多个构造函数的情况。

在Java中定义一个不做事没有参数的构造方法的作用

Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决方法是在父类里加上一个不做事且没有参数的构造方法。

成员变量与局部变量的区别有哪些？

4. 从语法形式上看：成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被public，private，static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；但是，成员变量和局部变量都能被final所修饰。
5. 从变量在内存中的存储方式来看，如果成员变量使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的，而对象存在于堆内存，局部变量则存在于栈内存。
6. 从变量在内存中的生存时间上看：成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
7. 成员变量如果没有被赋初值：则会自动以类型的默认值而赋值（一种情况例外：被final修饰的成员变量也必须显示的赋值），而局部变量则不会自动赋值。

创建一个对象为什么用运算符？对象实体与对象引用有何不同？

new运算符，new创建对象实例（对象实例），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）；一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。

一个类的构造方法的作用是什么？若一个类没有声明构造方法，该程序能正确执行吗？为什么？

主要作用是完成对类对象的初始化工作。可以执行，因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参数），Java就不会再添加默认的构造方法了，这时候，就不能直接new一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也就是为什么我们在创建对象的时候后面加一个括号（因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。

构造方法有哪些特性？

1. 名字与类名相同。
2. 没有返回值，但不能用void声明构造函数。
3. 生成类的对象时自动执行，无需调用。

在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？

帮助子类做初始化工作。

对象的相等与指向他们的引用相等，两者有什么不同？

对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。

面向对象的三大特征

封装

封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息（也就是属性），但是可以通过遥控器（方法）来控制空调。如果属性不想被外界访问，我们就大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。就好像如果没有空调遥控器，那么我们就无法操控空调制冷，空调本身就没有意义了（当然现在还有很多其他方法，这里只是为了举个例子）。

public class Student {
	private int id; //id属性私有化
	private String name; //name属性私有化

	//获取id的方法
	public int getId() {
		return id;
	}
	//设置id的方法
	public void setId(int id) {
		this.id = id;
	}
	//获取name的方法
	public String getName() {
		return name;
	}
	//设置name的方法
	public void setName(String name) {
		this.name = name;
	}
}		

继承

不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码地重用，程序地可维护性，节省大量创建新类地时间，提高我们的开发效率。
关于继承如下3点请记住：

• 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问的，只是拥有。
• 子类可以拥有自己属性和方法，既子类可以对父类进行拓展。
• 子类可以用自己的方式实现父类的方法。

多态

多态，顾名思义，表示一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。
多态的特点：

• 对象类型和引用类型之间具有继承（类）/实现接口的关系；
• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
• 多态不能调用“只能在子类存在但父类不存在”的方法；
• 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

修饰符

在一个静态方法内调用一个非静态成员为什么是非法的？

由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。

静态方法和实例方法有何不同

• 在外部调用静态方法时，可以使用“类名.方法名”的方式，也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法无需创建对象。
• 静态方法在访问本类的成员时，只允许访问静态成员（既静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

其他重要知识点

String StringBuffer和 StringBuilder的区别是什么？String为什么是不可变的？

可变性：简单的来说：String类中使用final关键字修饰字符数组来保存字符串，private final char value[]，所以String对象是不可变的。（在Java9之后，String、StringBuilder与StringBuffer的实现改用byte()数组存储字符串private final byte[] value）
而StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串char[]value但是没有用final关键字修饰，所以这两种对象都是可变的。
StringBuilder与StringBuffer的构造方法都是调用父类构造方法也就是AbstractStringBuilder实现的。
AbstractStringBuilder.java：

abstract class AbstractStringBuilder implements Appendable, CharSequence  {
	/**
	*The value is used for character storage.
	*/
	char[] value;

	/**
	*The count is the number of characters used.
	*/
	int count;
	AbstractStringBuilder(int capacity) {
		value = new char[capacity];
	}
}

线程安全性：String中的对象是不可变的，也就可以理解为常量，线程安全。AbstracStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以线程是安全的。StringBuilder并没有对方法进行同步锁，所以是非线程安全的。
性能：每次对String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StringBuilder相比使用StringBuffer仅能获得%10~%15左右的性能提升，但却要冒多线程不安全的风险。
对于三者使用的总结：

1. 操作少量的数据：适用String
2. 单线程操作字符串缓冲区下操作大量数据：适用StringBuilder
3. 多线程操作字符串缓冲区下操作大量数据：使用StringBuffer

Object类的常见方法总结

Object类是一个特殊的类，是所有类的父类。它主要 提供了以下11个方法：

public final native Class<?> getClass()//native方法,用于返回当前运行时对象的Class对象，使用final关键字修饰，故不允许子类重写。
public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap
public boolean equals(Object obj) //用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户比较字符串的值是否相等
protected native Object clone() throws CloneNotSupportedException //native方法，用于创建并返回当前对象的一份拷贝。一般情况下，对于任何对象x，表达式x.clone() != x为true，x.clone().getClass() == x.getClass()为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生CloneNotSuppoertedException异常
public String toString() //返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。
public final native void notify() //native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程（监视器相当于就是锁的概念）。如果有多个线程在等待只会任意唤醒一个。
public final native void notifyAll() //native，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
public final native void wait(long timeout) throws InterruptedException //native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁。timeout是等待时间。
public final void wait(long timeout, int nanos) throws InterruptedException //多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是0-999999）.所以超时的时间还需要加上nanos毫秒
public final void wait() throws InterruptedException //跟之前的2个wait方法一样，只不过该方法一直等待。没有超时时间这个概念
protected void finalize() throws Throwable{} //实例被垃圾回收器回收的时候触发的操作

==与equals（重要）

==：它的作用是判断两个对象的地址是不是相等。既：判断两个对象是不是同一个对象（基本数据类型= =比较的是值，引用数据类型= =比较的是内存的地址）
equals（）：它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

• 情况1：类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。
• 情况2：类覆盖了equals()。一般，我们都覆盖equals()方法来比较两个对象的内容是否相等；若它们的内容相等，则返回true（既，认为这两个对象相等）
• 注：String中的equals方法是被重写过的，因为Object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
• 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

hashCode与equals（重要）

1. hashCode()介绍：
   hashCode()的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数，这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()定义在JDK的Object类中，这就意味着Java中的任何类都包含有hashCode()函数。另外需要注意的是：Object的hashCode()方法是本地方法，也就是用C语言或C++实现的，该方法通常用来将对象的内存地址转换为整数之后返回。散列表存储的是键值对（key-value），它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

public native int hashCode();

1. 为什么要有hashCode？
   我们以“HashSet如何检查重复”为例子来说明为什么要有hashCode：当你把对象加入HashSet中时，HashSet会先计算对象的hashCode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashCode值作比较，如果没有相符的hashCode，HashSet会假设对象没有重复出现，但是如果发现有相同的hashCode值的对象，这时会调用equals()方法来检查hashCode相等的对象是否真的相同。如果两者相同，HashSet就不会让其中加入操作成功，如果不同的话，就会重新散列到其他位置，这样就可以大大减少了equals的次数，相应的就大大提高了执行速度。

2. 为什么重写equals时必须重写hashCode方法？
   如果两个对象相等，则hashCode一定也相同，两个对象相等，对两个对象分别调用equals方法返回true。但是，两个对象有相同的hashCode值，它们也不一定是相等的。因此，equals方法被覆盖过，则hashCode方法也必须被覆盖。hashCode()的默认行为是对堆上的对象产生独特值。，如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

3. 为什么两个对象有相同的hashCode值，它们也不一定是相等的？
   因为hashCode(）所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值，越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的hashCode）。我们刚刚提到了HashSet，如果HashSet在对比的时候，同样的hashCode有多个对象，它会使用equals()来判断是否真的相同，也就是说hashCode(）只是用来缩小查找成本。

4. hashCode()与equals的相关规定：如果两个对象相等，则hashCode一定也是相同的；两个对象相等，对两个对象分别调用equals方法都返回true；两个对象有相同的hashCode值，它们也不一定是相等的；equals方法被覆盖国，则hashCode方法也必须被覆盖；hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

Java序列化中如果有些字段不想进行序列化，怎么办？

对于不想进行序列化的变量，使用transient关键字修饰。
transient关键字的作用是：阻止实例中那些用此关键字修饰的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。

获取用键盘输入常用的两种方法

方法1：通过scanner

Scanner input = new Scanner(System.in);
String s = input.nextline();
input.close();

方法2：通过BufferReader

BufferReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();

Java核心技术

反射机制

Java反射机制是运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用的对象的方法的功能称为Java语言的反射机制。

静态编译和动态编译

• 静态编译：在编译时确定类型，绑定对象
• 动态编译：运行时确定类型，绑定对象

反射机制优缺点

• 优点：运行期类型的判断，动态加载类，提高代码灵活度。
• 缺点：性能瓶颈：反射相当于一系列解释操作，通知JVM要做的事情，性能比直接的Java代码要慢很多。安全问题：当我们可以动态操作改变类的属性同时也增加了类的安全隐患。

反射的应用场景

反射是框架设计的灵魂
在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代码设计模式也采用了反射机制，还有我们日常使用的Spring/Hibernate等框架也大量使用到了反射机制。
举例：

• 我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；
• Spring框架的IOC（动态加载管理Bean）创建对象以及AOP（动态代码）功能都和反射有联系；
• 动态配置实例的属性；

异常

Java异常类层次结构图

在Java中，所有的异常都有一个共同的祖先java.lang包中的Throwable类。Throwable类有两个重要的子类Exception（异常）和Error（错误）。Exception能被程序本身处理（try-catch），Error是无法处理的（只能尽量避免）。
Exception和Error二者都是Java异常处理的重要子类，各自都包含大量子类。

• Exception：程序本身可以处理的异常，可以通过catch来进行捕获。Exception又可以分为受检查异常（必须处理）和不受检查异常（可以不处理）。
• Error：Error属于程序无法处理的错误，我们没办法通过catch来进行捕获。例如，Java虚拟机运行错误（VirtualMachineError）、虚拟机内存不够错误（OutOfMemoryError）、类定义错误（NoClassDefFoundError）等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
  受检查异常
  Java代码在编译过程中，如果受检查异常没有被catch/throw处理的话，就没有办法通过编译。比如下面这段IO操作的代码
  
  除了RuntimeException以及其子类以外，其他的Exception类及子类都属于受检查异常。常见的受检查异常有：IO相关的异常、ClassNotFoundException、SQLException
  不受检查异常
  Java代码在编译过程中，我们即使不处理不受检查异常也可以正常通过编译
  RuntimeException以及其子类都统称为非受检查异常，例如：NullPointerException、NumberFormatException（字符串转换为数字）、ArrayIndexOutOfBoundsException（数组越界）、ClassCastException（类型转换错误）、ArithmeticException（算数错误）等。

Throwable类常用方法

• public string getMessage()：返回异常发生时的简要描述
• public string toString()：返回异常发生时的详细信息
• public string getLocalizedMessage()：返回时异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage()返回的结果相同。
• public void printStackTrace()：在控制台上打印Throwable对象封装的异常信息

try-catch-finally

• try块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
• catch块：用于处理try捕获的异常。
• finally块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
  注意：在以下三种情况下finally块不会被执行：
• 在try或finally块中用了System.exit(int)退出程序。但是，如果System.exit(int)在异常语句之后，finally还是会被执行。
• 程序所在的线程死亡
• 关闭CPU
  注意：当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容被执行，并且finally语句的返回值将会覆盖原始的返回值。如下：

public class Test {
	public static int f(int value) {
		try {
			return value * value;		
		} finally {
			if (value == 2) {
				return 0;
			}
		}
	}
}

如果调用f(2)，返回值将是0，因为finally语句的返回值覆盖了try语句块的返回值。

使用try-with-resources来代替try-catch-finally

1. 适用范围（资源的定义）：任何实现java.lang.AutoCloseable或者Java.io.Closeable的对象
2. 关闭资源和final的执行顺序：在try-with-resources语句中，任何catch或finally块在声明的资源关闭后运行
   《Effective Java》中明确指出：面对必须要关闭的资源，我们总是应该优先使用try-with-resources而不是try-finally。随之产生的代码更加简短，更清晰，产生的异常对我们也更有用。try-with-resources语句让我们更容易编写必须要关闭的资源的代码，若采用try-finally则几乎做不到这点。

Java中类似于InputStream、OutputStream、Scanner、PrintWriter等的资源都需要我们调用close()方法来手动关闭，一般情况下我们都是通过try-catch-finally语句来实现这个需求，如下：

//读取文本文件的内容
Scanner scanner = null;
try {
	scanner = new Scanner(new File("D://read.txt"));
	while (scanner.hasNext()) {
		System.out.println(scanner.nextLine());
	}
} catch (FileNotFoundException e) {
	e.printStackTrace();
} finally {
	if (scanner != null) {
		scanner.close();
	}
}

使用Java7之后的try-with-resources语句改造上面的代码：

try (Scanner scanner = new Scanner(new File("test.txt"))) {
	while (scanner.hasNext()) {
		System.out.println(scanner.nextLine());
	}
} catch (FileNotFoundException fnfe) {
	fnfe.printStackTrace();
}

当多个资源需要关闭的时候，使用 try-with-resources实现起来也非常简单，如果你还是用try-catch-finally可能会带来很多问题。
通过使用分号分隔，可以在try-with-resources块中声明多个资源。

try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt"))));
	BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt"))) {
		int b;
		while ((b = bin.read()) != -1) {
			bout.write(b);
		}
	} catch (IOException e) {
		e.printStackTrace();
	}

多线程

简述线程、程序、进程的基本概念，以及他们之间的关系是什么？

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间切换工作时，负担要比进程小得多，也正是因为如此，线程也被称为轻量级进程。
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
进程是程序一次执行的过程，是系统运行程序的基本单位，因此进行是动态的。系统运行一个程序既是一个进程从创建、运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各个进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序。

线程有哪些基本状态？

Java线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java线程状态变迁如下图所示：

由上图可以看出：
线程创建之后它将处于NEW（新建）状态，调用start()方法后开始运行，线程这时候处于READY（可运行）状态。可运行状态的线程获得了CPU时间片（timeslice）后就处于RUNNING（运行）状态。
当线程执行wait()方法之后，线程进入WAITING（等待）状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而TIME_WAITING（超时等待）状态相当于在等待状态的基础上增加了超时限制，比如通过sleep(long millis)方法或wait(long millis)方法可以将Java线程置于TIMED WAITING状态。当超时时间到达后Java线程将会返回到RUNNABLE状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到BLOCKED（阻塞状态）。线程在执行Runnable的run()方法之后将会进入到TERMINATED（终止）状态。

文件与I\O流

Java中IO流分为几种？

• 按照流的流向分，可以分为输入流和输出流；
• 按照操作单元划分，可以划分为字节流和字符流；
• 按照流的角色划分为节点流和处理流；

Java IO流设计40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系，Java IO流的40多个类都是从如下4个抽象类基类派生出来的。

• InputStream/Reader：所有的输入流的基类，前者是字节输入流，后者是字符输入流。
• OutputStream/Writer：所有输出流的基类，前者是字节输出流，后者是字符输出流。

按操作方式分类结构图：

按操作对象分类结构图：

既然有了字节流，为什么还要有字符流？

问题的本质：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么I/O流操作要分为字节流操作和字符流操作呢？
回答：字符流是由Java虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时的，并且，如果我们不知道编码类型就很容易出现乱码问题，所以，I/O流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果有音频文件、图片等媒体文件用字节流比较好。如果涉及到字符的文档文件使用字符类比较好。

BIO、NIO、AIO有什么区别？

• BIO（Blocking I/O）：同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模式是比较不错的，可以让每一个连接专注于自己的I/O并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的BIO模型是无能为力的。因此，我们需要一种更高效的I/O处理模型来应对更高的并发量
• NIO（Non-blocking/New I/O）：NIO是一种同步非阻塞的I/O模型，在Java1.4中引入了NIO框架，对应java.nio包，提供了Channel，Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现，两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用NIO的非阻塞模式来开发。
• AIO（Asynchronous I/O）：AIO也就是NIO2。在Java7中引入了NIO的改进版NIO2，它是异步非阻塞的IO模型。异步IO是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO是异步IO的缩写，虽然NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。对于NIO来说，我们的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作，IO操作本身是同步的。