Java错题集（一）

68 阅读 0 评论 45 点赞

我是靠谱客的博主合适蛋挞，最近开发中收集的这篇文章主要介绍Java错题集（一），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Java错题集（一）

1. String类时final类型的不能继承跟修改这个类。

2. Java 的垃圾回收器（GC）主要针对堆区。

3. 面向对象的五大基本原则：

单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
里氏替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口。

4. 成员方法又称为实例方法、静态方法又称为类方法。

5. 选择题，写出错误答案的原因：

class Demo
{
int show(int a,int b)
{
return 0;
}
}

下面哪些函数可以存在Demo的子类中。

A. public int show（int a，int b）{return 0}; 可以的，覆盖父类方法。
B. private int show（int a，int b）{return 0}；不可以，权限不够。
C. private int show （int a，long b）{return 0}；可以，子类特有方法。
D. public short show（int a，int b）{return 0}；不可以，调用的不确定性。
E. static int show（int a，int b）{return 0}；不可以，静态只能覆盖静态。

class Demo
{
public void func()
{
//位置1；
}
class Inner{}
public static void main(String[] args)
{
Demo d=new Demo();
//位置2
}
}

以下选项正确的是：

A. 在位置1写 new Inner()；可以的，外部类要通过建立内部类对象来调用内部类的方法。
B. 在位置2写 new Inner()；不可以，因为主函数是静态的，只能调用静态成员，所以内部类必须也是静态的。
C. 在位置2写 d.Inner()；不可以，格式错误，正确格式为：new Demo().new Inner()。
D. 在位置2写 new Demo.Inner()；不可以，虽然格式正确，但是只针对内部类是静态的才可以。

7. 在异常中多catch时，父类的catch要放到最下面。

class Exc0 extends Exception
{
}
class Exc1 extends Exc0
{
}
class
DemoDemo
{
public static void main(String[] args)
{
try
{
throw new Exc1();
}
catch (Exc0 e)
{
System.out.println("Exc0");
}
catch(Exception e)
{
System.out.println("Exception");
}
}
}

程序执行结果为：

如果将代码改成：

class Exc0 extends Exception
{
}
class Exc1 extends Exc0
{
}
class
DemoDemo
{
public static void main(String[] args)
{
try
{
throw new Exc1();
}
catch(Exception e)
{
System.out.println("Exception");
}
}
}

运行结果为：

如果将catch的子父类关系交换，编译会报错。由于在异常中多catch时，父类的catch要放到最下面。

9. 静态内部类不可以访问外部类的非静态成员变量，非静态内部类可以访问外部类的非静态成员变量。

10. 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用子类中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。

11. 说明输出结果：

package test;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(super.getClass().getName());
}
public static void main(String[]args){
new SuperTest().test();
}
}

TestSuper和Date的getClass都没有重写，他们都是调用Object的getClass，而Object的getClass作用是返回的是运行对象所属的类。这个运行时的类就是当前类，所以super.getClass().getName()返回的是test.SuperTest，与Date类无关要返回Date类的名字需要写super.getClass().getSuperclass()。

12.

default可以被可以被当前类，包内访问；

13. jre 判断程序是否执行结束的标准是所有的前台线程执行完毕.

main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程则是java中所有前台结束后结束，不管有没有完成，后台线程主要用与内存分配等方面。

前台线程和后台线程的区别和联系：

后台线程不会阻止进程的终止。属于某个进程的所有前台线程都终止后，该进程就会被终止。所有剩余的后台线程都会停止且不会完成。
可以在任何时候将前台线程修改为后台线程，方式是设置Thread.IsBackground 属性。
不管是前台线程还是后台线程，如果线程内出现了异常，都会导致进程的终止。
托管线程池中的线程都是后台线程，使用new Thread方式创建的线程默认都是前台线程。

说明： 应用程序的主线程以及使用Thread构造的线程都默认为前台线程。使用Thread建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。一般后台线程用于处理时间较短的任务，如在一个Web服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在Web服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序。

14. hashcode和equals的约定关系如下：

如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

15. java继承中对构造函数是不继承的，只是显式或者隐式调用。

16.

17. 以下代码段返回的值是什么？

public boolean returnTest()
{
try
{
return true;
}
catch (Exception e)
{
}
finally
{
return false;
}
}

分析：finally其实是仅在return 语句执行前执行，如果return 一个函数，那么会先执行函数，但如果函数内有（return）语句，那么finally就会在这个return 语句前执行。finally在catch中的return之前执行但是如果catch中有返回值而finally中也有返回值的话finally中的返回值会替换catch中的返回值，因为catch中的返回值是存放在一个临时区中。

如果catch块有异常向外抛出，执行顺序呢：我执行我的，你抛你得异常，我finally我的语句，我俩互不干涉，你别管我啥时执行，但我一定会执行。

关于finally，您只需记着一点：除非调用system.exit()让程序退出（也就是将调用这个程序的进程断开了、退出了这个程序）就不会执行或断电等因素致使程序停止进程终止，否则，无论任何因素，finally块都一定会执行。

17.c++中类和结构体的区别：

C++中的struct对C中的struct进行了扩充，它已经不再只是一个包含不同数据类型的数据结构了，它已经获取了太多的功能。

struct能包含成员函数吗？能！
struct能继承吗？能！！
struct能实现多态吗？能！！！

既然这些它都能实现，那它和class还能有什么区别？

最本质的一个区别就是默认的访问控制：默认的继承访问权限，struct是public的，class是private的。
结构体是一种值类型，而类是引用类型。值类型用于存储数据的值，引用类型用于存储对实际数据的引用。那么结构体就是当成值来使用的，类则通过引用来对实际数据操作。
结构使用栈存储（Stack Allocation），而类使用堆存储（Heap Allocation)。

18. final修饰方法，该方法不能被子类重写，但可被重载。

（方法的重写在子类继承父类时才会出现）

（方法的重载就是在一个类中可定义多个方法，这些方法具有相同的名字，但具有不同的参数和不同的方法体，调用时通过传递给它们的不同的参数个数和不同的参数类型来决定调用哪个方法）

19. 面向对象的设计方法一般说有4个基本特征：抽象、继承、封装、多态

20. this()和super()为构造方法，作用是在JVM堆中构建出一个对象。因此避免多次创建对象，同一个方法内只能调用一次this()或super()。同时为了避免操作对象时对象还未构建成功，需要this()和super()的调用在第一行实现以此来创建对象，防止异常。

21. 在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已。

22.

Java程序的种类有：