1. java语言的一些试题
1. 属性 方法 public private
3. interface
4. main
5. 10 10
6. Applet
7. java.io
22. .java
1 D
2 C
3 A
4 C
5 A
6 A
9 A
10 B
11 D
12 A
13 A
20 B
21 D
22 A
23 B
24 C
25 B
14 Object
供参考
2. (特急)《Java程序设计》理论题库—判断题(要准确答案)
异常的抛出，就是将异常抛给异常处理器，暂时不去处理它。
摘要：《Java程序员面试指南》第7章异常处理及内存管理，本章讲述的是要想成功地成为一名合格的Java程序员，掌握好异常处理机制是编写大型程序必不可少的基本功。本节为大家介绍异常的处理方式之三：throw。
标签：throw Java 程序员 Java程序员面试指南
Oracle帮您准确洞察各个物流环节
7.4 异常的处理方式之三：throw（1）
异常的抛出，就是将异常抛给异常处理器，暂时不去处理它。本节主要讲解用throw抛出异常的方式，以及如何由try-catch来接收所抛出的异常。
当一个方法发生异常时可以通过throw关键字来抛出异常，把异常抛给它上一级的调用者，抛出的可以是异常引用，也可以是异常对象，它的语法格式如下：
throw 异常对象名; 或者
throw new 异常类名(); 一条throw语句一旦被执行，程序立即转入相应的异常处理程序段，它后面的语句就不再执行了（这一点类似于return语句），而且它所在的方法也不再返回有意义的值。在一个方法中，throw语句可以有多条，但每一次最多只能执行其中的一条。在一般情况下，throw语句都会写在判断语句块中，以避免每次都执行该语句。
【代码剖析】下面来看一个例子，也许从中你会明白点什么。具体代码如下：
public class catchThows { static int x; public static void main(String argv[]) { double a = Math.random() * 10; if (x > 0) System.out.println(a / x); else throw new Exception(); // 抛出异常 } public void setX(int x) { this.x = x; } } 运行结果如图7.1所示。
（点击查看大图）图7.1 运行结果
从上面的运行结果中可以看出，一个方法中如果使用throw来抛出异常，要么自己捕获它，要么声明抛出了一个异常。要声明抛出了异常，需要用throws关键字在方法的头部声明。如果我们将上面的代码修改成下面的代码，那么结果又会怎样呢？
public class catchThows_1 { static int x; public static void main(String argv[]) { new catchThows().setX(0); double a = Math.random() * 10; if (x > 0) System.out.println(a / x); else try { throw new Exception();// 抛出异常 } catch (Exception e) { System.out.println("出现异常的原因是："+e.getMessage()); } } public void setX(int x) { this.x = x; } } 运行结果如下：
出现异常的原因是：null 还有一种抛出异常的方法是让被调用的方法表示它将不处理异常，该异常将被抛出到它的调用方法中。这点是和throws声明异常很相似的，但它们的位置是完全不同的。具体代码如下：
public class catchThows_2 { void findThows() { try { //抛出方法 throw new ArithmeticException(); } catch(ArithmeticException ae) { throw ae; } } public static void main(String args[]) { catchThows ct=new catchThows(); //对方法进行异常处理 try { ct.findThows(); } catch(ArithmeticException ae) { System.out.println("出现异常的原因是:"+ae); } } } 运行结果如下：
出现异常的原因是:java.lang.ArithmeticException
【责任编辑：云霞 TEL：（010）68476606】
回书目 上一节 下一节
上一篇： 7.3 异常的处理方式之二：throws（2） 下一篇： 7.4 异常的处理方式之三：throw（2）
相关文章
·7.5 内存的管理（2）
·7.4 异常的处理方式之三：throw（2）
·17.3 Java高级编程试题（1）
·17.1 Java基础编程试题（6）
·17.1 Java基础编程试题（5）
频道热门
·自己动手写搜索引擎
·1.1.2 编写代码（15分钟）
·1.1.1 准备工作环境（10分钟）
·软件调试的艺术
·WCF编程（第2版）
3. JAVA网络编程基础试题！300分！请一定要帮我做一下，两个解答题。一个编程题，重点是编程题，谢谢了！！
2.网络搜索很详细
3.附件中的代码仅供参考
TcpSocketServerDemo.java
packageyaoshun.InetAddress;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;
/*
*客户端：TCP服务器端
*/
{
;//服务器连接
privateintport;//服务器监听端口
privateList<Socket>sockets;
privateintranNumber;
/**
*服务器结束的标志
*/
publicbooleanISEND;
publicTcpSocketServerDemo(intport){
this.port=port;
serverSocket=null;
sockets=newArrayList<Socket>();
ranNumber=newRandom().nextInt(50);
}
/*
*启动服务器
*/
publicvoidstarServer(){
try{
//第一步：建立服务器连接（绑定监听端口）
serverSocket=newServerSocket(port);
System.out.println("姚舜的服务器已经启动...");
Socketsocket;//客户端连接(如果建立连接时，本机网络不容或服务器程序未启动则会抛出异常)
ServerThreadserverThread;
Threadt2;
while(!ISEND){
//第二步：监听端口（获取客户端连接）
socket=serverSocket.accept();
if(ISEND){
while(!socket.isClosed()){
socket.close();
Thread.sleep(100);
}
}else{
sockets.add(socket);
serverThread=newServerThread(this,socket);
t2=newThread(serverThread);
t2.start();
}
}
for(Sockets:sockets){
s.close();
}
serverSocket.close();
}catch(Exceptione){
e.printStackTrace();
}
}
publicstaticvoidmain(String[]args){
TcpSocketServerDemotDemo=newTcpSocketServerDemo(1000);
tDemo.starServer();
}
/**
*校验
*
*@parami
*@return
*/
publicintcheck(inti){
if(i<ranNumber){
return-1;
}elseif(i>ranNumber){
return1;
}
return0;
}
}
/**
*服务端处理线程
*
*/
{
;
privateSocketsocket;
privateDataInputStreamdis;//输入流（读取数据）
privateDataOutputStreamdos;//输出流（发送数据）
publicServerThread(TcpSocketServerDemotDemo,Socketsocket){
super();
this.tDemo=tDemo;
this.socket=socket;
try{
dis=newDataInputStream(socket.getInputStream());
dos=newDataOutputStream(socket.getOutputStream());
}catch(IOExceptione){
e.printStackTrace();
}
}
publicvoidrun(){
Stringmessage="";
inti;
intindex=0;
intresult=0;
while(!message.equals("Quit")&&index<5){
try{
message=dis.readUTF();
}catch(IOExceptione){
e.printStackTrace();
}
try{
i=Integer.parseInt(message);
result=tDemo.check(i);
if(result==1){
dos.writeUTF("数字大了");
}elseif(result==-1){
dos.writeUTF("数字小了");
}
if(result==0){
dos.writeUTF("猜中了");
break;
}
}catch(NumberFormatException|IOExceptione){
continue;
}
index++;
}
try{
dis.close();
dos.close();
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
TcpSocketClientDemo.java
packageyaoshun.InetAddress;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjava.util.Scanner;
/*
*演示类：TCP客户端
*/
{
privateSocketsocket;//客户端连接(如果建立连接时，本机网络不容或服务器程序未启动则会抛出异常)
privateDataInputStreamdis;//输入流（读取数据）
privateDataOutputStreamdos;//输出流（发送数据）
//privateStringserverIP;//服务器IP地址
//privateintserverPort;//服务器监听端口
privateStringsendData;//发送的数据
publicTcpSocketClientDemo(StringserverIP,intserverPort)throwsUnknownHostException,IOException{
//this.serverIP=serverIP;
//this.serverPort=serverPort;
socket=newSocket(serverIP,serverPort);
dis=newDataInputStream(socket.getInputStream());
dos=newDataOutputStream(socket.getOutputStream());
sendData=null;
startClient();
}
publicvoidstartClient(){
try{
//第一步：创建客户端连接
System.out.println("===我的客户端界面===");
//第二步：客户端向服务器发送数据
inti=0;
Scannerinput=newScanner(System.in);
while(i<5){
System.out.println("请输入你的内容（客户端的）：");
sendData=input.nextLine();
if(sendData.equals("quit")){
break;
}
dos.writeUTF(sendData);
sendData=dis.readUTF();
System.out.println("接收到服务器内容："+sendData);
if(i==5){
System.out.println("超过允许次数,请重新连接服务器.");
}
if(sendData.equals("猜中了")){
i=5;
}
i++;
}
input.close();
}catch(Exceptione){
e.printStackTrace();
}finally{
//第四步：关闭输入流、输出流和客户端连接
try{
dis.close();
dos.close();
socket.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
publicstaticvoidmain(String[]args){
try{
newTcpSocketClientDemo("127.0.0.1",1000);
}catch(IOExceptione){
e.printStackTrace();
}
}
}
4. java基础面试题有哪些
下面是10道java基础面试题，后附答案
1.什么是 Java 虚拟机?为什么 Java 被称作是“平台无关的编程语言”?
Java 虚拟机是一个可以执行 Java 字节码的虚拟机进程。Java 源文件被编译成能被 Java 虚拟机执行的字节码文件。
Java 被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java 虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。
2.“static”关键字是什么意思?Java 中是否可以覆盖(override)一个 private 或者是static 的方法?
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
Java 中 static 方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用。
3.JDK 和 JRE 的区别是什么?
Java 运行时环境(JRE)是将要执行 Java 程序的 Java 虚拟机。它同时也包含了执行 applet 需要的浏览器插件。Java 开发工具包 (JDK)是完整的 Java 软件开发包，包含了 JRE，编译器和其他的工具(比如：JavaDoc，Java 调试器)，可以让开发者开发、编译、执行 Java 应用程序。
4.是否可以在 static 环境中访问非 static 变量?
static 变量在 Java 中是属于类的，它在所有的实例中的值是一样的。当类被 Java 虚拟机载入的时候，会对 static 变量进行初始化。如果你的代码尝试不用实例来访问非 static 的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。
5.Java 支持的数据类型有哪些?什么是自动拆装箱?
Java 语言支持的 8 中基本数据类型是：
byte
short
int
long
float
double
boolean
char
自动装箱是 Java 编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把 int 转化成 Integer，double 转化成 double，等等。反之就是自动拆箱。
6.Java 支持多继承么?
不支持，Java 不支持多继承。每个类都只能继承一个类，但是可以实现多个接口。
7.Java 中，什么是构造函数?什么是构造函数重载?什么是复制构造函数?
当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java 编译器会为这个类创建一个默认的构造函数。
Java 中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
Java 不支持像 C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java 不会创建默认的复制构造函数。
8.Java 中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思?
Java 中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。
9.接口和抽象类的区别是什么?
Java 提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
抽象类可以在不提供接口方法实现的情况下实现接口。
Java 接口中声明的变量默认都是 final 的。抽象类可以包含非 final 的变量。
Java 接口中的成员函数默认是 public 的。抽象类的成员函数可以是 private， protected 或者是 public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含 main 方法的话是可以被调用的。
10.什么是值传递和引用传递?
对象被值传递，意味着传递了对象的一个副本。因此，就算是改变了对象副本，也不会影响源对象的值。
对象被引用传递，意味着传递的并不是实际的对象，而是对象的引用。因此，外部对引用对象所做的改变会反映到所有的对象上。
最后祝你面试顺利！
5. 求一些JAVA数据结构的试题及答案解析
1 下列数据结构中，能用二分法进行查找的是__A____。
A、顺序存储的有序线性表 B、线性链表 C、二叉链表 D、有序线性链表 解析：二分法查找只适用于顺序存储的有序表。在此所说的有序表是指线性表中的元素按值非递减排列(即从小到大，但允许相邻元素值相等)。 2 在软件设计中，不属于过程设计工具的是__D____。 A、PDL(过程设计语言) B、PAD图 C、N-S图 D、DFD图 解析：软件设计工具包括：程序流程图、N-S、PAD、HIPO，判定表，PDL(伪码)。而DFD(数据流图)属于结构化分析工具。
3 在switch(expression)语句中，expression的数据类型不能是__A____。 A、double B、char C、byte D、short
解析：表达式expression只能返回这个几种类型的值：int、byte、short和char。多分支语句把表达式返回的值依次与每个case子句中的值相比较，如果遇到匹配的值，则执行该case子句后的语句序列。
4 下列叙述中，错误的是__D____。
A、父类不能替代子类 B、子类能够替代父类 C、子类继承父类 D、父类包含子类 5 通过继承实现代码复用：
Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法，子类可以重写父类的方法，及命名与父类同名的成员变量。 子类通过隐藏父类的成员变量和重写父类的方法，把父类的状态和行为改变为自身的状态和行为。注意：子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。
由于子类继承了父类所有的属性(私有的除外)，所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。
java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写)，则运行时系统调用父类的方法。
6 自定义表格类中的model部分应实现的接口是___A___。
A、AbstractTableModel B、JTable C、TableModel D、TableModelable 7 下列代码中，将引起编译错误的行是__B____。 1)public class Exercise{
2) public static void main(String args[]){ 3) float f=0.0; 4) f+=1.0; 5) } 6) }
A、第2行 B、第3行 C、第4行 D、第6行
解析：float定义变量赋值时，需要在数值后面加f以标识它为浮点型，让系统知道该给它精确到多少位。
6. Java基础面试题都有哪些
1.java异常机制的原理与应用x0dx0a答：每当程序出现异常之后，如果程序没有进行相应的处理，则程序会出现中断现象。x0dx0a实际上，产生了异常之后，JVM会抛出一个异常类的实例化对象，如果此时使用了try语句捕获的话，则可以进行异常的处理，否则，交给JVM进行处理。当try语句捕获异常之后，将与catch语句的异常类型进行匹配，如果匹配成功则执行catch内的语句。简单的应用：在所以throws语句的地方加入try-catch。标准应用：try-catch-finally-throw-throws一起使用。 x0dx0ax0dx0a2. 垃圾回收机制的优点x0dx0a答：释放无用的对象所占用的空间。方式：自动回收，手动回收。使用System.gc(),实际上调用Runtime.getRuntime().gc()x0dx0ax0dx0a3. Error与Exception区别x0dx0a答：Error是jvm进行处理，是jvm出错x0dx0aexception是可以由程序处理的，可以用try-catch捕获的x0dx0ax0dx0a4. final,finally,finallizex0dx0a答：final定义的变量的值不能改变，定义的方法不能被覆盖，定义的类不能被继承x0dx0afinally是异常的统一出口，finallize是垃圾回收前的收尾工作，是Object类定义的x0dx0ax0dx0a5. Anonymous Inner Class是否可以extends，是否可以implements Interfacex0dx0a答：允许继承和实现，因为匿名内部类就是在抽象类和接口的基础上发展起来的x0dx0ax0dx0a6. Static Nested Class 与Inner Class的区别x0dx0a答：使用Static定义的Class就是外部类，可以通过外部类. 内部类直接访问x0dx0a而Inner Class是不能被外部访问的，只能通过外部类的实例再找到内部类实例。x0dx0ax0dx0a7. HashMap and HashTable？x0dx0a答：HashMap:1) released in jdk 1.2,new Class 2)采用异步处理方式，性能较高，是非线程安全的 3）允许nullx0dx0aHashTable:x0dx0a1)released in jdk 1.0 ,old Class x0dx0a2)采用同步处理方式，性能低，是线程安全的x0dx0a3）不允许nullx0dx0ax0dx0a8. assert代表什么？x0dx0a答：asserts是jdk 1.4之后发布的新关键字，表示断言，即程序执行到某个地方肯定是预计的值，一般开发很少使用。要使用assert，必须加上 -ea参数x0dx0ax0dx0a9. gc是什么？x0dx0a答：gc是garbage collection，垃圾回收，使用gc可以进行垃圾空间的释放x0dx0ax0dx0a10. String s = new String("xyz")产生了几个对象？x0dx0a答：一个匿名对象xyz，在栈空间内。一个new实例化的对象，在堆空间内。x0dx0ax0dx0a11. sleep() and wait()?x0dx0a答：sleep()是Thread类定义方法，表示线程的休眠，可以自动唤醒x0dx0await()方法是Object类定义的方法，需要手动notify()和notifyAll()//sleep()不释放资源，wait()释放资源x0dx0ax0dx0a12. Overload与Override的区别x0dx0a答：Overload：重载x0dx0a |- 在一个类中定义的若干方法x0dx0a |- 所有的方法名相同，但参数类型或个数不同x0dx0a |- 只有参数有关，与返回类型无关x0dx0aOverride：覆写x0dx0a |- 在继承的关系中x0dx0a |- 子类定义了父类同名的方法，参数类型或个数最好完全一样。x0dx0a |- 访问权限不能更严格x0dx0ax0dx0a13. abstract class 和 interface有什么区别？x0dx0a答：抽象类：x0dx0a |-由抽象方法和常量、变量、全局常量、构造方法、普通方法组成x0dx0a |-使用abstract声明x0dx0a |-子类要通过extends继承抽象类，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法x0dx0a |-存在单继承的局限x0dx0a |-抽象类可以实现若干个接口x0dx0a接口：x0dx0a |-由抽象方法和全局常量组成x0dx0a |-使用interface关键字x0dx0a |-子类要通过implements实现接口，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法x0dx0a |-一个子类可以实现多个接口x0dx0a |-接口不能继承一个抽象类，但允许继承多个接口
7. Java基础面试题都有哪些
1.java异常机制的原理与应用
答：每当程序出现异常之后，如果程序没有进行相应的处理，则程序会出现中断现象。
实际上，产生了异常之后，JVM会抛出一个异常类的实例化对象，如果此时使用了try语句捕获的话，则可以进行异常的处理，否则，交给JVM进行处理。当try语句捕获异常之后，将与catch语句的异常类型进行匹配，如果匹配成功则执行catch内的语句。简单的应用：在所以throws语句的地方加入try-catch。标准应用：try-catch-finally-throw-throws一起使用。
2. 垃圾回收机制的优点
答：释放无用的对象所占用的空间。方式：自动回收，手动回收。使用System.gc(),实际上调用Runtime.getRuntime().gc()
3. Error与Exception区别
答：Error是jvm进行处理，是jvm出错
exception是可以由程序处理的，可以用try-catch捕获的
4. final,finally,finallize
答：final定义的变量的值不能改变，定义的方法不能被覆盖，定义的类不能被继承
finally是异常的统一出口，finallize是垃圾回收前的收尾工作，是Object类定义的
5. Anonymous Inner Class是否可以extends，是否可以implements Interface
答：允许继承和实现，因为匿名内部类就是在抽象类和接口的基础上发展起来的
6. Static Nested Class 与Inner Class的区别
答：使用Static定义的Class就是外部类，可以通过外部类. 内部类直接访问
而Inner Class是不能被外部访问的，只能通过外部类的实例再找到内部类实例。
7. HashMap and HashTable？
答：HashMap:1) released in jdk 1.2,new Class 2)采用异步处理方式，性能较高，是非线程安全的 3）允许null
HashTable:
1)released in jdk 1.0 ,old Class
2)采用同步处理方式，性能低，是线程安全的
3）不允许null
8. assert代表什么？
答：asserts是jdk 1.4之后发布的新关键字，表示断言，即程序执行到某个地方肯定是预计的值，一般开发很少使用。要使用assert，必须加上 -ea参数
9. gc是什么？
答：gc是garbage collection，垃圾回收，使用gc可以进行垃圾空间的释放
10. String s = new String("xyz")产生了几个对象？
答：一个匿名对象xyz，在栈空间内。一个new实例化的对象，在堆空间内。
11. sleep() and wait()?
答：sleep()是Thread类定义方法，表示线程的休眠，可以自动唤醒
wait()方法是Object类定义的方法，需要手动notify()和notifyAll()//sleep()不释放资源，wait()释放资源
12. Overload与Override的区别
答：Overload：重载
|- 在一个类中定义的若干方法
|- 所有的方法名相同，但参数类型或个数不同
|- 只有参数有关，与返回类型无关
Override：覆写
|- 在继承的关系中
|- 子类定义了父类同名的方法，参数类型或个数最好完全一样。
|- 访问权限不能更严格
13. abstract class 和 interface有什么区别？
答：抽象类：
|-由抽象方法和常量、变量、全局常量、构造方法、普通方法组成
|-使用abstract声明
|-子类要通过extends继承抽象类，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法
|-存在单继承的局限
|-抽象类可以实现若干个接口
接口：
|-由抽象方法和全局常量组成
|-使用interface关键字
|-子类要通过implements实现接口，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法
|-一个子类可以实现多个接口
|-接口不能继承一个抽象类，但允许继承多个接口