、6一、基本知识

1. JDK和JRE的区别

答：JDK是java语言开发工具包，包含JRE和开发工具（javac.exe等）；JRE是java语言的运行环境，包含JVM和核心类库；JVM是java虚拟机，保证了java的跨平台性。

2. JVM跨平台吗？

答：JVM不具有跨平台性，不同的操作系统所对应的JVM不一样。正是因为JVM的不跨平台，才能够使java语言具有跨平台性。

3.保留字是什么？

答：保留字是还未使用的关键字，可能在java以后的版本中使用。有goto和const。

4. java语言的特点？

答：完全面向对象，跨平台性，开源，简单易学，安全可靠，高性能，分布式处理，多线程，健壮性，多态。

5. main是关键字吗？

答：不是的。main是主函数的名字，能够被虚拟机识别，是程序执行的入口。

6. path和classpath的区别？

答：path环境变量配置的是可执行文件.exe的执行路径;能够在不同盘符下访问path路径下的可执行文件。Classpath配置的java语言编译后生成的字节码文件的执行路径。

7.计算机最基本的存储单位是：字节（byte）

计算机能直接识别的进制是：二进制

8进行运算的时,变量和常量有什么区别?

答：变量在运算过程中的值是变化的，可以被多次赋值。常量则是固定的。

9标识符的组成？以及命名规则？

答：标识符有26个字母的大小写，0到9,_和$组成。

命名规则：不能使用关键字，不能数字开头，严格区分大小写，要见名知义。

函数名和变量名如果是多个单词组成，第一个单词的首字母小写，其余首字母大写。

类名和接口名如果是多个单词组成，首字母全部大写。

包名全部小写。

常量名全部大写，如果是多个单词，用_隔开。

10.变量数据类型分为哪几种？如何使用变量？

答：基本数据类型：整形：包括byte、short、int、long。浮点型：包括float、doble。

字符型;char;布尔型：boolean。

引用数据类型：数组、类、接口。

变量需要先定义，再赋值，才能使用。

11.常量分为哪几种？

答：自定义常量和字面值常量。自定义常量是我们自己通过final修饰定义的常量。字面值常量包括整数、小数、布尔、字符、字符串。

12.byte的范围多少？char的范围多少？

答:byte范围-128到127 。   char范围0到65535.

13. ASCII码表中 字符 '0'  , 'a' , 'A' 分别对应int类型的值是多少.

答:0在表中对应的值是48，a对应的是97；A对应的是65.

14.long是8个字节,float是4个字节,为什么long 比 float小?

答：底层采用的运算规则不一样。

15.以取值范围的大小排列数据的基本类型.

答：double>float>long>int>char>short>byte

16.+=、-=、这些运算符内隐含了强制类型转换。

17.++和—的使用？

答：单独使用的时候，在前在后都一样。

参与运算的时候，在前是先自加或者自减，然后再用这个结果参与运算。在后是先参与运算，再进行自加或者自减。

18.逻辑或" | " 和 短路或 " || "有什么区别？

答：|不管前面的结果是真是假后面的都会运算，||前面为真后面的不参与运算。但是结果是一样的。

19.逻辑与" & " 和 短路与 " && " 由什么区别？

答：&不管前面的结果是真是假后面的都会运算，&&前面为假后面的不参与运算。但是结果是一样的。

20.Math.round原理是什么？

答：先加0.5，然后再取floor值。

21.生成随机数的方法？

答：第一种：Random类中的方法；第二种Math.random()方法，生成的是0.0和1.0范围直接的小数。

22.if…else..和三元表达的区别

答：能用三元表达式写的就能用if语句写，但是能用if语句写的，三元表达式不一定能写。三元表达式必须要有一个结果。

23.while、do while 、for的区别？

答：do while语句是先性后判断，while和for先判断后执行。

for循环结束后，其中定义的初始化条件不能再使用。

24.if和switch区别？

答：if1.对具体的值进行判断。2.对区间判断。3.对运算结果是boolean类型的表达式进行判断。

switch： 1.对具体的值进行判断。2.值的个数通常是固定的

25.switch语句的表达式可以放什么？

答：byte、short、int、char。JDK1.5以后可以使用枚举，1.7之后可以使用String。

26.死循环的两种写法.

答：while(true)  和  for（；；）

27.break和continue的区别

答：break是完全跳出循环，不再执行循环体的代码。也可以用在switch语句中。Continue是提前结束本次循环，进入下次循环。Return是结束方法。

28.switch中break可以省略吗？default可以省略吗？

答：break在最后一个可以省略，其他的不要省略。Default可以省略。

29：方法重载和方法重写的区别？

答：方法重载是在同一个类中出现同名方法，参数列表不同，与返回值类型无关。

方法重写是在子父类间，子类出现和父类声明完全相同的方法时，就成为方法重写。重写要求返回值必须相同或者有子父类关系。

30.方法的注意事项：

答:要明确方法的返回值类型，明确方法的参数列表。

31.方法的调用？

答：有返回值时可以单独调用，但是没有意义；也可以放在输出语句中；可以赋值给变量。无返回值直接调用即可。

32.数组的定义格式？

答：int[] arr =new int[5];int arr[]= new int[5];

int[] arr = new int[]{1,5,6,7,…} int[] arr = {23,6,8,9…}

二维数组

String[][] arr = new String[3][];

Syso(arr[0])  打印的结果是null。

33.数组的默认值？

答;整形的默认值是0，引用数据类型是null；boolean型的是false。

34.栈内存和堆内存？

答：栈内存用于存储局部变量和代码的执行，堆内存中都是new出来的。

35.数组和集合的区别：

（1）长度区别：数组长度是固定的；集合长度可变。

（2）存储内容：一个数组只能存储同一种数据类型的元素；集合可以存储不同数据类型的元素。

（3）数据类型：数组能够存储基本数据类型，也能够存储引用数据类型；集合只能存储引用数组类型。

36.数组和集合的转换？

答：数组转为集合：Arrays.asList(数组)，转为集合后不能添加、删除元素。但是可以修改元素。把基本类型的数组转为集合，把这个数组作为对象存入集合中。

集合转为数组：list.toArray().

二、面向对象

37.局部变量和成员变量的区别：

（1）定义位置不同：成员变量定义在类中方法外，局部变量定义在方法内。

（2）作用范围不同：成员变量在整个类中有效，局部变量在所在的方法有效。

（3）内存位置不同：成员变量随着对象的创建存放在堆内存中，局部变量存放在栈内存中。

（4）初始化值不同：成员变量是有默认的初始化的值的；局部变量不赋值不能用。

（5）生命周期不同：成员变量随着对象的存在而存在，随着对象的消失而消失；局部变量随着方法的调用而存在，方法调用完毕而消失。

38.变量的使用顺序？

答:就近原则。先在局部找，局部找不到在本类中找，本类找不到就去父类找，找不到就编译失败。

39.类和对象的关系？

答：类是具有相同或相似一类事物的抽象；对象是类的实例化。

40.java描述事物最基本的单位？

答：类

41.什么叫面向对象？

答：面向对象是一种思想，它是基于面向过程的，强调的是具备功能的对象，让对象调用方法解决问题。在开发中，要完成特定的功能就去寻找相应的对象，如果找不到就创建对象，使用对象，维护完善对象。

自己举例说明：厨师做饭，女朋友洗衣服。。。。。

思想特点:1.让复杂的事情简单化；2,更符合人类的思维需求；3.角色从执行者到指挥者。

三大特征：封装，继承，多态。

42.什么是封装？封装的原则？好处？

答：封装就是把不需要对外暴露的状态信息隐藏在对象内部，不允许外部程序直接访问对象的信息，而是通过该类对外提供公共的访问方式对其访问和操作。

原则：（1）将不需要对外暴露的信息隐藏；（2）对外提供公共的访问方式。

好处：将变化隔离；提高了安全性；便于使用，提高了重用性。

43.封装就是私有，对吗？为什么？

答：private是封装的一种体现形式。方法也是封装。

44.Java中参数传递的问题：

答：如果是基本数据类型，传递的参数要和形参的类型一致；如果是引用数据类型，那么传递的参数类型和形参的一致，或者是他的子类。

45.构造方法，set方法都可以给成员变量赋值，这两种赋值方式有什么区别？

答：构造方法主要作用是用来给对象初始化，赋值只是他的兼职工作，也可以不用赋值。

Set方法只能用来赋值，在原有对象的基础上赋值。

46.static关键字的特点？注意事项是什么？有什么好处和弊端？

答：（1）被static修饰的变量和方法随着类的加载而加载（2）优于对象存在（3）能够被类名直接调用（4）资源共享。

注意事项：静态方法中不可以定义this、super关键字，因为静态优先于对象存在，静态只能覆盖静态。

好处：static能够被类名直接调用，定义的是对象的共性内容，不用每个对象单独定义，节省空间。弊端：生命周期过长。

47.类变量和实例变量的区别？

答：（1）所属不同：类变量属于类，是对象的共性内容；实例变量属于对象，是特性内容。

（2）存储位置不同：类变量随着类的加载存储于方法区；实例变量随着对象的创建存储于堆内存中。

（3）生命周期不同：类变量随着类的加载而存在，随着类的消失而消失；实例变量随着对象的存在而存在，随着对象的消失而消失。

（4）调用方式不同：类变量能够被类名直接调用，有对象的时候也能被对象调用；实例变量只能被对象调用。

48.构造方法能不能重载？

答：可以，在同一个类中，参数列表不同，与返回值无关。

49.静态代码块和构造代码块的区别？

答：（1）静态代码块属于类，给类进行初始化，类一加载就会执行，只执行一次，经常用于加载驱动。

（2）构造代码块给对象进行统一初始化，每创建一次就会执行一次。

50.什么是继承？

答：当多个类中有很多共性的内容时，我们可以把这些共性内容抽取出来封装成一个类，让这些类与这个封装的类产生关系。这种关系就是继承。

51.继承的的特点和好处，弊端？

答：特点：java只支持单继承，但是能够多层次继承；接口能够单继承，也能够多继承。

好处：（1）提高了代码的复用性（2）提高了代码的维护性（3）提高了代码的扩展性。（4）让类与类产生了关系，是多态的前提。

弊端：增强了类与类的耦合性。

52.this和super 的区别？

答：this代表对象的引用，super代表当前对象父类的引用。

53．Super（）和this（）在构造方法能同时使用吗？

答：不能，super调用的是父类的构造，要放在构造函数的第一行；this调用的是本类的构造，也要放在第一行。

Super关键字和this关键字能否在构造函数中共存？

答：能。

54.为什么每个构造函数中第一行都有默认的super()?

用于子类对象访问父类前，对父类数据进行初始化。

55.为什么默认的super()都是空参的呢？

因为Object类是所有 类的父类，Object中只有一个空参构造。

56.构造方法的特点？

答：（1）方法名和类名相同（2）没有返回值，连viod都没有。（3）不用写return，可以有return;

57.this的作用？

答：（1）区别局部变量和成员变量（2）代表本类对象的引用（3）也可以用于构造方法的调用。

58.子父类都有静态代码块，构造代码块，构造方法的执行顺序？

答：父类的静态代码块先执行，再执行子类中的静态代码块；接着执行父类的构造代码块和父类的构造方法，最后执行子类的构造代码块和构造方法。

59.final修饰的变量的初始化时机：

答：a.未被static关键字修饰

* 可以显示初始化

* 可以在构造方法中初始化

b.被static修饰

* 可以显示初始化

* 可以在静态代码块中初始化

* 不能在构造方法中初始化

60. final如果修饰局部变量，会发生什么事情？

答：基本类型，是值不能被改变，引用类型，是地址值不能被改变,对象中的属性可以改变。

61.什么是多态？多态的体现，前提，好处和弊端分别是什么？

答：同一事物在不同时刻表现出来的不同状态。

体现：父类引用指向子类对象，父类引用作为参数可以接收其子类对象，接口引用作为参数可以接收其实现类对象。

前提：（1）类与类之间要有关系，要么继承，要么实现（2）要有方法重写（3）父类或者接口引用指向子类对象。

好处：（1）提高了代码的维护性（2）提高了代码的扩展性，父类引用指向子类对象

弊端：父类引用只能调用父类的方法，不能调用子类特有的方法和属性。

*向上转型：父类或者父接口指向子类对象。

*向下转型：把那个引用强制转为子类对象。

62.多态中成员方法和变量的特点？

答：（1）一般方法：编译看左边，运行看右边。（2）静态方法：编译看左边，运行看左边。（3）变量：编译看左边，运行看左边。

63.抽象类和抽象方法的特点，有什么关系？

答：抽象类不能创建对象，需要子类继承；抽象方法没有方法体，需要子类去实现。抽象类不一定含有抽象方法，抽象方法一定在抽象类中。

64.抽象类中的抽象方法和非抽象方法的区别？

答：抽象方法要求子类必须重写，完成相应的功能；非抽象方法让子类继承，提高代码的复用性。

65.abstract不能和哪些关键字共同存在？

答：private：私有的方法是不可见的，无法被复写

final：被final修饰的方法是最终方法，无法被复写

static：被static修饰的方法，要随类加载到方法区，由于抽象方法没有方法体所以不能加载

66.final修饰的变量、方法、和类有什么特点？

答：final修饰的变量只能赋值一次，不能发生改变，如果修饰的基本类型，是其值不能发生改变，如果修饰的引用数据类型，是地址值不能发生改变；final修饰的方法不能被重写；final修饰的类不能被继承，也称最终类。

67.final、finally、finalized的区别？

答：（1）final是一个关键字，是用来修饰类，成员变量，成员方法的，

它修饰的类不能被继承，但是可以继承其他类，

它修饰的成员变量是一个常量，只能赋值一次

它修饰的成员方法不能被子类重写

（2）finally是 try-catch-finally语句的一个模块，正常情况下里边的代码永远会执行，一般是用来释放资源的

（3）finalize是Object类中的方法，当对象变成垃圾的时候，由GC(Java中的垃圾回收机制)来调用该类的finalize()方法回收垃圾。

68.接口中的成员的特点？

答：都是常量，public static final ;方法都是抽象方法，public abstract;没有构造方法。

69、类与类、类与接口、接口与接口的关系？

答：类只能单继承类，但是能够多层次继承；类实现接口，能同时实现多个接口，能在继承类的同时实现接口；接口可以单继承接口，也能多继承。

70.接口和抽象类的区别？

（1）成员的特点：抽象类可以有变量、常量、构造方法、一般方法、抽象方法；接口有且只能有常量和抽象方法。

（2）关系特点：类与类支持单继承，不能多继承，但是能够多层次继承，类与接口是实现关系，一个类能实现多个接口，一个类继承类一个类的同时能实现多个接口；接口与接口之间能单继承，也能多继承；

（3）设计理念：抽象类定义的是该继承体系的共性功能，是is a的关系。接口定义的是该体系的拓展功能，是like a的关系。

71.接口的思想特点？

（1）对外暴露的规则（2）接口是程序对外的功能拓展（3）接口是用来多实现的（4）接口的出现降低了类与类之间的耦合性。

72．什么是内部类，特点是什么？

答：在类中定义的类就是内部类。特点（1）能够直接访问所在类的成员，包括私有的。（2）外部类访问内部类需要创建内部类的对象。

73.成员内部类是什么？

答：成员内部类是定义在成员位置的类。能够被私有、静态修饰。

74．内部类的方法如果访问局部变量，内部类的成员变量，外部类的成员变量？

答：局部变量可以直接访问；内部类的成员变量this.   ；外部类的成员变量：外部类名.this.

75.局部内部类访问的局部变量为什么要用final修饰？

答：因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用。但是JDK1.8以后取消了这个特性，会默认加上final的。

76．什么是匿名内部类？

答:匿名内部类就是没有名字的内部类，是内部类的简化形式。匿名内部类必须继承或实现一个接口，在使用的时候直接用父类的名字创建一个子类对象并实现其中的方法，匿名内部类的实质是一个继承了该类或者实现该接口的匿名的子类对象。

前提：必须继承一个类或实现一个接口。

规则：（1）不能是抽象的，因为它的本质是一个子类对象。（2）不能定义构造方法，因为没有类名。

使用：（1）当接口中的只有一个抽象方法时，并对方法调用一次的时候（2）传递参数的时候，如果参数是接口或抽象类，其实需要的就是实现类对象或者子类对象，这个时候使用匿名内部类。

77、匿名对象何时使用？

答：（1）当对对象方法调用一次的时候（2）可以作为实际参数进行传递。

78适配器模式？

当一个接口有多个抽象方法时，而我们只使用其中的一个或两个方法时，每次使用的时候我们都要重写这些方法，比较麻烦。我们可以定义一个类去实现这个接口，并重写里面的方法，只是方法体为空，并把这个类定义为抽象类，我们使用的时候继承这个类重写需要的方法就就可以了。

79.四种权限修饰符的比较？

答：public的权限最大，同一类中，同一个包中，不同包中（子类），不同包中（无关类）都可以访问。给大家使用

Protected同一类中，同一个包中，不同包中（子类），可以访问。强调的是子类

默认同一类中，同一个包中可以访问。强调的是同一个包

Private   同一类中访问。强调的是自己

80.package在第一行，只能有一个；然后是import导包；最后是class。

81.代码块的分类：

局部代码块：让变量尽早的消失，节约资源，提高效率。

构造代码块：用于给对象初始化；

静态代码块儿：给类进行初始化，用于加载驱动。

同步代码块：为了防止CPU高速切换出现安全问题。

三、API

81.==和equals的区别？

答：“==”是比较运算符，既能比较基本数据类型，又能比较引用数据类型。基本数据类型比较的是数值，引用数据类型比较的是地址值。

equals是一个方法，只能比较引用数据类型。所有的类都会继承Object的equals方法。重写equals方法比较的是对象的内容，如果没有重写将调研Object的equals方法，比较的是地址值。

82.String str = null 和String str = “”的区别？

答：String str = null只是声明了引用，但是没有创建对象，没有为其开辟空间，不能操作方法。String = “”是创建了一个长度为0的字符串，并在内存中分配了空间。

83．String s1= “abc”, String s2= new String(“abc”),s1==s2结果是什么？s1.equals(s2)结果是什么？

答：s1==s2结果为false。s1指向的常量池中的对象，s2指向的是堆内存中的对象，两者的地址值不同。s1.equals(s2)结果是true。String重写了equals方法，比较的是内容。

84.String，StringBuffer、StringBuilder的区别？

答: String是一个特殊的引用数据类型，是一个长度不可变的字符序列，没有缓冲区，一旦创建就不会发生变化了。即使重新赋值不是在原来对象的基础上改变的，而是创建了一个新的对象，将引用指向这个新的对象，浪费空间，效率比较低。

StringBuffer、StringBuilder是容器，是可变的字符串序列。StringBuffer是JDK1.0版本的，线程是安全的，效率比较低。StringBuilder是JDK1.5出现的，线程不安全，效率高。

85.StringBuilder的底层是什么？

答：底层是字符数组，原始长度为16。通过append添加元素的时候，会自动扩容，扩容规则：大字符串的长度= 小数组长度*2+2.

86.为什么出现基本数据类型包装类？

答：将基本数据类型封装为对象的好处能在对象中封装更多的功能操作数据。

87.String 和int直接的转换？

答：将int类型转为String类型的方法：（1）基本数据类型+“”（2）Integer.toString（int num）（3）String.valueOf（int  i）

将String转为int：Integer.parseInt(String s)

88.基本数据类型包装类的自动拆装箱是什么？

答：是JDK1.5版本出现的新特性，自动装箱就是把基本数据类型转为为包装类型。拆箱就是把包装类转换为基本数据类型。

89.Object类中的常见方法有哪些？

答：hashCode():返回值是int，是该对象的哈希玛值。

equals():返回值是boolean，比较的是地址值。

toString():返回该对象的字符串表现形式。

getClass():返回值类型是Class。返回的是创建该对象所属类对应的字节码文件。

这些方法都需要对象调用，在开发的过程中要重写。

地址值的组成：类名@十六进制的哈希值。

90.获取当前时间毫秒值有哪几种方式？

答：（1）new Date().getTime();（2）System.currentTimeMillis()（3）Calendar.getInstance().getTimeInMillis()

91.正则表达式常用的;

\d 数字：[0-9]

\w 单词字符：[a-zA-Z_0-9]

(X)表示分组

\\1表示和前面的相同

.任何字符

X? ，一次或一次也没有

X* ，零次或多次

X+ ，一次或多次

X{n} ，恰好 n 次

X{n,} ，至少 n 次

X{n,m} ，至少 n 次，但是不超过 m 次

92.日历类和日期类相互转换：

Calendar c = Calendar.getInstance();  c.setTime(date);  c.getTime()

93.Date和String类型的转换？

Date类型转为String 是格式化：format

String转Date是解析；parse

三、集合

94.简述集合体系？

答：集合分为单列集合和双列集合。

单列集合的顶层是Collection接口，包括List和Set集合。

（1.1）List集合的特点是元素可重复，有序，有索引，能够有角标操作集合，有特有的迭代方式ListIterator。包括ArrayList、LinkedList和Vector。

ArrayList集合底层采用的是数组数据结构，查询速度比较快，因为数组有索引，在内存中分配的空间是连续的，但是增删比较慢。线程不同步，效率高。初始容量为10。

LinkedList集合的底层采用的是链表数据结构，增删速度比较快，查询速度比较慢。线程不同步。

Vector底层数据结构也是数组数据结构，但是线程同步，效率低，特有取出元素的方式是枚举。因为效率低，逐步被ArrayList替代。

（1.2） Set集合的特点元素是无序的（存入和取出的顺序不一致），元素不可以重复。包括HashSet和TreeSet。

HashSet的底层数据结构是哈希表，线程不同步，效率高。保证元素的唯一性额有的依据是元素的hashCode和equals方法。如果hashCode不同，不调用equals方法。如果hashCode相同，才会调用equals方法判断元素是否相同。

TreeSet的底层数据结构是二叉树，线程不同步，效率高。能够给元素进行排序。保证元素唯一性的依据是compareTo和return0。排序的两种方式：第一种元素自身实现Comparable接口，重写compareTo（）方法。这种排序方式叫元素的自热排序，也叫默认排序。第二种是当元素自身不具备比较性或者具备的比较性不是所需要的，这时就让集合自身具备比较性，当集合初始化时就有了比较性。定义一个比较器实现Comparator接口，重写compare方法，定义集合的时候将比较器作为参数传递给TreeSet的构造函数，这样集合就具有了比较性。

（2）Map是双列集合的顶层接口，该集合存储的是键值对，一对一对的往里存，而且要保证键的唯一性。包括Hashtable、HashMap、TreeMap。

Hashtable的底层数据结构是哈希表，不可以存储null键和null值，线程同步，效率低。JDK1.0.

HashMap的底层数据结构是哈希表，可以存储null键和null值，线程不同步，将Hashtable替代，JDK1.2效率高。保证键的唯一性的 依据是hashCode和equals方法。

TreeMap的底层数据结构是二叉树，线程不安全，能够给集合中的键排序。

95.什么时候使用什么集合？

答：（1）首先要看是单列还是双列，是单列的话就用Collection，双列就用Map。

（2）要是单列的话看元素是不是要求重复，元素重复的话使用List，看查询多还是增删多，查询多的话用ArrayList，增删多的话用LinkedList，不确定的话用ArrayList。不重复的话使用Set，看是否要求排序，排序的话用TreeSet，不需要排序用HashSet。不确定的话用HashSet。

（3）要是双列的话，看是否要求排序，要求排序用TreeMap，不要求排序用HashMap，不确定的话用HashMap。

96.Collection（单列）和（Map）双列的区别？

答：Collection是单列集合，Map是双列集合。Map的键是唯一的，Collection体系中的Set集合中的元素是唯一的。Map集合的数据结构针对键有效，Collection的底层数据结构针对元素有效。

100.遍历集合的方式有哪些？

答：遍历List集合的方式有普通for、增强for、迭代器Iterator、列表迭代器ListIterator。

遍历Set集合的方式有增强for、迭代器Iterator。

遍历map集合的方式有keySet（），entrySet（）。然后通过增强for、迭代器Iterator遍历。

101.用迭代器和增强for遍历集合，能否用集合的方法操作集合？

答：不能，会出现并发修改异常，ConcurrentModificationException。

并发修改异常就是在用普通迭代器的时候用集合的方法增加、删除元素。可以用列表迭代器。

102.泛型是什么？有什么好处？

答：简单的说一种标签，不确定的类型，用户使用的时候确定类型，是JDK1.5出现的新特性，用于解决安全问题，是一种类型安全机制。

好处：（1）将运行时期会可能出现的异常转移到编译期（2）提高了安全性。（3）避免了强制类型转换的麻烦。

103、上限和下限？

？super E：  E、E的父类，固定下边界。

？extends E： E、E的子类  固定的上边界。

104.字典排序，自然排序和比较器排序是什么？

答：字典排序按照字典上的顺序排序。

自然排序是对强制对实现Comparable接口的类进行排序，实现Comparable接口，重写compareTo（）方法，根据返回值进行排序。

比较器排序是实现Comparator方法，重写compare（）方法，根据返回值进行排序。

105.TreeSet的两种排序方式有什么区别？

答：TreeSet的构造方法中不传参数，会按照类的Comparable排序，没有的话就会报错。TreeSet传入比较器，会按照比较器排序。

106.Map有哪些取出元素的方式？原理是什么？

答：keySet（）：将Map集合中的键取出放在Set集合，然后通过遍历Set集合取出里面的键，再用map的get（key）方法取出对应的值。

entrySet（）将Map集合中的键值对关系取出放在Set集合，然后通过遍历Set集合取出里面的键值对关系，然后通过entry的getKey（）和getValue（）方法取出元素。

107.Collections 和 collection的区别？

答：Collections是用来操作集合的工具类，它是个类；collection是单列集合的顶层接口。

108：

*栈和队列：

队列结构：先进先出的规则

栈结构：先进后出规则

*链表和数组的区别：

数组：一块连续的存储区域

链表结构：每个元素指向下一个元素

四、异常

109.异常体系概述？

答:Throwable类

|--Error：无法通过处理解决的错误

|--Exception：

|--编译时异常:就是在编译程序生成.class文件时产生的异常,这种异常必须处理,要么抛出,要么捕获,否则编译无法通过

|--运行时异常:编译时期不会出现,只有在运行时才产生,这种异常,可以处理,也可以不处理,可以声明,也可以不声明

110.异常处理有哪些方式？

答（1）捕获处理try{}catch{}    try{}catch{}finally{}    try{}finally{}

（2）声明抛出

111.运行异常和编译异常的区别？

答：所有的RumtimeException类及其子类的实例是运行异常，其他异常时编译异常。编译异常必须显式处理，否则会编译失败。运行时异常可以不处理，可以通过编译。

112.throw和throws的区别？

答：throws是在方法声明后面，用来声明异常，后面跟的异常类名；可以跟多个异常类名，用逗号隔开；表示抛出异常，需要由调用者处理。

Throw定义在方法体内，跟的异常对象名；只能跟一个异常对象。

113.子父类间异常的注意事项？

答：（1）子类继承父类时，父类方法抛出了异常，子类重写该方法时只能抛出相同的异常或者该异常的子类。

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

（3）如果父类没有抛出异常，子类重写该方法时不能抛出异常。如果子类出现了异常，只能进行try处理，不能抛出。

114.异常处理的注意事项：

（1）子类不能出现父类没有的异常

（2）如果父类没有抛出异常，子类重写该方法时不能抛出异常。如果子类出现了异常，只能进行try处理，不能抛出。

（3）功能内部如果出现异常，如果内部可以处理，就用try。如果功能内部处理不了，就必须声明出来，让调用者处理。

116.JVM是如何处理异常的？

先自己处理，处理不了交给调用者处理。

五、IO

117.递归的注意事项？

答：1.递归必须要有出口，否则是死递归，造成栈内存溢出。2.递归不能多层次调用，否则会造成栈内存溢出。3.构造方法不能递归调用。

117.路径的分类？

答：分为相对路径和绝对路径。绝对路径是相对盘符而言的；相对路径相对的是工程。

118.集合的顶层是什么？IO的顶层是什么？

答：集合的顶层是接口。IO的顶层的是抽象类。

119.什么IO流？

用来在硬盘和内存直接交换数据的。

120：简述IO的分类？

答：按照流向分输入流和输出流。

按照操作分为字节流和子字符流。

字节流能操作任意类型的文件，如果操作文本，可能会出现乱码。分为字节输出流和字节输入流。

字符流只能操作纯文本文件，分为字符输入流和字符输出流。

121.为什么read（）方法返回值是int类型？

答:为了防止中间出现11111111（-1的反码）这样的数据，后面的内容就读不到了。

122.字符流通往字节流的桥梁是什么？字节流通往字符的桥梁是什么？

答：字符流通往字节流的桥梁是OutputStreamWriter；字节流通往字符流的桥梁是InputstreamReader。

123.标准输入流和输出流是什么？

答：标准输入流的是System.in。标准输出流是System.out.

124.高效字符流的方法？

ReadLine()读不到\r\n

newline()针对当前操作系统换行

125.字节输入流read()一次读取的一个字节，返回的字节的对应的ASCII值。

126.字符缓冲流和字节缓冲流的缓冲区的默认大小是多少？

答：字符缓冲流缓冲区默认的大小是8192个字符，16kb。

字节缓冲流缓冲区默认的大小是8192个字节，8kb。

Writer的2kb。

127.close（）和flush（）的区别：

答：flush()方法是来刷新缓冲区的，刷新之后还可以再次写出。

Close()是用来关闭流释放资源的，如果是带缓冲区的流对象关闭流之前还会刷新缓冲区，关闭之后无法写出。

六、网络编程

128.什么是网络编程？

答：网络编程又叫套接字编程，Socket编程，就是用来实现网络互连的不同计算机上运行程序之间可以进行数据的交换。大白话来讲:就是用java语言来实现网络上不同计算机的通信。

129.网络编程的三要素？

答：IP地址、端口、协议。

IP的组成网关和主机地址。127.0.0.1回环地址   255.255.255.255广播地址

130.端口的范围是什么？哪个范围的端口不能用，为什么？

答：端口的范围是0——65535.   0——1024这个范围的端口不能使用，因为已经被系统占用或者作为保留端口。

131.TCP和UDP协议的区别？

答：TCP是面向有连接的，三次握手机制；传输的数据无大小限制；安全（可靠）协议；效率低；区分客户端和服务器。

UDP是面向无连接的，发送的数据是通过数据报包的形式，不超过64k；不安全（可靠）协议，效率高；不区分客户端和服务器。（叫发送端和接收端）

132.Socket通信的原理是是什么？

答：通信的两端都有独有的Socket，Socket通信就是使用TCP或者UDP协议通过IO流在两个Socket间进行通信。

七、多线程

133.继承和线程？

进程是一个正在执行中的程序，每一个程序都至少有一个执行顺序，该顺序是一个路径，或者叫一个控制单元。

线程是进程中的一个独立的控制单元，线程在控制着进程的执行，是进程的执行路径。

进程：正在运行的程序

线程：进程的执行单元，执行路径。

多线程：进程有多条执行路径，每个执行路径就是线程。

134.多线程并发和多线程并行是什么呢?

答：两个或者多个任务发送请求时，CPU只能执行一个，就会安排这些任务交替执行，由于CPU做着高速的切换，间隔的时间比较短，我们看起来像同时执行的，这就是多线程并发。

并行是两个或多个任务同时执行，前提是多核CPU。

135.多线程的执行原理？

答：CPU在做着高速的切换。

136. 线程的执行具有随机性和延迟性。

137.线程的默认命名规则？

答：Thread-编号，编号是从0开始的。

138.线程的优先级的范围是多少？默认的优先级是？

答：线程的优先级范围是1——10。默认的优先级是5.

139.Java程序的启动原理？

答：JVM启动一个主线程，再由主线程调用某个类的main方法。

140.Java程序是多线程的吗？

答：是的，至少开启了一个主线程和负责垃圾回收的线程。

141.线程的优先级越高，代表这个线程一定是第一个执行的吗？

答：不是的，线程的优先级越高代表着在一定程度上让该线程获取更多的执行机会。

142.线程的两种实现 方式的区别？

答：继承Thread类：好处是：因为是继承，代码简单，能够直接使用Thread类的方法。确定是：扩展性比较差，因为继承了Thread类，不能再继承其他的类。

实现Runnable接口：好处是扩展性比较强。缺点时：代码比较冗余，因为不是继承Thread类，无法直接使用thread中的方法。

143.同步代码块和同步方法的锁是谁？

答;同步代码块的锁可以是任意类型的对象；非静态同步方法的锁是this；静态方法的锁是该类的字节码文件。

144.实现Runnable和Callable的区别？

答：实现Runnable接口的run方法没有返回值，不能抛异常；而实现Callable接口的call方法可以抛异常，有返回值。

Runnable接口的实现类对象既可以作为参数传递给Thread的构造方法，也可以用线程池submit的参数；Callable接口的实现类对象只适应于线程池。

145.线程的生命周期（线程的五种状态）是什么？

答：新建、就绪、运行（运行的时候可能阻塞）、死亡。

线程的六种状态：新建、就绪、运行（运行的时候可能阻塞或者等待）、死亡。

146.sleep和wait的区别？

答：（1）sleep是让线程睡眠，必须给相应的睡眠时间，不需要唤醒，时间到了会自动醒来，休眠时不放弃Cpu的执行权。

（2）wait的是让线程等待，可以传参也可以不传参，传参是在指定的时间后等待，需要被唤醒。等待的时候放弃cpu的执行权。

147.什么时候会出现安全性？

多线程，并发，操作同一数据。

148.为什么wait()和notify()定义在Object中？

答：因为锁对象可以是任意类型的对象。

149.什么情况下需要同步？

当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.

如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

八、模拟汤姆猫服务器

150.BS结构和CS的区别？

答：CS结构是指客户端和服务器端，开发比较容易，因为用户的应用程序都在客户端，降低了系统通压力，但是维护比较困难。

BS结构是指浏览器服务器端，开发比较困难，因为应用程序基本都在服务器端，维护比较方便。

151. 静态资源和动态资源是什么？

答：静态资源是Web页面给人们看到的数据是始终不变的，例如html。

动态资源是Web页面给人们看的数据是系统自动生成的，随时变化的。例如JSP/Servlet、ASP、PHP

在JAVA，动态Web资源开发技术通称Javaweb。

152.常用的状态码你知道哪些？

答：200  请求成功；404  请求的资源不存在；500  服务器发生未知的错误。

153.GET请求和POST请求的区别？

答：GET请求会将请求信息置于地址栏，不安全，适合小数据的传输。

POST请求将请求信息置于请求体，相对安全，适合大数据的传输。

154.客户端向服务器发送请求request，服务器对客户端的请求做出响应response。

http协议是互联网的通用协议（规则），客户端和服务端都要遵循这个协议。默认端口号是80.

155.请求信息包括什么？响应信息包括什么？

答：请求头和请求体。请求头又包括请求行和头信息。

响应信息包括响应头和响应体。

九．数据库

156.为什么要有数据库？常见的数据你知道哪些？

答：为了永久存储数据，并且能够操作数据。

MySQLSQL ServerOracle

157.数据库的本质是什么?

答;数据库的本质是一个文件系统。

158.数据库以什么为单位存储数据？

数据库中以表为组织单位存储数据。

159.常用的SQL语句？

create  database 数据库名;     创建数据库

show databases;                查看所有数据库

use 数据库名；                 使用指定数据库

create table 表名（            创建表

列名1  数据类型 约束，

列名2  数据类型，

列名3  数据类型，

...

列名n  数据类型    --不加，

）

insert into 表名（列名1，列名2，.列名n） values （值1，值2...）;添加数据

delete from 表名 where 条件删除指定条件的数据

update 表名 set 字端1 = 值1，字端2=值2  where 条件； 修改指定数据

select 字段1,字段2,...from 表名;      按照表中的字段名查询：

select * from 表名;查询表中所有字段

order by   排序

group by   分组：

160.聚合函数？

count、sum、max、min、avg

161.JDBC的核心功能是什么？

答：连接数据库；向数据库发送SQL语句；操作SQL语句的返回结果。

162.DBUtils能否创建数据库和表？

答：不能，只能操作数据库里面的数据。

163.SQL语言的分类？

答：SQL语言是JAVA操作数据库的语言。分为DDL（Data Definition Language）数据定义语言；DML（Data manipulation Language）数据操作语言(增删覆盖)；DCL（Data Control Language）数据控制语言；DQL(Data Query Language)数据查询语言。

164.SQL注入的问题产生原因和解决方法？

答：SQL注入是因为客户输入的是SQL语句。可以使用PreparedStatement接口的子类对象。

165.连接池？

答：数据库连接的建立和关闭都是极其消耗资源的。数据库连接池的解决方案是当应用程序启动时，系统主动创建足够的数据库连接，并将这些连接组成一个连接池，每次使用的时候无序重新创建联系，直接从连接池中取出已有的连接使用，使用完后不再关闭数据库连接，而是直接归还到连接池。通过连接池，将极大的提高了程序的运行效率。

1、面向对象的理解

面向对象是基于面向过程的。在开发过程中，要完成特定的功能就去找相应的对象，如果找不到就创建相应的对象，使用对象，维护完善对象。

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

面向过程强调的是功能行为；

面向对象将功能封装成对象，强调的是具备功能的对象

3、abstract与哪些关键字不能共存为什么

private：私有的方法是不可见的，无法被复写

final：被final修饰的方法是最终方法，无法被复写

static：被static修饰的方法，要随类

加载到方法区，由于抽象方法没有方法体所以不能加载

4、static的特点

随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名所调用。

静态方法只能访问静态成员，非静态方法既可以访问静态也可访问非静态

静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this；

5、类与类、类与接口、接口与接口的关系

继承，继承或实现，继承

6、final、finally、finalize的区别

final：可以修饰类、方法和变量，被final修饰的类无法被继承，方法无法被复写，变量为常量只能赋值一次

finally：异常处理trycatch时使用，可以添加也可以不添加，用于执行一些必须执行的代码，如关闭资源等

finalize：Object类中的方法，其中定义了对象要被垃圾收集器回收之前要做的相关的清理工作

7、什么是多态，多态的好处和弊端

多态可以理解为事物存在的多种体现形态。父类的引用指向了自己的子类对象；父类的引用也可以接收自己子类的对象。

好处：提高了代码的扩展性

弊端：父类的引用只能访问父类中有的成员(父类引用无法调用子类中特有的方法)

8、wait()和sleep()的区别

(1)wait是Object类中的方法，sleep是Thread类中的方法

(2)sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

(3)wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

(4)sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

9、网络编程的三要素

(1)IP：网络中设备的标识

(2)端口：用于标识设备中接收数据的网络应用程序具体是哪一个，有效端口0~65535，0~1024为系统端口及保留端口

(3)传输协议：UDP和TCP协议，信息通讯的规则

10、UDP和TCP的区别

UDP：不需要建立连接，是不可靠协议，将数据及源和目的封装到数据报中，每个数据报限制在64k以内，发送数据较少，速度快

TCP：通过三次握手建立连接通路，是可靠协议，可进行大量的数据传输，效率较低

11、什么是暴力反射

我们知道java的特性之一就是封装，将对象的属性和具体实现隐藏起来，只对外提供公共方法访问，private修饰的内部属性和方法对我们是不可见的。

我们通过正常的方法是无法获取以及修改的，可是通过反射却可以强制获取并做一些修改，这就破坏了封装性，这就是所谓的暴力反射

12、反射获取字节码对象方式、创建对象的两种方式

获取字节码方式三种：

(1)类名.class，例如：System.class

(2)对象.getClass()，例如：new Date().getClass();

(3)Class.forName("类名")，例如：Class.forName("java.util.Date");

创建对象的两种方式：

(1)直接用字节码创建对象，只能调用默认的构造方法：字节码.newInstance();

(2)获取构造方法Constructor，然后调用构造方法创建，可以通过参数不同调用不同的构造方式

13、怎么理解反射，反射的应用

反射就是把Java类中的各种成分映射成相应的Java类。

一般情况下我们要解决某个问题，先找到相关的类，创建该类的对象，然后通过该对象调用对应的方法来解决问题。

反射是一个正好相反的过程，开始可能并没有类可以解决这个问题，而我们却先用一个当时可能并不存在的方法解决了这个问题，后来才有的这个类。

这其实就是框架的原理，现有的框架再有的解决问题的类。框架描述了整体，制订了功能方法的规范，具体的实现之后按照这个规范编写。这些都需要靠反射来完成。

使用框架有良好的扩展性，某部分功能的优化不需要涉及程序整体，只需要修改特定的部分就好了，然后通过配置文件，获取对应的类名，就可以了。

14、对匿名内部类的理解

匿名内部类其实是内部类的简写形式。

内部类是定义在类中的类，就好比我们人类，我们人类都有心脏，而心脏又有自己独特组成，可以把心脏也抽象成一个类。

这个心脏类就是人类的内部类。如果要研究某一种心脏疾病，需要一个实例时，我们不需要知道这个患病的心脏到底是谁的，那找到的这个就是匿名的。

匿名内部类必须要继承一个类或实现一个接口，在使用时直接父类或接口的名称创建了一个子类对象并实现其中的方法，匿名内部类其实是一个匿名的子类对象。

15、IO体系

字节流InputStream/OutputStream

|--FileInputStream/FileOutputStream：文件字节流，用于文件的读写操作

|--BufferedInputStream/BufferedOutputStream：加缓冲区的字节流，用于提高效率

字符流Reader/Writer

|--FileReader/FileWriter：文件字符流，用于文本文件的读写操作

|--BufferedReader/BufferedWrite：加缓冲区的字符流，用于提高效率

转换流InputStreamReader/OutputStreamWriter：是字节流和字符流之间的桥梁

配置文件Properties

16、集合体系

|--Collection

|--List：元素是有序的，元素允许重复，因为该集合体系都具有索引

|--ArrayList：底层数据结构是数组，查询速度快，增删操作较慢，线程不同步

|--LinkedList：底层数据结构是链表，查询效率较低，增删操作快，线程不同步

|--Vector：功能同ArrayList类似，底层也是数组，不同是线程是同步的，效率较低

|--Set：元素是无序的，元素不允许重复，底层用到了Map

|--HashSet：底层hash表，存储的对象最好复写hashCode和equals方法，保证元素不会重复

|--TreeSet：底层二叉树，存储的对象具备比较性，有两种方法

|--Map：数据是以键值对的形式存储的，有的元素存在映射关系就可以使用该集合，元素不允许重复

|--HashMap：允许有null键或值，线程不同步

|--TreeMap

|--HashTable：类似HashMap，不允许有null键或值，线程同步

17、线程的创建方式，进程线程的理解继承Thread或实现Runnable

两种：进程是一个执行中的程序，每一个程序都至少有一个执行顺序，该顺序是一个路径，或者叫一个控制单元。

线程是进程中的一个独立的控制单元，线程在控制着进程的执行。

18、局部变量和成员变量区别

成员变量：作用于整个类中，随对象存储在堆内存中，生命周期跟对象一样

局部变量：作用于方法或语句中，方法或语句结束则生命周期结束，存放在栈内存中。

19、同步函数与同步代码块的区别

它们的作用都是封装多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与进来。

同步代码块：位置比较灵活，封装了操作共享数据的语句，多个线程中只有持有锁的才可以操作共享数据，需要指定一个对象作为锁

同步方法：声明方法时加synchronized关键字修饰，同步函数使用的锁是this，持有锁的线程调用这个方法时其他线程无法调用。

20、数组和集合的区别

数组可以存储基本数据类型和对象，它是一个线性的序列，可以快速的访问其中的元素。数组创建之后，容量就固定了，而且在其生命周期里是不能改变的

集合只用于存储对象，集合的长度是可变的，集合可以存储不同类型的对象。集合的长度并不是固定的，可以便捷的添加删除。能够更加便捷的操作元素，功能更加强大

21、StringBuffer和StringBuilder的区别

StringBuffer是线程安全的，StringBuilder是线程不安全的，所以效率比起来StringBuilder要比StringBuffer快。

一般单线程的程序使用StringBuilder比较好，多线程的情况下可以自己加锁，也可以直接使用StringBuffer

22、String和StringBuffer区别

String对象一经创建就不会发生变化了，即便是赋新值也不是在原对象的基础上改变，而是创建一个新的字符串对象，将引用指向这个新的对象，会造成空间的浪费，效率较低

StringBuffer只创建一个对象，是在同一个实例的基础之上追加，效率更高，当需要用到String的时候toString就可以了