面试题

1介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)? 
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

2.抽象类与接口？

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

如果要设计小而简练的功能块，则使用接口。如果要设计大的功能单元，则使用抽象类。

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

内部类的实现方式:

package com.test;

public class OuterClass

{

    static int a ;

    int b ;

    private class InnerClass

    {

        public InnerClass()

        {

            System.out.println("InnerClass create:" + a);

        }

    }

    public OuterClass()

    {

        InnerClass ic = new InnerClass();

        System.out.println("OuterClass create");

    }

    public static void main(String[] args)

    {

        OuterClass oc = new OuterClass();

    }

}

总结:

一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；

三.非静态内部类的非静态成员可以访问外部类的非静态变量

4.package com.test;

 

public class Parent

{

    //1

    static int a =  1;

    //2

    static

    {

        a = 10;

        System.out.println("parent static code");

    }

    //4

    public Parent()

    {

        System.out.println("Parent constructor");

        System.out.println("Parent a=" + a);

    }

   

    public static void main(String[] args)

    {

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

        Parent c = new Child();

    }

}

 

class Child extends Parent

{

    static int a = 2;

    //3

    static

    {

        a = 20;

        System.out.println("child static code");

    }

    //5

    public Child()

    {

        System.out.println("Child constructor");

        System.out.println("Child var a=" + a);

    }

   

}

输出结果:

parent static code

child static code

***************

Parent constructor

Parent a=10

Child constructor

Child var a=20

 

由此可看出在还没有实例化类的时候(注意*号)已经执行了static代码块。

顺序是先父类后子类.

然后才调用父类的构造方法,再调用子类的构造方法.就是这个顺序了.

 

 

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

答：区别如下：

作用域           当前类       同一package       子孙类       其他package

public            √              √                √             √

protected        √              √                √             ×

friendly          √              √                ×             ×

private           √              ×                ×             ×

不写时默认为friendly

 

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

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

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

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

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

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

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

三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

 

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

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

 

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

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

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

Sleep()与wait()的区别？（主动与被动）

sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.。

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处继续执行.

sleep就是睡自己的觉，让别人吵吵去（睡到定点醒）

wait就是等电话，电话来了立刻接，其它时间也在睡（睡到有人叫）

其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

 

9. public class Test2

{

    public static void main(String[] args)

    {

        float a = 3.4;

    }

 

}

这个简单的程序能不能编译通过呢？

其实是不能的。

原因是精度问题，应该用强制类型转换.

float a = (float)3.4;

 

再来看看这个能不能编译通过

public class Test2

{

    public static void main(String[] args)

    {

        Float a = new Float(3.4);

       

    }

 

}

其实是没问题的。

我们来看看Float类的源代码吧:

  public Float(double value) {

    this.value = (float)value;

}

 

 

 

10.

public class Test2

{

    public static void main(String[] args)

    {

        Float a = new Float(3.4);

        System.out.println(a.SIZE);

        a = new Float(34000);

        System.out.println(a.SIZE);

    }

 

}

让我们来看看此程序会输出什么呢?

 

32

32

 

我们先来看看JDK的解释吧.

public static final int SIZE

The number of bits used to represent a float value.

意思是说:通常去描述一个float值的位数.

这个是一个常量,来看看源码吧:

public static final int SIZE = 32;

final int 变量一旦被定义就不能被改变~

11.

写出下面代码的结果

 

　public class TestString{

 　　 public static void link(String a){

     　　 a += "World";

  　　}

 

 　　 public static void main(String[] args){

      　　String a = "Hello";

      　　link(a);

      　　System.out.println(a);

 　　 }

　}

 

答: 这道题考两个方面:

 

1).　String对象的内容是不能改变的,a+="World"并不是把a所指对象改变,

　　而是先生成一个临时String对象,其值为a+"World",然后在把这个临时

　　对象赋给a.

 

2).　Java中函数参数传递方式为Call by value,link方法中会生产a的一个

　　拷贝,同样指向a所指的对象,综合以上两点,得出结果为 Hello

 

 

2.写出下面代码的结果

System.out.println("ja"+"va" == "java");

结果：true

 

答:"=="用来比较对象的引用,而equals()用来比较对象的内容,但是如果是字符串常量,用"=="也可以比较内容

是否相等,"ja"+"va"和"java"都是字符串常量,因此结果为true

 

同理,下面代码结果也是true

final String str = "java";

System.out.println(str=="java")

12.

package com;

 

class A

{   

    public A()

    {

        a1();

    }

    public void a1()

    {

        System.out.println("A-a1");

    }

}

 

public class B extends A

{

    int bb = 0;

    public B()

    {

        bb = 1000;

    }

    public void a1()

    {

        System.out.println("bb is " + bb);

        System.out.println("B-a1");

    }

    public static void main(String[] args)

    {

        new B();

    }

}

 

结果：调用方法时，调用的是子类的方法（子类重写父类的方法）

bb is 0

B-a1

 

 

 

 

 

 

 

 

执行顺序：

package com;

class A

{   

  

    public A()

    { //3

        a1();

    }

    public void a1()

    {

        System.out.println("A-a1");

    }

}

 

public class B extends A

{

    //2

int bb = 0;

    public B()

    {

        //5

        bb = 1000;

    }

   

    public void a1()

    {//4

        System.out.println("bb is " + bb);

        System.out.println("B-a1");

    }

    public static void main(String[] args)

    {

        //1

        new B();

    }

}

13.java中实现多态的机制是什么？

　　答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

 

 

14. java 中静态变量与实例变量的区别

java类的成员变量有俩种：
一种是被static关键字修饰的变量，叫类变量或者静态变量
另一种没有static修饰，为实例变量

类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被类的所有实例共享。静态变量可以直接通过类名进行访问，其生命周期取决于类的生命周期。

而实例变量取决于类的实例。每创建一个实例，java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中，其生命周期取决于实例的生命周期。

例1.

    public class Temp {

    int t; //实例变量

    public static void main(String args[]){

    int t=1; //局部变量

    System.out.println(t); //打印局部变量

    Temp a= new Temp(); //创建实例

    System.out.println(a.t); //通过实例访问实例变量

    }

    }

结果为：

1

0 （成员变量具有缺省值 而局部变量则没有）

例2.

    public class Temp {

    static int t; //类变量

    public static void main(String args[]){

    System.out.println(t); //打印类变量

    int t=1; //局部变量

    System.out.println(t); //打印局部变量

    Temp a= new Temp(); //创建实例

    System.out.println(a.t); //通过实例访问实例变量

    }

    }

结果则为

0

1

0

 

15.谈谈final, finally, finalize的区别

　　答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载

　　finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

　　finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

 

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

 

答：主要有以下四方面：

　　1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

　　2.继 承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。 新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修 改或增加新的方法使之更适合特殊的需要。

　　3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

　　4. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

 

 

17、int 和 Integer 有什么区别

　　答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。

　　Int是java的原始数据类型，Integer是java为int提供的wapper。Java为每个原始类型提供了封装类。

　　原始类型封装类:

　　boolean : Boolean

　　char : Character

　　byte : Byte

　　short : Short

　　int : Integer

　　long : Long

　　float : Float

　　double : Double

　　引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关

 

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

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

 

 

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

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

 

20、error和exception有什么区别

　　答：error 表示恢复不是不可能但很困难的情况下的一种严重问题，比如说内存溢出，不可能指望程序能处理这样的情况；exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

 

21、Collection 和 Collections的区别。

　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

　　Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

22、&和&&的区别。

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与(and)。

 

Static

Finally

Abstract

Interface

23. native方法，java中调用C/C++的东西.

简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如 在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。
   "A native method is a Java method whose implementation is provided by non-java code."
   在定义一个native method时，并不提供实现体（有些像定义一个java interface），因为其实现体是由非java语言在外面实现的。，下面给了一个示例：   
    public class IHaveNatives
    {
      native public void Native1( int x ) ;
      native static public long Native2() ;
      native synchronized private float Native3( Object o ) ;
      native void Native4( int[] ary ) throws Exception ;
    }
    这些方法的声明描述了一些非java代码在这些java代码里看起来像什么样子（view）.
    标识符native可以与所有其它的java标识符连用，但是abstract除外。这是合理的，因为native暗示这些方法是有实现体的，只不过这些 实现体是非java的，但是abstract却显然的指明这些方法无实现体。native与其它java标识符连用时，其意义同非Native Method并无差别，比如native static表明这个方法可以在不产生类的实例时直接调用，这非常方便，比如当你想用一个native method去调用一个C的类库时。上面的第三个方法用到了native synchronized，JVM在进入这个方法的实现体之前会执行同步锁机制（就像java的多线程。）
    一个native method方法可以返回任何java类型，包括非基本类型，而且同样可以进行异常控制。这些方法的实现体可以制一个异常并且将其抛出，这一点与java 的方法非常相似。当一个native method接收到一些非基本类型时如Object或一个整型数组时，这个方法可以访问这非些基本型的内部，但是这将使这个native方法依赖于你所访 问的java类的实现。有一点要牢牢记住：我们可以在一个native method的本地实现中访问所有的java特性，但是这要依赖于你所访问的java特性的实现，而且这样做远远不如在java语言中使用那些特性方便和 容易。
    native method的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地 方法的所有细节。需要注意当我们将一个本地方法声明为final的情况。用java实现的方法体在被编译时可能会因为内联而产生效率上的提升。但是一个 native final方法是否也能获得这样的好处却是值得怀疑的，但是这只是一个代码优化方面的问题，对功能实现没有影响。
    如果一个含有本地方法的类被继承，子类会继承这个本地方法并且可以用java语言重写这个方法（这个似乎看起来有些奇怪），同样的如果一个本地方法被fianl标识，它被继承后不能被重写。
   本地方法非常有用，因为它有效地扩充了jvm.事实上，我们所写的java代码已经用到了本地方法，在sun的java的并发（多线程）的机制实现中，许 多与操作系统的接触点都用到了本地方法，这使得java程序能够超越java运行时的界限。有了本地方法，java程序可以做任何应用层次的任务。

 

 

实现步骤：

Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。
　　可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤：
　　１、在Java中声明native()方法，然后编译；
　　２、用javah产生一个.h文件；
　　３、写一个.cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）；
　　４、将第三步的.cpp文件编译成动态链接库文件；
　　５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。
　　JAVA本地方法适用的情况
　　1.为了使用底层的主机平台的某个特性，而这个特性不能通过JAVA API访问
　　2.为了访问一个老的系统或者使用一个已有的库，而这个系统或这个库不是用JAVA编写的
　　3.为了加快程序的性能，而将一段时间敏感的代码作为本地方法实现。

 

实现也可以这样说：

1.)    JAVA通过JNI调用本地方法，而本地方法是以库文件的形式存放的（在WINDOWS平台上是DLL文件形式，在UNIX机器上是SO文件形式）。通过调用本地的库文件的内部方法，使JAVA可以实现和本地机器的紧密联系，调用系统级的各接口方法

2.)    JAVA中所需要做的工作  
在JAVA程序中，首先需要在类中声明所调用的库名称，如下：  
static   {  
    System.loadLibrary(“goodluck”);  
 }  
在这里，库的扩展名字可以不用写出来，究竟是DLL还是SO，由系统自己判断。  

还需要对将要调用的方法做本地声明，关键字为native。并且只需要声明，而不需要具体实现。如下：  
    public   native   static   void   set(int   i);  
    public   native   static   int   get();  

然后编译该JAVA程序文件，生成CLASS，再用JAVAH命令，JNI就会生成C/C++的头文件。用javac testdll.java编译它，会生成testdll.class。  

再用javah testdll，则会在当前目录下生成testdll.h文件，这个文件需要被C/C++程序调用来生成所需的库文件。  

3.)    C/C++中所需要做的工作
    对于已生成的.h头文件，C/C++所需要做的，就是把它的各个方法具体的实现。然后编译连接成库文件即可。再把库文件拷贝到JAVA程序的路径下面，就可以用JAVA调用C/C++所实现的功能了。

4.)    编译连接成库文件，本例是在WINDOWS下做的，生成的是DLL文件。并且名称要与JAVA中需要调用的一致，这里就是goodluck.dll  
把goodluck.dll拷贝到testdll.class的目录下，java   testdll运行它，就可以观察到结果了。

 

 

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

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

 

 

25.构造器Constructor是否可被override（就是构造函数）

　 答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading

1.       构造器没有返回值,也没有void  

2.       构造器在生成对象时会被调用,一般由于初始化

3.       构造方法不能被继承,就是说构造方法不能重写

4.       构造函数可以被重载（overload）,即一个类中可以有若干个不同参数列表的构造函数（不同的数量或类型）

 

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

　 答：会执行，在return前执行

 

27.用最有效率的方法算出2乘以8等於几

　 答：2 << 3

 

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

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

 

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

　 答：不对，有相同的hash code

 

30.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上

　 答：switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich

 

31. 什么时候用assert?

断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 Assertionerror。它用于调试目的：
assert(a > 0); // throws an Assertionerror if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是 否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的 状态。

 

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

GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

 

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

 

String s = "xyz";只是创建了一个指向"xyz"的引用
new String("xyz")创建一个String对象的实例
String s 创建一个指向String对象的引用

    "xyz" 是一个

    new String() 又是一个

    所以说创建了两个。

new   String("xyz")根据常量"xyz"在heap上创建String对象 

s只不过是stack上的一个引用，指向heap上的String对象  

 

 

为了提高效率，JVM 有个 String constant pool 的东东，当用第一种方法创建 String 　时，首先在这个东东里找，看有没有现成的"xyz",如果有，就直接把　a 　指向它，如果没有，就在这个东东里面创建一个，然后把　ａ　指向它。。。。当用第二种方法创建String 时，用正常的方法在　heap 中创建一个"xyz" .然后再创建一个 "xyz" 放到　String constant pool 里，以备使用。。。。（String constant pool 与 heap 是两个不同的内存区域）
       "xyz"本身作为字符常量，在汇编语言中应该作为常量放在数据段，Java有一个类似数据段的constant   pool保存这个常量，在classloader加载这个类的时候就把"xyz"和这个类的其他一些信息放在constant   pool ,new   String("xyz")根据常量"xyz"在heap上创建String对象 ，s只不过是stack上的一个引用，指向heap上的String对象  
       所以，一共两个对象

 

 

34. Math:round()方法：Math.round(11.5)等於多少? Math.round(-11.5)等於多少?　　

如果 number 的小数部分大于等于 0.5，返回值是大于 number 的最小整数。否则，round 返回小于等于 number 的最大整数

结果 12 ，-11（返回比较大的数）

 

35.Short 数据类型（到右边自动变成int）

所有的short参与运算时都会自动转化成int,并且在一个short在Java虚拟机里面仍然占用四个字节的空间。 相反的,short和int赋值时还要经常进行类型转换。 所以很少使用short(byte也是一样),一般情况下都int

short s1 = 23;

short s2 = 23;

short s3；

s3 = s1 + s2;      //报错，short到右边自动转成int类型

System.out.println(s3);

编译报错，s3 = s1 + s2，等号两边类型不匹配,不能从int转换为short类型

 

 

   short r = 1;

   r = r+1;   //报错，short到右边自动转成int类型

   r +=1;    //不报错，因为r没到右边

 

36. heap和stack有什么区别。
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。
堆是栈的一个组成元素

 

37. JSP中动态INCLUDE与静态INCLUDE的区别？

动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。

静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面

 

38、Java有没有goto?

java中的保留字，现在没有在java中使用。

 

39、说出数据连接池的工作机制是什么?

J2EE 服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

 

40. swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。

long,string 都不能作用于swtich。

switch（）的参数必须是可以直接转换为一个整数的数值或表达式。  
因此int，short，char，   byte   都可以。  
long则不行。

  byte   a=3;  
  switch   (a)   {  
  case 3:  
  System.out.println("byte   a="+a);  
  break;  
  default:  
  System.out.println("default");  
  }

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

数组没有length()这个方法，有length的属性。String有有length()这个方法。

 

 

42.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

equals()和==方法决定引用值是否指向同一对象，equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

 

 

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

不能，一个对象的一个synchronized方法只能由一个线程访问。

 

 

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

JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类，文件的类。

 

45、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以。必须只有一个类名与文件名相同。

 

46、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。

 

47、List、Map、Set三个接口，存取元素时，各有什么特点？

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

 

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

MVC 是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

 

49、什么是java序列化，如何实现java序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(

如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

 

 

 

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

C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。

B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。

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

1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。 Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu 等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。

 

(2) 为了常规用途而创建一个类时，请采取“经典形式”，并包含对下述元素的定义：equals()hashCode()toString()clone()（implement Cloneable）implement Serializable

 

(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。

 

(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。

 

(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。

 

(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：一个复杂的开关语句：考虑采用“多形”机制数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现许多成员变量在特征上有很大的差别：考虑使用几个类

 

(7) 让一切东西都尽可能地“私有”——private。可使库的某一部分“公共化”（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护。

 

(8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。

 

(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。

 

(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的“用内部类改进代码”）。

 

(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。

 

(12) 避免使用“魔术数字”，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。

 

(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常——如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。

 

(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize ()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。

 

(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。

 

(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。

 

(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象“造型”到数组里。

 

(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。

 

(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。

 

(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。

 

(21) 在现成类的基础上创建新类时，请首先选择“新建”或“创作”。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。

 

(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个“颜色”字段。

 

(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。

 

(24) 在Java 1.1 AWT中使用事件“适配器”时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示——只不过代码的工作就变得不正常了。

 

(25) 用合理的设计方案消除“伪功能”。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。

 

(26) 警惕“分析瘫痪”。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入“死逻辑”中。

 

(27) 警惕“过早优化”。首先让它运行起来，再考虑变得更快——但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。

 

(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。