1. 为初始化其成员变量，每个类都定义的方法是（）
  • 构造方法
  1. 以下代码默认类型等价表示是哪一项:
public interface IService {String NAME="default";}

public static final String NAME="default";
  • 总结
    1. 接口中的变量默认是public static final
    2. 接口中的方法默认是public abstract
  1. java中下面哪个能创建并启动线程（）
public class MyRunnable implements Runnable { 
     public void run() { 
         //some code here 
     } 
 }
  • new Thread(new MyRunnable()).start() 总结：
    • 定义线程的方法
// 方式一：继承Threa类，重写run方法.
class MyThread extends Thread{
 	public void run(){
    }
}

// 启动线程
new MyThread().start();


// 方式二：实现Runnable接口，覆盖run方法
class MyThread implements Runnable{
 	public void run(){
    }
}

// 启动线程
new Thread(new MyThread()).start();
  1. 下面代码的执行结果是 :
class Chinese{
private static Chinese objref =new Chinese();
private Chinese(){}
public static Chinese getInstance() { return objref; }
}

public class TestChinese {
public static void main(String [] args) {
Chinese obj1 = Chinese.getInstance();
Chinese obj2 = Chinese.getInstance();
System.out.println(obj1 == obj2);
}
}

  • true

  • 总结 饿汉式单例模式，在类创建时，就已经实例化完成，在调用Chinese.getInstance()时，直接获取静态对象

  1. 运行下面代码，输出的结果是（）
class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); } 
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    { System.out.println("I'm B class"); }
    static { System.out.println("class B static"); }
     
    public static void main(String[] args) { 
 new B(); 
    }
}

class A static
class B static
I'm A class
class A
I'm B class
class B
  • 总结

类加载过程 关于Java程序初始化顺序：

父类的静态代码块

子类的静态代码块

父类的普通代码块

父类的构造方法

子类的普通代码块

子类的构造方法

  1. 在jdk1.5之后，下列 java 程序输出结果为______。
int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

  • true,true

  • 总结 本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上），下面的讨论都不针对新开辟对象的情况： 1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true； 2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关。 3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true 4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

  1. list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
    Object obj = it.next();
    if (needDelete(obj))  //needDelete返回boolean，决定是否要删除
    {
        //todo delete
    }
    index ++;
}

  • it.remove();

  • 总结： Iterator 支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

  1. Given the following code:
public class Test {
    private static int j = 0;

    private static Boolean methodB(int k) {
        j += k;
        return true;
    }

    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);

    }

    public static void main(String args[]) {
        methodA(0);
        System.out.println(j);
    }
}

  • The program prints”4”

  • 总结

  • 主要考察 按位或 | 与 逻辑或 || 。逻辑或会出现短路现象

  1. servlet周期包含哪些：
  • init初始化阶段
  • service运行阶段
  • destroy销毁
  1. 下列说法正确的是（）？

A. 我们直接调用Thread对象的run方***报异常，所以我们应该使用start方法来开启一个线程

B. 一个进程是一个独立的运行环境，可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源

C. synchronized可以解决可见性问题，volatile可以解决原子性问题

D. ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的

总结： a. 直接调用不会报错，只是一个普通的方法，不会创建线程

b. 对

c. volatile不能保证原子性问题

d. ThreadLocal存放的值是线程内共享的，线程间互斥的