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));
--------------------------------------------------------------------------------------------------------------------------------
案例如下：
- public class StringTest {
- public static void main(String[] args) {
- String s = new String("abc");
- // 问题1：当类中执行String s = new String("abc");这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
- // （生成2个对象；首先去String
- // Pool查找有没“abc”对象，没有的话，就在池里面放入abc，接着是new一个对象，是在堆里面生成另一个对象；
- // s是引用，指向堆里面的对象；）
- String s1 = "abc";
- // 问题2：当执行String s1 = "abc";这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
- // 答：一个对象也没生成；s1引用string pool里面的abc。
- String s2 = new String("abc");
- // 问题3：当类中执行String s2 = new String("abc");这行代码后，在内存里生成几个对象？他们是什么？在什么地方？
- // 答：生成一个对象，首先是在String Pool查找，发现有“abc”，就不生成，接着在堆里面生成一个对象；s2指向堆里的“abc”
- // 执行完前三行语句，内存一个有三个对象，一个池里面的，两个堆里面的；
- System.out.println(s == s1);// false
- System.out.println(s == s2);// false
- System.out.println(s1 == s2);// false
- // 对象的比较，是比较内存地址的，他们三个地址不同，都是输出false
- // intern:
- // 调用该方法，JAVA虚拟机首先检查字符串池中是否已经存在与该对象相等的对象存在，
- // 如果有则返回字符串池中对象的引用；如果没有，则先在字符串池中创建一个相同值的String对象，然后返回他的引用。
- // 可以理解成比较他们的值是否相等
- System.out.println("s == s.intern()" + (s == s.intern())); // false，执行intern才会创建s
- System.out.println(s1 == s1.intern());// true
- System.out.println(s == s2.intern());// true
- // intern如果pool存在，则指向它；
- String hello = "hello";
- String hel = "hel";
- String lo = "lo";
- System.out.println(hello == "hel" + "lo");// true,两个都是在池里面
- System.out.println(hello == "hel" + lo);// false，左边是在池里面，右边是在堆里面，当两个都不是字面值（引号里面、常量值）相加会生成新的对象
- System.out.println(hello == "hel" + lo);// false
- String hel_lo = ((hel + lo).intern());
- System.out.println("hello == hello.intern() " + (hello == hello.intern()));// true
- System.out.println(hello == hel_lo);// true
- System.out.println(hello == (hel + lo));// false
- }
- }
堆与栈的区别
- •栈（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），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中
----------------------------------------------------------------------------------------------------------------------------------------
- public class TestAA {
- private String str1 = "AA str1";
- protected String str2 = "AA str2";
- public String str3 = "AA str3";
- String str4 = "AA str4";
- public String getStr1() {
- return str1;
- }
- public static void main(String[] args) {
- TestAA aa = new TestAA();
- System.out.println(aa.getStr1() + "," + aa.str2 + "," + aa.str3 + "," + aa.str4);
- TestAA ab = new TestBB();
- System.out.println(ab.getStr1() + "," + ab.str2 + "," + ab.str3 + "," + ab.str4);
- TestBB bb = new TestBB();
- System.out.println(bb.getStr1() + "," + bb.str2 + "," + bb.str3 + "," + bb.str4);
- }
- }
- class TestBB extends TestAA {
- private String str1 = "BB str1";
- protected String str2 = "BB str2";
- public String str3 = "BB str3";
- String str4 = "BB str4";
- public String getStr1() {
- return str1;
- }
- }
运行结果
- 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个错误。
- public class Singleton {
- public Singleton() {
- System.out.println("Singleton is create");
- }
- private Singleton instance = new Singleton();
- public static Singleton getInstance() {
- return instance;
- }
- public static void createString() {
- System.out.println("createString in Singleton");
- }
- }
第2行public改为private；第6行 加上static。
2. 对代理模式的作用，描述最不恰当的一项是（单选题）D
B.延迟加载，提升系统性能
C.处于安全目的，保护被访问者
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
