Java面试题（一）

以下描述错误的一项是（C ）？

 A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行  到了第几行，是线程隔离的
 B.原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的
 C.方法区用于存储JVM加载的类信息、常量、静态变量，即使编译器编译后的代码等数据，是线程隔离的
 D.Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的

解析：方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

以下java程序代码，执行后的结果是（B）
public class Test {
    public static void main(String[] args) {   
        Object o = new Object() {  
             public boolean equals(Object obj) {  
                 return true; 
         }
     };   
     System.out.println(o.equals("Fred"));
     }
}
 A.Fred
 B.true
 C.编译错误
 D.运行时抛出异常

解析：重写了object 的equals 的方法，使他怎么输出都是tue

下面代码的输出结果是什么？（D）
public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
  }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
  }finally{
       System.out.print(2);
  }
      System.out.print(3);
 }
 }
 A.3
 B.123
 C.1
 D.12

解析：理解Try...catch...finally与直接throw的区别：try catch是直接处理，处理完成之后程序继续往下执行，throw则是将异常抛给它的上一级处理，程序便不往下执行了。本题的catch语句块里面，打印完1之后，又抛出了一个RuntimeException，程序并没有处理它，而是直接抛出，因此执行完finally语句块之后，程序终止了

HashMap和HashTable的描述，错误的是？（D）
 A.他们都实现了Map接口。
 B.HashMap非线程安全，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供额外同步。
 C.HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
 D.通过contains方法可以判断一个对象是否存在于HashMap或者Hashtable中。

解析：HashMap没有contains方法

尝试编译以下程序会产生怎么样的结果？（C）
public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

A.编译错误将发生在（1），因为构造函数不能指定返回值
B.编译错误将发生在（2），因为该类没有默认构造函数
C.编译错误将在（3）处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数
D.该程序将正确编译和执行

解析：第三行并不是MyClass的带参构造函数，而是有个方法，因此实例化是传入参数会编译错误

What is displayed when the following is executed;（A）
double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));

A.Ceil d1=-0.0
  floor d1=-1.0
B.Ceil d1=0.0
  floor d1=-1.0
C.Ceil d1=-0.0
  floor d1=-0.0
D.Ceil d1=0.0
  floor d1=0.0
E.Ceil d1=0
  floor d1=-1

解析：ceil（）天花板数，向上取整； floor（）地板数，向下取整； 保持数据符号不变，类型不变

（多选）关于Java的一些概念，下面哪些描述是正确的：(BF)
A. 所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException
B. 通过try … catch … finally语句，finally中的语句部分无论发生什么异常都会得到执行
C. java中所有的数据都是对象
D. Java通过垃圾回收回收不再引用的变量，垃圾回收时对象的finallize方法一定会得到执行
E. Java是跨平台的语言，无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行
F. Java通过synchronized进行访问的同步，synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的

解析：
A：Java中所有错误和异常的父类为java.lang.Throwable；
C：基本数据类型不是对象，不能new；
D：Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的 
   回收使用finallize；
E：JVM环境不同；
F：Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”
   Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。

（多选）关于Java中的数组，下面的一些描述，哪些描述是准确的：（ACF）
 A.数组是一个对象，不同类型的数组具有不同的类
 B.数组长度是可以动态调整的
 C.数组是一个连续的存储结构
 D.一个固定长度的数组可类似这样定义: int array[100]
 E.两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
 F.可以二维数组，且可以有多维数组，都是在Java中合法的

解析：
E：两个数组直接equals比较是比较对象的内存地址，逐个元素比较应该用Arrays.eques()。

关于JAVA的垃圾回收机制，下面哪些结论是正确？（B）
 A.程序可以任意指定释放内存的时间
 B.JAVA程序不能依赖于垃圾回收的时间或者顺序
 C.程序可明确地标识某个局部变量的引用不再被使用
 D.程序可以显式地立即释放对象占有的内存

解析：
    java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。
    当对象的引用变量被赋值为null，可能被当成垃圾，而局部变量存放在栈上，栈上的垃圾回收，由finalize()来实现。

以下哪个类包含方法flush()？（B）

A. InputStream
B. OutputStream
C. A 和B 选项都包含
D. A  和B 选项都不包含

解析：flush（）函数强制将缓冲区中的字符流、字节流等输出，目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。

关于 访问权限说法正确 的是 ？ (B)
A. 类定义前面可以修饰public,protected和private
B. 内部类前面可以修饰public,protected和private
C. 局部内部类前面可以修饰public,protected和private
D. 以上说法都不正确

解析：
（ 1 ）对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
（ 2 ）内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。
（ 3 ） 因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。

下面代码输出（B）
public static void main(String[] args) {
    Thread t = new Thread() {
        public void run() {
            360DW();
        }
    };
    t.run();
    System.out.print("DW");
}
static void 360DW() {
    System.out.print("360");
}
A.DW
B.360
C.360DW
D.都不输出

解析：程序跑出来是C...

（多选）.Java程序的种类有（BCD）
A. 类（Class）
B. Applet
C. Application
D. Servlet

解析：
内嵌于web文件，由浏览器来观看的Applet。
可独立运行的Application
服务器端的Servlet

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);
（多选）下列代码片段中，存在编译错误的语句是(BCD)
A.语句2
B.语句1
C.语句3
D.语句4

解析：
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

对于Java中异常的描述正确的是（D）
A. 用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
B. 如果try块中没有抛出异常，finally块中的语句将不会被执行。
C. 抛出异常意味着程序发生运行时错误，需要调试修改
D. Java中的可不检测（unchecked）异常可能来自RuntimeException类或其子类。

解析：
A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。
B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。
C错 抛出异常不一定是运行时异常，也有可能是编译时异常。
D对 运行时异常的特点是Java编译器不会检查它。

This调用语句必须是构造函数中的第一个可执行语句。（B）
A. 正确
B. 错误

解析：this()才必须是构造函数中的第一个可执行语句，用this调用语句并不需要。

下列关于构造函数的描述中，错误的是（D）
A. 构造函数可以设置默认的参数
B. 构造函数在定义类对象时自动执行
C. 构造函数可以是内联函数
D. 构造函数不可以重载

解析：构造函数可以被重载！

子类要调用继承自父类的方法，必须使用super关键字。（B）
A. 正确
B. 错误

解析：
1、子类构造函数调用父类构造函数用super
2、子类重写父类方法后，若想调用父类中被重写的方法，用super
3、未被重写的方法可以直接调用

下列代码执行结果为（A）
public static void main(String args[])throws InterruptedException{
            Thread t=new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.print("2");
                }
            });
            t.start();
             
            t.join();
            System.out.print("1");
        }

A. 21
B. 12
C. 可能为12，也可能为21
D. 以上答案都不对

解析：join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

下列不属于java语言鲁棒性（健壮性）特点的是（B）
 A.java能检查程序在编译和运行时的错误
 B.java能运行虚拟机实现跨平台
 C.java自己操纵内存减少了内存出错的可能性
 D.java还实现了真数组，避免了覆盖数据的可能

解析：跨平台不属于鲁棒性

（多选）以下哪种方式实现的单例是线程安全的（ABCD）
 A.枚举
 B.静态内部类
 C.双检锁模式
 D.饿汉式

解析：
1.饿汉式(线程安全，调用效率高，但是不能延时加载)；
2.懒汉式(线程安全，调用效率不高，但是能延时加载)；
3.Double CheckLock实现单例：DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）；
4.静态内部类实现模式（线程安全，调用效率高，可以延时加载）； 5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）。

如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？  (C)
A.void use() { …}
B.protected void use() { …}
C.public void use() { …}
D.以上语句都可以用在类SmallCup中

解析：既然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）

观察以下代码：
class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}
下列哪些针对代码运行结果的描述是正确的？（A）
A.Car
B.Vehicle
C.Compiler error at line 3
D.Compiler error at line 5
E.Exception thrown at runtime

解析：首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

（多选）关于多线程和多进程，下面描述正确的是（AC）：
A.	多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
B.	线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
C.	线程的通信速度更快，切换更快，因为他们在同一地址空间内。
D.	一个线程可以属于多个进程。

解析：
1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
4、处理机分给线程，即真正在处理机上运行的是线程。
5、线程是指进程内的一个执行单元，也是进程内的可调度实体。

（多选）在java中重写方法应遵循规则的包括（BC）
A.	访问修饰符的限制一定要大于被重写方法的访问修饰符
B.	可以有不同的访问修饰符
C.	参数列表必须完全与被重写的方法相同
D.	必须具有不同的参数列表

解析：
方法重写要注意的事项：
    1.方法重写时， 方法名与形参列表必须一致。
    2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
    3.方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型。
    4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
    Exception(大)
    RuntimeException(小)

Java的Daemon线程，setDaemon(A)设置必须要？
A.	在start之前
B.	在start之后
C.	前后都可以

解析：setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

事务隔离级别是由谁实现的？（C）
A.	Java应用程序
B.	Hibernate
C.	数据库系统
D.	JDBC驱动程序

解析：
A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
B，Hibernate是一个java的数据持久化框架，方便数据库的访问
C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
D，JDBC是java database connector，也就是java访问数据库的驱动

public interface IService {
    String NAME="default";
}
与上面等价表示是哪一项（D）？
A.	public String NAME=”default”;
B.	public static String NAME=”default”;
C.	private String NAME=”default”;
D.	public static final String NAME=”default”;

解析：
为什么是public：因为接口必然是要被实现的，如果不是public，这个属性就没有意义了；
为什么是static：因为如果不是static，那么由于每个类可以继承多个接口，那就会出现重名的情况；
为什么是final：这是为了体现java的开闭原则，因为接口是一种模板，既然是模板，那就对修改关闭，对扩展开放。

ArrayList和Vector主要区别是什么？（A）
A.	Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步
B.	Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步
C.	Vector是通过链表结构存储数据，ArrayList是通过数组存储数据
D.	上述说法都不正确

解析：
Vector支持线程的同步，也就是内部加锁的
但是效率低，因此在新版jdk中加入线程不安全的Arraylist

下面这条语句一共创建了多少个对象：String s="welcome"+"to"+360;（A）
A.	1
B.	2
C.	3
D.	4

解析：String在初始化时连接的全是常量，故只有一个String对象。

下列关于Java并发的说法中正确的是（B）
A.	CopyOnWriteArrayList适用于写多读少的并发场景
B.	ReadWriteLock适用于读多写少的并发场景
C.	ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
D.	只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析：
A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
   读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性

下面哪个Set类是排序的？（B）
A.	LinkedHashSet
B.	TreeSet
C.	HashSet
D.	AbstractSet

解析：TreeSet自然排序

以下J2EE中常用的名词解释错误的是？（B）
A.	EJB容器：Enterprise java bean 容器
B.	JNDI：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
C.	JMS：JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
D.	JAF：JAVA安全认证框架。提供一些安全控制方面的框架。

解析：
1.web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接和容器中的环境变量接接口互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
2.Web container：实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境，包括安全，一致性，生命周期管理，事务，配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。
3.EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。一个实现了J2EE体系结构中EJB组件规范的容器。 这个规范指定了一个Enterprise bean的运行时环境，包括安全，一致性，生命周期，事务， 配置，和其他的服务。
4.JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
5.JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
6.JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
7.JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
8.RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。RMI-IIOP出现以前，只有RMI和CORBA两种选择来进行分布式程序设计。RMI-IIOP综合了RMI和CORBA的优点，克服了他们的缺点，使得程序员能更方便的编写分布式程序设计，实现分布式计算。首先，RMI-IIOP综合了RMI的简单性和CORBA的多语言性（兼容性），其次RMI-IIOP克服了RMI只能用于Java的缺点和CORBA的复杂性（可以不用掌握IDL）。

以下哪项不属于java类加载过程？（B）
A.	生成java.lang.Class对象
B.	int类型对象成员变量赋予默认值
C.	执行static块代码
D.	类方法解析

解析：
类的加载包括：加载，验证，准备，解析，初始化。
选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。

下列哪个选项是正确计算42度（角度）的余弦值？（C）
A.	double d=Math.cos（42）
B.	double d=Math.cosine（42）
C.	double d=Math.cos（Math.toRadians（42））
D.	double d=Math.cos（Math.toDegrees（42））

解析：Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度

 关于 JAVA 堆,下面说法错误的是(D)
A.所有类的实例和数组都是在堆上分配内存的
B.对象所占的堆内存是由自动内存管理系统回收
C.堆内存由存活和死亡的对象,空闲碎片区组成
D.数组是分配在栈中的

解析：
D：数组的引用存在栈内存中，而数组对象保存在堆里面。

java中，静态变量static在不同线程的不同实例中地址是否一样？他们储存在什么区域（C）
A.地址一样，在堆栈区。
B.地址不一样，在堆栈区。
C.地址一样，在全局区。
D.地址不一样，在全局区。

解析：类信息、常量、静态变量等数据储存在方法区，只会在类加载的时候储存一次，地址一样。
因为方法区又称作为Non-Heap（非堆），直接把ABD都排除了，我也不知道全局区是个啥