java试题
http://202.201.112.11/jpk/apply/teacher/preface/53/test123/test3/exam.htm
1.接口中方法的前面有哪些修饰符
访问权限 返回值类型 是否静态 是否抽象
2.以下哪个为真
Interger a = new Interger(9);
Interger b = new Interger(9);
Long c = New Long(9)
-----
A. a==b
B. b==c
C. a.equals(b)
D. b.equals(new Interger(9))
cd
3.以下哪两个方法可以加到three中
class one{
public one foo(){return this;}
}
class two extends one{
public one foo(){return this;}
}
class three extends two{
//插入到这
}
---
A. public void foo(){}
B. public int foo(){return 1;}
C. public one foo(){return this;}
d. public two foo(){return this;}
e. public object foo(){return this;}
cd
4.以下哪些为true
class a{}
class b extends a{}
class c extends a{}
a p0=new a();
b p1=new b();
c p2=new c();
a p3=new b();
a p4=new c();
----
A. p1 = (b)p2
B. p3 = (a)p4
C. p3 = (b)p4
d. p0 = (a)p1
bcd
5. 以下有无问题
abstract class a{
public void fo(){ system.out.println("a");}
}
无 抽象类可以有非抽象方法
6. 以下有无问题
abstract class b{
static void f1(){ system.out.println("f1");}
public static void main(String[] args){
b b1=new b(); //抽象类不能有实例
b1.f1();
}
}
7. 以下代码运行结果是
try{
//此行会抛出NullPointedException
}
catch(NullPointedExecption e){
System.out.print("1")
}
catch(RuntimeExection e){
System.out.print("2")
}
finally{
System.out.print("3")
}
-
A. 1
B. 12
C. 123
d. 13
e. 23
d
8. 以下代码有什么问题，如何该
class a{
private int a=1;
public f(int b){return a}
} 缺少返回类型
class b extends a{
public void f1(){}
public void f2(){ return a }
无返回会类型
}
9.以下代码有问题吗
class a{
void f(){ system.out.println("f");}
public static void main(String[] args){
new a().f();
} 无
}
10. 以下程式运行时，可能产生的结果是什么
class a extends thread{ t大写
public void run{ 缺括号
System.out.print("a");
throw new runtimeExecetion("break") 缺分号
} Exception
}
class b{
public static void main(String[] args){
a a1 =new a();
system.out.println("b") 缺分号
}
} 不能在往外抛出了要捕获
-
12.为什么io,socket等一些对象所占的资源，垃圾回收器不能回收？
不仅仅是io socket还有其他很多类的对象，在接受调用之前都要调用一下，close()
就是释放他们占用的资源，向io socket他们是用本地代码实现的(c/c++),他们占用的
内存空间是垃圾管理器管理不到的
13.多线程有集中实现同步的方式，是什么？
实现多线程的方式继承Thread类实现Runnable接口
实现同步的方法synchronized wait与notify
14.事务acid的含义
他们分别是原子性，一致性，隔离性，持久性的缩写
原子性 把事务包含的程序作为数据库逻辑操作的工作单元，同时成功或同时失败，
成功后数据对外可见，失败时对数据库无影响.
一致性 在事务执行之前和事务执行之后，数据库的数据保持完整性。
完整性： 是数据的精确性和可靠性，他是为了防止数据库中存在不和语义的数据，或
应为错误的输入输出造成无效操作或，错误操作而提出的。
他包括四类
实体完整性：数据库中不存在形同行。
域完整性：对应每一列，的数据要满足这一列的要求，比如精度，有效值范围
引用完整性：主键与外键必须一直。
参照完整性：主键和外键数据的对应一致，A表中有主键和外键，这个外键在B表中
做主键，A表中主键下某个值找到对应的外键值，这个外键值可以在B
表中找到，一行数据。
用户自定义完整性：
隔离性 一个事务内部操作和操作要用到的数据必须封锁起来，如果别的事务也要使用这些数据
，但是看不到。
持久性 一旦数据提交且事务执行成功，数据的变化将反应在数据库中。
15.谈谈你对web MVC的理解，其优缺点
v是皮 可见的部分
m是骨 是内在的东西
c是筋 是连接皮和骨的
由于页面设计可变性的要求，mvc把系统分为视图部件，模型部件，控制部件
模型部件 是业务逻辑在独立于外在显示内容和形式的内在抽象，它封装了核心数据，逻辑和功能计算关系。它独立于外在表现和i/o操作
视图部件 把模型数据以及逻辑关系和状态按照一定的形式展示给用户，它从模型获得数据，对于相同的数据可以有不同的展示形式好或视图。
控制部件 它实现用户和软件之间的交互操作，他的职责是提供模型中状态的传播，从而确保视图和模型的对应关系。它提供用户输入，把输入传给模型，从而实现对模型的控制，使模型和视图协调工作。通常一个视图有一个控制器。
模型视图控制器的分离使一个模型可以有多个视图，如果用户通过某个视图控制器改变了模型的数据，所有与这些数据相关的视图都回反应这些变化。
16.谈谈你对javaEE框架的(spring/ejb)的理解，并列举其优缺点
优点
1）有效的组织中间层
2）减少singleton的使用
3）提供给一致的方法来处理配置文件
4）便于单元测试
缺点
1）要写很多jis代码
2）缺少公共控制器
ioc 控制反转 不创建对象，只描述创建对象的方式，在配置文件中配置组建需要的服务。由容器把组件联系在一起。
aop 面向方面编程 把程序中横切关注点的行为（日志，事务）抽到公共模块中
17.画出代理模式的结构图，并简要说明其每个角色
client------------>Interface(提供实体和代理共用的接口)
| |
| |
RealSubject<----Project
实体 保存一个实体的引用，和实体一样的接口
18.设计模式的原则有哪些
开闭原则 对扩展开放，对修改关闭
里氏代换原则 如果调用的是父类，那么换成子类也可以实现
合成复用原则 少用继承，多用合成复用
依赖原则 针对接口编程，细节依赖于抽象
接口隔离原则 每个接口是一个角色
抽象类
迪米特法则 最少知识原则
19.has a 和 is a的区别
has a 表示类和成员之间的从属关系
is a 表示类之间的继承关系
20.类图中的聚合和依赖的区别
聚合是指整体和部分的关系，先定义一个整体，再分析整体是由那些组成体组成，整体类和组成体类就是聚合关系。
比如航母编队，由航母舰，驱逐舰，舰载机，潜艇组成
依赖 如果a元素的变化会引起b元素发生变化，就说这两个元素从在依赖关系。依赖可能从在如下情况
1）一个类发消息给另一个类。
2）一个类把把另一个类作为自己数据的一部风。
3）一个类在操作中将另一个类作为自己的参数使用
组合 也是整体和部分的关系，但是有生命期，整体不存在了部分也不存在了。
关联 是指类之间的很弱的关系，关联可以有单向关联和双向关联，关联两端的类可以以某种角色参与关联，比如一个类作为另一个类的参数
21.说说java本身的性能优化
比如for()循环外层应该循环少，内层可以循环多。
21.谈谈hibernate的延时加载机制，其会导致什么问题
真正需要数据的时候在进行数据加载。有对象属性集合延迟加载。
1)对象延迟加载
<class name="包名.类名" table="表名" lazy="true">
</class>
User u = (User)session.load(User.class,"1");//1
System.out.println(u.getName());//2
session.load()会返回实体对象的代理对象
在执行的第一句的时候不会加载数据。此时获得的是cglib类型的代理对象，这个代理对象中的属性值都是null。
当执行的第二句的时候cglib调用getName()方法，如果该属性值不为null就直接掉用实体对象的getName().如果为null
就执行sql语句，构造目标对象,对CGLIB$CALBACK.targer属性赋值
2)属性的延迟加载
对于某个字段比如recom java.sql.Clob类型 它里面存储了1000条文本数据，在加载对象的时候每次都要加载它，对系统性能影响很大
对于这样的属性可以在映射文件中
<class>
<property name="recom" type="java.sql.Clbo" column="recom" lazy="true"></property>
</class>
String sql = "from User u where u.name='zz' ";
Query query = session.query(sql);//1
List list = query.list();
for(int i=0;i<list.size();i++)
{
User u = (User)list.get(i);
System.out.println(u.getName());//2
}
当执行到第一句的时候hibernate会索引所有没有延迟加载的属性的数据
当执行的第二句的时候hibernate会执行一句Select recom from user where id="1";
此时会发起对这个字段的读取操作.
3)集合延迟加载
一对多的关系,使用set元素
<set name="addresses" table="address" lazy="true">
<one-to-mang class="包名。类名"></one-to-many>
</set>
User user = (User)Session.load(User.class,"1");
Collection addressSet = user.getAddress();//1
Iterator it = addressSet.iterator();//2
while(it.hasNext())
{
Address address = (Address)it.Next();
Systom.out.println(address.getAddress());
}
执行第一句的时候不会加载数据
执行第二句的时候根据缓存中符合条件的数据索引区查找实体
hibernate中的数据索引，对集合进行缓存时分两部分进行缓存,先缓存集合中实体对象的id列表，在缓存集合中实体对象，那个实体
对象的id列表就是数据索引
查找实体对象id列表，如果没找到，就执行sql，获得符合条件的数据，用这些数据构造实体对象集合和数据索引，
返回实体对象集合，并且将实体对象集合和数据索引放入缓存。
查找实体对象id列表，如果找到，就按照id列表，到缓存中招对应的实体对象，若果缓存中不存在实体对象，就执行sql
以上有系统效率问题，可以<cache usage="read-write"></cache>
Java试题（一）
一、 选择
1.欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的 ？B
ArrayList ar = new ArrayList();//也对
A ArrayList myList=new Object（）；
B List myList=new ArrayList（）；
C ArrayList myList=new List（）；
D List myList=new List（）；
2.paint()方法使用哪种类型的参数?A
A Graphics
B Graphics2D
C String
D Color
3.指出正确的表达式 cd 类型首字母都对
A byte=128; //-128~+127 byte b=-128~127;
B Boolean=null; //boolean b = true/false;
C long l=0xfffL;
D double=0.9239d;
4.指出下列程序运行的结果 good and gbc
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 ");
Sytem.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
5.运行下列程序, 会产生什么结果 a
public class X extends Thread implements Runable{
public void run(){
System.out.println("this is run()");
}
public static void main(String args[])
{
Thread t=new Thread(new X());
t.start();
}
}
A 第一行会产生编译错误
B 第六行会产生编译错误
C 第六行会产生运行错误
D 程序会运行和启动
6.要从文件" file.dat"文件中读出第10个字节到变量C中,下列哪个方法适合? a 但是读出来的是ascii码
FileInputStream in = new FileInputStream("a.txt"); in.skip(9); int c = in.read();
RandomAccessFile in = new RandomAccessFile("a.txt","rw"); in.skipBytes(9); int c = in.readByte();
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();
7.容器被重新设置大小后，哪种布局管理器的容器中的组件大小不随容器大小的变化而改变？ b
A CardLayout
B FlowLayout
C BorderLayout
D GridLayout
8.给出下面代码： c
public class Person{
static int arr[] = new int[10];
public static void main(String a[])
{
System.out.println(arr[1]);
}
}
那个语句是正确的？
A 编译时将产生错误；
B 编译时正确，运行时将产生错误；
C 输出零；
D 输出空。
9.哪个关键字可以对对象加互斥锁？ b
A transient
B synchronized
C serialize
D static
10.下列哪些语句关于内存回收的说明是正确的? bc
A 程序员必须创建一个线程来释放内存；
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象
11.下列代码哪几行会出错: c
1) public void modify() {
2) int I, j, k;
3) I = 100;
4) while ( I > 0 ) {
5) j = I * 2;
6) System.out.println (" The value of j is " + j );
7) k = k + 1;
8) I--;
9) }
10) }
A line 4
B line 6
C line 7
D line 8
二、多项选择
1.执行下列代码后,哪个结论是正确的 String[] s=new String[10]; bd
A s[10] 为 "";
B s[9] 为 null;
C s[0] 为 未定义
D s.length 为10
2.下面的表达式哪个是正确的? ac
A String s="你好";int i=3; s+=i;
B String s="你好";int i=3; if(i==s){ s+=i};
C String s="你好";int i=3; s=i+s;
D String s="你好";int i=3; s=i+;
E. String s=null; int i=(s!=null)&&(s.length>0)?s.length():0;
3.选出合理的标识符 ac java标识符只能以字母下划线$开头 标识符内不能有$之外的字符
A _sys1_lll
B 2mail
C $change
D class
4.哪个布局管理器使用的是组件的最佳尺寸（ preferred size） FlowLayout流式布局
A FlowLayout
B BorderLayout
C GridLayout
D CardLayout
E.GridBagLayout
5.下列哪个方法可用于创建一个可运行的类? A 继承Thread类,实现Runnable接口
A public class X implements Runable{ public void run(){ ......} }
B public class X implements Thread{ public void run(){ ......} }
C public class X implements Thread{ public int run(){ ......} }
D public class X implements Runable{ protected void run(){ ......} }//方法覆盖不能比父类的访问权限小
E.public class X implements Thread{ public void run(){ ......} }
6.下面哪个方法可以在任何时候被任何线程调用?def
A notify()
B wait()
C notifyAll()
D sleep()
E.yield() //由于cpu效率不高，现在中断
F.synchronized(this)
7.构造BufferedInputStream的合适参数是哪个? C
A BufferedInputStream
B BufferedOutputStream
C FileInputStream
D FileOuterStream
E. File
8.下列说法正确的是 BCD
A java.lang.Clonable是类 ///是接口
B java.lang.Runnable是接口
C Double对象在java.lang包中
D Double a=1.0是正确的java语句
9.指出正确的表达式 ABD
A double a=1.0;
B Double a=new Double(1.0);
C byte a = 340; //-128~+127
D Byte a = 120;
10.定义一个类名为"MyClass.java"的类，并且该类可被一个工程中的所有类访问，那么该类的正确声明应为： D
A private class MyClass extends Object
B class MyClass extends Object
C public class MyClass
D public class MyClass extends Object
11.指出下列哪个方法与方法public void add(int a){}为合理的重载方法。 BCD
A public int add(int a)
B public void add(long a)
C public void add(int a,int b)
D public void add(float a)
12.如果下列的方法能够正常运行，在控制台上将显示什么？ ACD
public void example(){
try{
unsafe();
System.out.println("Test1");
}
catch(SafeException e)
{System.out.println("Test 2");}
finally{System.out.println("Test 3");}
System.out.println("Test 4");
}
A Test 1
B Test 2
C Test 3
D Test 4
13.下列哪些情况可以终止当前线程的运行？ AB
A 抛出一个例外时。
B 当该线程调用sleep()方法时。
C 当创建一个新线程时。
D 当一个优先级高的线程进入就绪状态时。
三、 填空题
1.执行下列代码后的结果是什么? int x,a=2,b=3,c=4; x=++a+b+++c++;
vector hashtable array bitset set map
3.main方法的声明格式包括 ppublic static void mian(String[] args){}
4.下列程序中构造了一个SET并且调用其方法add（），输出结果是 1
public class A{
public int hashCode（）{return 1；}
public Boolean equals（Object b）{return true}
public static void main（String args[]）{
Set set=new HashSet（）；
set.add(new A());
set.add(new A());
set.add(new A());
System.out.println(set.size());
}
}
5.下列程序的运行结果是 26
class A{
class Dog{
private String name;
private int age;
public int step;
Dog(String s,int a)
{
name=s;
age=a;
step=0;
}
public void run(Dog fast)
{
fast.step++;
}
}
public static void main (String args[])
{
A a=new A();
Dog d=a.new Dog("Tom",3);
d.step=25;
d.run(d);
System.out.println(d.step);
}
}
四、 编程题
2.打印输出10行杨晖三角形 ??????
package com.huawei.odp.action;
public class Yanghui {
public static void main(String[] args) {
Yanghui yang = new Yanghui();
yang.printYanghuiTriangle(16);
}
/**
* 生成指定行数的杨辉三角形
*
* @param lines 杨辉三角形的行数
*/
public void printYanghuiTriangle(int lines) {
if(lines < 1) {
throw new IllegalArgumentException("lines must be great than 0.");
}
if(lines > 30) {
throw new IllegalArgumentException("lines is too big.");
}
int[] line = new int[lines];
int maxLen = getMaxLen(lines);
for(int i = 0; i < lines; i++) {
line[0] = line[i] = 1;
for(int j = 1, k = i / 2, pre = line[0]; j <= k; j++) {
int cur = line[j];
line[i - j] = line[j] += pre;
pre = cur;
}
printLine(line, i + 1, maxLen);
}
}
/**
* 根据指定行数的杨辉三角形，计算其中最大数字的长度
* @param lines 杨辉三角形的行数
* @return 最大数字的长度
*/
private int getMaxLen(int lines) {
int k = lines / 2;
long maxNum = factorial(k + 1, lines - 1) / factorial(1, lines - 1 - k);
return getLength(maxNum);
}
/**
* 阶乘计算
* @param start 阶乘计算的起始数字
* @param num 阶乘计算的终止数字
* @return 阶乘计算结果
*/
private long factorial(int start, int num) {
long result = start > 0 ? start : 1L;
while(num > start) {
result *= num--;
}
return result;
}
/**
* 根据指定数字计算数字的长度
* @param num 数字
* @return 数字的长度
*/
private int getLength(long num) {
int len = 0;
while(num > 0L) {
num /= 10L;
len++;
}
return len;
}
private void printLine(int[] yanghui, int line, int width) {
printSpaces((yanghui.length - line) * width);
for(int i = 0; i < line; i++) {
if(i > 0) {
printSpaces(width);
}
printSpaces(width - getLength(yanghui[i]));
System.out.print(yanghui[i]);
// System.out.print("*");
}
System.out.println();
if(width > 1) {
System.out.println();
}
}
private void printSpaces(int spaceCount) {
for(int i = 0; i < spaceCount; i++) {
System.out.print(" ");
}
}
}
???
3. 有下面一段Server段程序，目的是能够同时服务多个客户，客户的请求是一句话（一个 String）。如果这个请求的内容是字符串"plain"的话，服务器仅将"hello"字符串返回给用户。
否则将用户的话追加到当前目录的文本文件 Memo.txt中（路径为"Memo.txt"），并向用户返回"OK"。注意Server并发的处理多用户，Memo.txt被共享，要求不能出现数据不一致。
Server的程序如下文件Server.java:
public class Server{
public static void main(String args[]){
MemoController memoController = new MemoController();
try{
ServerSocket ss = new ServerSocket(1999);
while (true){
Socket s = ss.accept();
try{
UserThread t = new UserThread(s, memoController);
t.start();
}catch(Exception e){
e.printStackTrace();
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
memoController.close();
}
}
}
类UserThread程序如下：
文件UserThread.java：
public class UserThread extends Thread{
Socket s;
MemoController memo;
public UserThread (Socket s, MemoController memo){
this.s = s;
this.memo = memo;
}
public void run(){
try{
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter pw = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
String req = br.readLine();
if (req.equals("plain")){
pw.println("hello");
}else{
memo.append(req);
pw.println("OK");
}
pw.flush();
pw.close();
br.close();
s.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
请根据题目的要求和现有的Server.java, UserThread.java的程序完成类MemoController.java的程序。
???
4. 用输入/输出写一个程序，让用户输入一些姓名和电话号码。每一个姓名和号码将加在文件里。用户通过点"Done"按钮来告诉系统整个列表已输入完毕。
如果用户输入完整个列表，程序将创建一个输出文件并显示或打印出来。
格式如：555-1212,Tom 123-456-7890,Peggy L. 234-5678,Marc 234-5678,Ron 876-4321,Beth&Brian 33.1.42.45.70,Jean-Marc
Java试题（二）
一、 选择
1.MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。 ABCD
A public int MAX_LENGTH=100;
B final int MAX_LENGTH=100;
C final public int MAX_LENGTH=100;
D public final int MAX_LENGTH=100.
2.给出下面代码： D
1) class Parent {
2) private String name;
3) public Parent(){}
4) }
5) public class Child extends Parent {
6) private String department;
7) public Child() {}
8) public String getValue(){ return name; }
9) public static void main(String arg[]) {
10) Parent p = new Parent();
11) }
12) }
那些行将引起错误？
A 第3行
B 第6行
C 第7行
D 第8行
3.类Teacher和Student是类Person的子类；B
Person p;
Teacher t;
Student s;
//p, t and s are all non-null.
if(t instanceof Person) { s = (Student)t; }
最后一句语句的结果是：
A 将构造一个Student对象；
B 表达式是合法的；
C 表达式是错误的；
D 编译时正确，但运行时错误。
4.给出下面代码段 D
1) public class Test {
2) int m, n;
3) public Test() {}
4) public Test(int a) { m=a; }
5) public static void main(String arg[]) {
6) Test t1,t2;
7) int j,k;
8) j=0; k=0;
9) t1=new Test();
10) t2=new Test(j,k);
11) }
12) }
哪行将引起一个编译时错误？
A line 3
B line 5
C line 6
D line 10
5.对于下列代码： D
1) class Person {
2) public void printValue(int i, int j) {//... }
3) public void printValue(int i){//... }
4) }
5) public class Teacher extends Person {
6) public void printValue() {//... }
7) public void printValue(int i) {//...}
8) public static void main(String args[]){
9) Person t = new Teacher();
10) t.printValue(10);
11) }
第10行语句将调用哪行语句？?
A line 2
B line 3
C line 6
D line 7
8.System类在哪个包中? D
A java.util
B java.io
C java.awt
D java.lang
9.对于下列代码： C
public class Parent {
public int addValue( int a, int b) {
int s;
s = a+b;
return s;
}
}
class Child extends Parent {
}
下述哪些方法可以加入类Child?
A int addValue( int a, int b ){// do something...}
B public void addValue (int a, int b ){// do something...}
C public int addValue( int a ){// do something...}
D public int addValue( int a, int b )throws MyException {//do something...}
10.给出下面代码： A
public class test{
static int a[] = new a[10]; //int[] a = new int[10];
public static void main(String args[]) {
System.out.println(args[10]);
}
}
那个选项是正确的？
A 编译时将产生错误；
B 编译时正确，运行时将产生错误；
C 输出零；
D 输出空。
二、多项选择ACD
1.下面哪些代码段是正确的Java源程序？
A. package testpackage;
public class Test{//do something...}
B. import java.io.*;
package testpackage;
public class Test{// do something...}
C. import java.io.*;
class Person{// do something...}
public class Test{// do something...}
D. import java.io.*;
import java.awt.*;
public class Test{// do something...}
2. public class parent {
int change() {}
}
class Child extends Parent { }
哪些方法可加入类Child中？ AB
A public int change(){}
B int chang(int i){}
C private int change(){}
D abstract int chang(){}
3. ACD
String s = "hello";
String t = "hello";
char c[] = {'h','e','l','l','o'} ;
下列哪些表达式返回true？
A s.equals(t);
B t.equals(c);//类型不同
C s==t;
D t.equals(new String("hello"));
4.给出下面代码段： C
1) switch(m)
2) {
case 0: System.out.println("case 0");
3) case 1: System.out.println("case 1"); break;
4) case 2:
5) default: System.out.println("default");
6) }
下列m的哪些值将引起"default"的输出？
A 0
B 1
C 2
D 3
5.下列哪些说法是正确的？ A
要想多继承可以采用接口
A Java 语言只允许单一继承
B Java 语言只允许实现一个接口
C Java 语言不允许同时继承一个类并实现一个接口 //允许
D Java 语言的单一继承使得代码更加可靠 //使关系简单
6.下列关于" < <"和">>"的运算,哪些是正确的? AD Integer.parseInt("0000",2);//十进制转换成二进制
A 0000 0100 0000 0000 0000 0000 0000 0000 < <5 的运行结果是 1000 0000 0000 0000 0000 0000 0000 0000
B 0000 0100 0000 0000 0000 0000 0000 0000 < <5的运行结果是 1111 1100 0000 0000 0000 0000 0000 0000
C 1100 0000 0000 0000 0000 0000 0000 0000>>5的运行结果是 1111 1110 0000 0000 0000 0000 0000 0000
D 1100 0000 0000 0000 0000 0000 0000 0000>>5的运行结果是 0000 0110 0000 0000 0000 0000 0000 0000
7.下述哪些说法是正确的？ AD
A 实例变量是类的成员变量 //实例变量就是一个对象 成员变量是类中的静态变量
B 实例变量是用static关键字声明的
C 方法变量在方法执行时创建
D 方法变量在使用之前必须初始化 //方法中的变量时局部不变量，在使用之前必须进行初始化,否则编译不通过
在方法中，有if()else()，无论是在if还是在else中，有一个地发进行初始化就可以
有try{}catch(){}finally{}只在try中有则部分通过编译，在catch和finally中都有则可以通过编译
8.对于下列代码：
public class Sample{
long length;
public Sample(long l){ length = l; }
public static void main(String arg[]){
Sample s1, s2, s3;
s1 = new Sample(21L);
s2 = new Sample(21L);
s3 = s2;
long m = 21L;
}
}
下列哪些表达式返回值为'true'? B
A s1 = = s2;
B s2 = = s3;
C m = = s1;
D s1.equals(m) //s1是对象，值是包名。Sample@1c5765sdgji59
//m是属性，值是，21
9.下面说法哪些是正确的？ BD
A Applet可以访问本地文件 //浏览器的Applet不能访问本地文件
B 对static方法的调用不需要类实例
C socket类在java.lang中 //java.net
D 127.0.0.1地址代表本机
10.下列说法正确的是： BCD
A java语言里的线程是没有优先级的
B String类在java.lang包中
C java语言支持类的序列化
D 能序列化的类必须实现java.io.Serializable接口
11.关于awt和swing说法正确的是： BD
A awt在不同操作系统中显示相同的风格。
B swing在不同的操作系统中显示相同的风格
C java.awt的子类
D awt和swing都支持事件模型
12.关于Float，下列说法正确的是 ABD
A Float是一个类
B Float在java.lang包中
C Float a=1.0是正确的赋值方法 //Float f = 1.0f;
D Float a= new Float(1.0)是正确的赋值方法
13.下述哪些说法是正确的？ BD
A java语言中的类只能有一个构造函数
B 程序员可以自己定义自己的异常
C java语言允许多继承 //单继承
D socket在java.net包中
14.下列哪些说法是正确的？ AD
A IOException必须被捕获或抛出
B java语言会自动初始化变量的值 //局部变量必须显示初始化
C java 语言不允许同时继承一个类并实现一个接口
D java语言会自动回收内存中的垃圾
三、 填空题
1.Collection的 四种主要接口是
BeanContext 是javaBean的逻辑层次容器
List 有序可重复
Set 有序不重复
SortedSet 按照自然顺序排序或按照创建时集合的顺序排序
5.0
Query
BlockingQuery
3. 下列代码不能编译的原因是 没有继承class B
Class A
{
Private int x;
Public static void main(String args[])
{
new B();
}
}
class B
{
B()
{
System.out.println(x);
}
}
四、 编程题
2. 编写一个应用程序，完成文件的拷贝功能，文件名从命令行得到。
public class CopyFile
{
public void cop()
{
try
{
System.out.println("请输入文件名");
Scanner in = new Scanner(System.in);
String name = "";
name = in.nextLine();
String str = "E://workspace//ii//WebRoot//"+name;
String str2 = "E://workspace//ii//WebRoot//b.txt";
File file = new File(str);
if(null != file && !"".equals(file))
{
FileReader reader = new FileReader(file);
BufferedReader br = new BufferedReader(reader);
FileWriter writer = new FileWriter(str2);
BufferedWriter bw = new BufferedWriter(writer);
String readLine;
while(br.ready())
{
readLine = br.readLine();
bw.write(readLine+"/n");
}
bw.flush();
}
}catch(Exception e)
{
System.out.println("sorry");
}
}
public static void main(String[] args)
{
CopyFile copyFile = new CopyFile();
copyFile.cop();
}
}
一、 选择
1.给定下面的代码片段： A 应该在方法内部
1) String str = null;
2) if ((str != null) && (str.length() > 10)) {
3) System.out.println("more than 10");
4) }
5) else if ((str != null) & (str.length() < 5)) {
6) System.out.println("less than 5");
7) }
8) else { System.out.println("end"); }
哪些行会导致错误？
A line 1
B line 2
C line 5
D line 8
2.下面哪种注释方法能够支持javadoc命令: D
A /**...**/
B /*...*/
C //
D /**...*/
6.下面关于Applet的说法正确的是 BC
A Applet也需要main方法 //applet是嵌入到浏览器中运行的
B Applet必须继承自java.awt.Applet
C Applet能访问本地文件
D Applet程序不需要编译
7.看下面一段程序：C
class Aclass{
void go(){
System.out.println("Aclass");
}
}
public class Bclass extends Aclass{
void go{
System.out.println("Bclass");
}
public static void main(String args[]){
Aclass a=new Aclass();
Aclass a1=new Bclass();
a.go();
a1.go();
}
以上程序运行结果是：
A Aclass
Aclass
B Bclass
Bclass
C Aclass
Bclass
D Bclass
Aclass
8.下列关于Java线程的说法那些是正确的（A）
A 每一个Java线程可以看成由代码、一个真实的CPU以及数据三部份组成。
B 创建线程的两种方法中，从Thread类中继承的创建方式可以防止出现多父类问题。
C Thread类属于java.util程序包。
D 以上说法无一正确。
9.看以下程序： A
boolean a=false;
boolean b=true;
boolean c=(a&&b)&&(!b); flase
int result=c==false?1:2; 1
这段程序执行完后，c与result的值是:
A c=false;result=1;
B c=true;result=2;
C c=true;result=1;
D c=false;result=2;
10.运行下列程序, 会产生什么结果 D
public class X extends Thread implements Runable{
public void run(){
System.out.println("this is run()");
}
public static void main(String args[])
{
Thread t=new Thread(new X());
t.start();
}
}
A 第一行会产生编译错误
B 第六行会产生编译错误
C 第六行会产生运行错误
D 程序会运行和启动
12.运行下列程序，会产生什么结果： B
class Outer1{
private int a;
void foo(double d,final float f){
String s;
final boolean b;
class Inner{
void methodInner(){
System.out.println("in the Inner");
}
}
}
public static void main(String args[])
{
Outer1 me=new Outer1();
me.foo(123,123);
System.out.println("outer");
}
}
A in the Inner outer
B outer
C in the Inner
D 编译不通过
二、多项选择
1.下面哪些标识符在Java语言中是合法的？ AB
A persons$
B TwoUsers
C *point
D instanceof F.end-line
2.下面哪些代码片段会产生编译错误？ BD
A String s = "Gone with the wind"; String t = " good "; String k = s + t;
B String s = "Gone with the wind"; String t; t = s[3] + "one";
C String s = "Gone with the wind"; String standard = s.toUpperCase();
D String s = "home directory"; String t = s - "directory".
3.下面哪些赋值语句是错误的？ AD
A float f = 11.1;
B double d = 5.3E12;
C char c = '/r';
D byte bb = 433;//-128~+127
E Boolean b=true;
5.下列哪些语句是正确的? BCD
A int a[][]=new int[][3];
B int a[][]={{1,3},{2,3,4},{1,2}};
C String s[][]=new String[2][];
D String s[][]={{"can","I"},{"help","you"}}
6.下面哪些语句能够正确地生成5个空字符串？ AB
A String a [] = new String [5]; for (int i = 0; i < 5; a[i++] = "");
B String a [] = {"", "", "", "", ""};
C String a [5];
D String [5] a;
E String [] a = new String [5]; for (int i = 0; i < 5; a[i++] = null);
7.下面关于Java代码安全的说法哪些是正确的？ ABCD
A 程序执行过程中需要的所有类都是通过字节码校验程序装入的。
B 代码的运行是由Java运行环境中的解释器完成的。
C 在运行时，字节码要经过装入，校验之后，才能在解释器中执行。
D 在缺省的安全配置条件下，Java Applet不能访问任何本地资源。
8.下列方法属于java.lang.Math类的有（方法名相同即可）： ABCD
abs ，ceil ，floor ，max ，min ，random ，round ，sin， cos， tan， sqrt
A random()
B abs()
C sqrt()
D sin()
9.下列表达式哪些是正确的： C
A byte=340;
B Boolean=1;
C long l=-2;
D double=0.9239d;
10.下面的说法正确的是： BC
A Java语言里的线程不是对象
B Applet不需要main方法
C Java语言的对象都是java.lang.Object的子类
D double是Java语言的合法标识符 //关键字
11.下面的Java语句错误的是：C D
A Double a=1.0;
B double a=1.0;
C out.println("hello");
D DatagramSocket a = new DatagramSocket()
三、 填空题
3. 请填出在java.lang包中与下列基本数据类型相对应的封装类： float：java.lang.Float， char： java.long.Character
4. 请写出下面程序的运行结果。
public class Test extends TT{
public void main(String args[]){
Test t = new Test("Tom");
}
public Test(String s){
super(s); //调父类有参构造
System.out.println("How do you do?");
}
public Test(){
this("I am Tom");
}
}
class TT{
public TT(){ //父类中的空参构造，一定会被调用
System.out.println("What a pleasure!");
}
public TT(String s){
this();
System.out.println("I am "+s);
}
}
结果：
5. 给定下面的未完成的代码片断：
public class Example{
int x,y;
public Example(int a){
…
x = a;
}
public Example(int a, int b){
//和上面一个参数的构造方法做同样的操作，包括赋值 this(a)
x=a y = b;
}
}
如果要用最简捷的一行代码实现"//和上面一个参数的…"注释所指出的功能，请写出你认为最合适的一行代码：
6. 如果有一个类MyFrame是Frame的子类，能够被不同包中的类所使用，同时又能够为线程提供运行代码（run()方法），请写出该类的声明头。 你的解答：
public class MyFarme extends Frame implements Runnable
四、 编程题
1. 编写一个程序用选择法对数组a[]={20,10,50,40,30,70,60,80,90,100}进行由大到小的排序。
public class Stores
{
public static void stor(int[] a)
{
int temp;
for(int i=0;i<a.length;i++)
{
for(int j=i+1;j<a.length;j++)
{
if(a[i] < a[j])
{
temp = a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
}
public static void main(String[] args)
{
int[] a = {20,10,50,40,30,70,60,80,90,100};
Stores.stor(a);
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
2. 使用socket编写一个服务器端程序，服务器端程序在端口8888监听，如果它接到客户端发来的"hello"请求时会回应一个"hello"，对客户端的其他请求不响应。
public class Server
{
public static void main(String[] args)throws Exception
{
ServerSocket serverSocket = new ServerSocket(8888);
Socket cliectSocket = serverSocket.accept();
BufferedReader is = new BufferedReader(new InputStreamReader(cliectSocket.getInputStream()));
PrintWriter os = new PrintWriter(cliectSocket.getOutputStream());
while(true)
{
String line = is.readLine();
if(line.equals("hello"))
{
os.print("hello");
os.flush();
}
}
}
}
3. 编写一个应用程序，创建三个线程分别显示各自的时间。
public class ThreeTimeThread extends Thread
{
public ThreeTimeThread(String str)
{
super(str);
}
public void run()
{
while(true)
{
SimpleDateFormat formate = new SimpleDateFormat("yyyy:MM:dd hh:mm:ss");
Date date = new Date();
try
{
sleep(2000);
}catch(Exception e){}
String dateString = formate.format(date);
System.out.println(dateString);
}
}
public static void main(String[] args)
{
ThreeTimeThread t1 = new ThreeTimeThread("first ");
ThreeTimeThread t2 = new ThreeTimeThread("second ");
ThreeTimeThread t3 = new ThreeTimeThread("thired ");
t1.start();
t2.start();
t3.start();
}
}
4. 编写一个计算器程序，只有加减乘除功能，当作applet运行。
Calculator.java:
import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.applet.*;
public class Calculator extends Applet implements ActionListener{
Panel buttonPanel;
TextField tf; //用于显示输入的数字的文本框
Button b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,bDot,bPlus,bSub,bDiv,bMulti,bEqual; //按键
String onDisplay=""; //显示在文本框中的字符串
boolean isDotPressed=false; //按键'.'是否被按下
float operand; //通过按键输入的数
float operand1,operand2;//operand1和operand2为计算用的操作数
char operator; //计录所用的操作符
float result; //计算结果
int times=1; //小数点后有几位的10次方幂
public void init(){
setLayout(new BorderLayout(5,5));
tf=new TextField(30);
add(tf,BorderLayout.NORTH);
buttonPanel=new Panel();
buttonPanel.setLayout(new GridLayout(4,4,5,5));
add(buttonPanel,BorderLayout.CENTER);
//下面依次把按钮添加上去
b1=new Button("1");
buttonPanel.add(b1);
b1.addActionListener(this);
b1.setActionCommand("1");
b2=new Button("2");
buttonPanel.add(b2);
b2.addActionListener(this);
b2.setActionCommand("2");
b3=new Button("3");
buttonPanel.add(b3);
b3.addActionListener(this);
b3.setActionCommand("3");
bPlus=new Button("+");
buttonPanel.add(bPlus);
bPlus.addActionListener(this);
bPlus.setActionCommand("+");
b4=new Button("4");
buttonPanel.add(b4);
b4.addActionListener(this);
b4.setActionCommand("4");
b5=new Button("5");
buttonPanel.add(b5);
b5.addActionListener(this);
b5.setActionCommand("5");
b6=new Button("6");
buttonPanel.add(b6);
b6.addActionListener(this);
b6.setActionCommand("6");
bSub=new Button("-");
buttonPanel.add(bSub);
bSub.addActionListener(this);
bSub.setActionCommand("-");
b7=new Button("7");
buttonPanel.add(b7);
b7.addActionListener(this);
b7.setActionCommand("7");
b8=new Button("8");
buttonPanel.add(b8);
b8.addActionListener(this);
b8.setActionCommand("8");
b9=new Button("9");
buttonPanel.add(b9);
b9.addActionListener(this);
b9.setActionCommand("9");
bMulti=new Button("*");
buttonPanel.add(bMulti);
bMulti.addActionListener(this);
bMulti.setActionCommand("*");
b0=new Button("0");
buttonPanel.add(b0);
b0.addActionListener(this);
b0.setActionCommand("0");
bDot=new Button(".");
buttonPanel.add(bDot);
bDot.addActionListener(this);
bDot.setActionCommand(".");
bEqual=new Button("=");
buttonPanel.add(bEqual);
bEqual.addActionListener(this);
bEqual.setActionCommand("=");
bDiv=new Button("/");
buttonPanel.add(bDiv);
bDiv.addActionListener(this);
bDiv.setActionCommand("/");
}
public void actionPerformed(ActionEvent e){
String str=e.getActionCommand();
char b=str.charAt(0);
switch(b){
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': onDisplay+=b;
operand=operand*10+Integer.parseInt(str);
if(isDotPressed) times*=10;
tf.setText(onDisplay);
break;
case '.': onDisplay+=b;
isDotPressed=true;
tf.setText(onDisplay);
break;
case '+':
case '-':
case '*':
case '/': operator=b;
operand1=operand/times;
System.out.println(operand1);
onDisplay="";
times=1;
isDotPressed=false;
operand=0;
break;
case '=': operand2=operand/times;
System.out.println(operand2);
switch(operator){
case '+': result=operand1+operand2;break;
case '-': result=operand1-operand2;break;
case '*': result=operand1*operand2;break;
case '/': result=operand1/operand2;break;
}
tf.setText(float.toString(result));
onDisplay="";
times=1;
isDotPressed=false;
operand=0;
break;
}
}
}
Calculator.html:
<html>
<applet code="Calculator.class" width=250 height=250>
</applet>
</html>
五、 程序填空题：
1. 在空白处填上合适的语句。
public class ServerTimedOutException extends Exception {
private int port;
public ServerTimedOutException(String message, int port) {
super(message);
this.port = port;
}
public int getPort() {
return port;
}
}
class Client{
//在下行空白出填上声明抛弃ServerTimedOutException例外的语句
public void connectMe(String serverName) _____________________
{
int success;
int portToConnect = 80;
success = open(serverName, portToConnect);
if (success == -1) {
/*在下行空白处填上抛出ServerTimedOutException例外的语句*/
_________________________
}
}
}
五、程序填空题答案
程序填空第1题
throws ServerTimedException;
throw new ServerTimedException(serverName,portName);
User Interface
你是做网站的UI,还是软件的UI,还是手机的UI,或者是游戏的UI,再或者的硬件的UI?
我现在的职业就是和手机UI相关的工作，以前做过网站的美工
如果你是程序员,那建议你学好JAVA C++等语言
如果你是美工,最好学会使用PHOTOSHOP、CorelDraw、Illustrator、3DMAX、FLASH等图形绘画矢量软件，当然还要会点象素！
还有就是平时多练习自己的绘画技术，有时间再看一些人机交互相关书籍，
UI的目标就是简洁，美观，大方，让人一目了然能找到自己想找的图标和内容！
图标要有寓意性，色彩搭配合理！
java中进行二进制，八进制，十六进制，十进制间进行相互转换
关键字: java 进制转换
十进制转成十六进制：
Integer.toHexString(int i)
十进制转成八进制
Integer.toOctalString(int i)
十进制转成二进制
Integer.toBinaryString(int i)
十六进制转成十进制
Integer.valueOf("FFFF",16).toString()
八进制转成十进制
Integer.valueOf("876",8).toString()
二进制转十进制
Integer.valueOf("0101",2).toString()
有什么方法可以直接将2,8,16进制直接转换为10进制的吗?
java.lang.Integer类
parseInt(String s, int radix)
使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
examples from jdk:
parseInt("0", 10) returns 0
parseInt("473", 10) returns 473
parseInt("-0", 10) returns 0
parseInt("-FF", 16) returns -255
parseInt("1100110", 2) returns 102
parseInt("2147483647", 10) returns 2147483647
parseInt("-2147483648", 10) returns -2147483648
parseInt("2147483648", 10) throws a NumberFormatException
parseInt("99", throws a NumberFormatException
parseInt("Kona", 10) throws a NumberFormatException
parseInt("Kona", 27) returns 411787
进制转换如何写（二，八，十六）不用算法
Integer.toBinaryString
Integer.toOctalString
Integer.toHexString
例二
public class Test{
public static void main(String args[]){
int i=100;
String binStr=Integer.toBinaryString(i);
String otcStr=Integer.toOctalString(i);
String hexStr=Integer.toHexString(i);
System.out.println(binStr);
}
例二
public class TestStringFormat {
public static void main(String[] args) {
if (args.length == 0) {
System.out.println("usage: java TestStringFormat <a number>");
System.exit(0);
}
Integer factor = Integer.valueOf(args[0]);
String s;
s = String.format("%d", factor);
System.out.println(s);
s = String.format("%x", factor);
System.out.println(s);
s = String.format("%o", factor);
System.out.println(s);
}
}
其他方法：
Integer.toHexString(你的10进制数);
例如
String temp = Integer.toHexString(75);
输出temp就为 4b
//输入一个10进制数字并把它转换成16进制
import java.io.*;
public class toHex{
public static void main(String[]args){
int input;//存放输入数据
//创建输入字符串的实例
BufferedReader strin=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个的整数：");
String x=null;
try{
x=strin.readLine();
}catch(IOException ex){
ex.printStackTrace();
}
input=Integer.parseInt(x);
System.out.println ("你输入的数字是："+input);//输出从键盘接收到的数字
System.out.println ("它的16进制是："+Integer.toHexString(input));//用toHexString把10进制转换成16进制
}
}
1.4经典题解
一、选择题
1．在下列说法中，选出最正确的一项是（）。
A） Java语言是以类为程序的基本单位的
B） Java语言是不区分大小写的
C） 多行注释语句必须以//开始
D） 在Java语言中，类的源文件名和该类名可以不相同
解析：选项B）错误，Java语言是区分大小写的，这点在初学Java时需要特别注意；选项C）错误，以//开始的应该是单行注释语句；选项D）错误，Java程序源文件名必须和public类名相同，否则编译出错；因此正确的答案应该是选项A）。
答案： A）
2．下列选项中不属于Java虚拟机的执行特点的一项是（）。
A） 异常处理B） 多线程C） 动态链接D） 简单易学
解析：选项D）错误，简单易学是Java语言和其他高级语言相比所拥有的一个重要特点，而不是Java虚拟机的执行特点。
答案： D）
3．下列选项中属于Java语言的垃圾回收机制的一项是（）。
A） 语法检查B） 堆栈溢出检查
C） 跨平台D） 内存跟踪
解析：选项A）错误，语法检查是编译器的一项工作，不属于垃圾回收；选项B）错误，堆栈溢出在解释执行时进行检查；选项C）错误，跨平台是Java语言的一个特点，不属于垃圾回收机制。选项D）正确，为了充分利用资源，Java语言提供了一个系统级的线程，用于监控内存，在有必要时释放不再使用的内存，这就是垃圾回收机制。
答案： D）
4．下列选项中属于Java语言的安全性的一项是（）。
A） 动态链接B） 高性能
C） 访问权限D） 内存跟踪
解析：选项A）错误，动态链接属于JVM的执行特性；选项B）错误，高性能是Java语言的一个特点，但不能体现Java语言的安全性；选项D）错误，内存跟踪属于垃圾回收机制；选项C）正确，Java通过访问权限限制对不同内容的访问，从而提高安全性。
答案： C）
5．下列选项中，属于JVM执行过程中的特点的一项是（）。
A） 编译执行B） 多进程
C） 异常处理D） 静态链接
解析：选项A）错误，Java语言是解释执行的语言，不是编译执行的；选项B）错误，在Java中使用的是多线程技术，而不是多进程，进程概念是从操作系统角度考虑程序运行，一个进程可以有多个线程；选项D）错误，在Java中采用动态链接；选项C）正确，在JVM执行过程中提供了异常处理机制，处理程序抛出的异常。
答案： C）
6．Java语言和C++语言相比，哪一项是Java有的，而C++没有？()
A） 面向对象B） 动态链接
C） 有类库D） 跨平台
解析：选项A）错误，因为C++和Java都是面向对象的程序设计语言；选项B）错误，C++语言中也有动态链接技术，库文件(．DLL)就是C++的动态链接库；选项C）错误，这两种语言都有类库，因为类是面向对象的最基本的概念；选项D）正确，跨平台的特性是Java语言所特有的，在不同的操作系统上，只要装有JVM就可以解释执行Java程序，而C++没有这种特性。
答案： D）
7．下列选项中，不属于Java语言特点的一项是（）。
A） 分布式B） 安全性
C） 编译执行D） 面向对象
解析：选项A）中，分布式计算是Java语言的一个重要特性，提供了在网络环境中的编程方法；选项B）中，安全性也是Java语言的一个重要特点，提供代码的安全机制，以及访问权限的检查等；选项D）中，Java是面向对象的一种编程语言，而不是面向过程的；选项C）中，Java语言是解释执行的，而不像C++是编译执行的。
答案： C）
8．在下列选项中，属于Java语言的代码安全检测机制的一项是（）。
A） 动态链接B） 访问权限的检查
C）通过接口实现多重继承D）将所有的Java应用都看做对象，按类进行封装
解析：选项A）错误，动态链接是JVM的一个重要特点；选项C）错误，接口是用来实现多重继承的一种方法，Java通过这种方法来提高类继承的灵活性和扩展性；选项D）错误，用类把Java的所有应用封装起来，是面向对象的基本思想；选项B）正确，访问权限是解释器在解释执行Java程序时进行检查的，属于Java安全机制。
答案： B）
9．下列选项中，不属于Java语言安全机制的一项是（）。
A) 语法检查B) 不允许使用指针
C) 代码参数类型合法性检查D) 对内存进行跟踪
解析：选项A）错误，语法检查是在编译Java程序时的代码安全检查，属于安全机制；选项B）错误，不允许使用指针，可以防止对内存的非法访问，属于安全机制；选项C）错误，代码参数类型的合法性是在解释执行Java程序时进行检测的，也属于安全机制；选项D）正确，对内存进行跟踪属于Java垃圾回收机制，不属于安全机制，因此正确答案是D）。
答案： D）
10．下面关于Java代码安全的说法哪一项是不正确的（）？
A） Java程序在解释执行时所需要的类都是通过字节码校验程序装入的
B） Java字节码的执行是由JVM中的编译器完成的
C）在Java程序运行时，首先装入字节码，然后进行校验，最后在解释器中执行
D） 在默认的安全配置条件下，Applet不能访问任何本地资源
解析：选项A），由于解释执行之前需要做字节码的校验，因此执行需要的类都是通过字节码校验程序装入的；选项C），解释和选项A）一样；选项D），体现了Java安全配置策略的一个重要的方面；选项B），应该是由JVM中的解释器完成的。
答案： B）
11．下列API不属于java．lang．Math类的一个是（）。
A） random()B） abs()
C） drawLine()D） sin()
解析：选项A），random()方法是java．lang．Math类中给出的求随机数的方法；选项B），abs()方法是java．lang．Math类提供的求绝对值的方法；选项D），sin()方法是java．lang．Math类提供的求正弦函数的方法；选项C），是Graphics类提供的画直线的方法。
答案： C）
12．阅读下列代码段，选出该代码段的正确的文件名（）。
class A{
void method1(){
System．out．println("method1 in class A");
}
}
public class B
void method2(){
System．out．println("method2 in class B");
}
public static void main(String args［］){
System．out．println("main() in class B");
}
}
A） A．javaB） A．class
C） B．classD） B．java
解析： Java源文件以．java为后缀，Java字节码文件以．class为后缀，而且Java源文件中只有一个public的类，该类的名字为源文件名，这里类B是以public修饰的，因此源文件名为B．java，正确答案应该是选项D）。
答案： D）
13．编译下面源程序会得到哪些文件？
class A1{ }
class A2{ }
public class B{ }
public static void main(String args［］){ }
A） 只有B．class文件B） 只有A1．class和A2．class文件
C） 有A1．class、A2．class和B．class文件D） 编译不成功
解析： Java语言一个源程序可以含有多个类，每个类编译都生成一个字节码文件。因此这里有3个类，应该有3个字节码文件。
答案： C）
14．在Java语言中，哪一个是最基本的元素？
A） 方法B） 包
C） 对象D） 接口
解析：作为面向对象的编程语言，Java语言中最基本的元素就是对象，一切概念都是以对象为基础的，因此选项C）为正确答案。
答案： C）
15．如果有2个类A和B，A类基于B类，则下列描述中正确的一个是（）。
A） 这2个类都是子类或者超类B） A是B超类的子类
C） B是A超类的子类D） 这2个类都是对方的子类
解析：定义其他类的类是超类，从某个已有类继承得到的类是子类。本题中，A类基于B类，因此，A类是子类，而B类是超类，选项B）为正确答案。
答案： B）
16．使用如下哪个保留字可以使只有在定义该类的包中的其他类才能访问该类？
A） abstract B） private
C） protectedD） 不使用保留字
解析：类的默认访问控制策略是不使用保留字来定义类，这会限制其他包中的类访问该类。protected保留字不起作用，原因是具有protected成员的类的子类可以在包外访问这些被保护的成员。因此正确答案应该是选项D）。
答案： D）
17．编译一个定义了3个类和10个方法的Java源文件后，会产生多少个字节码文件，扩展名是什么？
A） 13个字节码文件，扩展名是．class
B） 1个字节码文件，扩展名是．class
C） 3个字节码文件，扩展名是．java
D） 3个字节码文件，扩展名是．class
解析： Java程序的源文件扩展名为．java。在编译源文件之后，产生的是字节码文件，其扩展名为．class。而对于源文件中定义的每一个类都会有一个字节码文件与之对应，并且扩展名均为．class，这里有3个类，因此有3个字节码文件，正确答案是D）。
答案： D）
18．在创建Applet应用程序时，需要用户考虑的问题是（）。
A） 窗口如何创建B） 绘制的图形在窗口中的位置
C） 程序的框架D） 事件处理
解析： Applet类是所有Applet应用程序的基础，该类为Applet应用提供了程序框架，在创建Applet应用程序时，只需要在框架中填入相应的方法，至于窗口如何创建、事件处理如何进行都不需要用户考虑。用户只需要把注意力集中在如何在窗口中进行用户界面设计等问题上。
答案： B）
19．定义类头时能使用的修饰符是（）。
A） privateB） static
C） protectedD） abstract
解析：用于定义类头的修饰符可以是public、abstract、final或者是默认（friendly）。
答案： D）
二、填空题
1．Java语言中的是程序的基本单位。
解析： Java是面向对象的程序设计语言，对象是客观世界不同实体的抽象，类是某些具有共同属性的实体的集合，它是对象的抽象，即对于有相同属性和行为的对象，可以由一个类来定义。Java程序的最基本的组成就是类。
答案： 类
2．多线程是Java语言的机制，它能够处理同步共享数据和各种不同的事件。
解析： Java语言的开发运行环境都是互联网，在这种分布式的环境中，并发和共享是很常见的事务，要能并行地处理很多事务，就要求Java语言提供一种可靠和高效的机制，来满足高并发事务处理的需求。多线程很好地解决了网络上的瓶颈问题和大数量的网络访问问题。
答案： 并发
3．Java程序的编译和执行模式包括2点，是和。
解析： Java程序首先由编译器编译成字节码文件，然后再由JVM解释器解释执行字节码文件。由于编译和解释有先后，所以称为半编译和半解释，一般都认为Java语言是解释执行的。
答案： 半编译半解释
4．Java语言支持协议，从而使得Java程序在分布式环境中能够很方便地访问处于不同地点的。
解析： Java语言的一个重要特性就是支持分布式计算，在基于互联网的分布式环境中编写程序，就要求程序设计语言有强大的网络功能，因此必须支持TCP/IP协议。由于Java语言的基本单位是类，而类是对具有相同属性的对象的一种抽象，因此在网络中Java程序访问的应该是对象。
答案： TCP/IP对象
5．在Java语言中，类按照程序设计所需要的常用和接口封装成。
解析：将具有相同属性的对象抽象成类，在类中定义对象的各种共同属性和方法，然后对这些类进行分类并封装成包，包中还可以包含其他的包，从而生成一个树型的类结构层次。
答案： 方法包
5858
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
