Java 30道经典笔试题

转自云栖社区——茶花盛开：https://yq.aliyun.com/articles/73655?utm_content=m_17183

下面都是我自己的答案非官方，仅供参考，如果有疑问或错误请一定要提出来，大家一起进步啦~~~

1. 下面哪些是Thread类的方法（）
   A start() B run() C exit() D getPriority()

答案：ABD

解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)。

1. 下面关于java.lang.Exception类的说法正确的是（）

A 继承自Throwable B Serialable CD 不记得，反正不正确

答案：A

解析：Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承 Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。
扩展：错误和异常的区别(Error vs Exception)

1) java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。
java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。

2) Error和RuntimeException 及其子类都是非检查异常（unchecked exceptions），而所有其他的Exception类都是检查异常（checked exceptions）.
checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。检查异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。在Java的标准包java.lang java.util 和 java.net 中定义的异常都是非运行异常。
unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。 因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。

RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。

处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

1. 下面程序的运行结果是（）

String str1 = “hello”;
String str2 = “he” + new String(“llo”);
System.err.println(str1 == str2);
答案：false

解析：因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值，所以不一样。如果是String str2 = str1，那么就是true了。

1. 下列说法正确的有（）
   A． class中的constructor不可省略
   B． constructor必须与class同名，但方法不能与class同名
   C． constructor在一个对象被new时执行
   D．一个class只能定义一个constructor

答案：C

解析：这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。

1. 具体选项不记得，但用到的知识如下：

String []a = new String[10];
则：a[0]~a[9] = null
a.length = 10

如果是int []a = new int[10];
则：a[0]~a[9] = 0
a.length = 10

解析：引用类型与基本数据类型的默认值。

1. 下面程序的运行结果：（）

 public static void main(String args[]) {

        Thread t = new Thread() {

            public void run() {
                pong();
            }
        };

        t.run();
        System.out.print("ping");

    }

    static void pong() {

        System.out.print("pong");

    }

A pingpong B pongping C pingpong和pongping都有可能 D 都不输出

答案：B

解析：这里考的是Thread类中start()和run()方法的区别了。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。

1. 下列属于关系型数据库的是（）

A. Oracle B MySql C IMS D MongoDB

答案：AB

解答：IMS（Information Management System ）数据库是IBM公司开发的两种数据库类型之一;
一种是关系数据库，典型代表产品：DB2；
另一种则是层次数据库，代表产品：IMS层次数据库。
非关系型数据库有MongoDB、memcachedb、Redis等。

1. GC线程是否为守护线程？（）
   答案：是
   解析：线程分为守护线程和非守护线程（即用户线程）。
   只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
   守护线程最典型的应用就是 GC (垃圾回收器)

2. volatile关键字是否能保证线程安全？（）
   答案：不能
   解析：volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对
   volatile的写操作，无法保证线程安全。例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

3. 下列说法正确的是（）
   A LinkedList继承自List
   B AbstractSet继承自Set
   C HashSet继承自AbstractSet
   D WeakMap继承自HashMap
   答案：AC
   解析：下面是一张下载的Java中的集合类型的继承关系图，一目了然。
   

java.util.concurrent.ConcurrentHashMap继承AbstractMap

扩展：Collections与Collection的区别：
1、Collection是集合类的一个顶级接口，其直接继承接口有List与Set

Collection是个Java.util下的接口，它是各种集合结构的父接口。
Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

2、Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。Collections.sort();
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
collections 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。 如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。

WeakHashMap:
1. 以弱键 实现的基于哈希表的 Map。在 WeakHashMap 中，当某个键不再正常使用时( 当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值)，将自动移除其条目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。丢弃某个键时，其条目从映射中有效地移除
2. WeakHashMap 类的行为部分取决于垃圾回收器的动作。因为垃圾回收器在任何时候都可能丢弃键，WeakHashMap 就像是一个被悄悄移除条目的未知线程。特别地，即使对 WeakHashMap 实例进行同步，并且没有调用任何赋值方法，在一段时间后 size 方法也可能返回较小的值，对于 isEmpty 方法，返回 false，然后返回true，对于给定的键，containsKey 方法返回 true 然后返回 false，对于给定的键，get 方法返回一个值，但接着返回 null，对于以前出现在映射中的键，put 方法返回 null，而 remove 方法返回 false，对于键 set、值 collection 和条目 set 进行的检查，生成的元素数量越来越少。
3. WeakHashMap 中的每个键对象间接地存储为一个弱引用的指示对象。因此，不管是在映射内还是在映射之外，只有在垃圾回收器清除某个键的弱引用之后，该键才会自动移除。

1. 存在使i + 1 < i的数吗（）
   答案：存在
   解析：如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时不就小于i了吗。
   扩展：存在使i > j || i <= j不成立的数吗（）
   答案：存在
   解析：比如Double.NaN或Float.NaN。
   NaN,是Not a Number的缩写.
   NaN 用于处理计算中出现的错误情况,比如 0.0 除以 0.0 或者求负数的平方根.由上面的表中可以看出,对于单精度浮点数,NaN 表示为指数为 emax + 1 = 128（指数域全为 1）,且尾数域不等于零的浮点数.IEEE 标准没有要求具体的尾数域,所以 NaN 实际上不是一个,而是一族.不同的实现可以自由选择尾数域的值来表达 NaN,比如 Java 中的常量 Float.NaN 的浮点数可能表达为 01111111110000000000000000000000,其中尾数域的第一位为 1,其余均为 0（不计隐藏的一位）,但这取决系统的硬件架构.Java 中甚至允许程序员自己构造具有特定位模式的 NaN 值（通过 Float.intBitsToFloat() 方法）.比如,程序员可以利用这种定制的 NaN 值中的特定位模式来表达某些诊断信息.

2. 0.6332的数据类型是（）
   A float B double C Float D Double
   答案：B
   解析：默认为double型，如果为float型需要加上f显示说明，即0.6332f

3. 下面哪个流类属于面向字符的输入流( )
   A BufferedWriter B FileInputStream C ObjectInputStream D InputStreamReader
   答案：D
   解析：Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
   面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
   面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
   总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流；以Reader（输入）/Writer（输出）为后缀的是字符流。
   扩展：Java流类图结构：
   

4. Java接口的修饰符可以为（）
   A private B protected C final D abstract
   答案：CD
   解析：接口很重要，为了说明情况，这里稍微啰嗦点：
   （1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们；
   （2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
   （3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态（static）变量；
   （4）接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因为变化的东西也不能够算共有。所以变量是不可变(final)类型，也就是常量了。
   （5） 接口中不可以定义变量？如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，可以通过 实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是考虑这样的情况。如果接口 A 中有一个public 访问权限的静态变量 a。按照 Java 的语义，我们可以不通过实现接口的对象来访问变量 a，通过 A.a = xxx; 就可以改变接口中的变量 a 的值了。正如抽象类中是可以这样做的，那么实现接口 A 的所有对象也都会自动拥有这一改变后的 a 的值了，也就是说一个地方改变了 a，所有这些对象中 a 的值也都跟着变了。这和抽象类有什么区别呢，怎么体现接口更高的抽象级别呢，怎么体现接口提供的统一的协议呢，那还要接口这种抽象来做什么呢？所以接口中 不能出现变量，如果有变量，就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常量，只能读不能改，这样才能为实现接口的对象提供一个统 一的属性。

通俗的讲，你认为是要变化的东西，就放在你自己的实现中，不能放在接口中去，接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展（不同的实现 implements）开放，接口是对开闭原则的一种体现。
所以：
接口的方法默认是public abstract；
接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以接口的属性默认是public static final 常量，且必须赋初值。
注意：final和abstract不能同时出现。

1. 不通过构造函数也能创建对象吗（）
   A 是 B 否
   答案：A
   解析：Java创建对象的几种方式（重要）：
   (1) 用new语句创建对象，这是最常见的创建对象的方法。
   (2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
   (3) 调用对象的clone()方法。
   (4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
   (1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。

2. ArrayList list = new ArrayList(20);中的list扩充几次（）
   A 0 B 1 C 2 D 3
   答案：A
   解析：这里有点迷惑人，大家都知道默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍），但是这里显示指明了需要多少空间，所以就一次性为你分配这么多空间，也就是不需要扩充了。

3. 下面哪些是对称加密算法（）
   A DES B AES C DSA D RSA
   答案：AB
   解析：常用的对称加密算法有：DES、3DES、RC2、RC4、AES
   常用的非对称加密算法有：RSA、DSA、ECC
   使用单向散列函数的加密算法：MD5、SHA

18.新建一个流对象，下面哪个选项的代码是错误的？（）
A）new BufferedWriter(new FileWriter(“a.txt”)); //BufferedWriter(Writer out) BufferedWriter(Writer out, int sz)
B）new BufferedReader(new FileInputStream(“a.dat”)); //BufferedReader(Reader in) BufferedReader(Reader in, int sz)
C）new GZIPOutputStream(new FileOutputStream(“a.zip”));//
D）new ObjectInputStream(new FileInputStream(“a.dat”));
答案：B
解析：Reader只能用FileReader进行实例化。

1. 下面程序能正常运行吗（）

public class NULL {

    public static void haha(){
        System.out.println("haha");
    }
    public static void main(String[] args) {
        ((NULL)null).haha();
    }

}

答案：能正常运行
解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似

1. 下面程序的运行结果是什么（）

public class HelloB extends HelloA{
            public HelloB(){
                        System.out.println("HelloB");
            }

            {
                        System.out.println("I am  HelloB.class");
            }

            static{
                        System.out.println("Static HelloB ");
            }

            public static void main(String[] args) {
                        System.out.println("-------main start-------");
                        new HelloB();
                        System.out.println("-------main end-------");
            }
}
class HelloA{
            public HelloA(){
                        System.out.println("HelloA");
            }

            {
                        System.out.println("I am  HelloA.class");
            }

            static{
                        System.out.println("Static HelloA ");
            }
}

答案：
Static HelloA
Static HelloB
——-main start——-
I am HelloA.class
HelloA
I am HelloB.class
HelloB
——-main end——-

解析：说实话我觉得这题很好，考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。
对象的初始化顺序：
（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；
（2）当static语句执行完之后,再执行main方法；
（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

1. getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（）

  public void getCustomerInfo() {

        try {

            // do something that may cause an Exception
        } catch (java.io.FileNotFoundException ex) {

            System.out.print("FileNotFoundException!");

        } catch (java.io.IOException ex) {

            System.out.print("IOException!");

        } catch (java.lang.Exception ex) {

            System.out.print("Exception!");

        }

    }

A IOException!
B IOException!Exception!
C FileNotFoundException!IOException!
D FileNotFoundException!IOException!Exception!
答案：A
解析：考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。

1. 下面代码的运行结果为：（）

import java.io.*;
import java.util.*;

public class foo{

    public static void main (String[] args){

        String s;

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

    }

}

A 代码得到编译，并输出“s=”
B 代码得到编译，并输出“s=null”
C 由于String s没有初始化，代码不能编译通过
D 代码得到编译，但捕获到 NullPointException异常
答案：C
解析：开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

1. System.out.println(“5” + 2);的输出结果应该是（）。
   A 52 B7 C2 D5
   答案：A
   解析：Java会自动将2转换为字符串。

2. 指出下列程序运行的结果 （）

public class Example {

    String str = new String("good");

    char[] ch = { 'a', 'b', 'c' };

    public static void main(String args[]) {

        Example ex = new Example();

        ex.change(ex.str, ex.ch);

        System.out.print(ex.str + " and ");

        System.out.print(ex.ch);

    }

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';

    }
}

A、 good and abc
B、 good and gbc
C、 test ok and abc
D、 test ok and gbc
答案：B
解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递
这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，
但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递，可能说的不是很清楚，下面给出一个完整的能说明情况的例子吧：

import java.util.Arrays;
public class ReferencePkValue {
            public static void main(String[] args) {
                        ReferencePkValue pkValue=new ReferencePkValue();
                        String string="String";
                        pkValue.changeString(string);
                        System.out.println("String 传递后的值："+string);

                        StringBuffer buffer=new StringBuffer("StringBuffer");
                        pkValue.changeStringBuffer(buffer);
                        System.out.println("StringBuffer 传递后的值为："+buffer);

                        Integer integer=99;
                        pkValue.changeInteger(integer);
                        System.out.println("Integer 传递后的值为："+integer);

                        String[] strings={"value","strings"};
                        pkValue.changeArray(strings);
                        System.out.println("StringArray 传递后的值为："+Arrays.asList(strings));
            }

            public void changeString(String str){
                        str=str+" change";
            }

            public void changeStringBuffer(StringBuffer buffer){
                        buffer.append(" change");
            }

            public void changeInteger(Integer i){
                        i=i+1;
            }

            public void changeArray(String[] chars){
                        chars[0]="change";
            }
}

运行结果：
String 传递后的值：String
StringBuffer 传递后的值为：StringBuffer change
Integer 传递后的值为：99
StringArray 传递后的值为：[change, strings]

结论：
（1）基本数据类型传值，对形参的修改不会影响实参；
（2）引用类型传引用，形参和实参指向同一个内存地址（同一个对象），所以对参数的修改会影响到实际的对象；
（3）String, Integer, Double等immutable的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。

1. 要从文件”file.dat”中读出第10个字节到变量c中,下列哪个方法适合? （）
   A FileInputStream in=new FileInputStream(“file.dat”); in.skip(9); int c=in.read();
   B FileInputStream in=new FileInputStream(“file.dat”); in.skip(10); int c=in.read();
   C FileInputStream in=new FileInputStream(“file.dat”); int c=in.read();
   D RandomAccessFile in=new RandomAccessFile(“file.dat”); in.skip(9); int c=in.readByte();
   答案：A?D?
   解析：long skip(long n)作用是跳过n个字节不读，主要用在包装流中的，因为一般流（如FileInputStream）只能顺序一个一个的读不能跳跃读，但是包装流可以用skip方法跳跃读取。那么什么是包装流呢？各种字节节点流类，它们都只具有读写字节内容的方法，以FileInputStream与FileOutputStream为例，它们只能在文件中读取或者向文件中写入字节，在实际应用中我们往往需要在文件中读取或者写入各种类型的数据，就必须先将其他类型的数据转换成字节数组后写入文件，或者从文件中读取到的字节数组转换成其他数据类型，想想都很麻烦！！因此想通过FileOutputStream将一个浮点小数写入到文件中或将一个整数写入到文件时是非常困难的。这时就需要包装类DataInputStream/DataOutputStream，它提供了往各种输入输出流对象中读入或写入各种类型的数据的方法。
   DataInputStream/DataOutputStream并没有对应到任何具体的流设备，一定要给它传递一个对应具体流设备的输入或输出流对象，完成类似 DataInputStream/DataOutputStream功能的类就是一个包装类，也叫过滤流类或处理流类。它对InputOutStream/OutputStream流类进行了包装，使编程人员使用起来更方便。其中DataInputStream包装类的构造函数语法：public DataInputStream(InputStream in)。包装类也可以包装另外一个包装类。

首先BC肯定 是错的，那A正确吗？按上面的解析应该也不对，但我试了下，发现A也是正确的，与网上解析的资料有些出入。
那么D呢，RandomAccessFile是IO包的类，但是其自成一派，从Object直接继承而来。可以对文件进行读取和写入。支持文件的随机访问，即可以随机读取文件中的某个位置内容，这么说RandomAccessFile肯定可以达到题目的要求，但是选项有些错误，比如RandomAccessFile的初始化是两个参数而非一个参数，采用的跳跃读取方法是skipBytes()而非skip()，即正确的写法是：

RandomAccessFile in = new RandomAccessFile("file.dat", "r"); in.skipBytes(9); int c = in.readByte();

这样也能读到第十个字节，也就是A和D都能读到第十个字节，那么到底该选哪个呢？A和D有啥不同吗？求大神解答~~~

1. 下列哪种异常是检查型异常，需要在编写程序时声明 （）
   A NullPointerException B ClassCastException C FileNotFoundException D IndexOutOfBoundsException
   答案：C
   解析：看第2题的解析。

2. 下面的方法，当输入为2的时候返回值是多少?（）

public static int getValue(int i) {
        int result = 0;
        switch (i) {
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;
        case 3:
            result = result + i * 3;
        }
        return result;
    }

A 0 B 2 C 4 D 10
答案：D
解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

1. 选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）

public abstract class MyClass {
    public int constInt = 5;
     //add code here
     public void method() {
     }
}

A public abstract void method(int a);
B constInt = constInt + 5;
C public int method();
D public abstract void anotherMethod() {}
答案：A
解析：考察抽象类的使用。
抽象类遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。
（5）含有抽象方法的类必须定义成抽象类。

所以：
对于选项B中：变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。
对于选项C：普通方法必须实现。应为：public int method(){}
对于选项D：抽象方法不能实现，在子类中实现。应为：public abstract void anotherMethod();

扩展：抽象类和接口的区别，做个总结吧：
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。

（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是”is-a”关系，interface表示的是”has-a”关系。
（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。
（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

1. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？ ( )

class Shape {
       public String name;
}

class Circle extends Shape implements Serializable{

       private float radius;

       transient int color;

       public static String type = "Circle";

}

A name
B radius
C color
D type
答案：B
解析：transient修饰的变量不能序列化。序列化是针对实例，而static代表的是类。

30.下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(“mike”)的时候都有哪些构造方法被顺序调用？请选择输出结果 ( )

class People {
    String name;

    public People() {
        System.out.print(1);
    }

    public People(String name) {
        System.out.print(2);
        this.name = name;
    }
}

class Child extends People {
    People father;

    public Child(String name) {
        System.out.print(3);
        this.name = name;
        father = new People(name + ":F");
    }

    public Child() {
        System.out.print(4);
    }

}

A312 B 32 C 432 D 132
答案：D
解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？
第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super(); 这样就会调用父类没有参数的构造方法。
第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。
总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。

最后，给大家出个思考题：下面程序的运行结果是什么？

public class Dervied extends Base {

    private String name = "dervied";

    public Dervied() {
        tellName();
        printName();
    }

    public void tellName() {
        System.out.println("Dervied tell name: " + name);
    }

    public void printName() {
        System.out.println("Dervied print name: " + name);
    }

    public static void main(String[] args){

        new Dervied();   
    }
}

class Base {

    private String name = "base";

    public Base() {
        tellName();
        printName();
    }

    public void tellName() {
        System.out.println("Base tell name: " + name);
    }

    public void printName() {
        System.out.println("Base print name: " + name);
    }
}

运行结果为：
Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied

解析：首先new Dervied()时，先执行了Base的构造方法，继而去执行了Base的tellName()与printName()这两个方法，但是由于Dervied继承了Base，所以执行的是子类也就是Dervied中的
tellName()与printName()的方法，但是由于此时Dervied的构造方法没有执行，访问不到name，所以此时的name是null。