JAVA_3

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

答案：不能.静态成员不能访问非静态成员.

对一个类而言,包含三种最常见的成员:构造器、属性、方法。类内各成员的定义顺序没有影响，各成员之间可以相互调用，但是，static修饰的成员不能修饰没有static修饰的成员。

还记得我说的，如果类A中有一个普通方法f()，那么编译器会隐式地把它转化为f(A this)吗？那你也还记得我说，static方法就是没有这个this的方法吗？

如果A中有两个普通方法f()和g()，那么编译器会隐式地把它们变成f(A this)和g(A this)。这样，在f方法里面调用g方法的时候，编译器就可以隐式地把f方法参数中的this传递给g方法。

然而，如果f方法是static的，而g方法是非static的，那么，f方法本身就没有this参数，所以它无法隐式地提供给g方法一个this参数，因此，f方法就不能直接调用g方法了。我们有一个解决的办法，就是在f方法中手动产生一个A的对象obj，然后把这个对象当作this参数传递给g方法(obj.g())，这样就可以调用g方法了，明白了吗？

其实还可以跟你说简单一点。普通方法是对象的方法，也就是说，普通方法的调用都是跟某一个具体的对象相关联的(this)，我们要用一个对象来调用它，它也可以改变这个对象属性；而静态方法是用作工具的方法，也就是说，它不跟任何对象相关联，它可以不通过对象来调用，它做的事情也不能改变任何对象的属性。明白了吗？

使用方法如下：

静态成员一般通过类名调用，也可以通过对象来调用，或者在所在类的其他方法( 可以是静态，也可以是非静态)里直接使用（不管如何调用，只要记住一点：同类所有对象共用同一个静态成员)。但是在静态方法里，只能直接访问静态成员，不能直接访问非静态成员。（要想在静态方法里访问非静态成员，可以实例该类的一个对象，然后在通过对象调用非静态成员。）非静态成员只能通过实例调用，别无他法。

只要记住一点：把static 成员和非静态成员彻底分隔开，他们各自作用不同，用法不同，之间没有任何联系

这个跟编译器的内存处理有关系，静态成员变量需要在一开始就分配内存进行初始化，而一般的类成员只是在类实例化的时候才会为止分配内存初始化，从方面来说，假如允许非静态类中有静态成员变量，如下面所示：

class A{

 public class B{

  static string var_a;

  }

}

那么在程序一开始就需要给A.B.var_a分配内存并初始化，假如这个成立了，那么A.B也应该会有相应的内存，但是由于B只是A的一个非静态成员变量，在类A还没有实例化的时候就以及有了相应的内存(也就是非静态成员变量只有在类的实例中才会有相应的内存位置)，这样跟原来的标准有冲突，假如JAVA编译器（或者JAVA虚拟机）支持这种做法（其实也是可以实现的），这有的后果会导致编译器混乱无序的，大大增加了编译器的难度和复杂性，每一种语言都有预先制定好的语言标准，相对应的编译器都是基于这种标准来实现的，假如随意突破这种标准，那只会导致灾难性的后果而已

我的理解，因为静态的东西是在编译的时候就要有内存空间的，但是不是静态的东西只有当实例化的时候才会分配空间，如果你在非静态方法里面包含了静态的东西，这个方法还没有去分配空间，怎么又能为里面的变量去分配空间呢，个人理解

JVM启动的时候要先把static的东西初始化 但此时外部类可能还没有被实例化所以会引起混乱

java的主函数写public和static的原因？

public使得该函数可以被外部（Java虚拟机）调用；

static使得该函数不需要任何对象便可直接被调用。

 

Java is not a C。下面一点是不同的。

static不能在方法中修饰变量，只能在类中申明使用！

把static intm=0;放在main()方法的上面 

static 是静态的,它所修饰的东西属于类,在程序加载的时候就分配内存,而方法在被调用的时候才分配内存,所以你把一个静态变量放到一个方法中是错误的

我们运行java程序使用的是java虚拟机。虚拟机启动之后，会在.class文件里面去找一个名为main的函数，然后运行它，我们的程序便运行了。

那么你想一想，这个main函数是在它所属的类的实例产生之前就被调用的，所以它只能是static的。另外，这个main函数是虚拟机来调用的，即是外部代码来调用的，所以它只能是public的。

然后，你也可以把这个函数声明为int返回值。但是虚拟机并不需要返回状态，所以它只会找返回值为void的main，如果你定义为int，则不会当作主函数被调用。

最后，函数参数是String类型的一个数组，这个数组也就是运行时的参数。args是型参名，可以随意。

2. 同一个文件里是否可以有两个public类?

答案：不能.同个源文件有多个公共类，编译器就找不到应该执行的main方法了

3. 方法名是否可以与构造器的名字相同? 答案：可以。

　public classTest //定义类，把类当成一种自定义数据类型，即，所有类是引用数据类型。（引用数据类型即是对一个对象的引用，即为指针。对象包括实例和数组。引用类型包括类、接口、数组和特殊的null类型）。类包含三种常见成员：构造器、属性、方法。

　　{

       publicString name; //属性用于定义该类或该类的实例所包含的数据。

       publicint age;

　　publicTest(String iceboy) 　　{ 　System.out.println(iceboy);　} //构造器用于构造该类的实例。Java通过new关键字来调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常将无法创建实例。Java中，如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器。系统提供的构造器总是没有参数的。

构造器名必须与类名相同。构造器不能定义返回值类型声明，也不能使用void定义构造器没有返回值，因为构造器的返回值为实例（new调用构造器时，生成实例），因此构造器的返回值类型总是当前类，因此无须定义。故，不能在构造器里显式使用return返回当前类对象，因为构造器的返回值是隐式的。

　　public voidTest(String iceboy)  {  System.out.println(iceboy); 　} //Test方法；方法用于定义该类或该类的实例的行为特征或功能实现。若无返回值必须void声明。如果声明了方法返回值类型，则方法体内必须有一个有效的return语句。

方法体内多条可执行语句之间有严格的执行顺序，排在前面的总是先执行。

　　publicstatic void main(String[] args)  //static修饰的成员表明它是属于这个类共有的，而不是属于该类的单个实例。

因此，通常把static修饰的属性和方法称为类属性、类方法（即是翻译过来的静态属性静态方法）。不使用static修饰的普通方法属性则只是属于该类的单个实例，通常称为实例属性、实例方法（即是翻译过来的对应的非静态属性非静态方法）。——静态成员不能访问非静态成员。

　　{

　　Test a = newTest("abc");//输出“abc” //创建对象的根本途径是构造器，too那个过new关键字来调用某个类的构造器即可创建这个类的实例。

　　a.Test("iceboy");//输出“iceboy” 　　} 　　}

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

答案：不会。

第一种方法：直接继承Thread类。

　　public classTest

　　{

　　publicstatic void main(String[] args)

　　{

　　ThreadClasst = new ThreadClass();

　　t.start();

　　System.out.println("end");//输出“end”

　　}

　　}

　　classThreadClass extends Thread //Thread类已经实现了空的run()方法。

　　{

　　}

第二种方法：实现Runnable接口

　public classTest

　　{

　　publicstatic void main(String[] args)

　　{

　　ThreadClasst = new ThreadClass();

　　Threadthread = new Thread(t);

　　thread.start();

　　System.out.println("end");

　　}

　　}

　　classThreadClass implements Runnable

　　{

　　public voidrun() //必须有此方法否则编译报错。它是Runnable接口中的抽象方法。

　　{

　　System.out.println("Threads");

　　}

　　}

4. 局部内部类是否可以访问非final变量?

答案：不能访问局部的，可以访问成员变量(全局的)。

　　class Out

　　{

　　privateString name = "out.name";

　　void print()

　　{

　　final Stringwork = "out.local.work";//若不是final的则不能被Animal 使用.

　　int age=10;

　　class Animal

　　//定义一个局部内部类.只能在print()方法中使用.

　　//局部类中不能使用外部的非final的局部变量.全局的可以.

　　{

　　public voideat()

　　{

　　System.out.println(work);//ok

　　//age=20;errornot final

　　System.out.println(name);//ok.

　　}

　　}

　　Animal local= new Animal();

　　local.eat();

　　}

　　}

5. 选择语句case中，允许使用的值有哪些?

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

6. Math,String是不可继承的。(final类)

Instanceof 后面跟的应该是OBJECT。

构造器可以是私有的。(private)

=与= =意义是完全不同的。一个是赋值，一个是等于。

全局变量可以不进行初始化，如果使用一个局部变量，则这个局部变量要被初始化。

7. 在try-catch-final块中的退出语句。

　public classTest

　　{

　　publicstatic void main(String[] args)

　　{

　　int a=1;

　　try

　　{

　　a=a/0;

　　}catch(Exceptione)

　　{

　　System.out.println("catch");

　　return;//当return时，finally中的语句会执行。

　　//System.exit(0);//若用上这句，finally中的语句不会执行。直接返回，退出程序。

　　}

　　finally //当没有System.exit(0);时，无论是否发生异常它都会执行。

　　{

　　System.out.println("finally");　　} 　　} 　　}

注：try-catch-final块的顺序不能调换。

8. 下面都是正确的main方法签名。

　public staticvoid main(String[] args)

　　publicstatic final void main(String[] args)

　　staticpublic void main(String[] args)

　　staticpublic synchronized void main(String[] args)

　　staticpublic abstract void main(String[] args)//错误

9. if(-0.0 == 0.0)是相等还是不等?　　答案：相等。

10.一个抽象类是否可以没有抽象方法?   答案：可以。

11.RandomAccessFile 类继承Object，并且实现了DataInput和DataOutput接口。答案正确

12.Collection与Collections的区别?

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

13.class Child extends Parents{}　　class Parents{}　　是否可以这样声明类，在一个文件中?

答案：可以。无所谓的。

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

　　String 是被初始化为 null,不是空字符。　　null,““,”“,都是不同的。

　“continue”只能在一个循环里(如for,do,while)，它不能在case语句中出现。

　　Primitive(int,char,long等)数组是不能互相赋值的，即使它们本身可以。

　　一个Constructor可以抛出任何异常。　初始化块是按照声明的顺序执行的。

　　所有关于 NaN(Nota Number) 和 non-NaN 的比较，都返回false. 这条很重要。

　　==会产生编译错误，如果两边类型不匹配的话。

　　equals() 返回 false 如果对象类型不同，但不产生 编译错误。

15.Java成员变量默认初始化的值。

成员变量类型 取值　　byte-0 short-0 int-0 long-0L

　　char-'u0000'float-0.0F double-0.0D boolean-false　　所有引用类型 null

16. integer和long 操作 /和% 的话，可能会抛出ArithmeticException，比如除0。但是 float与double不会，即使是除以0。

　doublea=0;a=a/0;则a等于NaN。

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

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

18.面向对象的特征有哪些方面 ?

答案：最基本特征：封装，继承，多态。

　其他特征：抽象关联，聚合，组合，内聚，耦合

19.String是最基本的数据类型吗? String 和StringBuffer的区别?

答案：String不是一最基本的数据类型。

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

　20.int 和 Integer 有什么区别

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

21.运行时异常与一般异常有何异同?

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

22.说出一些常用的类，包,接口，请各举5个?

答案：常用类-System,ArrayList,FileInputStream,Thread,Socket.

　常用的包-java.io,java.util,java.sql,java.javax.naming,java.net

　常用接口-Collection,Connection,Cloneable, Comparable, Serializable

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

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

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

　注：因为这4个线程共享J，所以线程类要写到内部类中。

　　加线程：每次对j加一。　　减线程：每次对j减一。

　public classTestThreads

　　{

　　private int j=1;

　　//加线程

　　privateclass Inc implements Runnable

　　{

　　public voidrun()

　　{

　　for(int i =0;i < 10;i++)

　　{ 　　inc(); 　　} 　　} 　　}

　　//减线程

　　privateclass Dec implements Runnable

　　{

　　public voidrun()

　　{

　　for(int i =0;i < 10;i++)

　　{ 　　dec(); 　　} 　　} 　　}

　　//加1

　　privatesynchronized void inc()

　　{

　　j++;

　　System.out.println(Thread.currentThread().getName()+"-inc:"+j);

　　} 　　//减1

　　privatesynchronized void dec()

　　{

　　j--;

　　System.out.println(Thread.currentThread().getName()+"-dec:"+j);　　}

　　//测试程序

　　publicstatic void main(String[] args)

　　{

　　TestThreadstest = new TestThreads();

　　//创建两个线程类

　　Threadthread = null;

　　Inc inc =test.new Inc();

　　Dec dec =test.new Dec();

　　//启动4个线程

　　for(int i =0;i < 2;i++)

　　{

　　thread = newThread(inc);

　　thread.start();

　　thread = newThread(dec);

　　thread.start();　　} 　　} 　　}

25.数组转换问题。

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;//不可以转换

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

　Server.java:源代码

　importjava.net.*; 　　importjava.io.*;

　　class Server

　　{

　　publicServer()

　　{

　　BufferedReaderbr = null;

　　PrintWriterpw = null;

　　try

　　{

　　ServerSocketserver = new ServerSocket(8888);//建立服务器端

　　Socketsocket = server.accept();//监听客户端

　　//得到该连接的输入流

　　br = newBufferedReader(new InputStreamReader(socket.getInputStream()));

　　//得到该连接的输出流

　　pw = newPrintWriter(socket.getOutputStream(),true);

　　//先读后写

　　String data= br.readLine();

　　System.out.println(data);//输出到控制台

　　pw.println(data);//转发给客户端

　　}catch(Exceptione) 　　{ 　　e.printStackTrace(); 　　}

　　finally

　　{

　　try

　　{ 　　//关闭读写流　　br.close(); 　　pw.close(); 　　}catch(Exception e) 　　{}

　　} 　　}

　　publicstatic void main(String[] args)

　　{ 　　Server server = new Server(); 　　} 　　}

Client.java:源代码

　import java.net.*; 　　import java.io.*;

　　class Client

　　{

　　publicClient()

　　{ 　　BufferedReader br = null; 　　PrintWriter pw = null;

　　try

　　{

　　Socketsocket = new Socket("localhost",8888);//与服务器建立连接，服务器要先启

　　//得到Socket的输入与输出流

　　br = newBufferedReader(new InputStreamReader(socket.getInputStream()));

　　pw = newPrintWriter(socket.getOutputStream(),true);

　　//先写后读

　　pw.println("Client:你好!"); 　　String data = null;

　　while(true) 　　{ 　　data = br.readLine(); 　　if(data!=null) break; 　　}

　　System.out.println(data);

　　}catch(Exceptione) 　　{ 　　e.printStackTrace(); 　　}

　　finally

　　{ 　　try 　　{ 　　br.close(); 　　pw.close(); 　　}catch(Exception e) 　　{}

　　} 　　}

　　publicstatic void main(String[] args)

　　{ 　　Client c = new Client(); 　　} 　　}

27.谈谈final, finally, finalize的区别。

答案：final 用于声明属性，方法和类，分别表示属性不可变,注意：如果是基本类型说明变　　量本身不能改变，如果是引用类型，说明它不能指向其他的对象了。但对象还是可以改变　　的。方法不可覆盖，类不可继承。　　

finally是异常处理语句结构的一部分，表示无论是否出现异常总是执行。

　　finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

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

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

29.Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

答案：StaticNested Class是被声明为静态(static)的内部类，它可以不依赖于外部类实例　　被实例化。而通常的内部类需要在外部类实例化后才能实例化。

30.&和&&的区别。

答案：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与(and).另外，&也可以用于逻辑运算，与&&的区别在于&是非短路运算符，&&是短路运算符

31.HashMap和Hashtable的区别。

答案：HashMap是Hashtable的轻量级实现(非线程安全的实现)，他们都实现了Map接口，

　　主要区别在于HashMap允许空(null)键值(key)与空值(value),由于非线程安全，效率上可能高于Hashtable,Hashtable不允许有空(null)键值(key)与空值(value)。

32.什么时候用assert?

答案：1.4新增关键字(语法)，用于测试boolean表达式状态，可用于调试程序。使用方法 assert ，表示如果表达式为真(true),则下面的语句执行，否则抛出AssertionError。

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

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

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

　　答案：两个，一个是对象，一个是对象的引用。

35.Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　答案：Math.round(11.5)==12　　Math.round(-11.5)==-11，总是返回接近0的数。

36.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

　答案：short s1 =1; s1 = s1 + 1; 有错(s1+1运算结果是int型，需要强制转换类型)

　　short s1 =1; s1 += 1;(没有错，s1==2)

37.sleep() 和 wait() 有什么区别?

　答案：sleep是线程类(Thread)的方法，导致此线程暂停执行指定时间(休息)，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复，时间到了会继续运行。调用sleep不会释放对象锁。

　　wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。

38.Java有没有goto语句?　　答案：没有

39.数组有没有length()这个方法? String有没有length()这个方法?

答案：数组没有length()这个方法，有length的属性。String有length()这个方法。(参见API)

40.数组是不是基本类型?　　答案：不是。

41.Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

答案：方法的重写Overriding和重载Overloading是Java多态性的不同表现。

　　重载Overload是一个类中多态性的一种表现，方法名必需相同,参数列表必需不同.(长度不同或类型不同),与返回值类型没有关系. 构造器也可以重载.方法名和参数列表都相同,只有返回类型不相同则是方法重复定义.编译出错. Overloaded的方法是可以改变返回值的类型。

　　重写Override是父类与子类之间多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

42.Set里的元素能重复吗?那么用什么方法区分是否重复?

答案：Set里的元素是不能重复的，如果重复就不加到里面。用iterator()方法来区分重复与否。应该首先equals()判断两个Set是否相等。

43.”==”与equal有何区别?

答案：“==”比较的是内存地址，equal比较的是内容本身。

equals()方法是用来检测两个对象的内容是否相等/  

而==的比较分两种：一种是比较基本数据类型，例如int,那么比较的就是基本数据类型的值；  

如果比较的是对象(引用数据类型),例如String,那么比较的是两个句柄是否指向内存中的同一个对象。!

44.给我一个你最常见到的runtime exception。

答案：IndexOutOfBoundsException数组越界BufferOverflowException

BufferUnderflowException  NegativeArraySizeException

NullPointerException 空指针异常　SystemException 系统异常

45.error和exception有什么区别?

答案：Error表示系统级的错误和程序不必处理的异常，我们无法处理它。

　Exception表示是可以捕捉或者需要程序进行处理的异常。

46.List, Set, Map是否继承自Collection接口?

答案：List，Set是。Map不是(C/p241)

48.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

答案：都不能。

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

答案：接口可以继承接口。接口间继承(extends),不能实现(implements)。

抽象类可以实现(implements)接口，但接口不能实现抽象类。抽象类间也用继承(extends)。

抽象类是否可继承实体类，但前提是实体类必须有无参的构造函数。

50.启动一个线程是用run()还是start()?有什么区别?

答案：启动一个线程是调用start()方法，这并不意味着线程就会立即运行，只是进入了可运行状态。直接调用run()方法不会产生线程，而是把它当作普通的方法调用，马上执行。

51.Constructor是否可被override?　　答案：不可以，但可以重载。

52. Class.forName的作用?　　答：调用该访问返回一个类名为指定字符串的类的对象。

53.文件读写的基本类有哪些?  答案：FileInputStream,FileOutputStread,File,IOException等。

54.写一个冒泡排序的程序。

public class Sort

{ 　　

public staticvoid main(String[] args)

　　{ 　　int[] array ={2,3,4,1,43,432,1,344,234,2,3,43,32,434,3432,43,2432,432,4,43};

　　int num = 0;

　　/*

　　冒泡排续

　　*/

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

　　/*

　　每下底一个元素，则调换的次数减一。　　注意：j

　*/

　　for(int j =0;j  　　{ 　　int temp =0;

　　/*

　　两两比较若前面的大于后面的则进行调换。

　　*/

　　if(array[j]> array[j+1])

　　{ 　　temp = array[j]; 　　array[j] = array[j+1]; 　　array[j+1] = temp; 　　} } 　　}

　　/*

　　输出排序后的数组

　　*/

　　System.out.println("****************已排序的数组********");

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

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

　　if(num ==5)//每行输出5个。

　　{ 　　System.out.println(); 　　num = 0; 　　} 　} 　　} 　　}

55.串行化的注意事项以及如何实现串行化?(Serializable)

1.串行化能保存的元素

串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。

2.transient关键字

对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的。例如一个Thread对象或一个FileInputStream对象 ，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。

另外 ，串行化可能涉及将对象存放到磁盘上或在网络上发达数据，这时候就会产生安全问题。因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。　　

56.线程的基本概念、线程的基本状态以及状态之间的关系

57.线程的同步、如何实现线程的同步?

58.几种常用的数据结构及内部实现原理。

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

60.Java的事件委托机制和垃圾回收机制

61.作用域public,private,protected,以及不写时的区别。

答案：private-类可见，不写-包可见　　protected-包可见，并子类可见 public-都可见

62.Java的国际化

63.怎样让程序到后台去运行?

64.怎么把一个文件中的东西做全文替换。

65.ArrayList和Vector的区别?

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

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

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

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

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

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

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

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

68.垃圾回收机制,如何优化程序?

69.float型float f=3.4是否正确?

答:不正确。类型不匹配,应该用强制类型转换，如下所示：float f=3.4f;

70. Java中异常处理机制，事件机制?

71.现在输入n个数字，以逗号，分开; 然后可选择升或者降序排序;

　importjava.util.StringTokenizer;

　　importjava.util.Arrays;

　　public classTest

　　{

　　publicstatic void main(String[] args)

　　{

　　String s ="2,654,24,6554,3234,3544,666,354,5435,11";

　　StringTokenizertok = new StringTokenizer(s,",");

　　//返回有多少个被分割元素

　　int count =tok.countTokens();

　　int[] result= new int[count];

　　//把分割得到的数字存到数组中去。

　　for(int i =0;i 

　　{ Stringtemp = (String)tok.nextElement(); 　　result[i] = Integer.parseInt(temp); 　　}

　　//排序

　　Arrays.sort(result);

　　for(int i =0;i 

　　{

　　if(i==0)

　　{System.out.print(result[i]); 　　continue;//第一个元素的前面不打印“，”　　}

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

　　} 　　System.out.println();//输出：2,11,24,354,654,666,3234,3544,5435,6554

　　} 　　}

72.金额转换，阿拉伯数字的金额转换成中国传统的形式如：

(￥1011)->(一千零一拾一元整)输出。

73.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

答案：能，一个对象的synchronized方法只能由一个线程访问。但其他线程可以同时访问这个对象的非synchronized方法

74.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

答案：会执行，在return前执行。

75.编程题: 用最有效率的方法算出2乘以8等於几? 有C背景的程序员特别喜欢问这种问题。

答案：2 <<3 。如果是2的10次方则是：1<<10.

76.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

答案：两个对象的值是否相同，根据的是equals方法，而hash code是由hashCode()方法决定。因此值相同的对象hash code可能不同。

77.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

答案：是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

78。编程题: 写一个Singleton出来。

　方式一：醉汉式

　public classSingleton

　　{

　　privatestatic Singleton test = new Singleton();//静态的。保留自身的引用。

　　//必须是私有的构造函数

　　privateSingleton(){}

　　publicstatic Singleton getInstance()//公共的静态的方法。

　　{ 　　return test; 　　} 　　}

　方式二：懒汉式

public class Singleton

　　{

　　privatestatic Singleton test = null;//静态的。保留自身的引用。

　　//必须是私有的构造函数

　　privateSingleton(){}

　　publicstatic Singleton getInstance()//公共的静态的方法。

　　{

　　if(test ==null)

　　{

　　test = newSingleton();

　　} 　　return test; 　　} 　　}

79.描述一下JVM加载class文件的原理机制?

80.试举例说明一个典型的垃圾回收算法?

81.请写一个java程序实现线程连接池功能?

82.给定一个C语言函数，要求实现在java类中进行调用。

83.编一段代码，实现在控制台输入一组数字后，排序后在控制台输出。

84.列出某文件夹下的所有文件;

85.实现从文件中一次读出一个字符的操作;

86.列出一些控制流程的方法;

87.多线程有哪些状态?

88.编写了一个服务器端的程序实现在客户端输入字符然后在控制台上显示，直到输入"END"为止，让你写出客户端的程序。

99.请用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来.

100.调用系统命令实现删除文件的操作;

101.C++或Java中的异常处理机制的简单原理和应用。

答案：当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

102.Java的接口和C++的虚类的相同和不同处。

答案：由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。

103.垃圾回收的优点和原理。并考虑2种回收机制。

答案：Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

104.描述一下你最常用的编程风格。

105.heap和stack有什么区别。

答案：栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。　　堆是栈的一个组成元素

106.Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

答案：NestedClass (一般是C++的说法)，Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。

　　注： 静态内部类(Inner Class)意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

107.JAVA类实现序列化的方法?在collection中，实现比较要实现什么样的接口?

答案：java类实现序列化需要实现java.io.Serializable接口。

　在collection中实现比较要实现java.lang.Comparable接口或java.util.Comparator接口。

108．抽象类和java接口的区别？

C++没有接口的结构，但是java接口非常类似于抽象类。

如果必须在没有接口的前提下开发程序，则可以像C++那样通过使用抽象类来达到目的。但是，作为一种独立的结构，接口在n层应用程序开发中扮演着至关重要的角色。

（设计模式）在使用上，没有非抽象方法的抽象类与接口非常类似：

A．一个类可以实现任意多个接口，但它最多只能扩展一个抽象类。

B． 一个抽象类可以含有若干个非抽象方法，而一个接口的所有方法都是抽象的，无论是否将它的方法显式声明为抽象的。（接口的方法总是公共的，无论是否显式声明）

C． 抽象类可以声明和使用字段；接口不能，尽管接口可以创建staticfinal常量。

D．抽象类方法的可见性修饰符可以使public、protected、private或者无修饰符（表示包内可见）；而接口方法的可见性修饰符只能是public。

E． 抽象类可以定义构造器；而接口不行。