JAVA面试题1

1、在main(String[] args)方法内是否可以调用一个非静态方法？

答案：不能【public static void main(String[] args){}】

2、同一个文件里是否可以有两个public类？

答案：不能

3、方法名是否可以与构造器的名字相同？

答案：可以。
public class Test{
public Test(String iceboy){
System.out.println(iceboy);
}
public void Test(String iceboy){
System.out.println(iceboy);
}
public static void main(String[] args){
Test a = new Test("abc");//输出“abc”
a.Test("iceboy");//输出“iceboy”
}
}

4、 初始化一个没有run()方法的线程类,是否会出错？

答案：不会。
第一种方法：直接继承Thread类。
public class Test{
public static void main(String[] args){
ThreadClass t = new ThreadClass();
t.start();
System.out.println("end");//输出“end”
}
}
class ThreadClass extends Thread{
//Thread类已经实现了空的run()方法。
}
第二种方法：实现Runnable接口
public class Test{
public static void main(String[] args){
ThreadClass t = new ThreadClass();
Thread thread = new Thread(t);
thread.start();
System.out.println("end");
}
}
class ThreadClass implements Runnable {
public void run(){
//必须有此方法否则编译报错。它是Runnable接口中的抽象方法。
System.out.println("Threads");
}
}

5、局部内部类是否可以访问非final变量？

class Out{
private String name = "out.name";
void print(){
final String work = "out.local.work";//若不是final的则不能被Animal 使用.
int age=10;
class Animal{
//定义一个局部内部类.只能在print()方法中使用.
//局部类中不能使用外部的非final的局部变量.全局的可以.
public void eat(){
System.out.println(work);//ok
//age=20;error not final
System.out.println(name);//ok.
}
}
Animal local = new Animal();
local.eat();
}
}

6、选择语句case中，允许使用的值有哪些？

答案：int,short,char,byte(都在int范围之内，且是整数)

7、Math,String是不可继承的。（final类）

Instanceof 后面跟的应该是OBJECT。
构造器可以是私有的。（private）
=与==意义是完全不同的。一个是赋值，一个是等于。
全局变量可以不进行初始化，如果使用一个局部变量，则这个局部变量要被初始化。

8、在try-catch-final块中的退出语句。

public class Test{
public static void main(String[] args){
int a=1;
try{
a=a/0;
}catch(Exception e){
System.out.println("catch");
return;//当return时，finally中的语句会执行。
//System.exit(0);//若用上这句，finally中的语句不会执行。直接返回，退出程序。
}finally{
//当没有System.exit(0);时，无论是否发生异常它都会执行。
System.out.println("finally");
}
}
}
注：try-catch-final块的顺序不能调换。

9、下面都是正确的main方法签名。

public static void main(String[] args)
public static final void main(String[] args)
static public void main(String[] args)
static public synchronized void main(String[] args)
static public abstract void main(String[] args)//错误

10、if(-0.0 == 0.0)是相等还是不等？

答案：相等。

11、一个抽象类是否可以没有抽象方法？

答案：可以。

12、RandomAccessFile 类继承Object，并且实现了DataInput和DataOutput接口。

答案：正确

13、Collection与Collections的区别？

答案：Collection是一个接口，但 Collections却是一个辅助类，里面有很多静态的工具方法。而且很有用的。如：reverse(List list)；sort(List list, Comparator c)等。Collections没有实现任何接口。它直接继承了Object。

14、class Child extends Parents{} class Parents{}是否可以这样声明类，在一个文件中？

答案：可以。

15、 数组，无论是当前的，还是类等级的，都会被初始化。

String 是被初始化为 null,不是空字符。
null,““,” “,都是不同的。
“continue”只能在一个循环里(如for,do,while)，它不能在case语句中出现。
Primitive(int,char,long等)数组是不能互相赋值的，即使它们本身可以。
一个Constructor可以抛出任何异常。
初始化块是按照声明的顺序执行的。
所有关于 NaN(Not a Number) 和 non-NaN 的比较，都返回false. 这条很重要。
==会产生编译错误，如果两边类型不匹配的话。
equals() 返回 false 如果对象类型不同，但不产生编译错误。

16、Java成员变量默认初始化的值。

成员变量类型        取值
byte              　　 0
short　　　　　　  0
int　　　　　　　　0  
long　　　　　　　0L
char 　　　　　　 '\u0000'
float　　　　　    0.0F
double　　　　    0.0D
boolean　　　　   false

17、integer和long 操作 /和% 的话， 可能会抛出ArithmeticException，比如除0。

float与double不会，即使是除以0。
double a=0;a=a/0;则a等于NaN。【 NaN，是Not a Number的缩写】

18、普通内部类不可以拥有静态变量，但静态内部类可以。

File类没有任何处理文件内容的方法。
 InputStream 和 OutputStream 是抽象类,DataInput和DataOutput是接口。DataInputStream实现了DataInput接口。

19、面向对象的特征有哪些方面 ？

答案：最基本特征：封装，继承，多态。
　　　其他特征：抽象关联，聚合，组合，内聚，耦合

20、String是最基本的数据类型吗? String 和StringBuffer的区别？

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

21、int 和 Integer 有什么区别

答案：int是基本类型。Integer是引用类型。Integer可以把String转换成int。

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

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

23、说出一些常用的类，包,接口，请各举5个？

常用类-System,ArrayList,FileInputStream,Thread,Socket.
常用的包-java.io,java.util,java.sql,java.javax.naming,java.net
常用接口-Collection,Connection, Cloneable, Comparable, Serializable

24、说出ArrayList,Vector, LinkedList的存储性能和特性.

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

25、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

注：因为这4个线程共享J，所以线程类要写到内部类中。
加线程：每次对j加一。
减线程：每次对j减一。
public class TestThreads{
private int j=1;
//加线程
private class Inc implements Runnable{
public void run(){
for(int i = 0;i < 10;i++){
inc();
}
}
}
//减线程
private class Dec implements Runnable{
public void run(){
for(int i = 0;i < 10;i++){
dec();
}
}
}
//加1
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
//减1
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
//测试程序
public static void main(String[] args){
TestThreads test = new TestThreads();
//创建两个线程类
Thread thread = null;
Inc inc = test.new Inc();
Dec dec = test.new Dec();
//启动4个线程
for(int i = 0;i < 2;i++){
thread = new Thread(inc);
thread.start();
thread = new Thread(dec);
thread.start();
}
}
}

26、数组转换问题

Object[] object = new Person[2];
Person [] person = new Person [3];
person = (Person [])object;//可以转换
int[] i = new int[2];
long[] l = new int[3];
i = (long[])l;//不可以转换

27、用socket通讯写出客户端和服务器端的通讯，要求客户发送数据后能够回显相同的数据。

Server.java:源代码
import java.net.*;
import java.io.*;
class Server{
public Server(){
BufferedReader br = null;
PrintWriter pw = null;
try{
ServerSocket server = new ServerSocket(8888);//建立服务器端
Socket socket = server.accept();//监听客户端
//得到该连接的输入流
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//得到该连接的输出流
pw = new PrintWriter(socket.getOutputStream(),true);
//先读后写
String data = br.readLine();
System.out.println(data);//输出到控制台
pw.println(data);//转发给客户端
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭读写流
br.close();
pw.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args){
Server server = new Server();
}
}
Client.java:源代码
import java.net.*;
import java.io.*;
class Client{
public Client(){
BufferedReader br = null;
PrintWriter pw = null;
try{
Socket socket = new Socket("localhost",8888);//与服务器建立连接，服务器要先启，得到Socket的输入与输出流
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
pw = new PrintWriter(socket.getOutputStream(),true);
//先写后读
pw.println("Client:你好！");
String data = null;
while(true){
data = br.readLine();
if(data!=null) break;
}
System.out.println(data);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
br.close();
pw.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args){
Client c = new Client();
}
}

28、final, finally, finalize的区别

答案：final用于声明属性，方法和类，分别表示属性不可变,注意：如果是基本类型说明变量本身不能改变，如果是引用类型，说明它不能指向其他的对象了。但对象还是可以改变的。方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示无论是否出现异常总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。