应聘Java笔试时可能出现问题

Java基础方面:

1、作用域public,private,protected,以及不写时的区别

Public、Protected、Private是成员访问修饰符；

final、abstract、transient、synchronized、native、strictfp是非访问成员修饰符。

可见性PublicProtectedDefaultPrivate

同一个类是是是是

同一个包中的类是是是否

同一个包中的子类是是是否

同一包外的子类是是否否

同一包外的非子类是否否否

Java的基本包

java.lang 其中包含有：

接口：Comparable、Cloneable、Runable等

类：八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等

集合框架

集合是将多个元素组成一个单元的对象。集合用于存储、检索和操纵数据。

集合框架提供管理对象集合的接口和类。它包含几个组件，接口是表示集合的抽象数据类型，用于操纵集合；类是用于存储集合的实际数据对象；算法是用于操纵集合的。

2、ArrayList和Vector的区别,HashMap和Hashtable的区别

答：就ArrayList与Vector主要从二方面来说.

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的

二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

就HashMap与HashTable主要从三方面来说.

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一实现

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的

三.值：只有HashMap允许在一个集合中有一个null键和在一个集合中有多个null值

Hashtable是HashMap的同步版本；HashMap允许有null值和一个null键，但是，Hashtable不允许有任何内容为null

Hashtable类的对象必须覆盖Object类的hashCode()和equals()方法

关于其他集合类型：

一.ArrayList 提供快速遍历和快速访问。现在设计了新的 RandomAccess 接口，它指出这种列表支持快速随机访问。Vector也实现了RandomAccess 接口。

二.遍历HashSet与HashMap时，其顺序是未知的（但添加删除快）。LinkedHashSet和LinkedHashSet是按照元素的插入的顺序遍历的（遍历快）。

三．TreeSet和TreeMap将保证元素按照元素的自然顺序进行排列。也可以使用一个用户自己实现的比较规则。

四、HashSet有一个散列表支持它。它为基本操作提供固定时间性能。TreeSet它确保了排序集将按元素升序，根据自然顺序排序。

Dictionary类

主要用于将关键字转换成值，该类接收一个关键字并返回一个值。Dictionary是一个抽象类，它是H

Hashtable的超类。

Properties类

扩展了Hashtable类，但Properties对象的关键字和值必须是String类型，并能将对象写入一个输出流并保存在一个文件中，然后可以把它读回一个输入流。

如果需要维护和搜索一个部件列表，它们由唯一的字母数字序列号标示，其中的部件是Part类型，这时应该使用哪种集合？如果我们改变需求，你也需要能够按顺序、按它们的序列号打印出部件？

1、应该选择HashMap

2、应该选择TreeMap

3、char型变量中能不能存贮一个中文汉字?为什么?

答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

7、垃圾回收机制,如何优化程序?

当一个对象失去引用或者离开了作用域后，就成为垃圾而被Java运行环境自动清除，清除垃圾就是清除这些对象。

Java垃圾回收机制的特点是：

1、垃圾回收机制自动运行。系统提供一个低优先级的线程来跟踪内存的分配情况。如果发现某个内存单元不再使用，就清除它。

2、何时清除垃圾是不可预期的。

3、垃圾回收机制随JVM的不同而不同。

Java的垃圾搜索器为内存管理器提供一种自动解决方案。缺点是不能完全控制它什么时候执行以及什么时候不执行。

当垃圾搜集器运行时，其目的是查找和删除不能被访问的对象。

垃圾搜集器受JVM控制，JVM决定什么时候运行垃圾搜集器。从Java程序内可以请求JVM运行垃圾搜集器，但是，在任何情况下都无法保证JVM会答应你的请求。JVM通常会在它感到内存减少时运行垃圾搜集器。

垃圾收集器运行时，当它发现一个对象不能被任何活线程访问时，它将认为该对象符合删除条件，它可能在某时删除该对象。

垃圾收集器不能保证有足够的内存，它只能保证可以使用的内存将尽可能被有效的管理。

使对象符合垃圾搜集器搜索条件的情况有：出现空引用、重新为引用变量赋值、隔离引用。

强制执行垃圾搜集：

Runtime对象为直接与虚拟机通信提供一种机制。System类可以调用与其相同的方法。

请求垃圾收集器的最简单的方法是：System.gc();

Javac编译选项？

G产生调试信息

g:none不产生调试信息

verbose输出编译器消息，可以知道程序编译时用到了哪些Java类

Noware编译时不产生警告信息

encoding指出原文件的编码方式

D指定类文件产生的目录

classPath指出用户class文件的路径

sourcePath指出用户源文件路径

9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?

答：Collection FrameWork如下：

核心接口有：

CollectionSetSorted Set

ListMapSorted Map

Set接口：不允许重复的元素。它对add、equals、hashCode方法增加了限制

SortedSet接口：扩展了Set接口，此接口的元素按升序排序。

List接口：一些集合具有顺序，即在一个项目后添加另一个项目。列表可以有重复元素。提供了ListIterator，允许向前或向后移动元素。

Map接口：将键映射到值得对象。Map不能包含重复键，但可以包含重复值。每个键最多都只能映射到一个值。

核心设计类：

Map 设计Set 设计List 设计

HashMapHashSetArrayList

HashtableLinkedHashSetVector

TreeMapTreeSetLinkedLisk

LinkedHasMap

散列表是最快的数据存储结构，它是一个数组。数据存储在数组中散列函数指定的特定下标。散列函数是一组输入数据和一组整数之间的映射。

集合类和接口层次

Collections是一个类，带有用于处理集合的静态实用方法

Collection是一个接口，带有多数集合常用的方法声明，包括add、remove、contains、size、iterator

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）

Map提供key到value的映射

集合框架的优点：

提供一组可用的集合接口，可以方便地扩展或改写集合；

接口和算法的可重用性提高了软件的可重用性；

提供了有效的数据结构和算法，减少了编程工作。

10、Java中异常处理机制，事件机制？

事件代表了组件之间的交互。是一种在源对象和监听对象之间，某种状态发生变化的传递机制。

通过事件处理机制，可以让一些组件作为事件源，发出可被组件环境或其它组件接收的事件。这样，不同的组件就可以组合在一起，组件之间通过事件传递进行通信，构成一个应用。

在java中实现事件机制的事件模型由三个部分构成：一个事件对象用于描述事件源的状态变化；一个事件源将会产生事件，提供注册的事件监听器的方法，把事件发送到监听器；事件监听器接收事件通知，实现该事件的监听器接口。

异常实际上是程序中错误导致中断了正常的指令流的一种事件.

Java异常处理用于在方法中能检查出错误但不能处理错误的情况，在这样的方法中将抛出一个异常。如果一个异常与某个catch程序块中的参数匹配，那么就执行该catch块中的代码。指出try catch finally的工作顺序。

运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

事件有哪些？

什么是断言机制？

断言从JDK1.4版开始引入，它让开发期间测试假设，而没有付出为异常编写异常处理程序方面的代价，一旦程序完成开发，并全部部署，假设将从不会发生。

主要作用：因为在开发时对自己的假设非常肯定，所以不想花费时间来编写异常处理代码。断言让在开发期间测试你的假设。

private void method（int num）{

assert(num>=0）;//这里假定参数num是正数，如果不是真的将抛出一个AssertionError错误

useNum(num+x);

}

断言有两种形式：简单和非常简单。

非常简单：

private void doStuff（）{

assert(y>x);

//其他代码

}

简单：

将通过表达式的值向错误跟踪栈中添加更多信息，提供了更多调式帮助信息。

private void doStuff（）{

assert(y>x):”y is ”+y+” x is”+x;

//其他代码

}

运行时启用断言：

java –ea com.geeksanonymous.TestClass

运行时禁用断言：

java –da com.geeksanonymous.TestClass

11、JAVA中的多形与继承？

希望大家补上，谢谢

对象是定义了边界的、与要解决的问题有关的概念或事物。它们用于帮助理解现实世界。

类是拥有相同特性、共同的行为和共同的关系的一组对象。

封装是让开发者有选择地隐藏类中的特性和方法的过程

继承是允许通过重用现有类来构建新类的特性。]

多态性使用同一函数在不同的类上具有不同的行为。Java中的多态性是通过方法的动态绑定实现的。

12、抽象类与接口？

答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 都不能

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其他类或完成其他接口，在swing编程中常用此方式。

IO流

字节流：数据在存储时与传输时都是以字节为单位进行的。通常用于读写二进制数据，如图像和声音文件。

字符流：数据在存储与传输时都是以字符为单位进行的。

流：对数据源的一种抽象，其目的是想用统一的方式访问各种不同的数据源（文件、网络、内存的缓冲区）

文件读写的基本类：File类提供定位本地文件系统，描述文件和目录的功能。

管道流用于在线程之间通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter

线程1àPipedOutputStreamàPipedInputStreamà线程2

键盘输入：

try{

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String s=br.readLine();

System.out.println(s);

}catch(Exception e){

}

文件输入输出：

try{

File f=new File("test.txt");

FileOutputStream fout=new FileOutputStream(f);

fout.write(System.in.read());

fout.close();

FileInputStream fin=new FileInputStream(f);

int size=fin.available();

for(int i=0;i<size;i++){

System.out.print((char)fin.read());

}

fin.close();

}catch(Exception e){

}

通过网络传输文件：

客户端：

File f=new File("bk.exe");

FileInputStream fin=new FileInputStream(f);

Socket st=new Socket("localhost",6000);

BufferedOutputStream bout=new BufferedOutputStream(st.getOutputStream());

int size=fin.available();

for(int i=0;i<size;i++){

bout.write(fin.read());

}

服务器端：

ServerSocket server=new ServerSocket(6000);

Socket st=server.accept();

File f=new File("kk.exe");

BufferedInputStream bin=new BufferedInputStream(st.getInputStream());

FileOutputStream fout=new FileOutputStream(f);

int i=0;

while(i!=-1){

i=bin.read();

fout.write(i);

}

串行化的注意事项以及如何实现串行化

对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization)。

序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。

一：对象序列化可以实现分布式对象。

二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。

// 序列化 today's date 到一个文件中.

   FileOutputStream f = new FileOutputStream("tmp");

   ObjectOutputStream s = new ObjectOutputStream(f);

   s.writeObject("Today");

   s.writeObject(new Date());

   s.flush();

//从文件中反序列化 string 对象和 date 对象

   FileInputStream in = new FileInputStream("tmp");

   ObjectInputStream s = new ObjectInputStream(in);

   String today = (String)s.readObject();

   Date date = (Date)s.readObject();

记住，对象流不序列化static或transient。

序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。

如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流

NIO的特征

l旧的I/O是以字节为单位进行读写的，而新的I/O是以块为单位进行读写的

l以新的Channel抽象类来配合节点类

l使用Buffer的概念来进行基本数据类型的存取

l增加更多字节编码的支持

l内存映像及数据锁定的支持

l提供非阻塞的存取机制

l提供正则表达式式的验证机制

import java.io.*;

import java.nio.*;

import java.nio.channels.*;

import java.nio.channels.spi.*;

import java.net.*;

import java.util.*;

class NBTest {

NBTest(){}

public void startServer() throws Exception{

int channels = 0;

int nKeys = 0;

int currentSelector = 0;

Selector selector = Selector.open();

//建立Channel 并绑定到9000端口

ServerSocketChannel ssc = ServerSocketChannel.open();

InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),9000);

ssc.socket().bind(address);

//使设定non-blocking的方式。

ssc.configureBlocking(false);

//向Selector注册Channel及我们有兴趣的事件

SelectionKey s = ssc.register(selector, SelectionKey.OP_ACCEPT);

printKeyInfo(s);

while(true) //不断的轮询

{

debug("NBTest: Starting select");

//Selector通过select方法通知我们我们感兴趣的事件发生了。

nKeys = selector.select();

//如果有我们注册的事情发生了，它的传回值就会大于0

if(nKeys > 0){

debug("NBTest: Number of keys after select operation: " +nKeys);

//Selector传回一组SelectionKeys

//我们从这些key中的channel()方法中取得我们刚刚注册的channel。

Set selectedKeys = selector.selectedKeys();

Iterator i = selectedKeys.iterator();

while(i.hasNext()){

s = (SelectionKey) i.next();

printKeyInfo(s);

debug("NBTest: Nr Keys in selector: " +selector.keys().size());

//一个key被处理完成后，就都被从就绪关键字（ready keys）列表中除去

i.remove();

if(s.isAcceptable()){

// 从channel()中取得我们刚刚注册的channel。

Socket socket = ((ServerSocketChannel)s.channel()).accept().socket();

SocketChannel sc = socket.getChannel();

sc.configureBlocking(false);

sc.register(selector, SelectionKey.OP_READ |SelectionKey.OP_WRITE);

System.out.println(++channels);

}else{

debug("NBTest: Channel not acceptable");

}

}

}else{

debug("NBTest: Select finished without any keys.");

}

}

}

private static void debug(String s){

System.out.println(s);

}

private static void printKeyInfo(SelectionKey sk)

{

String s = new String();

s = "Att: " + (sk.attachment() == null ? "no" : "yes");

s += ", Read: " + sk.isReadable();

s += ", Acpt: " + sk.isAcceptable();

s += ", Cnct: " + sk.isConnectable();

s += ", Wrt: " + sk.isWritable();

s += ", Valid: " + sk.isValid();

s += ", Ops: " + sk.interestOps();

debug(s);

}

public static void main (String args[])

{

NBTest nbTest = new NBTest();

try{

nbTest.startServer();

}catch(Exception e){

e.printStackTrace();

}

}

}

Socket通信(TCP、UDP区别及Java实现方式)

套接字是一种进程间的数据交换机制。客户端和服务器通过套接字建立连接和进行通信。套接字是由IP地址、传输协议和一个端口号三部分组成的。

TCP/IP协议：其中TCP 为传输控制协议是传输层协议，

功能TCPUDP

数据传输连续的有序数据流消息传输

多路功能接收主机根据端口号决定数据流向那个应用相同

可靠传输使用TCP头部的序列与确认字段进行数据确认无

流量控制使用窗口机制的流量控制无

连接使用3次握手建立连接；连接后一直保持连接直到终止连接无连接

URL的组件：协议、IP地址或主机名、端口号和实际文件路径

import java.net.*;

import java.io.*;

public class DatagramServer{

public static DatagramSocket ds;

public static int clientport=1089,serverport=1090;

public static void main(String args[]) throws Exception{

byte buffer[]=new byte[1024];

ds=new DatagramSocket(serverport);

BufferedReader dis=new BufferedReader(new InputStreamReader(System.in));

System.out.println("服务器正等待输入");

InetAddress ia=InetAddress.getByName("localhost");

while(true){

String str=dis.readLine();

if(str==null||str.equals("end")){

break;

}

buffer=str.getBytes();

ds.send(new DatagramPacket(buffer,str.length(),ia,clientport));

}

}

}

import java.net.*;

import java.io.*;

public class DatagramClient{

public static DatagramSocket ds;

public static byte buffer[]=new byte[1024];

public static int clientport=1089,serverport=1090;

public static void main(String args[]) throws Exception{

ds=new DatagramSocket(clientport);

System.out.println("客户端正在等待服务器发送数据");

while(true){

DatagramPacket p=new DatagramPacket(buffer,buffer.length);

ds.receive(p);

String psx=new String(p.getData(),0,p.getLength());

System.out.println(psx);

}

}

}

13、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？

答:Server端程序:

package test;

import java.net.*;

import java.io.*;

public class Server {

private ServerSocket ss;

private Socket socket;

private BufferedReader in;

private PrintWriter out;

public Server() {

try {

ss=new ServerSocket(10000);

while(true) {

socket = ss.accept();

String RemoteIP = socket.getInetAddress().getHostAddress();

String RemotePort = ":"+socket.getLocalPort();

System.out.println("A client come in!IP:"+RemoteIP+RemotePort);

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

String line = in.readLine();

System.out.println("Cleint send is :" + line);

out = new PrintWriter(socket.getOutputStream(),true);

out.println("Your Message Received!");

out.close();

in.close();

socket.close();

}

}catch (IOException e) {

out.println("wrong");

}

}

public static void main(String[] args) {

new Server();

}

};

Client端程序:

package test;

import java.io.*;

import java.net.*;

public class Client {

Socket socket;

BufferedReader in;

PrintWriter out;

public Client() {

try {

System.out.println("Try to Connect to 127.0.0.1:10000");

socket = new Socket("127.0.0.1",10000);

System.out.println("The Server Connected!");

System.out.println("Please enter some Character:");

BufferedReader line = new BufferedReader(new

InputStreamReader(System.in));

out = new PrintWriter(socket.getOutputStream(),true);

out.println(line.readLine());

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

System.out.println(in.readLine());

out.close();

in.close();

socket.close();

}catch(IOException e) {

out.println("Wrong");

}

}

public static void main(String[] args) {

new Client();

}

};

常见排序法：

public class Sort{

public static int count=0;

public boolean LT(int num1,int num2){

return num1<num2;

}

public void output(int[] array){

System.out.print("第"+count+"次排序：");

for(int i=0;i<array.length;i++)

System.out.print(array[i]+"    ");

System.out.println();

}

//冒泡排序法

public void BubbleSort(int[] array){

boolean swap=true;

int index=0;

int i=0;

while(i<array.length-1){

int temp=array[i];

for(int j=i;j<array.length;j++){

if(!LT(array[i],array[j])){

int temp2=array[i];

array[i]=array[j];

array[j]=temp2;

swap=true;

index=j;

}else{

swap=false;

}

}

i++;

if(swap){

array[i]=array[index];

array[index]=temp;

i++;

}

output(array);

}

}

//直接插入排序法

public void InsertSort(int[] array){

for(int i=1;i<array.length;++i){

if (LT(array[i],array[i-1])){

int temp=array[i];

array[i]=array[i-1];

array[i-1]=temp;

for(int j=i-1;j>0;--j){

if(LT(array[j],array[j-1])){

array[j]=array[j-1];

array[j-1]=temp;

}else{

break;

}

}

output(array);

}

}

}

//快速排序法

private int Partition(int array[],int low,int high){

int temp=array[low];

int pivotkey=array[low];

while(low<high){

while(low<high&&array[high]>pivotkey)--high;

array[low]=array[high];

while(low<high&&array[low]<=pivotkey)++low;

array[high]=array[low];

}

array[low]=temp;

output(array);

return low;

}

public void QSort(int array[],int low,int high){

if(low<high){

int pivotloc=Partition(array,low,high);

QSort(array,low,pivotloc-1);

QSort(array,pivotloc+1,high);

}

}

void QuickSort(int array[]){

QSort(array,0,array.length-1);

}

public static void main(String args[]){

int array[]={49,38,65,97,76,13,27,49};

Sort sort=new Sort();

System.out.println("===================================");

sort.output(array);

System.out.println("优化冒泡排序法");

sort.BubbleSort(array);

System.out.println();

System.out.println("===================================");

array=new int[]{49,38,65,97,76,13,27,49};

sort.output(array);

System.out.println("直接插入排序法");

sort.InsertSort(array);

System.out.println();

System.out.println("===================================");

array=new int[]{49,38,65,97,76,13,27,49};

sort.output(array);

System.out.println("快速排序法");

sort.QuickSort(array);

}

}

14、如在COLLECTION框架中，实现比较要实现什么样的接口？

Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

什么是线程？

线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weight process）。一个进程中可以包含多个线程。

　　一个线程是一个程序内部的顺序控制流。

　　1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。

　　2. 线程：轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。

　　3. 多进程：在操作系统中，能同时运行多个任务程序。

4. 多线程：在同一应用程序中，有多个顺序流同时执行。

同步和异步有和异同，在什么情况下分别使用他们？

临界资源问题

线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。

我们需要做的是允许一个线程彻底完成其任务后，再允许下一个线程执行。必须保证一个共享的资源一次只能被一个线程使用。实现此目的的过程称为同步。

同步是用于确保资源一次只能被一个线程使用的过程。

同步对于单线程程序没有任何好处。使用同步比非同步的性能差三到四倍。

线程方法介绍：

构造函数：

Thread()

Thread(Runable target）

Thread(Runable target，String name）

Thread(ThreadGroup group,Runable target）

Thread(ThreadGroup group,Runable target,String name）

Thread(ThreadGroup group,String name）

用于完成一个线程“实际功能”的代码放在run方法中。Run方法可以在Thread的子类中重写，也可以在Runable对象中重写。

一旦线程死去，它就永远不能再重新启动，否则会抛出异常。用start方法启动一个已经启动的线程也会抛出异常。

isAlive、interrupt、Thread.currentThread、suspend、resume、stop

Sleep方法可以使低优先级的线程得到执行的机会，Yield方法只能使同优先级的线程有执行的机会。Join方法能够使调用该方法的线程在此之前执行完毕，在该方法之后，调用join方法的线程不会产生输出了，

Wait与notify使用时，需要注意的事项？

它们只能用于synchronized同步块中；

它们需要配对使用；

Wait一般出现在一个while循环中，while语句使用一个boolean标志控制。

死锁

当被锁定的A对象试图访问另一个被锁定的B对象，B对象同时又要访问已被锁定的A对象。这样导致两个线程都在等待另一个线程释放资源，这样就出现了死锁。

16、JAVA多线程编程。 用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。

希望大家补上，谢谢

17、STRING与STRINGBUFFER的区别。

答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

String s = new String("xyz");创建了几个String Object? 两个

JDBC调用数据库的基本步骤

Weblogic Server中的JDBC配置

1、建立到指定数据库的连接池Connection Pool

2、建立基于该连接池的数据源DataSource

3、访问数据库时通过数据源的JNDI名字查找到该数据源，然后通过数据源获得数据库连接对象。得到该对象后就可以依次生成数据库语句对象和结果集对象，进行相应的数据库操作。

import java.sql.*;

import javax.naming.*;

import javax.sql.*;

import java.util.*;

import javax.rmi.*;

public class DataSourceTest{

private static Context getInitialContext() throws Exception{

String url="t3://localhost:7001";

String user="system";

String password="11111111";

Properties properties=null;

try{

properties=new Properties();

properties.put(Context.INITIAL_CONTEXT_FACTORY,

"weblogic.jndi.WLInitialContextFactory");

properties.put(Context.PROVIDER_URL,url);

if(user!=null){

properties.put(Context.SECURITY_PRINCIPAL,user);

properties.put(Context.SECURITY_CREDENTIALS,

password==null?"":password);

}

return new InitialContext(properties);

}catch(Exception e){

throw e;

}

}

public static void main(String args[]){

UserTransaction tx=null;

DataSource ds=null;

Context ctx=null;

Connection myConn=null;

try{

ctx=getInitialContext();

tx=(UserTranscation)ctx.lookup("javax.transcation.UserTranscation");

tx.begin();

ds=(DataSource)ctx.lookup("myTxDataSource");

}catch(Exception e){

e.printStackTrace();

}

Statement myStatement=null;

ResultSet myResultSet=null;

try{

myConn=ds.getConnection();

myStatement=myConn.createStatement();

myResultSet=myStatement.executeQuery(

"select fullname from employee");

while(myResultSet.next()){

System.out.println(myResultSet.getString("fullname"));

}

tx.commit();

}catch(Exception e){

try{

tx.rollback();

}catch(Exception e){

}

}finally{

myStatement.close();

myConn.close();

}

}

}

JavaMail发邮件的步骤：

Properties props=System.getProperties();

props.put(“mail.smtp.host”,”*******”); //设置相关的属性

try{

    //创建一个会话对象

    Session session=Session.getDefaultInstance(props,null);

    //创建一个消息对象

    MimeMessage message=new MimeMessage(session);

    message.setText(“*****”); //发送文本格式的邮件

    message.setSubject(“*****”);

    message.setFrom(“*****”);

    message.addRecipient(Message.RecipientType.To,

                        new InternetAddress(“******”));

   //使用传送类的send方法发送消息

   Transport.send(message);

}catch(MessagingException me){

          me.printStackTrace();}

解析XML文件的几种方式和区别

XML解析器使用的两种基本API是:

文档对象模型DOM，一种基于树结构的API。它定义了一组java接口，用于创建、访问和操纵XML文档的内部结构。它是基于对象。整个XML文档被作为对象体系结构排列进行解析和存储，应用程序可以随机访问这些对象。

DOM主要用于：在结构上修改XML文档时；在内存中与其他应用程序共享文档时。

SAX提供一种用于解析XML文档的事件驱动模型，使用SAX接口的XML处理器并不创建数据结构，而是扫描输入的XML文档，并生成元素开始、元素结束等事件，在发生事件时，解析器会通知应用程序。

SAX优点：在解析大型文档时，不必将整个文件加载到内存中，因此占有的内存比DOM少。在只需要一个信息子集时，SAX忽略不需要的数据，而DOM无法做到这点。

SAX的缺点是：必须按到达顺序处理数据，不能对文档进行随即访问。SAX是只读的，它是设计来读取XML文档而不是写入的。文档只能遍历一次。

使用DOM API查找XML文档中的元素和属性

import org.w3c.dom.*;

import javax.xml.parsers.*;

import java.io.*;

import java.net.URL;

public class BookDetails{

public BookDetails(String filename){

Document doc=null;

try{

DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

dbf.setNamespaceAware(true);

DocumentBuilder db=dbf.newDocumentBuilder();

doc=db.parse(new File(filename));

String nm="<a href="List.jsp?page=<%=upPage%>">上一页</a>

<%

for(int j=1;j<=intPageCount;j++){

if(currentPage!=j){

%>

//显示所有页面的连接

<a href="list.jsp?page=<%=j%>">[<%=j%>]</a>

<%

}else{

out.println(j);

} //end of if

} //end of for

%>

<a href="List.jsp?page=<%=nextPage%>">下一页</a>

<a href="List.jsp?page=<%=intPageCount%>">最后页 </a>

Xml方面

2、你在项目中用到了xml技术的哪些方面?如何实现的?

答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。

3、用jdom解析xml文件时如何解决中文问题?如何解析?

答:看如下代码,用编码方式加以解决

package test;

import java.io.*;

public class DOMTest {

private String inFile = "c:\\people.xml";

private String outFile = "c:\\people.xml";

public static void main(String args[]){

new DOMTest();

}

public DOMTest() {

try {

javax.xml.parsers.DocumentBuilder builder =

javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();

org.w3c.dom.Document doc = builder.newDocument();

org.w3c.dom.Element root = doc.createElement("老师");

org.w3c.dom.Element wang = doc.createElement("王");

org.w3c.dom.Element liu = doc.createElement("刘");

wang.appendChild(doc.createTextNode("我是王老师"));

root.appendChild(wang);

doc.appendChild(root);

javax.xml.transform.Transformer transformer =

javax.xml.transform.TransformerFactory.newInstance().newTransformer();

transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");

transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");

transformer.transform(new javax.xml.transform.dom.DOMSource(doc),

new javax.xml.transform.stream.StreamResult(outFile));

} catch (Exception e) {

System.out.println (e.getMessage());

}

}

}

4、编程用JAVA解析XML的方式.

答:用SAX方式解析XML，XML文件如下：

<?xml version="1.0" encoding="gb2312"?>

<person>

<name>王小明</name>

<college>信息学院</college>

<telephone>6258113</telephone>

<notes>男,1955年生,博士，95年调入海南大学</notes>

</person>

事件回调类SAXHandler.java

import java.io.*;

import java.util.Hashtable;

import org.xml.sax.*;

public class SAXHandler extends HandlerBase {

private Hashtable table = new Hashtable();

private String currentElement = null;

private String currentvalue = null;

public void setTable(Hashtable table) {

this.table = table;

}

public Hashtable getTable(){

return table;

}

public void startElement(String tag, AttributeList attrs) throws SAXException {

currentElement = tag;

}

public void characters(char[] ch, int start, int length) throws SAXException {

currentvalue = new String(ch, start, length);

}

public void endElement(String name) throws SAXException {

if (currentElement.equals(name)) table.put(currentElement, currentvalue);

}

}

JSP内容显示源码,SaxXml.jsp:

<HTML>

<HEAD>

<title>剖析XML文件people.xml</title>

</HEAD>

<BODY>

<%@ page errorPage="ErrPage.jsp" contentType="text/html;charset=GB2312" %>

<%@ page import="java.io.*" %>

<%@ page import="java.util.Hashtable" %>

<%@ page import="org.w3c.dom.*" %>

<%@ page import="org.xml.sax.*" %>

<%@ page import="javax.xml.parsers.SAXParserFactory" %>

<%@ page import="javax.xml.parsers.SAXParser" %>

<%@ page import="SAXHandler" %>

<%

File file = new File("c:\\people.xml");

FileReader reader = new FileReader(file);

Parser parser;

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser sp = spf.newSAXParser();

SAXHandler handler = new SAXHandler();

sp.parse(new InputSource(reader), handler);

Hashtable hashTable = handler.getTable();

out.println("<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>");

out.println("<TR><TD>姓名</TD>" + "<TD>" +

(String)hashTable.get(new String("name")) + "</TD></TR>");

out.println("<TR><TD>学院</TD>" + "<TD>" +

(String)hashTable.get(new String("college"))+"</TD></TR>");

out.println("<TR><TD>电话</TD>" + "<TD>" +

(String)hashTable.get(new String("telephone")) + "</TD></TR>");

out.println("<TR><TD>备注</TD>" + "<TD>" +

(String)hashTable.get(new String("notes")) + "</TD></TR>");

out.println("</TABLE>");

%>

</BODY>

</HTML>

EJB方面

1、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?

答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDBC,JMS.....

2、EJB与JAVA BEAN的区别？

JavaBean是可复用的平台独立的软件组件，开发者可以在软件构造器工具中对其直接进行可视化操作。

Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

3、EJB的基本架构

答:一个EJB包括三个部分:

Remote Interface 接口的代码

package Beans;

import javax.ejb.EJBObject;

import java.rmi.RemoteException;

public interface Add extends EJBObject {

//some method declare

}

Home Interface 接口的代码

package Beans;

import java.rmi.RemoteException;

import jaax.ejb.CreateException;

import javax.ejb.EJBHome;

public interface AddHome extends EJBHome {

//some method declare

}

EJB类的代码

package Beans;

import java.rmi.RemoteException;

import javax.ejb.SessionBean;

import javx.ejb.SessionContext;

public class AddBean Implements SessionBean {

//some method declare

}

J2EE,MVC方面

1、MVC的各个部分都有那些技术来实现?如何实现?

答:MVC是Model－View－Controller的简写。设计的基本原理是将复杂性分解为三个组件，即模型、视图、控制器。

模型表示数据和处理数据的业务逻辑或应用程序对象。

试图是用户要查看或存取的数据的表示。

控制器定义了用户与模型和试图交互的方式。

2、应用服务器与WEB SERVER的区别？

Web Service 是一种新的分布式技术。一个Web服务本质上是一个应用组件，可以通过Web协议和数据编码机制，例如HTTP和XML，对这个组件进行访问。

Soap简单对象访问协议：

是一种基于XML的通信协议。它包括3个部分。

Soap封装结构：定义消息的XML格式，包括其整体框架、消息内容、由谁处理这些内容等。

Soap编程规则：定义如何将程序数据表示为XML。

Soap RPC表示：定义如何使用scap进行远程过程调用。

WSDL Web服务描述语言：

WSDL文件是一个XML文档，用于说明一组soap消息以及如何交换这些消息。还定义了服务的位置以及使用服务的通信协议等。

Uddi统一描述、发现和集成标准

是wed服务的黄页。它提供了用于服务注册的目录技术，并用它来建立Web服务的目录信息。UDDI的核心组件是UDDI商业注册，它使用一个XML文档来描述企业及所提供的Web服务。它包括3个部分：

白页：介绍提供服务的公司，包括名称、地址和联系方式等；

黄页：包括按照标准分类法进行分类的行业类别；

绿页：详细介绍，访问服务接口等技术信息。

Web服务是构建在soap（简单对象访问协议）、wsdl（web服务描述语言）、uddi（统一描述、发现和集成标准）3个开放的核心标准之上的。Soap用来进行Web服务通信的协议，WSDL用来进行说明和描述Web服务

由于Web服务完全基于XML的，使Web服务成为一个跨语言、跨平台、跨网络的可互操作的分布式应用软件的新平台。

3、J2EE是什么？

J2EE是sun公司推出的一个高层次的全方位、多功能的企业应用开发环境。它包括了当今软件工业界许多最新、最重要的软件技术。J2EE平台包含一整套的服务、应用程序接口和协议，是java技术企业级应用的整体解决方案。J2EE平台通过基于组件的应用程序模型大大简化了开发过程，同时还支持任何分布式体系和多层次的应用开发。随着越来越多的第三方对J2EE的支持和标准认证，J2EE已被广泛用来开发企业级应用软件、中间件和组件软件。

J2EE Java2平台企业版：

1、提供了基于组件的方式来设计、开发、组装和部署企业应用。

2、提供了一个多层次分布式的应用模型，包括了可复用的组件、基于XML数据交换、统一的安全模式以及灵活的事务控制。基于这些技术，可开发出满足市场要求的，基于平台无关的J2EE组件的解决方案。

3、J2EE平台使用的多层分布式应用模型中应用程序主要分为：客户层（Applet）、Web层（Servlet和JSP）、业务层（EJB）、企业信息系统层。

使用类库开发与使用框架包进行开发的区别？

框架包简单的可以认为是一组类和接口，它们相互协作以解决特定类型的软件问题。

类库包含的是应用程序可以调用的函数或例程。而框架包提供通用的、相互协作的组件，应用程序通过扩展这些组件提供特定函数组。应用程序将在这些扩展点进行扩展，运行时这些扩展将被框架系统反调用。这正与使用类库开发的应用程序，运行时的函数调用时颠倒的。

5、BS与CS的联系与区别。

传统的分布式应用程序都是基于Client/Server结构的，而近年来人们发现基于Client/Server结构的应用程序有很多缺点，比如：如果客户端的代码需要改变，那么所有机器上的客户端程序都要重新安装；如果某台机器有了不可修复的损坏，那么得去别的机器上重新安装客户端软件才能够使用。而基于Browser/Server结构的应用程序就没有以上的缺点了，我们可以使用任何一台有浏览器的机器来工作，而因为所有的程序逻辑都在服务器端，所以服务器端的代码变动不需要作为客户端的浏览器再做任何工作。

6、STRUTS的应用(如STRUTS架构)

答：Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：

一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。

二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。

三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

设计模式方面

1、开发中都用到了那些设计模式?用在什么场合?

答：人们在自己的环境中不断发现问题和寻找问题的解决方案的时候，发现有一些问题及其解决方案不断变换面孔重复出现，但在这些不同的面孔后面有着共同的本质，这些共同的本质就是模式。设计模式就是用来描述解决这些问题的解决方案的核心的。

工厂模式

专门负责将大量有共同接口的类实例化。工厂模式可以动态确定将那一个类实例化，不必事先知道每次要实例化那一个类。

简单工厂模式

或称静态工厂方法模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式就是由一个工厂类根据传入的参数决定创建那一种产品类的实例。

简单工厂模式涉及到工厂角色、抽象产品角色以及具体产品角色：l工厂类角色：含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象。l抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或它们共同拥有的接口。l具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例。

优点是：允许客户端相对独立于产品创建的过程，并且在系统引入新产品的时候无需修改客户端。缺点是：如果有新的产品加入到系统中去，就需要修改工厂类，将必要的逻辑加入到工厂类中。

工厂方法模式

或称多态性工厂模式。工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。它仅负责给出具体工厂子类必须实现的接口。这样可以用来允许系统在不修改具体工厂角色的情况下引进新的产品。

工厂方法模式涉及到的角色：l抽象工厂角色：它不包含应用逻辑。任何在模式中创建对象的工厂类必须实现这个接口。l具体工厂角色：含有与应用密切相关的逻辑，并且受到应用程序的调用以创建产品对象。l抽象产品角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。l具体产品角色：这个角色实现了抽象产品角色所声明的接口。

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

特点：单例类只能有一个实例；单例类必须自己创建自己的惟一的实例；单例类必须给所有其他对象提供这一实例。

多例模式

多例类可以有多个实例，并且多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。

在系统中可以用于数据库连接池、键值缓存等。

代理模式

给某个对象提供一个代理对象，并由代理对象控制对原对象的引用。

代理模式所涉及的角色：抽象主题角色：声明了真实主题和代理主题的共同接口，这样一来在任何可以使用真实主题的地方都可以使用代理主题角色。

名称

2、UML方面

UML包括的图有：案例图、类图、序列图、合作图、状态图、活动图、构件图、部署图。

类图中的关系有：

一般关系（类于类的继承关系、接口与接口的继承关系、类对接口的实现关系）；

关联关系：它使一个类知道另一个类的属性和方法。在java中，使用实例变量实现。

聚合关系：是整体与个体之间的关系。也是使用实例变量实现。

合成关系：是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。

依赖关系：总是单向的。表示一个类依赖于另一个类的定义。

3、软件的可维护性与可复用性

一个好的系统设计应该有如下性质：

可扩展性：新的性能可以很容易地加入到系统中。

灵活性：可以允许代码修改平稳地发生、而不会波及到很多其他的模块。

可插入性：可以很容易地将一个类抽出去，同时将另一个有同样接口的类加入进来。

在java中可以给出一个或多个抽象java类或java接口，规定出所有的具体类必须提供的方法特征作为系统设计的抽象层。这个抽象层预见了所有的可能扩展，因此，在任何扩展情况下都不会改变。

接口是实现构件的可插入性的关键。一个java接口是一些方法特征的集合，这些方法一般都是在系统经常出现的方法。一个接口只有方法的特征，没有方法的实现，因此在不同地方的该方法实现，可以具有不同的行为。

接口是对可插入性的保证：

因为在类的关联中，如果一个关联不是针对一个具体类的，而是针对一个接口的，那么任何实现这个接口的类就都可以满足要求。当前对象并不在意所关联的是哪个具体类，而仅仅关心这个类是否实现了某个接口。这样一来，就可以动态地将这个关联从一个具体类转换到另一个具体类，而这样做的唯一条件是它们都实现某个接口。

抽象类仅提供一个类型的部分实现。抽象类通常代表一个抽象概念，它提供一个继承的出发点。

javascript方面

1、如何校验数字型?

var re=/^\d{1,8}$|\.\d{1,2}$/;

var str=document.form1.all(i).value;

var r=str.match(re);

if (r==null) {

sign=-4;

break;

} else{

document.form1.all(i).value=parseFloat(str);

}

CORBA方面

什么是RMI？

Java RMI（Remote Method Invocation）--Java的远程方法调用是Java所特有的分布式计算技术，它允许运行在一个Java虚拟机上的对象调用运行在另一个Java虚拟机上的对象的方法，从而使Java编程人员可以方便地在网络环境中作分布式计算。面向对象设计要求每个任务由最适合该任务的对象执行，RMI将这个概念更深入了一步，使任务可以在最适合该任务的机器上完成。

RMI定义了一组远程接口，可以用于生成远程对象。客户机可以象调用本地对象的方法一样用相同的语法调用远程对象。RMI API提供的类和方法可以处理所有访问远程方法的基础通信和参数引用要求的串行化。

使用RMI开发步骤：

1、定义一个远程接口（远程接口必须继承接口，每个方法必须抛出远程异常，方法参数和方法返回值都必须是可序列化的）

2、实现远程接口

3、定义使用远程对象的客户程序

4、产生远程访问对象的桩和框

5、注册远程对象

6、运行服务器和客户程序

RMI和CORBA的区别？

远程方法调用（RMI）和CORBA都是分布式计算技术，在进行分布式时各有其优缺点，CORBA和RMI的区别。

　　CORBA（Common Object Request Broker Architecture）是OMG的Object Management Architecture（对象管理结构），它是面向对象的分布式系统建立所依据的标准。CORBA被设计成一个能供所有编程语言使用的一个开放性说明，就是说一个机器上的Java客户可以要求另一个用SmallTalk或C++的机器服务。正是由于这种语言的独立性使得CORBA这么灵活和吸引人。为了适应语言独立性，CORBA采用了非常通用的标准作为其接口。在不同的语言中，远程调用、签名和对象的引入有各自不同的定义，所以CORBA必须尽可能的中立和开放。正是这种通用性是CORBA的一个弱点。当开发人员都采用CORBA时，他们要用一种新的标准定义语言接口，它要求开发者学习新的编程接口，从而减小了远程模型的透明性。

　　RMI是为仅在Java对Java的分布式计算中而开发的。远程调用的标准是为了Java和应用Java的自然Java签名和调用而开发的，这使得RMI对Java的开发者相当透明而且易于实现。RMI用Java语言紧密集成从而同CORBA相比能够提供非常好的容错能力及对异常的处理。尽管Java的RMI标准不像CORBA那样语言独立，但Java本身是一个独立的平台，这就使RMI在跨平台的分布软件开发中是一个很好的选择。

　　RMI是Java语言在分布式计算上的基本模型，很多Java的分布式系统，包括我们本章要涉及的EJB，都是建立在RMI的思想上的。

基于IIOP协议的远程方法调用（RMI-IIOP）

RMI是一个分布对象系统，允许java对象与运行在其他虚拟机上的java对象进行交互。使得可以象访问本地对象一样访问远程对象；只要获得一个远程对象的引用，就可以把这个对象看作如同运行在同一虚拟机上那样来调用它的方法。但RMI是一个仅限于Java的分布式对象系统，这个系统使用了一个java特有的传输协议，即java远程方法协议（JRMP），在客户端和服务器之间进行信息传输。然而，这也意味着使用这种协议只能访问其他java对象，而无法访问非java对象。

远程方法调用的实际处理过程与CORBA的过程相似，即RMI使用客户端桩和服务器端框。要调用远程方法，客户端首先在桩上生成一个请求，然后将此请求传递给服务器，在服务器的框将请求转换成对远程对象的实际方法调用。客户端桩将远程方法的所有参数序列化后传递给服务器框，框将对参数反序列化。

但是由于这种协议不支持EJB需要的企业级交互，因为在这种类型的交互中必须通过远程方法调用来传递事务和安全环境。为此sun公司创建了RMI-IIOP即基于因特网内部对象请求代理协议之上的远程方法调用。IIOP是一个用在CORBA对象请求代理间进行通信的协议，在IIOP之上的RMI同时具有RMI和CORBA技术的特点。

LINUX方面

1、LINUX下线程，GDI类的解释。

答：LINUX实现的就是基于核心轻量级进程的"一对一"线程模型，一个线程实体对应一个核心轻量级进程，而线程之间的管理在核外函数库中实现。

GDI类为图像设备编程接口类库。