java笔试题(5)

时间：2014-08-24 00:06:41 阅读：383 评论：0 收藏：0 [点我收藏+]

标签：style blog http color java os 使用 io strong

1.Comparable和Comparator接口是干什么的？列出它们的区别。

Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。

Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

2.下面的代码片段中，行A和行B所标识的代码有什么区别呢？

public class ConstantFolding {
 
    static final  int number1 = 5;
 
    static final  int number2 = 6;
 
    static int number3 = 5;
 
    static int number4= 6;
 
    public static void main(String[ ] args) {
 
          int product1 = number1 * number2;         //line A
 
          int product2 = number3 * number4;         //line B
 
    }
 
}

在行A的代码中，product的值是在编译期计算的，行B则是在运行时计算的。如果你使用Java反编译器（例如，jd-gui）来反编译ConstantFolding.class文件的话，那么你就会从下面的结果里得到答案。

public class ConstantFolding
{
  static final int number1 = 5;
  static final int number2 = 6;
  static int number3 = 5;
  static int number4 = 6;
 
  public static void main(String[ ] args)
  {
      int product1 = 30;
      int product2 = number3 * number4;
  }
}

常量折叠是一种Java编译器使用的优化技术。由于final变量的值不会改变，因此就可以对它们优化。Java反编译器和javap命令都是查看编译后的代码（例如，字节码）的利器。

3.你能想出除了代码优化外，在什么情况下，查看编译过的代码是很有帮助的？

Java里的泛型是在编译时构造的，可以通过查看编译后的class文件来理解泛型，也可以通过查看它来解决泛型相关的问题。

4.下面哪些是发生在编译时，运行时，或者两者都有？

方法重载：这个是发生在编译时的。方法重载也被称为编译时多态，因为编译器可以根据参数的类型来选择使用哪个方法。
```
public class {
     public static void evaluate(String param1);  // method #1
     public static void evaluate(int param1);   // method #2
}
```
如果编译器要编译下面的语句的话：
```
evaluate(“My Test Argument passed to param1”);
```
它会根据传入的参数是字符串常量，生成调用#1方法的字节码
方法覆盖：这个是在运行时发生的。方法重载被称为运行时多态，因为在编译期编译器不知道并且没法知道该去调用哪个方法。JVM会在代码运行的时候做出决定。
```
public class A {
   public int compute(int input) {          //method #3
        return 3 * input;
   }        
}
 
public class B extends A {
   @Override
   public int compute(int input) {          //method #4
        return 4 * input;
   }        
}
```
子类B中的compute(..)方法重写了父类的compute(..)方法。如果编译器遇到下面的代码：
```
public int evaluate(A reference, int arg2)  {
     int result = reference.compute(arg2);
}
```
编译器是没法知道传入的参数reference的类型是A还是B。因此，只能够在运行时，根据赋给输入变量“reference”的对象的类型（例如，A或者B的实例）来决定调用方法#3还是方法#4.
泛型（又称类型检验）：这个是发生在编译期的。编译器负责检查程序中类型的正确性，然后把使用了泛型的代码翻译或者重写成可以执行在当前JVM上的非泛型代码。这个技术被称为“类型擦除“。换句话来说，编译器会擦除所有在尖括号里的类型信息，来保证和版本1.4.0或者更早版本的JRE的兼容性。
```
List<String> myList = new ArrayList<String>(10);
```
编译后成为了：
```
List myList = new ArrayList(10);
```
注解（Annotation）：你可以使用运行时或者编译时的注解。
```
public class B extends A {
   @Override
    public int compute(int input){      //method #4
        return 4 * input;
    }       
}
```
@Override是一个简单的编译时注解，它可以用来捕获类似于在子类中把toString()写成tostring()这样的错误。在Java 5中，用户自定义的注解可以用注解处理工具(Anotation Process Tool ——APT)在编译时进行处理。到了Java 6，这个功能已经是编译器的一部分了。
```
public class MyTest{
    @Test
     public void testEmptyness( ){
         org.junit.Assert.assertTrue(getList( ).isEmpty( ));
     }
 
     private List getList( ){
        //implemenation goes here
     }
}
```
@Test是JUnit框架用来在运行时通过反射来决定调用测试类的哪个（些）方法的注解。
```
@Test (timeout=100)
public void testTimeout( ) {
    while(true);   //infinite loop
}
```
如果运行时间超过100ms的话，上面的测试用例就会失败。
```
@Test (expected=IndexOutOfBoundsException.class)
public void testOutOfBounds( ) {
       new ArrayList<Object>( ).get(1);
}
```
如果上面的代码在运行时没有抛出IndexOutOfBoundsException或者抛出的是其他的异常的话，那么这个用例就会失败。用户自定义的注解可以在运行时通过Java反射API里新增的AnnotatedElement和”Annotation”元素接口来处理。
异常（Exception）：你可以使用运行时异常或者编译时异常。
运行时异常（RuntimeException）也称作未检测的异常（unchecked exception），这表示这种异常不需要编译器来检测。RuntimeException是所有可以在运行时抛出的异常的父类。一个方法除要捕获异常外，如果它执行的时候可能会抛出RuntimeException的子类，那么它就不需要用throw语句来声明抛出的异常。
例如：NullPointerException，ArrayIndexOutOfBoundsException，等等
受检查异常（checked exception）都是编译器在编译时进行校验的，通过throws语句或者try{}cathch{} 语句块来处理检测异常。编译器会分析哪些异常会在执行一个方法或者构造函数的时候抛出。
面向切面的编程（Aspect Oriented Programming-AOP）：切面可以在编译时，运行时或，加载时或者运行时织入。
编译期：编译期织入是最简单的方式。如果你拥有应用的代码，你可以使用AOP编译器（例如，ajc – AspectJ编译器）对源码进行编译，然后输出织入完成的class文件。AOP编译的过程包含了waver的调用。切面的形式可以是源码的形式也可以是二进制的形式。如果切面需要针对受影响的类进行编译，那么你就需要在编译期织入了。
编译后：这种方式有时候也被称为二进制织入，它被用来织入已有的class文件和jar文件。和编译时织入方式相同，用来织入的切面可以是源码也可以是二进制的形式，并且它们自己也可以被织入切面。
装载期：这种织入是一种二进制织入，它被延迟到JVM加载class文件和定义类的时候。为了支持这种织入方式，需要显式地由运行时环境或者通过一种“织入代理（weaving agent）“来提供一个或者多个“织入类加载器（weaving class loader）”。
运行时：对已经加载到JVM里的类进行织入
继承 – 发生在编译时，因为它是静态的
代理或者组合 – 发生在运行时，因为它更加具有动态性和灵活性。

5.你能够通过实例来区别编译期继承和运行时继承，以及指出Java支持哪种吗？

“继承”表示动作和属性从一个对象传递到另外一个对象的场景。Java语言本身只支持编译期继承，它是通过“extends”关键字来产生子类的方式实现的，如下所示：
```
public class Parent {
    public String saySomething( ) {
          return “Parent is called”;
    }
}
 
public class Child extends Parent {
     @Override
     public String saySomething( ) {
          return super.saySomething( ) +  “, Child is called”;
    }
}
```
“Child”类的saySomething()方法的调用会返回“Parent is called，Child is Called”，因为，子类的调用继承了父类的“Parenet is called”。关键字“super”是用来调用“Parent”类的方法。运行时继承表示在运行时构建父/子类关系。Java语言本身不支持运行时继承，但是有一种替代的方案叫做“代理”或者“组合”，它表示在运行时组件一个层次对象的子类。这样可以模拟运行时继承的实现。在Java里，代理的典型实现方式如下：
```
public class Parent {
    public String saySomething( ) {
          return “Parent is called”;
    }
}
 
public class Child  {
     public String saySomething( ) {
          return new Parent( ).saySomething( ) +  “, Child is called”;
    }
}
```
子类代理了父类的调用。组合可以按照下面的方式来实现：
```
public class Child  {
     private Parent parent = null;
 
     public Child( ){
          this.parent = new Parent( );
     }
 
     public String saySomething( ) {
          return this.parent.saySomething( ) +  “, Child is called”;
    }
}
```
6.Java中的volatile 变量是什么？

volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生。

7.什么是FutureTask？

在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装，由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。

8.Java中interrupted 和 isInterrupted方法的区别？

interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。Java多线程的中断机制是用内部标识来实现的，调用Thread.interrupt()来中断一个线程就会设置中断标识为true。当中断线程调用静态方法Thread.interrupted()来检查中断状态时，中断状态会被清零。而非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何，一个线程的中断状态有有可能被其它线程调用中断来改变。

9.如果你提交任务时，线程池队列已满。会时发会生什么？

这个问题问得很狡猾，许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。

10.Java线程池中submit() 和 execute()方法有什么区别？

两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。

11.volatile 变量和 atomic 变量有什么不同？

首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。

12.如果同步块内的线程抛出异常会发生什么？

这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的，里面的线程都会释放锁，所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁，该功能可以在finally block里释放锁实现。

我是天王盖地虎的分割线

java笔试题(5)

标签：style blog http color java os 使用 io strong

原文地址：http://www.cnblogs.com/yydcdut/p/3929243.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

java笔试题(5)

我是天王盖地虎的分割线