2014年java复习1

中级Java软件开发工程师笔试题（附答案） Java

—————————————–Part I ，总计70分—————————————————-

一、 单选题（共12题，每题2分，共24分）

1．下面关于Java的表述有错误的是_______D_

A．Java中没有sizeof操作符，所有数据类型的长度都是确定的，与平台无关。 B．在Java中，局部变量不会被自动初始化，需要显式的赋初值。 //类的成员变量会自动初始化，会有默认值。局部变量必须初始化

C．Java中的instanceof运算符，可以判断一个对象是否属于某个类的实例。

美

//

n. 例子，实例

instance ['?nst?ns] [??nst?n

s]

英

D．一个Java文件里可以有多个public类，但Java文件名必须和包含main方法的那个public类名精确一致。//一个java文件里只有一个public类

2．下面关于Java中static关键字的表述错误的是____B____

A．被static修饰的类成员变量在编译时由内存分配一块空间，直到程序停止运行才会被释放。

B．被static修饰的类方法只能访问其自身类未被static修饰的实例方法，而不能访问其他类的。//静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

C．被static修饰的类方法不能使用this关键字。//Static方法是类方法,先于任何的实例(对象)

存在。即Static方法在类加载时就已经存在了,但是对象是在创建时才在内存中生成。而this指代的是当前的对象。

D．在没有创建该类的对象时，该类中用static修饰的类方法就可以被调用。

static：★★★ 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3，静态随着类的加载而加载。而且优先于对象存在。

弊端：

1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2，静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。 3，静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。 4，主函数是静态的。

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？ 成员分两种： 1，成员变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：

如果是，那么该变量需要被静态修饰，因为是共享的数据。 如果不是，那么就说这是对象的特有数据，要存储到对象中。 2，成员函数。（方法中没有调用特有数据时就定义成静态） 如果判断成员函数是否需要被静态修饰呢？

只要参考，该函数内是否访问了对象中的特有数据： 如果有访问特有数据，那方法不能被静态修饰。

如果没有访问过特有数据，那么这个方法需要被静态修饰。

成员变量和静态变量的区别：

1，成员变量所属于对象。所以也称为实例变量。 静态变量所属于类。所以也称为类变量。 2，成员变量存在于堆内存中。

静态变量存在于方法区中。

3，成员变量随着对象创建而存在。随着对象被回收而消失。 静态变量随着类的加载而存在。随着类的消失而消失。 4，成员变量只能被对象所调用 。

静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

静态的注意：静态的生命周期很长。

静态代码块：就是一个有静态关键字标示的一个代码块区域。定义在类中。

作用：可以完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

Public：访问权限最大。

static：不需要对象，直接类名即可。 void：主函数没有返回值。 Main：主函数特定的名称。

(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。

jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 ? 构造代码块 ? 构造函数；

3．下面关于Java中abstract关键字的表述有错误的是_____B___

A．用abstract修饰不在类内实现的方法，称为抽象方法；抽象方法必须在子类派生时被重载。

B．用abstract修饰的类为抽象类；抽象类可以同时被static或final关键字修饰。 C．抽象类中不一定包含抽象方法，但包含抽象方法的类一定要声明为抽象类。 D．如果一个类被定义为抽象类，则该类不能进行实例化。 抽象类: abstract

抽象：不具体，看不明白。抽象类表象体现。

在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。

抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。 3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。 2：抽象类中是否可以定义非抽象方法？

可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final , private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

----------------------------------------------------------------------------------------------- 模板方法设计模式：

解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。 abstract class GetTime{

public final void getTime(){ //此功能如果不需要复写，可加final限定 long start = System.currentTimeMillis();

code(); //不确定的功能部分，提取出来，通过抽象方法实现 long end = System.currentTimeMillis();

System.out.println(\毫秒是：\ }

public abstract void code(); //抽象不确定的功能，让子类复写实现 }

class SubDemo extends GetTime{

public void code(){ //子类复写功能方法 for(int y=0; y<1000; y++){ System.out.println(\ } } }

4．下面关于Java中垃圾回收（gc）的表述有错误的是_______

A．在String str1 = “Hello”;String str2 = str1;str1 = null;中，对象”Hello”不会被垃圾回收。

B．调用Runtime.getRuntime().gc()会立即启动垃圾回收线程对当前程序进行垃圾回收。 C．调用Systmer.gc()只是提示垃圾回收器进行垃圾回收操作，但并不保证gc线程立即启动。

D．当垃圾回收器将要释放无用对象的内存时，先调用该对象的finalize()方法。

5．下面关于Java中接口(interface)的表述有错误的是______A__

A．在接口中定义的常量可以被多个类共享，具有public,final,static属性，可被任意类访问。 //只能被实现了该接口的类访问

B．接口中只对方法进行声明而没有实现体，而且用分号结尾，具有public和abstract属性 C．子接口中定义了与父接口同名的常量或者相同的方法，则父接口的常量被隐藏，方法被重写

D．实现接口的类必须实现接口和其父接口中的所有方法。 接 口：★★★★★

1：是用关键字interface定义的。

2：接口中包含的成员，最常见的有全局常量、抽象方法。

注意：接口中的成员都有固定的修饰符。 成员变量：public static final 成员方法：public abstract

interface Inter{

public static final int x = 3; public abstract void show(); }

3：接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 4：类与类之间存在着继承关系，类与接口中间存在的是实现关系。 继承用extends ；实现用implements ；

5：接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java

将多继承机制通过多现实来体现。

6：一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。

7：其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。

接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）

1：接口是对外提供的规则。 2：接口是功能的扩展。

3：接口的出现降低了耦合性。

抽象类与接口：

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

抽象类和接口的共性：都是不断向上抽取的结果。

抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都有抽象方法，需要子类去实现。 3：抽象类使用的是 is a 关系。

接口使用的 like a 关系。 4：抽象类的成员修饰符可以自定义。

接口中的成员修饰符是固定的。全都是public的。

在开发之前，先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。至于A是如何对规则具体实现的，B是不需要知道的。这样这个接口的出现就降低了A和B直接耦合性。

6．下面哪个方法不属于String类提供的_____D_ A．IndexOf() B．getChar2()

C．replace() //替代String里的某个字符 D．append() //StringBuffer类的方法

1.字符串串联(String Concatenation) var q =

from c in db.Customers select new {

c.CustomerID,

Location = c.City + \ };

语句描述：这个例子使用+运算符在形成经计算得出的客户Location值过程中将字符串字段和字符串串联在一起。

2.String.Length var q =

from p in db.Products

where p.ProductName.Length < 10 select p;

语句描述：这个例子使用Length属性查找名称短于10个字符的所有产品。

3.String.Contains(substring) var q =

from c in db.Customers

where c.ContactName.Contains(\ select c;

语句描述：这个例子使用Contains方法查找所有其联系人姓名中包含“Anders”的客户。

4.String.IndexOf(substring) var q =

from c in db.Customers select new {

c.ContactName,

SpacePos = c.ContactName.IndexOf(\ };

语句描述：这个例子使用IndexOf方法查找每个客户联系人姓名中出现第一个空格的位置。

5.String.StartsWith(prefix) var q =

from c in db.Customers

where c.ContactName.StartsWith(\ select c;

语句描述：这个例子使用StartsWith方法查找联系人姓名以“Maria”开头的客户。

6.String.EndsWith(suffix) var q =

from c in db.Customers

where c.ContactName.EndsWith(\ select c;

语句描述：这个例子使用EndsWith方法查找联系人姓名以“Anders”结尾的客户。

7.String.Substring(start) var q =

from p in db.Products

select p.ProductName.Substring(3);

语句描述：这个例子使用Substring方法返回产品名称中从第四个字母开始的部分。

8.String.Substring(start, length) var q =

from e in db.Employees

where e.HomePhone.Substring(6, 3) == \ select e;

语句描述：这个例子使用Substring方法查找家庭电话号码第七位到第九位是“555”的雇员。

9.String.ToUpper() var q =

from e in db.Employees select new {

LastName = e.LastName.ToUpper(), e.FirstName };

语句描述：这个例子使用ToUpper方法返回姓氏已转换为大写的雇员姓名。

10.String.ToLower()

var q =

from c in db.Categories

select c.CategoryName.ToLower();

语句描述：这个例子使用ToLower方法返回已转换为小写的类别名称。

11.String.Trim() var q =

from e in db.Employees

select e.HomePhone.Substring(0, 5).Trim();

语句描述：这个例子使用Trim方法返回雇员家庭电话号码的前五位，并移除前导和尾随空格。

12.String.Insert(pos, str) var q =

from e in db.Employees

where e.HomePhone.Substring(4, 1) == \ select e.HomePhone.Insert(5, \

语句描述：这个例子使用Insert方法返回第五位为 ) 的雇员电话号码的序列，并在 ) 后面插入一个 :。

13.String.Remove(start) var q =

from e in db.Employees

where e.HomePhone.Substring(4, 1) == \ select e.HomePhone.Remove(9);

语句描述：这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除从第十个字符开始的所有字符。

14.String.Remove(start, length) var q =

from e in db.Employees

where e.HomePhone.Substring(4, 1) == \ select e.HomePhone.Remove(0, 6);

语句描述：这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除前六个字符。

15.String.Replace(find, replace)

var q =

from s in db.Suppliers select new {

s.CompanyName, Country = s.Country

.Replace(\

.Replace(\ };

语句描述：这个例子使用 Replace 方法返回 Country 字段中UK 被替换为 United Kingdom 以及USA 被替换为 United States of America 的供应商信息。 7．在Java多线程中，调用下面哪种方法不会使线程进入阻塞状态？______B__ A．sleep()

B．suspend() //uspend() 和 resume() 方法:两个方法配套使用,suspend()使得线程进入阻塞状态,

并且不会自动恢复,必须其对应的resume() 被调用,才能使得线程重新进入可执行...

C．wait() D．yield()

//java之yield(),sleep(),wait()区别详解-备忘笔记

博客分类： java-->>线程

java线程sleep yieldrun start 1、sleep()

使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。 例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为

MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。

总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。 2、join()

join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。

加同步，解决安全问题；效率高吗？不高；怎样解决？通过双重判断的形式解决。

//懒汉式：延迟加载方式。 当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。

为了效率问题，通过双重判断的形式解决。 class Single{

private static Single s = null; private Single(){}

public static Single getInstance(){ //锁是谁？字节码文件对象； if(s == null){

synchronized(Single.class){ if(s == null)

s = new Single(); } }

return s; } }

---------------------------------------------------------

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。 1：将资源封装成对象。

2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

等待唤醒机制：涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。 notifyAll:唤醒的是线程池中的所有线程。

注意：

1：这些方法都需要定义在同步中。 2：因为这些方法必须要标示所属的锁。

你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？ 因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。 wait：线程会释放执行权，而且线程会释放锁。 Sleep：线程会释放执行权，但不是不释放锁。

线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。

怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。 第一种方式：定义循环的结束标记。 第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

---------< java.lang.Thread >---------- interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。 getPriority()：返回线程的优先级。

toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

join：临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

8．下面程序被编译运行时，下面哪些描述是正确的______C___。 class B{

public int f(int i){ return i+i; }

public int f(int i, int j){ return i+j; }

public int f(char c){ return c; } }

public class Test extends B{ public int f(int i, int j){ return super.f(i,j); }

public int f(int j){ return -j; }

public static void main(String[] args){ B x = new Test();

System.out.println(x.f(5,10)+” “+x.f(4)+” “+x.f(‘A’)); } }

A．编译不通过，B x = new Test() 出错，类型不匹配

B．编译不通过，原因是B.f(char c)，一个char类型不能直接当做int类型返回 C．编译通过，运行输出结果是15 -4 65 D．编译通过，运行输出结果是15 8 65

9．下面哪个类或接口定义了wait()、notify()、notifyAll()方法___C____ A．java.lang.Thread B．java.lang.Runnable C．java.lang.Object D．java.lang.TreadGroup

10．在Java API文档中，下面的哪部分未被包括在内__D_____ A．类的用途的描述 B．类层次

C．父类方法的列表 D．成员变量的列表

11．下面列出的修饰符中，哪一个用来修饰方法(method)要求此方法必须显式地获得某个对象才能执行____B____ A．final

B．synchronized C．static D．public

12．下面的各种异常中，哪种异常在一个方法中没有声明抛出此异常时也可以在其方法体中直接抛出_____D___

A．java.lang.ClassNotFoundException

B．java.lang.Exception

C．java.lang.NullPointerException D．java.ioException

二、 多选题（共5题，每题3分，共15分）

1．下面对操作系统中线程和进程的表述有错误的是___BD____

A．进程是程序的运行实例，它包含内存和资源，而线程是由进程进一步派生出来的一组代码的执行过程

B．每个进程都有一个主线程，还可以建立另外的线程。进程中的线程是并行执行的，每个线程占用CPU的时间由此进程来调度。

C．进程中的所有线程共享进程的虚拟地址空间，这意味着所有线程都可以访问进程的全局变量和资源。

D．进程中的每个线程的声明周期都在该进程中，每个线程都有自己的私有虚拟地址空间。

2．下面关于HashMap与Hashtable区别的表述正确的是__ABC____ A．HashMap与Hashtable采用的hash/rehas算法基本一致。

B．HashMap允许将null作为一个entry得key或value，而Hashtable不允许。 C．HashMap与Hashtable都是Map interface的实现。

D．Hashtable的方法是syncronized的，而HashMap不是，因此HashMap非线程安全 //--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。 |--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

Map集合：

|--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。 |--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。 Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。 特点：要保证map集合中键的唯一性。

1，添加。

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。 void putAll(Map); 2，删除。

void clear()：清空

value remove(key) ：删除指定键。 3，判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value) ：是否包含value 4，取出。

int size()：返回长度

value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。 Collection values()：获取map集合中的所有的值。 5，想要获取map中的所有元素： 原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

3．对于一个abstract的method，不能用下面哪个Java关键字同时修饰___D____ A．static B．native C．synchronized D．final

//final可以用于类名前，表示类不可被继承；final用于变量前，表示它是只能一次赋值的变量，如果初始化了那就是常量。

static可用于类内部的变量或方法前，表示这是整个类共享的变量和方法，与类对象无关。 abstract用于类名前表示一个抽象类，abstract用于成员方法前表示抽象方法，而抽象类内部至少要有一个抽象方法，这个跟final不能一起用，至于为什么，你一想就清楚了，抽象类本身必须有子类需要实现它的方法，但是final类又不能有子类，这不矛盾了么，所以不能一起用。

static final 用于修饰类的静态变量时表示一个常数，其实更多的还是用在接口里，毕竟用在类里面可能会被子类隐藏。

4．下面关于Java中Vector、ArrayList、LinkedList的表述正确的是____AC___ A．这三个类都实现了java.util.List接口，但只有Vector是线程安全的

B．ArrayList与Vector在从指定位置用index检索一个元素的时候，时间开销是O(1) C．LinkedList在插入、删除任意位置元素的时间开销都是O(1)，但它在索引一个元素的时候比较慢，为O(i)，其中i是索引的位置。

D．当向这几种类型中增加元素时，如果数目超出了其目前的长度，Vector缺省情况下自动增长原来一倍的长度，而ArrayList与LinkedList则增长50%的长度。//LinkedList是链表结构

//|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。

|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。 |--Vector：底层的数据结构就是数组，线程同步的，Vector无论查询和增删都巨慢。

5．在J2EE中，JSP可以使用下列哪些技术对客户端会话状态进行跟踪_____BD_____ A．建立匿名的表格字段 B．使用URL重写 C．使用持久化Cookies

D．使用session会话机制

三、 填空题（共5题，每题3分，共15分）

1．下面程序的运行结果为___XYAB______ public class Test{

public static void main(String[] args){ B obj = new B(); } } class A{

static {System.out.print(“X”);} public A(){System.out.print(“A”);} }

class B extends A{

static {System.out.print(“Y”);} public B(){System.out.print(“B”);} }

2．下面程序的运行结果为____XB_____ public class Test{

public static void main(String[] args) {

Sub obj = new Sub(); obj.print(); } }

class Base{

public String s = “X”; public void print() {

System.out.print(s); printAgain(); }

public void printAgain() {

System.out.print(“A”); } }

class Sub extends Base{ public String s = “Y”; public void printAgain()

{

System.out.print(“B”); } }

3．下面程序的运行结果为_____AC0___ public class Test{

static int func(int i, int j){ try{

return i/j;

}catch(ArithmeticException e){ System.out.print(“A”); return 0; }catch(Exception e){

System.out.print(“B”); return 0; }finally{

System.out.print(“C”); } }

public static void main(String[] args){

Thread cThread = new Thread(test.new B()); cThread.start(); }

class A extends Thread{ public void run() {

// TODO Auto-generated method stub for(int i=0;i<100;i++){ n++;

System.out.println(\+n); } } }

class B implements Runnable { @Override

public void run() {

// TODO Auto-generated method stub for(int i=0;i<100;i++){ n--;

System.out.println(\+n); } } }

}

//线程同步的话就是 public class Test{

private static int n=100;

public static void main(String[] args){ Test test = new Test(); A a = test.new A(); a.start();

Thread cThread = new Thread(test.new B()); cThread.start(); }

class A extends Thread{ public void run() {

// TODO Auto-generated method stub for(int i=0;i<100;i++){ synchronized(Test.class){ n++;

System.out.println(\+n); } } }

}

class B implements Runnable { @Override

public void run() {

// TODO Auto-generated method stub for(int i=0;i<100;i++){ synchronized(Test.class){ n--;

System.out.println(\+n); } } } } }

—————————————–Part II，总计30分————————————————–

一、选择题(共7题，每题2分，共14分) 1.下面哪个是java的关键字 B A NULL B new C instanceOf

D wend

2.下面语句哪个是正确的 A char s=’abc’; B long l=oxfff; C float f=0.45; D double d =0.8E-3;

3.public class ExampleStringBuffer {

public static void main(String[] args) {

StringBuffer sb = new StringBuffer(“mytest”); System.out.println(“buffer=” + sb); System.out.println(“length=” + sb.length()); } }

程序的运行结果中在“length=”后输出的值是 B A 10 B 6 C 20 D 30

4.在下列的整数数据类型中，需要内存空间最小的是 D A short B long

C int D byte

5. public class MyFor {

static boolean out(char input){ System.out.print(input); return true; }

public static void main(String arg[]){ int i=0;

for(out(‘A’);out(‘B’)&&i<2;out(‘C’)){ i++; out(‘D’); } } }

程序的运行结果是 A A ABDCBDCB B ABCDABCD C 程序编译时出错 D 程序运行时异常

6.在Eclipse中程序代码自动排版的热键是：C

A Ctrl+Shift+O B Ctrl+O C Ctrl+Shift+F D Ctrl+F

7.编译运行以下程序后，关于输出结果的说明正确的是 B public class Test{

public static void main(String args[ ]){ int x=6;

System.out.println(“value is “+ ((x>6) ? 99.9 :9)); } }

A、 输出结果为：value is 99.99 B、 输出结果为：value is 9 C、 输出结果为：value is 9.0 D、 编译错误

三、问答编程题(共5题，共16分)

1.spring配置文件中 (2分)

10000

10000

Period(時間)属性配置的含义是： Delay（延遲）属性配置的含义是：

2. http头中 transfer-encoding: chunked 的含义是？（2分）

//通常，HTTP协议中使用Content-Length这个头来告知数据的长度。然后，在数据下行的过程中，Content-Length的方式要预先在服务器中缓存所有数据，然后所有数据再一股脑儿地发给客户端。

如果要一边产生数据，一边发给客户端，WEB 服务器就需要使用\chunked\这样的方式来代替Content-Length。

3.写一程序将”张三”, “李四”, “王五” 按汉字拼音首字母排序 （4分） //public class TestDem {

public static void main(String arg[]){ Comparator cmp

=

Collator.getInstance(java.util.Locale.CHINA); String[] arr = {\张三\,\李四\,\王五\};

Arrays.sort(arr,cmp); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

4.写一段JAVA程序按一定格式输出系统当日期和时间。 （4分）

public static void main(String arg[]){ Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat(\年-MM月-dd日: HH时mm分SS秒\);

System.out.println(sdf.format(date)); }

5. 有一自然数满足如下条件 x%2=1 x%3=2 x%5=4 x%6=5 x%7=0 ，请写一java程序算出x值。 （4分）

public static void main(String arg[]){ boolean flag=true; int i=1; while (flag) {

if ((i%2==1)&&(i%3==2)&&(i%5==4)&&(i%7==0)) { System.out.println(i);

flag=false; }else { i++; } } }

本文来源：https://www.bwwdw.com/article/5rt7.html