java教程之javaSE面试题总结(3)

当前位置:

首页 > Python基础教程 >

java教程之javaSE面试题总结(3)

继承条件下构造方法的执行过程

	继承条件下构造方法的调用规则如下：

如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。
特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

	==和equals的区别和联系

	==：

	a) 基本类型，比较的是值

	b) 引用类型，比较的是地址

	c) 不能比较没有父子关系的两个对象

	equals()

	a) 系统类一般已经覆盖了equals()，比较的是内容。

	b) 用户自定义类如果没有覆盖equals()，将调用父类的equals（比如是Object），而Object的equals的比较是地址（return (this == obj);）

	c) 用户自定义类需要覆盖父类的equals()

	注意：Object的==和equals比较的都是地址，作用相同

	多态的技能点（前提条件，向上转型、向下转型）

	实现多态的三个条件

继承的存在；（继承是多态的基础，没有继承就没有多态）
子类重写父类的方法。（多态下会调用子类重写后的方法）
父类引用变量指向子类对象。（涉及子类到父类的类型转换）

	向上转型 Student person = new Student()

将一个父类的引用指向一个子类对象，成为向上转型，自动进行类型转换。
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法
此时通过父类引用变量无法调用子类特有的方法

	向下转型 Student stu = (Student)person;

将一个指向子类对象的引用赋给一个子类的引用，成为向下转型，此时必须进行强制类型转换。
向下转型必须转换为父类引用指向的真实子类类型，，否则将出现ClassCastException，不是任意的强制转换
向下转型时可以结合使用instanceof运算符进行强制类型转换，比如出现转换异常。

	接口和抽象类的异同之处

	相同点

抽象类和接口均包含抽象方法，类必须实现所有的抽象方法，否则是抽象类
抽象类和接口都不能实例化，他们位于继承树的顶端，用来被其他类继承和实现

	两者的区别主要体现在两方面：语法方面和设计理念方面

	语法方面的区别是比较低层次的，非本质的，主要表现在：

接口中只能定义全局静态常量，不能定义变量。抽象类中可以定义常量和变量。
接口中所有的方法都是全局抽象方法。抽象类中可以有0个、1个或多个，甚至全部都是抽象方法。
抽象类中可以有构造方法，但不能用来实例化，而在子类实例化是执行，完成属于抽象类的初始化操作。接口中不能定义构造方法。
一个类只能有一个直接父类（可以是抽象类），但可以充实实现多个接口。一个类使用extends来继承抽象类，使用implements来实现接口。

	二者的主要区别还是在设计理念上，其决定了某些情况下到底使用抽象类还是接口。

抽象类体现了一种继承关系，目的是复用代码，抽象类中定义了各个子类的相同代码，可以认为父类是一个实现了部分功能的“中间产品”，而子类是“最终产品”。父类和子类之间必须存在“is-a”的关系，即父类和子类在概念本质上应该是相同的。
接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。接口和实现之间可以认为是一种“has-a的关系”

	简述Java的垃圾回收机制

	传统的C/C++语言，需要程序员负责回收已经分配内存。显式回收垃圾回收的缺点：

程序忘记及时回收，从而导致内存泄露，降低系统性能。
程序错误回收程序核心类库的内存，导致系统崩溃。

	Java语言不需要程序员直接控制内存回收，是由JRE在后台自动回收不再使用的内存，称为垃圾回收机制。

可以提高编程效率。
保护程序的完整性。
其开销影响性能。Java虚拟机必须跟踪程序中有用的对象，确定哪些是无用的。

	垃圾回收机制的特点

垃圾回收机制回收JVM堆内存里的对象空间,不负责回收栈内存数据。
对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力。
垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。
可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。
现在的JVM有多种垃圾回收实现算法，表现各异。
垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。
程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾回收依然不确定。
永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

	第六章 异常处理

	Error和Exception的区别

Error类，表示仅靠程序本身无法恢复的严重错误，比如说内存溢出、动态链接异常、虚拟机错误。应用程序不应该抛出这种类型的对象。假如出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以在进行程序设计时，应该更关注Exception类。
Exception类，由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等。它的各种不同子类分别对应不同类型异常。可分为两类：Checked异常和Runtime异常

	Checked异常和Runtime异常的区别

运行时异常：包括RuntimeaException及其所有子类。不要求程序必须对它们作出处理，比如InputMismatchException、ArithmeticException、NullPointerException等。即使没有使用try-catch或throws进行处理，仍旧可以进行编译和运行。如果运行时发生异常，会输出异常的堆栈信息并中止程序执行。
Checked异常（非运行时异常）：除了运行时异常外的其他异常类都是Checked异常。程序必须捕获或者声明抛出这种异常，否则出现编译错误，无法通过编译。处理方式包括两种：通过try-catch捕获异常，通过throws声明抛出异常从而交给上一级调用方法处理。

	Java异常处理try-catch-finally的执行过程

	try-catch-finally程序块的执行流程以及执行结果比较复杂。基本执行过程如下：

	程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。catch语句块可以有多个，分别捕获不同类型的异常。catch语句块执行完后程序会继续执行finally语句块。finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行。

	需要注意的是即使try和catch块中存在return语句，finally语句也会执行。是在执行完finally语句后再通过return退出。

	异常处理中throws和throw的区别

作用不同：throw用于程序员自行产生并抛出异常；throws用于声明在该方法内抛出了异常
使用的位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。
内容不同：throw抛出一个异常对象，且只能是一个；throws后面跟异常类，而且可以有多个。

	常用工具类

	基本数据类型和包装类

	1)八个基本数据类型的包装类

	基本数据类型 包装类

	byte Byte

	boolean Boolean

	short Short

	char Character

	int Integer

	long Long

	float Float

	double Double

	list.add()

	2)为什么为基本类型引入包装类

	基本数据类型有方便之处，简单、高效。

	但是Java中的基本数据类型却是不面向对象的（没有属性、方法），这在实际使用时存在很多的不便（比如集合的元素只能是Object）。

	为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行包装，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

	3) 包装类和基本数据类型之间的转换

	包装类------ wrapperInstance.xxxValue() ----------->基本数据类型

	包装类<-----new WrapperClass(primitive) new WrapperClass(string)------基本数据类型

	4)自动装箱和自动拆箱

	JDK1.5提供了自动装箱（autoboxing）和自动拆箱（autounboxing）功能, 从而实现了包装类和基本数据类型之间的自动转换

	5)、包装类还可以实现基本类型变量和字符串之间的转换

	基本类型变量------------String.valueof()------------>字符串

	基本类型变量<------------WrapperClass.parseXxx(string)------------字符串

	Integer与int的区别

	int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

	在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

	另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

	String类为什么是final的

为了效率。若允许被继承，则其高度的被使用率可能会降低程序的性能。
为了安全。JDK中提供的好多核心类比如String，这类的类的内部好多方法的实现都不是java编程语言本身编写的，好多方法都是调用的操作系统本地的API，这就是著名的“本地方法调用”，也只有这样才能做事，这种类是非常底层的，和操作系统交流频繁的，那么如果这种类可以被继承的话，如果我们再把它的方法重写了，往操作系统内部写入一段具有恶意攻击性质的代码什么的，这不就成了核心病毒了么？
不希望别人改，这个类就像一个工具一样，类的提供者给我们提供了，就希望我们直接用就完了，不想让我们随便能改，其实说白了还是安全性，如果随便能改了，那么java编写的程序肯定就很不稳定，你可以保证自己不乱改，但是将来一个项目好多人来做，管不了别人，再说有时候万一疏忽了呢？他也不是估计的，所以这个安全性是很重要的，java和C++相比，优点之一就包括这一点；

	String、StringBuffer、StringBuilder区别与联系

String类是不可变类，即一旦一个String对象被创建后，包含在这个对象中的字符序列是不可改变的，直至这个对象销毁。
StringBuffer类则代表一个字符序列可变的字符串，可以通过append、insert、reverse、setChartAt、setLength等方法改变其内容。一旦生成了最终的字符串，调用toString方法将其转变为String
JDK1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和方法基本相同。不同是StringBuffer是线程安全的，而StringBuilder是线程不安全的，所以性能略高。通常情况下，创建一个内容可变的字符串，应该优先考虑使用StringBuilder

	String类型是基本数据类型吗？基本数据类型有哪些

	基本数据类型包括byte、int、char、long、float、double、boolean和short。

	java.lang.String类是引用数据类型，并且是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

	String s="Hello";s=s+"world!";执行后，s内容是否改变？

	没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。 通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。 同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做： public class Demo { private String s; ... public Demo { s = "Initial Value"; } ... } 而非 s = new String("Initial Value"); 后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。 上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。 至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

	String s = new String("xyz");创建几个String Object?

	两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

	下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";

	答：对于如下代码：

	String s1 = "a";

	String s2 = s1 + "b";

	String s3 = "a" + "b";

	System.out.println(s2 == "ab");

	System.out.println(s3 == "ab");

	第一条语句打印的结果为false，第二条语句打印的结果为true，这说明javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

	题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，

	String s = "a" + "b" + "c" + "d";

	System.out.println(s == "abcd");

	最终打印的结果应该为true。 

	java.sql.Date和java.util.Date的联系和区别

	java.sql.Date是java.util.Date的子类，是一个包装了毫秒值的瘦包装器，允许 JDBC 将毫秒值标识为 SQL DATE 值。毫秒值表示自 1970 年 1 月 1 日 00:00:00 GMT 以来经过的毫秒数。 为了与 SQL DATE 的定义一致，由 java.sql.Date 实例包装的毫秒值必须通过将时间、分钟、秒和毫秒设置为与该实例相关的特定时区中的零来“规范化”。 说白了，java.sql.Date就是与数据库Date相对应的一个类型，而java.util.Date是纯java的Date。

	JAVA里提供的日期和时间类，java.sql.Date和java.sql.Time,只会从数据库里读取某部分值，这有时会导致丢失数据。例如一个包含2002/05/22 5:00:57 PM的字段，读取日期时得到的是2002/05/22,而读取时间时得到的是5:00:57 PM. 你需要了解数据库里存储时间的精度。有些数据库，比如MySQL,精度为毫秒，然而另一些数据库，包括Oracle,存储SQL DATE类型数据时，毫秒部分的数据是不保存的。以下操作中容易出现不易被发现的BUG：获得一个JAVA里的日期对象。 从数据库里读取日期 试图比较两个日期对象是否相等。如果毫秒部分丢失，本来认为相等的两个日期对象用Equals方法可能返回false。.sql.Timestamp类比java.util.Date类精确度要高。这个类包了一个getTime()方法，但是它不会返回额外精度部分的数据，因此必须使用...

	总之，java.util.Date 就是Java的日期对象，而java.sql.Date 是针对SQL语句使用的，只包含日期而没有时间部分。

	使用递归算法输出某个目录下所有文件和子目录列表

	import java.io.File;

	public class $ { 

	public static void main(String[] args) { 

	String path = "D:/301SXT"; 

	test(path); 

}

	private static void test(String path) { 

	File f = new File(path); 

	File[] fs = f.listFiles(); 

	if (fs == null) { 

	return; 

}

	for (File file : fs) { 

	if (file.isFile()) { 

	System.out.println(file.getPath()); 

	} else { 

	test(file.getPath()); 

}

}

}

}

	第八章 集合

	Java集合体系结构（List、Set、Collection、Map的区别和联系）

	Collection 接口存储一组不唯一，无序的对象

	List 接口存储一组不唯一，有序（插入顺序）的对象

	Set 接口存储一组唯一，无序的对象

	Map接口存储一组键值对象，提供key到value的映射。Key无序，唯一。value不要求有序，允许重复。（如果只使用key存储，而不使用value，那就是Set）

	Vector和ArrayList的区别和联系

	Vector和ArrayList的区别和联系

	实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用

	两者的主要区别如下

Vector是早期JDK接口，ArrayList是替代Vector的新接口
Vector线程安全，ArrayList重速度轻安全，线程非安全
长度需增长时，Vector默认增长一倍，ArrayList增长50%

	ArrayList和LinkedList的区别和联系

	两者都实现了List接口，都具有List中元素有序、不唯一的特点。

	ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高；

	LinkedList采用链表存储方式。插入、删除元素时效率比较高

	HashMap和Hashtable的区别和联系

	实现原理相同，功能相同，底层都是哈希表结构，查询速度快，在很多情况下可以互用

	两者的主要区别如下

Hashtable是早期JDK提供的接口，HashMap是新版JDK提供的接口
Hashtable继承Dictionary类，HashMap实现Map接口
Hashtable线程安全，HashMap线程非安全
Hashtable不允许null值，HashMap允许null值

	HashSet的使用和原理（hashCode()和equals()） 

哈希表的查询速度特别快，时间复杂度为O（1）。
HashMap、Hashtable、HashSet这些集合采用的是哈希表结构，需要用到hashCode哈希码，hashCode是一个整数值。
系统类已经覆盖了hashCode方法自定义类如果要放入hash类集合，必须重写hashcode。如果不重写，调用的是Object的hashcode，而Object的hashCode实际上是地址。
向哈希表中添加数据的原理：当向集合Set中增加对象时，首先集合计算要增加对象的hashCode码，根据该值来得到一个位置用来存放当前对象，如在该位置没有一个对象存在的话，那么集合Set认为该对象在集合中不存在，直接增加进去。如果在该位置有一个对象存在的话，接着将准备增加到集合中的对象与该位置上的对象进行equals方法比较，如果该equals方法返回false,那么集合认为集合中不存在该对象，在进行一次散列，将该对象放到散列后计算出的新地址里。如果equals方法返回true，那么集合认为集合中已经存在该对象了，不会再将该对象增加到集合中了。
在哈希表中判断两个元素是否重复要使用到hashCode()和equals()。hashCode决定数据在表中的存储位置，而equals判断是否存在相同数据。
6） Y=K(X) ：K是函数，X是哈希码，Y是地址

	TreeSet的原理和使用（Comparable和comparator）

TreeSet中的元素不允许重复，但是有序
TreeSet采用树结构存储数据，存入元素时需要和树中元素进行对比，需要指定比较策略。可以通过Comparable和Comparator来指定比较策略。
实现了Comparable的系统类可以顺利存入TreeSet。自定义类可以实现Comparable接口来指定比较策略。
可创建Comparator接口实现类来指定比较策略，并通过TreeSet构造方法参数传入。这种方式尤其对系统类非常适用。

	集合和数组的比较（为什么引入集合）

	数组不是面向对象的，存在明显的缺陷，集合完全弥补了数组的一些缺点，比数组更灵活更实用，可大大提高软件的开发效率而且不同的集合框架类可适用于不同场合。具体如下：

数组的效率高于集合类.
数组能存放基本数据类型和对象，而集合类中只能放对象。
数组容量固定且无法动态改变，集合类容量动态改变。
数组无法判断其中实际存有多少元素，length只告诉了array的容量。
集合有多种实现方式和不同的适用场合，而不像数组仅采用顺序表方式。
集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性调用即可实现各种复杂操作，大大提高软件的开发效率。

	Collection和Collections的区别

	Collection是Java提供的集合接口，存储一组不唯一，无序的对象。它有两个子接口List和Set。

	Java中还有一个Collections类，专门用来操作集合类 ，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

	IO流

	输入流和输出流联系和区别，节点流和处理流联系和区别

栏目列表