abstract
class
Animal{
abstract
void
say();
}
public
class
Cat
extends
Animal{
public
Cat(){
System.out.printf(
"I am a cat"
);
}
public
static
void
main(String[] args) {
Cat cat=
new
Cat();
}
}
|
原因：子类继承Abstract类后必须重写父类中的抽象方法，否则子类也需要使用Abstract修饰。
2.下面不是面向对象的基本原则的是？
单一职责原则（Single-Resposibility Principle）
开放封闭原则（Open-Closed principle）
抽象类原则（Abstract-Class principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）
答案：C
原因：
面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）
3.String str = new String(“abc”)，“abc”在内存中是怎么分配的？
堆
栈
字符串常量区
寄存器
原因：new String("abc")时，其实会先在字符串常量区生成一个abc的对象，然后new String()时会在堆中分配空间，然后此时会把字符串常量区中abc复制一个给堆中的String，故abc应该在堆中和字符串常量区
4.关于以下程序代码的说明正确的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
HasStatic{
private
static
int
x =
100
;
public
static
void
main(String args[ ]){
HasStatic hs1 =
new
HasStatic();
hs1.x++;
HasStatic hs2 =
new
HasStatic();
hs2.x++;
hs1=
new
HasStatic();
hs1.x++;
HasStatic.x--;
System.out.println(
"x="
+x);
}
}
5行不能通过编译，因为引用了私有静态变量 10行不能通过编译，因为x是私有静态变量 程序通过编译，输出结果为：x=103 程序通过编译，输出结果为：x=102
原因：
因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有，
刚开始x=100
调用hs1.x++ x为101;
调用hs2.x++ x为102;
调用hs1.x++ x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
调用HasStatic.x-- x为102
所以结果为D
|
5.下列代码执行结果为（）
public
static
void
main(String argv[])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 你的答案: C (错误)
21
12
可能为12，也可能为21
以上答案都不对
原因：
t.join(1000); //等待 t 线程，等待时间是1000毫秒
6.下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
正确答案: A B E 你的答案: A E (错误)
Thread
Number
Double
Math
ClassLoader
正确答案: A B D 你的答案: E (错误)
long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128
原因：
8.下列 java 程序输出结果为______。
|
1
2
3
4
|
int
i=
0
;
Integer j =
new
Integer(
0
);
System.out.println(i==j);
System.out.println(j.equals(i));
|
正确答案: B 你的答案: B (正确)
true,false
true,true
false,true
false,false
对于不同的环境结果不同
程序无法执行
原因：本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上）
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较
9.我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。
正确答案: B 你的答案: B (正确)
对
错
原因：System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。
10.有如下4条语句：()
|
1
2
3
4
|
Integer i01=
59
;
int
i02=
59
;
Integer i03=Integer.valueOf(
59
);
Integer i04=
new
Integer(
59
);
|
正确答案: C 你的答案: 空 (错误)
System.out.println(i01==i02);
System.out.println(i01==i03);
System.out.println(i03==i04);
System.out.println(i02==i04);
原因：①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
③两个都是new出来的,都为false
④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比
11.下面代码输出的是：
- public class Test {
- public static void main(String [] args){
- System.out.println(new B().getValue());
- }
- static class A{
- protected int value;
- public A(int v) {
- setValue(v);
- }
- public void setValue(int value){
- this.value = value;
- }
- public int getValue(){
- try{
- value++;
- return value;
- } catch(Exception e){
- System.out.println(e.toString());
- } finally {
- this.setValue(value);
- System.out.println(value);
- }
- return value;
- }
- }
- static class B extends A{
- public B() {
- super(5);
- setValue(getValue() - 3);
- }
- public void setValue(int value){
- super.setValue(2 * value);
- }
- }
答案：22 34 17
原因：此题考点考的是子类重写了父类的方法，调用时就会调用子类中的方法
可以通过断点调试来追踪程序执行。
12.程序结果是什么？
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 你的答案: D (错误)
Car
Vehicle
Compiler error at line 3
Compiler error at line 5
Exception thrown at runtime
原因：父类中的方法虽然被final修饰表明子类不可重写（本类中可以覆盖），但是由于其属性为private对子类不可见。所以子类可以拥有同名方法。
13.以下程序执行的结果是：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class
X{
Y y=
new
Y();
public
X(){
System.out.print(
"X"
);
}
}
class
Y{
public
Y(){
System.out.print(
"Y"
);
}
}
public
class
Z
extends
X{
Y y=
new
Y();
public
Z(){
System.out.print(
"Z"
);
}
public
static
void
main(String[] args) {
new
Z();
}
}
|
正确答案: C 你的答案: C (正确)
ZYXX
ZYXY
YXYZ
XYZX
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package algorithms.com.guan.javajicu;
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'
;
}
}
|
正确答案: D 你的答案: C (错误)
test okandabc
test okandgbc
goodandabc
goodandgbc
原因：String作为基本类型的封装类型，是一个final修饰的不可变类。一开始str指向“good”,在change方法中作为参数会复制一个副本引用对象传入，str指向“test ok”，但是原来的“good”依然存在字符串常量池中。change方法外，str依然指向“”good".而对于char[]数组作为参数传入时传入的是引用传递。
记住！8种数据类型传递的参数是值的副本，而String传递的是引用的副本（不会改变原来的值）。其他都是引用传递(会改变原来的值)。
14.下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。
正确答案: C 你的答案: B (错误)
java.exe
javadoc.exe
jdb.exe
javaprof.exe
15.下列程序输出结果是：
public
class
B
{
public
static
B t1 =
new
B();
public
static
B t2 =
new
B();
{
System.out.println(
"构造块"
);
}
static
{
System.out.println(
"静态块"
);
}
public
static
void
main(String[] args)
{
B t =
new
B();
}
}
|
正确答案: C 你的答案: A (错误)
静态块 构造块 构造块 构造块
构造块 静态块 构造块 构造块
构造块 构造块 静态块 构造块
构造块 构造块 构造块 静态块
原因：
16.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package
NowCoder;
class
Test {
public
static
void
hello() {
System.out.println(
"hello"
);
}
}
public
class
MyApplication {
public
static
void
main(String[] args) {
// TODO Auto-generated method stub
Test test=
null
;
test.hello();
}
}
|
正确答案: A 你的答案: B (错误)
能编译通过，并正确运行
因为使用了未初始化的变量，所以不能编译通过
以错误的方式访问了静态方法
能编译通过，但因变量为null，不能正常运行
原因：test虽然指向一个空的对象，但是声明了她的类型为Test类，而方法hello为静态方法属于类方法，所以能编译成功并且正常运行。
17.下列代码输出结果是：
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();
}
}
正确答案: C 你的答案: A (错误)SuperTest SuperTest.class test.SuperTest test.SuperTest.class
首先 super.getClass() 是父类的getClass（）方法，其父类是Date，它的getClass（）方法是继承自Object类而且没有重写，
所以就是调用
object的getClass（）
所以可以知道是返回当前运行时的类。
2.在调用getName()方法而getName()是：
包名+类名
１８．下列有关java构造函数叙述正确的是（）
正确答案: C D 你的答案: A B C D (错误)构造器的返回值为void类型 如果一个源文件中有多个类，那么构造器必须与公共类同名 构造器可以有0个，1个或一个以上的参数 每个类可以有一个以上的构造器 |
正确答案: C 你的答案: D (错误)
修饰常量
修饰不可继承的类
修饰不可变类
修饰不可覆盖的方法
原因：首先看看什么是可变类和不可变类：可变类和不可变类(Mutable and Immutable Objects)
1. 可变类和不可变类(Mutable and Immutable Objects)的初步定义：
可变类：当你获得这个类的一个实例引用时，你可以改变这个实例的内容。
不可变类：当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。不可变类的实例一但创建，其内在成员变量的值就不能被修改。
举个例子：String和StringBuilder，String是immutable的，每次对于String对象的修改都将产生一个新的String对象，而原来的对象保持不变，而StringBuilder是mutable，因为每次对于它的对象的修改都作用于该对象本身，并没有产生新的对象。
2. 如何创建一个自己的不可变类：
.所有成员都是private final
.不提供对成员的改变方法，例如：setXXXX 提供带参数的构造器，用于根据传入的参数来初始化属性。
.确保所有的方法不会被重载。手段有两种：使用final Class(强不可变类)，或者将所有类方法加上final(弱不可变类)。
所以，仅仅有final修饰的类不一定是不可变类别。但是对于本题，我觉得还是比较有争议的。不可变类必定使用final修饰的，但是final修饰的类不一定是不可变类。
20.What is the result of compiling and executing the following fragment of code:
|
1
2
3
4
5
6
7
8
9
|
Boolean flag =
false
;
if
(flag =
true
)
{
System.out.println(“
true
”);
}
else
{
System.out.println(“
false
”);
}
|
正确答案: C 你的答案: A (错误)
The code fails to compile at the “if” statement.
An exception is thrown at run-time at the “if” statement.
The text“true” is displayed.
The text“false”is displayed.
Nothing is displayed.
原因：
java中赋值符号“=”也是有返回值的，不行可以是测试一下啊
String str = null;Sysotem.out.println(str = "test");
结果打印“test”。
21.下面有关 java 类加载器,说法正确的是?()
正确答案: A B C D 你的答案: B C (错误)
引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用
记住吧！
22.已知如下类定义：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class
Base {
public
Base (){
//...
}
public
Base (
int
m ){
//...
}
public
void
fun(
int
n ){
//...
}
}
public
class
Child
extends
Base{
// member methods
}
|
正确答案: D 你的答案: A (错误)
private void fun( int n ){ //...}
void fun ( int n ){ //... }
protected void fun ( int n ) { //... }
public void fun ( int n ) { //... }
原因：重写啊
23.
public
class
NameList
{
private
List names =
new
ArrayList();
public
synchronized
void
add(String name)
{
names.add(name);
}
public
synchronized
void
printAll() {
for
(
int
i =
0
; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public
static
void
main(String[]args)
{
final
NameList sl =
new
NameList();
for
(
int
i =
0
; i <
2
; i++)
{
new
Thread()
{
public
void
run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
|
正确答案: E G 你的答案: E (错误)
An exception may be thrown at runtime.
The code may run with no output, without exiting.
The code may run with no output, exiting normally(正常地).
The code may rum with output “A B A B C C “, then exit.
The code may rum with output “A B C A B C A B C “, then exit.
The code may ruin with output “A A A B C A B C C “, then exit.
The code may ruin with output “A B C A A B C A B C “, then exit.
原因：输出一定是连续的。
24.下面哪几个语句正确的声明一个整型的二维数组（）
正确答案: C D 你的答案: A C D (错误)
int a[][]=new int[][]
int b[10][10]=new int[][]
int c[][]=new int[10][10]
int []d[]=new int[10][10]
25.变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？
正确答案: B 你的答案: C (错误)
1
-1
2^63+2^62+…+2^2+2^1+2^0
–(2^63+2^62+…+2^2+2^1+2^0)
原因：
public
class
Test2
{
public
void
add(Byte b)
{
b = b++;
}
public
void
test()
{
Byte a =
127
;
Byte b =
127
;
add(++a);
System.out.print(a +
" "
);
add(b);
System.out.print(b +
""
);
}
}
|
正确答案: D 你的答案: B (错误)
127 127
128 127
129 128
以上都不对
原因：注意！这里的add函数对Byte类型丝毫不影响。但是这里的++a会触发自动拆箱。byte类型的最大值为127，所以a会变为-128.而b的值不变。
27.下面为true的是
Integer i =
42
;
Long l = 42l;
Double d =
42.0
;
|
正确答案: G 你的答案: A B C (错误)
(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)
原因：
28.代码片段：
|
1
2
3
4
5
|
byte
b1=
1
,b2=
2
,b3,b6;
final
byte
b4=
4
,b5=
6
;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);
|
正确答案: C 你的答案: B (错误)
输出结果：13
语句：b6=b4+b5编译出错
语句：b3=b1+b2编译出错
运行期抛出异常
原因：向下转型需要进行强转，但是被定义为final的变量在加载是jvm会对其优化。题中
b6=b4+b5,在编译后就等价于b6=10,直接赋值。
29.final、finally和finalize的区别中，下述说法正确的有？
正确答案: A B 你的答案: A B C (错误)
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。
原因：
要关闭文件要应该在finally中关闭。
30.下面哪些写法能在 java8 中编译执行（）
正确答案: A D 你的答案: C (错误)
dir.listFiles((File f)->f.getName().endsWith(“.Java”));
dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
dir.listFiles((_.getName().endsWith(“.Java”)));
dir.listFiles( f->f.getName().endsWith(“.Java”));
原因：
由此可见，应该是A和D正确。
31.What results from the following code fragment?
|
1
2
3
|
int
i =
5
;
int
j =
10
;
System.out.println(i + ~j);
|
正确答案: C 你的答案: C (正确)
Compilation error because”~”doesn’t operate on integers
-5
-6
15
原因：
故程序结果-6
32.
package
Wangyi;
class
Base
{
public
void
method()
{
System.out.println(
"Base"
);
}
}
class
Son
extends
Base
{
public
void
method()
{
System.out.println(
"Son"
);
}
public
void
methodB()
{
System.out.println(
"SonB"
);
}
}
public
class
Test01
{
public
static
void
main(String[] args)
{
Base base =
new
Son();
base.method();
base.methodB();
}
}
|
正确答案: D 你的答案: B (错误)
Base SonB
Son SonB
Base Son SonB
编译不通过
答案：D
原因：
|
1
|
Base base =
new
Son();
|
33.各个基本数据类型的默认值及取值范围：
| 默认值 | 存储需求（字节） | 大小 | 取值范围 | |
| byte | 0 | 1 | -2^7—2^7-1 | byte b=10; |
| char | ‘ \u0000′ | 2 | 0—2^16-1 | char c=’c’ ; |
| short | 0 | 2 | -2^15—2^15-1 | short s=10; |
| int | 0 | 4 | -2^31—2^31-1 | int i=10; |
| long | 0 | 8 | -2^63—2^63-1 | long o=10L; |
| float | 0.0f | 4 | -2^31—2^31-1 | float f=10.0F |
| double | 0.0d | 8 | -2^63—2^63-1 | double d=10.0; |
| boolean | false | 1 | true\false | boolean flag=true; |
- clone();
- equals();
- finalize();
- getClass();[align=left][/align]
- notify(),notifyAll();
- hashCode();
- toString();
- wait();
| 默认值 | 存储需求（字节） | 取值范围 | 示例 | |
| byte | 0 | 1 | -2^7—2^7-1 | byte b=10; |
| char | ‘ \u0000′ | 2 | 0—2^16-1 | char c=’c’ ; |
| short | 0 | 2 | -2^15—2^15-1 | short s=10; |
| int | 0 | 4 | -2^31—2^31-1 | int i=10; |
| long | 0 | 8 | -2^63—2^63-1 | long o=10L; |
| float | 0.0f | 4 | -2^31—2^31-1 | float f=10.0F |
| double | 0.0d | 8 | -2^63—2^63-1 | double d=10.0; |
| boolean | false | 1 | true\false | boolean flag=true; |
class
Foo {
final
int
i;
int
j;
public
void
doSomething() {
System.out.println(++j + i);
}
}
|
正确答案: D 你的答案: B (错误)
0
1
2
不能执行，因为编译有错
原因：
类的
final
成员变量必须满足以下其中一个条件
1
、在构造函数中赋值
2
、初始化赋值
36.下面有关java hashmap的说法错误的是？
正确答案: C 你的答案: D (错误)
HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。
HashMap 的实现不是同步的，意味着它不是线程安全的
HashMap通过开放地址法解决哈希冲突
HashMap中的key-value都是存储在Entry数组中的
原因：
1. 关于HashMap的一些说法： a) HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。HashMap的底层结构是一个数组，数组中的每一项是一条链表。 b) HashMap的实例有俩个参数影响其性能： “初始容量” 和 装填因子。 c) HashMap实现不同步，线程不安全。 HashTable线程安全 d) HashMap中的key-value都是存储在Entry中的。 e) HashMap可以存null键和null值，不保证元素的顺序恒久不变，它的底层使用的是数组和链表，通过hashCode()方法和equals方法保证键的唯一性 f) 解决冲突主要有三种方法：定址法，拉链法，再散列法。HashMap是采用拉链法解决哈希冲突的。 注： 链表法是将相同hash值的对象组成一个链表放在hash值对应的槽位； 用开放定址法解决冲突的做法是：当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。 沿此序列逐个单元地查找，直到找到给定 的关键字，或者碰到一个开放的地址(即该地址单元为空)为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。 拉链法解决冲突的做法是： 将所有关键字为同义词的结点链接在同一个单链表中 。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数 组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于1，但一般均取α≤1。拉链法适合未规定元素的大小。 2. Hashtable和HashMap的区别： a) 继承不同。 public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map b) Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。 c) Hashtable 中， key 和 value 都不允许出现 null 值。 在 HashMap 中， null 可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为 null 。当 get() 方法返回 null 值时，即可以表示 HashMap 中没有该键，也可以表示该键所对应的值为 null 。因此，在 HashMap 中不能由 get() 方法来判断 HashMap 中是否存在某个键， 而应该用 containsKey() 方法来判断。 d) 两个遍历方式的内部实现上不同。Hashtable、HashMap都使用了Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。 e) 哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。 f) Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。 注： HashSet子类依靠hashCode()和equal()方法来区分重复元素。 HashSet内部使用Map保存数据，即将HashSet的数据作为Map的key值保存，这也是HashSet中元素不能重复的原因。而Map中保存key值的,会去判断当前Map中是否含有该Key对象，内部是先通过key的hashCode,确定有相同的hashCode之后，再通过equals方法判断是否相同
37.以下程序的输出结果为
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
Base{
public
Base(String s){
System.out.print(
"B"
);
}
}
public
class
Derived
extends
Base{
public
Derived (String s) {
System.out.print(
"D"
);
}
public
static
void
main(String[] args){
new
Derived(
"C"
);
}
}
正确答案: D 你的答案: A (错误)BD DB C 编译错误 原因：
子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：
public
Derived(String s){
super
(
"s"
);
System.out.print(
"D"
);
}
38.下面论述正确的是（）？
正确答案: D 你的答案: D (正确)如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值 如果a,b的hashcode相同，那么a.equals(b)必须返回true 对于一个类，其所有对象的hashcode必须不同 如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同 |
原因：
hashcode和equals的约定关系如下：
1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）