1.8java常用英语单词,Java基础面试大全

答案：扩展名是.java

答案：在Java语言中凡是我们可以自己起名字的都是标识符。

答案：标识符由英文大小写字母、数字字符、$和_组成，不能以数字开头，也不能是java中关键字，并区分大小写

答案：字节码文件扩展名是.class

答案：path是系统用来指定可指定文件的完整路径。Path是用来搜索所执行的可执行文件路径的，如果执行的可执行文件不在当前目录下，那就会依次搜索path中设置的路径。

classpath是指定你在程序中所使用的类(.class)文件所在的位置。

答案：d: 回车 ： 盘符切换

dir (directory) ：列出当前目录下的文件以及文件夹

cd (change directory) : 改变指定目录(进入指定目录)

cd.. ： 退回到上一层目录

cd\ ： 退回到跟目录

md (make directory) ：创建目录

rd (remove directory) ：删除目录

del (delete) ：删除文件，删除一堆后缀名一样的文件*.txt

cls (clear screen) ：清屏

exit：退出dos命令行

答案：包：全部小写

单层包：小写，举例：itcast，com

多层包：小写，并用 . 隔开，举例：cn.itcast，com.baidu

类或者接口：

一个单词：首字母大写，举例：Student，Demo

多个单词：每个单词首字母大写，举例：HelloWorld，StudentName

方法或者变量：

一个单词：首字母小写，举例：name，main

多个单词：从第二个单词开始，每个单词首字母大写，举例：studentAge，showStudentNames()

常量：全部大写

一个单词：大写，举例：PI

多个单词：大写，并用 _ 隔开，举例：STUDENT_MAX_AGE

答案：Java语言是跨平台运行的，其实就是不同的操作系统，使用不同的JVM映射规则，让其与操作系统无关，完成了跨平台性。JVM对上层的Java源文件是不关心的，它关注的只是由源文件生成的类文件(class file)。

答案：JDK: Java Development

Kit(Java开发工具包)。JDK是整个JAVA的核心，包括了Java运行环境(Java Runtime Environment)，一堆Java工具(javac/java/javap等)

JRE：Java Runtime Environment(java运行时环境)。也就是我们说的JAVA平台。所有的Java程序都要在JRE下才能运行。包括JVM和JAVA核心类库和支持文件。与JDK相比，它不包含开发工具(编译器、调试器和其他工具)。

JVM：Java Virtual Mechinal(JAVA虚拟机)。JVM是JRE的一部分，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

答案：单行注释、多行注释、文档注释

单行注释：注释单行代码或为单行代码添加描述的时候使用

多行注释：注释多行代码或为代码添加多行描述的时候使用

文档注释：生产java帮助文档的时候使用，开发中常用来描述类、描述方法

答案：

基本数据类型

|- byte         1

|- short         2

|- int           4

|- long          8

|- float         4

|- double       8

|- char         2

|- boolean      1

引用数据类型

|- 数组

|- 类

|- 接口

答案：变量，在程序运行时，值可以被修改的量。

答案：数据类型 变量名 = 变量值;

答案：强制类型转换：容量大的类型向容量小的类型转换时使用

隐式类型转换：容器小的类型向容量大的类型转换时使用

答案：char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中可以存储汉字。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

答案：&和&&都可以用作逻辑与的运算符，表示逻辑与(and)，当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作。

答案：==： 比较运算符，用来比较操作符两边的变量的值是否相等。

= ： 赋值运算符，把操作符右边的值，赋值给左边的变量

答案:  三元运算符的格式是:     条件表达式 ? 表达式1 : 表达式2 ;

答案:  三元运算符的执行流程: 首先计算条件表达式的值看其返回结果是true还是false,如果是true就执行表达式1,如果是false就执行表达式2

答案:  第一步导包:格式:     importjava.util.Scanner ;位置:       在class上边

第二步创建Scanner对象，格式:    Scanner sc = new Scanner(System.in) ;

第三步获取键盘录入数据:格式:      int x= sc.nextInt() ;

答案：for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {

循环体语句;

}

执行流程：

a) 执行初始化语句

b) 执行判断条件语句，看其结果是true还是false，如果是false，循环结束；如果是true，继续执行。

c) 执行循环体语句

d) 执行控制条件语句

e) 回到b继续

while循环语句格式：

while(判断条件语句) {

循环体语句;

}

执行流程：

a) 执行判断条件语句，看其结果是true还是false

如果是false，循环结束。

如果是true，继续执行。

b) 执行循环体语句

c) 回到a继续

do…while循环语句格式：

do {

循环体语句;

}while((判断条件语句);

执行流程：

a) 执行循环体语句

b) 执行判断条件语句，看其结果是true还是false，如果是false，循环结束；如果是true，继续执行。

c) 回到a继续

三种循环语句的区别：

a) do...while循环至少会执行一次循环体

b) for循环和while循环只有在条件成立的时候才会去执行循环体

注意：写程序优先考虑for循环，再考虑while循环，最后考虑do...while循环

答案：修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2 ….){

方法体;

return返回值;

}

注意事项:

A:   方法不调用不执行

B:   方法与方法是平级关系，不能嵌套定义

C:   方法定义的时候参数之间用逗号隔开

D:   方法调用的时候不用在传递数据类型

E:    如果方法有明确的返回值，一定要有return带回一个值

答案：方法重载指在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点：

a) 与返回值类型无关，只看方法名和参数列表

b) 在调用时，虚拟机通过参数列表的不同来区分同名方法

答案：2种。动态创建和静态创建。

答案:类是一组相关属性和行为的集合是一个抽象的东西,对象则是该类的一个具体的体现。

举例:  学生就是一个类,然后每一个学生都是学生的一个个具体的体现,所以每一个学生就是一个学生。

答案:类由成员变量和成员方法组成

成员变量对应的就是事物的属性(就是事物固有的信息,比如: 人的属性有身高 , 姓名 , 年龄 , 学历...) , 成员方法对应的是行为(行为: 就是该事物可以做的事情,比如:人的行为有: 吃饭,睡觉....)

答案：

A:在类中的位置不同

成员变量：在类中方法外

局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同

成员变量：在堆内存

局部变量：在栈内存

C:生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D:初始化值不同

成员变量：有默认初始化值

局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

答案：匿名对象指：没有起名字的对象

使用匿名对象:

a:调用方法，仅仅只调用一次的时候

b:匿名对象可以作为实际参数传递

答案：隐藏实现细节，提供公共的访问方式；

提高了代码的复用性；

提高安全性。

答案：类中的成员需要私有的时候使用private关键字

特点：

是一个权限修饰符。

可以修饰成员(成员变量和成员方法)

被private修饰的成员只在本类中才能访问

答案：this用来解决成员变量与局部变量重名问题

this关键字代表的是本类对象引用；谁调用我,this就代表谁.

答案：构造方法的作用是用于给类的成员变量赋值,完成类的初始化工作

构造方法的特点:

构造方法的名称和类名相同

构造方法没有返回值类型,连void也没有

构造方法没有具体的返回值

构造方法的注意事项:

a: 如果一个类没有给出构造方法,系统将会提供一个默认无参的构造方法

b: 如果我们给出类构造方法,系统将不会提供默认无参的构造方法,这个时候如果我们还想使用无参的构造方法来创建对象,那么就需要我们给出无参的构造方法

可以写空的return语句.

答案:  一个类的缺省构造方法没有参数

答案：1:所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

2:内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

3:内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

4:调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

答案：Student s = newStudent();

1：将Student.class 字节码文件加载到内存

2: 在栈内存中，开辟一个空间存储 s变量，用来记录Student对象的引用

3: 在堆内存中，开辟一个空间存储 new Student()对象的成员信息

2：加载类中静态成员

3：执行类中静态代码块

4：加载对象中普通成员

5：执行构造代码块

6：执行构造方法

7：将new Student()的地址赋值给 s 变量

答案: A: 提高了代码的维护型

B:提供了代码的复用性

C:让类与类之间产生了关系, 是多态的前提

答案：继承的特点:      在java语言中类的继承只支持单继承,不支持多继承.但是可以多层继承。

继承的注意事项:

A: 子类只能继承父类非私有的成员

B: 子类不能继承父类的构造方法,但是可以通过super去访问父类的构造方法

C:不要为了某个功能去使用继承

答案：this代表的是本类对象的引用 , 谁调用我这个方法,这个方法里边的this就代表谁。一般的使用场景是,当局部变量隐藏了成员变量的时候,我们可以使用this去明确指定要访问的是成员变量

super代表的是父类存储空间的一个标志(可以理解为父类对象的引用),我们可以使用super来访问父类的成员

答案：方法重写：指子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写

需要注意的问题：

父类中私有方法不能被重写

子类重写父类方法时，访问权限不能更低

父类静态方法，子类也必须通过静态方法进行重写。(其实这个算不上方法重写，但是现象确实如此)

答案：重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同(即参数个数或类型不同),与返回值类型无关。

重写Override是发生在子父类中的一个现象, 子类中出现了和父类中一模一样的方法,与返回值有关.

答案：1、子类有所有的构造方法默认都会访问父类中空参数的构造方法。

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。每一个构造方法的第一条语句默认都是：super()

2、如果父类中没有空参数的构造方法，通过下列方式解决

a) 子类通过super去显示调用父类其他的带参的构造方法

b) 子类通过this去调用本类的其他构造方法(本类其他构造也必须首先可以访问了父类构造)

注意：super(...)或者this(...)必须出现在第一条语句上，否则，就会有父类数据的多次初始化

答案：A: 先执行所有的静态代码块，再执行所有的构造代码块，最后执行构造方法

B: 静态代码块只执行一次, 构造代码块和构造方法,每创建一次对象就执行一次

答案：final最终的意思。

final可以修饰类,成员变量,成员方法

final修饰类，此类不能被继承。

final修饰变量，变量就成了常量，只能被赋值一次

final修饰方法，方法不能被重写

答案：一种事物在不同时刻表现出来的状态就是多态

多态的前提:

a: 需要有继承

b: 需要有方法重写(其实没有也是可以的,但是没有意义)，不同状态的表现就是就是靠方法重写体现的

c: 需要有父类的引用指向子类对象：Fu f = new 子类();

答案:         访问成员变量:  编译看左边 , 运行看左边   (因为成员变量其实就是属性,属性就是只该事物的描述信息,所以使用父类在访问的时候,访问的就是父类的成员变量)

成员方法:编译看左边,运行看右边(这个是多态的本质,存在动态绑定的机制)

静态成员方法:  编译看左边,运行看左边(所以说静态算不上重写)

答案:  A:提供了代码的维护性(通过继承保证)

B:提供了代码的扩展性(通过多态保证),这个特点也体现了多态的最常见的应用,作为参数传递.

答案:  多态的弊端,不能访问子类中特有的功能

如果我们还想使用子类中特有的功能,我们需要使用向下转型(向下转型: 就是将父类的引用强制转换成子类的引用,在向下转型的过程中需要注意一个异常: ClassCastException)

答案：使用了关键字abstract声明的类叫做“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract(抽象)。“抽象方法”，属于一种不完整的方法，只含有一个声明，没有方法主体。

抽象类的特点:

A: 抽象类的定义格式: abstractclass类名{}

抽象方法的定义格式:   publicabstract返回值类型 方法名();

B:抽象类中可以存在抽象方法,也可以存在非抽象方法

C:抽象类不能直接进行实例化,我们可以使用多态的形式进行进行间接实例化

D:抽象类的子类

可以是抽象类(没有意思,如果子类还是抽象类,那么我们还是不能进行实例化，还需要一个子类去继承)，也可以是非抽象类(存在一个前提: 子类必须重写父类的抽象方法)

答案: 抽象类虽然不能进行实例化,但是抽象类中是存在构造方法,该构造方法的作用是用于子类访问父类数据是的初始化.

答案：接口中的成员变量都是常量,存在默认的访问修饰符:public static final

接口中的成员方法的特点: 都是抽象方法,存在默认的访问修饰符: public abstract

答案:类与类是继承的关系,只支持单继承,可以是多层继承。

类与接口是实现的关系,可以是多实现

一个类可以继承一个类的同时,还可以实现多个接口

接口与接口是继承的关系,可以是单继承也可以是多继承

答案：A:成员区别

抽象类：

成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

B:关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C:设计理念区别

抽象类       被继承体现的是：”is a”的关系。  抽象类中定义的是该继承体系的共性功能。

接口    被实现体现的是：”like a”的关系。      接口中定义的是该继承体系的扩展功能。

答案: 形式参数是基本类型要的是一个基本类型的变量或者具体的常量值

是类名的时候要的是一个该类的对象

是抽象类名的时候的要的是一个继承自该类的一个子类对象

是接口的时候要的是一个实现了该接口的子类对象

答案:返回值是基本数据类型的时候返回的是一个具体的值

是类名的时候,本质上返回的是一个该类对应的子类对象

是抽象类名的时候返回的应该是一个继承自该类的子类对象

是接口名的时候返回的是一个实现了该接口的子类对象

答案：package，包的意思，其实就是文件夹，它可以对类进行分类管理

答案：在不同包下的类之间相互访问的时候，发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦，这个时候，java就提供了( import )导包的功能。使用import可以将包中的类导入进来，以后使用类的时候，不需导包，直接使用，简化了书写。

答案：1. 内部类可以直接访问外部类的成员，包括私有

2. 外部类要访问内部类的成员，必须先创建内部类对象

答案:  匿名内部类的格式:

new 类名或者接口名() {

方法重写;

} ;

本质:  匿名内部类本质是一个继承了某一个类或者实现了某一个接口的子类对象

答案：== 号比较基本数据类型比较的是值,比较引用数据类型比较的是地址值

equals方法只能比较引用数据类型,默认比较的是地址值,如果我们想要建立自己的比较方式,我们就需要复写equals方法

“a”+“b”+”c”; 分别都是什么？

答案：5个对象，分别是"a" , "b" , "c" , "ab" ,

"abc"，因为字符串的特点是一旦被创建就不能被改变,所有在使用常量进行相加的时候,都是在创建新的字符串对象，最后在把字符串"abc"这个常量值赋值给引用变量s

答案：StringBuffer转换到 String的方式：

1.    通过String类的构造方法

2.    通过StringBuffer类中的toString()方法

3.    通过StringBuffer类中的substring()方法 (注：不常用)

String 转换到 StringBuffer的方式：

1.    通过StringBuffer类的构造方法

2.    通过StringBuffer类的append()、insert()方法

答案：String转换到 int的方式：

1.    String–Integer -- int通过Integer类的intValue()方法

2.    通过Integer类的parseInt(String

s)方法

Int 转换到 String的方式：

1.    Int– Integer–String  Integer的toSting()

2.    通过String类的valueOf()方法

3.    通过Integer类的toSting(int

i)方法

4.    通过与字符串""相连接

答案：基本数据类型 转换到 包装类的方式：

1.    通过包装类的构造方法

2.    通过包装类的静态方法valueOf()

包装类 转换到 基本数据类型的方式：

1.    通过包装类的方法xxxValue()

答案：Java平台提供了两个类：String和StringBuffer，他们可以存储和操作字符串，即包含多个字符的字符数据。String类表示内容不可以改变的字符串；而StringBuffer类表示内容可以被修改的字符串。

答案：StringBuffer和StringBuilder类都表示内容可以被修改的字符串，StringBilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。

答案：正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器里，正则达表示通常被用来检索、替换那些符合某个模式的文本。

答案：Date 转换到 long的方式：通过Date类的getTime()方法

long 转换到 Date的方式：通过Date类的构造方法

答案：Date 转换到String的方式：

1.    Date类的toString()方法

2.    DateFormat类的format()方法

String 转换到 Date的方式：

1． Date类的构造方法(已过时，被DateFormat类的parse(String

s)方法取代)

2． DateFormat类的parse()方法

答案：集合：

可以存储不同类型的元素(通常使用存储一种类型元素)

集合的长度可以改变

数组：

必须存储相同一类型的元素

数组的长度固定

答案：迭代器就是对容器中的元素进行遍历，每次取出一个元素，然后对元素进行操作。

答案：线性表、链表、栈、队列、树、哈希表

答案：ArrayList：底层数组结构；线程不同步，效率高；元素查找快、增删慢；

Vector：底层数组结构；线程同步，安全；元素查找快、增删慢；

LinkedList：底层链表结构，线程不同步，效率高；元素增删快、查找慢

答案：程序是否要考虑线程安全？

是：Vector

否： 查找操作多还是增删操作多？

查找多：ArrayList

增删多：LinkedList

答案：ConcurrentModificationException并发修改异常，在迭代器迭代的过程中，集合中的元素个数发生了改变，此时导致并发修改异常。

解决方式：

1. 通过列表迭代器自带的方法完成元素增删操作。

2. 通过for循环遍历集合，使用集合中的方法完成元素增删操作。

答案：泛型是一种特殊的类型，它把指定类型的工作推迟到客户端代码声明并实例化类或方法的使用进行。也被称为参数化类型，可以把类型当做参数一样传递过来，在传递过来之前我不明确，但是在使用的时候就就明确了。

泛型的好处：

1.提高了程序的安全性

2.将运行期遇到的问题转移到了编译期

3.省去了类型强转的麻烦

泛型的常见应用：

1.泛型类

2.泛型方法

3.泛型接口

答案：List：向下限制

List ：向上限制

? extends T ： 代表接收的泛型类型为T类型或T子类类型

? super T ：代表接收的泛型类型为T类型或T父类类型

答案：泛型方法，指把泛型定义在方法上，使用泛型类型来替代原始类型

public static T[] sort(T[] t){

Arrays.sort(t);

return t;

}

答案：泛型类，指把泛型定义在类上，使用泛型类型来替代原始类型

class GenericClass {

private T t;

public void setT(T t) {

this.t = t;

}

public T getT() {

return t;

}

}

答案：Set集合中不能存储重复元素；

Set集合中的元素是按照某种排序规则存储的

答案：HashSet集合中存储的元素，通过重写hashCode() 与 equals()方法来保证元素唯一性

答案：TreeSet集合中保证元素唯一性与排序有两种方式：

方式1：实现自然排序接口 Comparable，重写 compareTo(T t)方法

方式2：实现比较器排序接口 Comparator，重写 compare(T t1, T t2)方法

答案：Map接口是双列集合顶层接口，每个位置存储一对元素(key, value)

Collection接口是单列集合顶层接口，每个位置存储一个元素

答案：Map集合遍历方式有两种：

方式一： 键找值

方式二： 键值对对象，找键，找值

答案：HashMap：线程不同步，效率高；可以存储null键null值

Hashtable：线程同步，数据安全；不可以存储null键null值

答案：Collection:单列集合的顶层接口，包含集合中常用的方法。

Collections:集合工具类，包含获取集合最大元素值、集合排序等方法。

答案：Java异常是java提供的用于处理程序中错误的一种机制。

所谓错误是指在程序运行的过程中发生的一些异常事件(如：除0错误，数组下标越界，所要读取的文件不存在)。设计良好地程序应该在程序异常发生时提供处理这些错误的方法，使得程序不会因为异常的发送而阻断或产生不可预见的结果。

Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息，并将被提交给java运行时系统，这个过程称为抛出异常。

当java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交其处理，这一过程称为捕获异常。

异常的分类：

Error：称为错误，由java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序对其不做处理。

Exception：所有异常类的父类，其子类对应了各种各样的可能出现的异常事件，一般需要用户显示的声明或捕获。

Runtime Exception:一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理)。

答案：捕获异常：try...catch...finally

抛出异常：throw

\ throws()

其实异常部分主要讲的就是五个关键字：try、catch、finally、throw、throws

try语句：

try{...}语句制定了一段代码，这段代码就是一次捕获并处理异常的范围。在执行过程中，这段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。如果没有异常发生，所有的catch代码段都被略过不执行。

catch语句

在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。在catch中声明的异常对象(catch(XxxException e))封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这些信息。

finally语句：

finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序的状态做统一的管理。无论try所指定的程序块中是否抛出异常，finally所指定的代码都要执行。通常在finally语句中可以进行资源的清除工作。

throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。

throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通常throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指定要抛出的异常；如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

答案：编译时异常：程序正确，但因为外在的环境条件不满足引发。对商用软件系统，程序开发者必须考虑并处理这类异常。Java编译器强制要求处理这类异常，如果不捕获这类异常，程序将不能被编译。

运行期异常：这意味着程序存在bug，如数组越界，0被除，传入参数不满足规则等，这类异常需要更改程序来避免，java编译器强制要求处理这类异常。

错误：一般很少见，也很难通过程序解决。它可能源于程序的bug，但一般更可能源于环境问题，如内存耗尽。错误在程序中无须处理，而由运行环境处理。

答案：throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。

throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通常throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指定要抛出的异常；如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

答案：final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提高垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

答案：1. 子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。

2.如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常。

3.如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try...catch，不能throws

答案：FilenameFilter是文件名过滤器，用来过滤不符合规则的文件名，并返回合格的文件。

答案：

NullPointerException - 空指针引用异常

ClassCastException - 类型强制转换异常

IllegalArgumentException - 传递非法参数异常

ArithmeticException - 算术运算异常

ArrayStoreException - 向数组中存放与声明类型不兼容对象异常

IndexOutOfBoundsException - 下标越界异常

NumberFormatException - 数字格式异常

答案：所谓递归，是指程序调用自身。注意，递归不会无休止地调用下去，它必然有一个出口，当满足条件时程序也就结束了，不然的话，那就是死循环了。

答案：IO流

|-字节流

|-字节输入流InputStream

|-字节输出流OutputStream

|-字符流

|-字符输入流Reader

|-字符输出流Writer

答案：字符编码(英语：Character

encoding)也称字集码，是把字符集中的字符编码为指定集合中某一对象，以便文本在计算机中存储和通过通信网络的传递。常见的例子包括将拉丁字母表编码成摩斯电码和ASCII。其中，ASCII将字母、数字和其他符号编号，并用7比特的二进制来表示这个整数。通常会额外使用一个扩充的比特，以便以1个字节的方式存储。

常见的字符编码表如下：

ASCII

GB2312：是一个简体中文字符集，由6763个常用汉字和682个全角的非汉字字符组成。

GBK：GBK编码标准兼容GB2312，共收录汉字21003个、符号883个，并提供1894个造字码位，简、繁体字融于一库

GB18030：是在GBK基础上增加了一部分汉字

Big5：在台湾、香港与澳门地区，使用的是繁体中文字符集

Unicode：将世界上所有的符号都纳入其中，无论是英文、日文、还是中文等，大家都使用这个编码表，这样就利于同一的管理,在这个编码表中每一个字符占两个字节

UTF-8：为了提高Unicode的编码效率，于是就出现了UTF-8编码。UTF-8可以根据不同的符号自动选择编码的长短。比如英文字母可以只用1个字节就够了。

答案：字节输入流InputStream

read()读取一个字节

read(byte[])读取一个字节数组

字节输出流

write(int)写入一个字节

write(byte[])写入一个字节数组

字符输入流

read()读取一个字符

read(char[])读取一个字符数组

字符缓冲输入流

readLine()读取一行字符串

字符输出流

write(int)写入一个字符

write(char[])写入一个字符数组

write(String)写入一个字符串

字符缓冲输出流

newLine()写入一个换行符

答案：OutputStreamWriter：使用编码表对字节流的数据进行编码

InputStreamReader：使用编码表对字节流中的数据进行解码

答案：PrintStream在OutputStream基础之上提供了增强的功能，即可以方便地输出各种类型的数据(而不仅限于byte类型)的格式化表示形式。PrintStream的方法从不抛出IOException

PrintWriter提供了PrintStream的所有打印方法，其方法也从不抛出IOException。

与PrintStream的区别：作为处理流使用时，PrintStream只能封装OutputStream类型的字节流，而PrintWriter既可以封装OutputStream类型的字节流，还能够封装Writer类型的字符输出流并增强其功能。