1.设有String s=”Java”；以下语句中合法的是____A______。
A、s+=” programming”；
B、int len=s.length；
C、char c=s[0]；
D、String s1=s.touppercase()；
2.在Java中，由Java编译器自动引入，无需在程序中用import语句引入的包是___B____。
A、java.applet B、java.lang C、java.io D、java.awt
3.下列四个选项中，不是File类的构造方法是__D___。
A、File(String filename)
B、File(String directoryPath ,String filename)
C、File(File f,String filename)
D、File(char filename[])
4.RandomAccessFile 类创建的流的指向____C______。
A、作为源
B、作为目的地
C、既可以作为源，也可以作为目的地
D、既不可以作为源，也不可以作为目的地
5.下列方法中，不是File 类的方法是____C______。
A、getName( )
B、canWriter( )
C、seek( )
D、lastModified( )
6.下列Java语言的常用异常类中，属于非检测异常的是__C___。
A、ClassNotFoundException
B、FileNotFoundException
C、NullPointException
D、IOException
7.下列描述中，错误的一项是__D___。
A、异常抛出点后的代码在抛出异常后不再执行
B、每个catch代码段声明其能处理的一种特定类型的异常
C、一定发生的事件不应该用异常机制来处理
D、try代码段后只能跟有一个catch代码段
8.下列哪一项不属于applet中的显示方法？（C ）
A、update() B、repaint() C、drawLine() D、paint()
下列applet实现键盘事件处理，当一个键按下时，判断是否为26个英文字母，并9.输出该字母。选择正确的语句填入横线处。（B ）
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import class test extends Applet{
String str = “”;
public void init(){
addKeyListener(new KeyAdapter(){
_______________
{
char ch;
ch = ke.getKeyChar();
if((ch>=’a'&&ch<=”z”)||(ch>=’A'&&ch<=’Z'))
str = “字母：” + ch;
else
str = “不是字母”;
repaint();
}
});
requestFocus();
}
public void paint(Graphics g)
{
g.drawstring(str,50,50);
}
} A、public void keyPress(KeyEvent ke)
B、public void keyTyped(KeyEvent ke)
C、public void keyPressing(KeyEvent ke)
D、public void keyTyped(Event ke)
10. 方法resume()负责恢复下列哪一个线程的执行？（D ）
A、通过调用stop()方法而停止的线程
B、通过调用sleep()方法而停止运行的线程
C、通过调用wait()方法而停止运行的线程
D、通过调用suspend()方法而停止运行的线程
11. 下列哪一个操作不能使线程从等待阻塞状态进入对象锁阻塞状态？（D ）
A、等待阻塞状态下的线程被notify()唤醒
B、等待阻塞状态下的线程被interrupt()中断
C、等到时间到
D、等待阻塞状态下的线程调用wait()方法
12. 下列哪一项不属于Java线程模型的组成部分？（D ）
A、虚拟的CPU
B、虚拟CPU执行的代码
C、代码所操作的数据
D、执行流
13.Java 语言的特点不包括__C___。
A、平台无关 B、面向对象 C、多重继承 D、多线程
14.下面关于继承的叙述正确的是__C___。
1) 在Java中，只允许单一继承
2) 在Java中，一个类不能同时继承一个类和实现一个接口
3) 在Java中，一个类只能实现一个接口
4) Java的单一继承使代码更可靠
A、2）3）
B、1）2）3）4）
C、1）4）
D、1）3）4）
15.下列是不完整的类代码，构造方法中的横线处可以填入的表达式是
_C___。
class Student
{
String name,department;
Int age;
public Student(String n)
{name=n}
public Student(String n,int a)
{name=n;age=a;}
public Student(String n,String d,int a)
{
__________________
department=d;
}
} A、 Student(n,a);
B、 this(Student(n,a));
C、 this(n,a);
D、 this(name,age);
16.监听事件和处理事件__A__。
A、 都由Listener完成
B、 都由相应的事件Listener处登记过的组件完成
C、 由Listener和相应的组件分别完成
D、 由Listener和相应的窗口完成
17.构造方法在__A__时被调用。
A、创建对象时
B、类定义时
C、使用对象的方法时
D、使用对象的属性时
18.方法内的变量_B__。
A、一定在方法内所有位置可见
B、可能在方法内的局部可见
C、可以在方法外可见
D、方法外也可用
19.return语句___A_。
A、可以让方法返回数值
B、方法都必须含有
C、方法中可以有多句return
D、用来返回对象
20.下列叙述中，错误的是__D____。
A、父类不能替代子类 B、子类能够替代父类
C、子类继承父类 D、父类包含子类
下列不可以作为类修饰词的是____B______。
A、abstract B、private C、final D、public
下列哪个选项不是FilterInputStream的子类？( D )
A、DataInputStream
B、BufferedInputStream
C、PushbackInputStream
D、FileInputStream
编写applet需要引入的包是___B__。
A、java.awt.Window
B、java.applet.Applet
C、java.io
D、java.sql
下列哪一个操作不能使线程从等待阻塞状态进入对象锁阻塞状态？（D ）
A、等待阻塞状态下的线程被notify()唤醒
B、等待阻塞状态下的线程被interrupt()中断
C、等到时间到
D、等待阻塞状态下的线程调用wait()方法
下列说法中错误的一项是_B____。
A、当线程需要在synchronized块中等待共享数据状态改变时，则需要调用wait()方法
B、当线程需要在synchronized块中等待共享数据状态改变时，则需要调用notify()方法
C、线程在synchronized块中执行完操作后，调用notify()方法通知正在等待的线程重新占有锁
D、wait()和notify()可以实现线程的同步操作
下列哪一种情况一定不会使当前的线程暂停执行？（C ）
A、该线程抛出一个InterruptedException
B、该线程调用sleep()方法
C、该线程创建一个新的子线程
D、该线程从输入流读取文件数据
Java applet的浏览器可以是:__D___。
A、appletviewer
B、Internet Explore
C、Netscape
D、以上都可以
Java语言中，通过传递_D____来实现对象之间的交互。
A、方法 B、对象 C、类 D、消息
对于构造方法，下列叙述正确的是___B__。
A、构造方法不允许重载
B、用户不能直接调用构造方法，只能由new运算符调用它
C、父类对象不可以用子类构造方法实例化
D、构造方法是实现对象初始化的唯一方法
设有下面两个类定义：
class A
{
void show()
{
System.out.println(“我喜欢Java！”);
}
}
class B extends A
{
void show()
{
System.out.println(“我喜欢C++！”);
}
} 则顺序执行如下语句输出结果为__A___。
A a;
B b;
a.show();
b.show();
A、 我喜欢Java！我喜欢C++！
B、 我喜欢C++！我喜欢Java！
C、 我喜欢Java！我喜欢Java！
D、 我喜欢C++！我喜欢C++！
__C__是抽象类的一种，只包含常量和方法的定义，而没有变量和方法的实现，且其方法都是抽象方法。
A、包 B、main C、接口 D、继承
下面哪个赋值语句是正确的？ ( B)
A、float f = 11.1; B、double d = 5.3E12;
C、Boolean b=true; D、byte bb = 433;
下列哪个选项可以正确用来表示八进制值8？( D)
A、0×8 B、0×10 C、08 D、010
下列说法正确的是:__A_。
A、一个程序可以包含多个源文件
B、一个文件中只能有一个类
C、一个源文件中可以有多个公共类
D、一个源文件只能供一个程序使用
给出以下代码的运行结果：_C___。
class S1{
public static void main(String[] args) {
new S2();
}
S1(){
System.out.print(“S1″);
}
}class S2 extends S1 {
S2() {
System.out.print(“S2″);
}
} 结果为：
A、S1
B、S2
C、S1S2
D、S2S1
下列哪个类是由编译器自动生成对象的特殊类，用于类操作的？(B )
A、System类 B、Class类 C、Thread类 D、Object类
下列关于变量的叙述哪个是错的？( B)
A、实例变量是类的成员变量
B、实例变量用关键字static声明
C、在方法中定义的局部变量在该方法被执行时创建
D、局部变量在使用前必须被初始化
在如下源代码文件Test.java中, 哪个是正确的类定义？( B )
A、public class test {
public int x = 0;
public test(int x)
{
super.x = x;
}
}
B、public class Test extends T1{
public int x=0;
public Test(int x){
this.x = x;
}
}
C、protected class Test extends T2{
public int x=0;
public Test(int x){
this.x=x;
}
}
D、public class Test extends T1,T2{
public int x = 0;
public Test (int x){
this.x = x;
}
}
能构成多分支的语句是___C___。
A 、for语句 B、 while语句
C、switch 语句 D、do-while语句
下列程序执行的结果是（ A ）。
public class ex32
{
public static void main(String[ ] args)
{
int y=10;
int x=20;
if(x>y11y>x)
System.out.println(“ok “);
else if(x<10)
System.out.println(x+y)
else if(y>10)
System.out.println(y-x);
}
}A、 ok B、 x+y C、 y-x D、 10
下列程序的输出结果是__D___。
import java.io.*;
public class A
{
public static void main(String args[])
{ int i;
int a[]={11,22,33,44,55,66,77,88,99};
for(i=0;i<=a.length/2;i++)
System.out.print(a[i]+a[a.length-i-1]+ ” “); // 原文少个“[i]”
System.out.println();
}
}A、110 B、110 110 C、 110 110 110 D、110 110 110 110 110
已知定义：int a[]={1,2,3,4,5,6,7,8,9,10};为了打印输出数组a的最后一个元素，下面选项中正确的代码是（B ）。
A、 System.out.println(a[10]);
B、 System.out.println(a[9]);
C、 System.out.println(a[a.length]);
D、 System.out.println(a(8));
--------------------------------------------------------------------------------------------------------------------------------
1. public class StringTest {
2. public static void main(String[] args) {
3. new String("abc");
4. // 问题1：当类中执行String s = new String("abc");这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
5. // （生成2个对象；首先去String
6. // Pool查找有没“abc”对象，没有的话，就在池里面放入abc，接着是new一个对象，是在堆里面生成另一个对象；
7. // s是引用，指向堆里面的对象；）
8. "abc";
9. // 问题2：当执行String s1 = "abc";这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
10. // 答：一个对象也没生成；s1引用string pool里面的abc。
11. new String("abc");
12. // 问题3：当类中执行String s2 = new String("abc");这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
13. // 答：生成一个对象，首先是在String Pool查找，发现有“abc”，就不生成，接着在堆里面生成一个对象；s2指向堆里的“abc”
14. // 执行完前三行语句，内存一个有三个对象，一个池里面的，两个堆里面的；
15. // false
16. // false
17. // false
18. // 对象的比较，是比较内存地址的，他们三个地址不同，都是输出false
19. // intern:
20. // 调用该方法，JAVA虚拟机首先检查字符串池中是否已经存在与该对象相等的对象存在，
21. // 如果有则返回字符串池中对象的引用；如果没有，则先在字符串池中创建一个相同值的String对象，然后返回他的引用。
22. // 可以理解成比较他们的值是否相等
23. "s == s.intern()" + (s == s.intern())); // false，执行intern才会创建s
24. // true
25. // true
26. // intern如果pool存在，则指向它；
27. "hello";
28. "hel";
29. "lo";
30. "hel" + "lo");// true,两个都是在池里面
31. "hel" + lo);// false，左边是在池里面，右边是在堆里面，当两个都不是字面值（引号里面、常量值）相加会生成新的对象
32. "hel" + lo);// false
33. String hel_lo = ((hel + lo).intern());
34. "hello == hello.intern() " + (hello == hello.intern()));// true
35. // true
36. // false
37. }
38. }
堆与栈的区别
- •栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。
- •堆（heap）：用于存储对象。
CPU:寄存器
内存:主存储器、ROM、RAM、高速缓存缓存器
JAVA数据存储：寄存器、堆(new对象、垃圾回收等、Java堆可以处于物理上不连续的内存空间)、栈（RAM）、静态存储区域与常量存储区域（静态数据变量、常量）、非RAM（持久化的对象Serializable、对象转化为字符流发送到其他位置）
栈：Java虚拟机栈(OutOfMemoryError)（描述的是JAVA方法执行的内存模式，每个方法执行都会创建一个栈帧用于存储局部变量表(存储基本类型和对象引用)、操作栈、动态链接、方法出口）、本地方法栈(native)（StackOverflowError、OutOfMemoryError）
方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池
（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中
----------------------------------------------------------------------------------------------------------------------------------------
1. public class TestAA {
2. private String str1 = "AA str1";
3. protected String str2 = "AA str2";
4. public String str3 = "AA str3";
5. "AA str4";
6.
7. public String getStr1() {
8. return str1;
9. }
10.
11. public static void main(String[] args) {
12. new TestAA();
13. "," + aa.str2 + "," + aa.str3 + "," + aa.str4);
14. new TestBB();
15. "," + ab.str2 + "," + ab.str3 + "," + ab.str4);
16. new TestBB();
17. "," + bb.str2 + "," + bb.str3 + "," + bb.str4);
18. }
19.
20. }
21.
22. class TestBB extends TestAA {
23. private String str1 = "BB str1";
24. protected String str2 = "BB str2";
25. public String str3 = "BB str3";
26. "BB str4";
27.
28. public String getStr1() {
29. return str1;
30. }
31.
32. }
运行结果
- AA str1,AA str2,AA str3,AA str4
- BB str1,AA str2,AA str3,AA str4
- BB str1,BB str2,BB str3,BB str4
总结：子类中只有private的方法才会覆盖父类的private方法
----------------------------------------------------------------------------------------------------------------------------------------
1. 下面代码视图实现单例模式，但是犯了2处明显的错误，请找出这2个错误。
1. public class Singleton {
2. public Singleton() {
3. "Singleton is create");
4. }
5.
6. private Singleton instance = new Singleton();
7.
8. public static Singleton getInstance() {
9. return instance;
10. }
11.
12. public static void createString() {
13. "createString in Singleton");
14. }
15. }
第2行public改为private；第6行 加上static。
2. 对代理模式的作用，描述最不恰当的一项是（单选题）D
A.控制对象访问和通信
B.延迟加载，提升系统性能
C.处于安全目的，保护被访问者
D.动态扩充对象功能
3.Android UI体系中，事件通知实现的基本思想来源于（单选题）：A
A.观察者模式
B.代理模式
C.策略模式
D.装饰者模式
4. Vector和ArrayList的主要区别是（单选题）：B
A. ArrayList内部基于链表，而Vector是基于数组的
B. Vector的大部分方法做了同步，而ArrayList没有同步
C. Vector是可串行化的，而ArrayList不是
D. Vector实现了RandomAccess，而ArrayList没有
5.如果HashMap发生大量Hash冲突，则会导致（单选题）：D
A. HashMap崩溃，导致不可用
B. HashMap没有影响，依然可以高效的工作
C. HashMap的性能会有一点影响，但总体依然是高效的
D. HashMap依然可用，但是性能受到重创。
6.下面哪些关键字是和多线程并发有关的（多选）AB
A. volatile
B. synchronized
C. public
D. final
7. ReadWriteLock能够提高并发性能的原因是（单选）：C
A.它是无锁的操作
B.它为每个线程都提供了一份数据的复本
C.它可以使得读读操作真正的并发，无需等待
D.它自动进行了锁的粗化
8.对象池和享元模式的根本不同在于（单选）：C
A.对象池中的对象可以复用，享元模式中的对象不能复用
B.对象池可以提升系统性能，享元模式不能
C.对象池中的每个对象都是等价的，享元模式中的每个对象是不等价的
D.对象池中的每个对象是不等价的，享元模式中的每个对象是等价的
9.下面哪些是String对象的特性（多选）A BC
A.不变性
B.针对常量池的优化
C.类是final的
D.用户可自定义的多态
10.简要分析String的subString()方法造成内存泄漏的原因
substring()方法的实现中使用以下形式构造新的字符串：
new String(offset + beginIndex, endIndex - beginIndex, value);
该构造方法实现如下：
String(int offset, int count, char value[]) {
this.value = value;
this.offset = offset;
this.count = count;
}
可见，并没有对value进行裁剪，只是设置了偏移量。因此使用subString()会造成泄漏。
