Java措施员口试问答
副标题#e#
谈谈final, finally, finalize的区别
final—修饰符（要害字）假如一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被担任。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或要领声明为final，可以担保它们在利用中不被改变。被声明为final的变量必需在声明时给定初值，而在今后的引用中只能读取，不行修改。被声明为final的要领也同样只能利用，不能重载
finally—再异常处理惩罚时提供 finally 块来执行任何排除操纵。假如抛出一个异常，那么相匹配的 catch 子句就会执行，然后节制就会进入 finally 块（假如有的话）。
finalize—要领名。Java 技能答允利用 finalize() 要领在垃圾收集器将工具从内存中排除出去之前做须要的清理事情。这个要领是由垃圾收集器在确定这个工具没有被引用时对这个工具挪用的。它是在 Object 类中界说的，因此所有的类都担任了它。子类包围 finalize() 要领以整理系统资源可能执行其他清理事情。finalize() 要领是在垃圾收集器删除工具之前对这个工具挪用的。
Anonymous Inner Class (匿名内部类) 是否可以extends(担任)其它类，是否可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(担任) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。
Static Nested Class 和 Inner Class的差异，说得越多越好(口试题有的很笼统)
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的差异就在于是否有指向外部的引用上。
注： 静态内部类（Inner Class）意味着1建设一个static内部类的工具，不需要一个外部类工具，2不能从一个static内部类的一个工具会见一个外部类工具
&和&&的区别
&是位运算符。&&是布尔逻辑运算符。
HashMap和Hashtable的区别
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类可能排序。它答允一个 null 键和多个 null 值。
Hashtable 雷同于 HashMap，可是不答允 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。
Collection 和 Collections的区别
Collections是个java.util下的类，它包括有各类有关荟萃操纵的静态要领。
Collection是个java.util下的接口，它是各类荟萃布局的父接口。
什么时候用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 标志。还可以在包的基本上启用可能禁用断言。
可以在估量正常环境下不会达到的任何位置上安排断言。断言可以用于验证通报给私有要领的参数。不外，断言不该该用于验证通报给公有要领的参数，因为不管是否启用了断言，公有要领都必需查抄其参数。不外，既可以在公有要领中，也可以在非公有要领中操作断言测试后置条件。别的，断言不该该以任何方法改变措施的状态。
#p#副标题#e#
GC是什么? 为什么要有GC? (基本)
GC是垃圾收集器。Java 措施员不消担忧内存打点，因为垃圾收集器会自动举办打点。要请求垃圾收集，可以挪用下面的要领之一：
System.gc()
Runtime.getRuntime().gc()
String s = new String("xyz");建设了几个String Object?
两个工具，一个是“xyx”,一个是指向“xyx”的引用工具s。
Math.round(11.5)等於几多? Math.round(-11.5)等於几多?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;
short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。
sleep() 和 wait() 有什么区别? 搞线程的最爱
sleep()要领是使线程遏制一段时间的要领。在sleep 时距离断期满后，线程不必然当即规复执行。这是因为在谁人时刻，其它线程大概正在运行并且没有被调治为放弃执行，除非(a)“醒来”的线程具有更高的优先级；(b)正在运行的线程因为其它原因而阻塞
wait()是线程交互时，假如线程对一个同步工具x 发出一个wait()挪用，该线程会暂停执行，被调工具进入期待状态，直到被叫醒或期待时间到。
Java有没有goto?
Goto—java中的保存字，此刻没有在java中利用。
数组有没有length()这个要领? String有没有length()这个要领？
数组没有length()这个要领，有length的属性。
String有length()这个要领。
Overload和Override的区别。Overloaded的要领是否可以改变返回值的范例?
#p#分页标题#e#
要领的重写Overriding和重载Overloading是Java多态性的差异表示。重写Overriding是父类与子类之间多态性的一种表示，重载Overloading是一个类中多态性的一种表示。假如在子类中界说某要领与其父类有沟通的名称和参数，我们说该要领被重写 (Overriding)。子类的工具利用这个要领时，将挪用子类中的界说，对它而言，父类中的界说如同被“屏蔽”了。假如在一个类中界说了多个同名的要领，它们或有差异的参数个数或有差异的参数范例，则称为要领的重载(Overloading)。Overloaded的要领是可以改变返回值的范例。
Set里的元素是不能反复的，那么用什么要领来区分反复与否呢? 是用==照旧equals()? 它们有何区别?
Set里的元素是不能反复的，那么用iterator()要领来区分反复与否。equals()是判读两个Set是否相等。
equals()和==要领抉择引用值是否指向同一工具equals()在类中被包围，为的是当两个疏散的工具的内容和范例相配的话，返回真值。
给我一个你最常见到的runtime exception
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFORMatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
error和exception有什么区别?
error 暗示规复不是不行能但很坚苦的环境下的一种严重问题。好比说内存溢出。不行能指望措施能处理惩罚这样的环境。
exception 暗示一种设计或实现问题。也就是说，它暗示假如措施运行正常，从不会产生的环境。
List, Set, Map是否担任自Collection接口?
List，Set是
Map不是
abstract class和interface有什么区别?
声明要领的存在而不去实现它的类被叫做抽象类（abstract class），它用于要建设一个浮现某些根基行为的类，并为该类声明要领，但不能在该类中实现该类的环境。不能建设abstract 类的实例。然而可以建设一个变量，其范例是一个抽象类，并让它指向详细子类的一个实例。不能有抽象结构函数或抽象静态要领。Abstract 类的子类为它们父类中的所有抽象要领提供实现，不然它们也是抽象类为。取而代之，在子类中实现该要领。知道其行为的其它类可以在类中实现这些要领。
接口（interface）是抽象类的变体。在接口中，所有要领都是抽象的。多担任性可通过实现这样的接口而得到。接口中的所有要领都是抽象的，没有一个有措施体。接口只可以界说static final成员变量。接口的实现与子类相似，除了该实现类不能从接口界说中担任行为。当类实现非凡接口时，它界说（即将措施体给以）所有这种接口的要领。然后，它可以在实现了该接口的类的任何工具上挪用接口的要领。由于有抽象类，它答允利用接口名作为引用变量的范例。凡是的动态联编将生效。引用可以转换到接口范例或从接口范例转换，instanceof 运算符可以用来抉择某工具的类是否实现了接口。
abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能
接口是否可担任接口? 抽象类是否可实现(implements)接口? 抽象类是否可担任实体类(concrete class)?
接口可以担任接口。抽象类可以实现(implements)接口，抽象类是否可担任实体类，但前提是实体类必需有明晰的结构函数。
启动一个线程是用run()照旧start()?
#p#分页标题#e#
启动一个线程是挪用start()要领，使线程所代表的虚拟处理惩罚机处于可运行状态，这意味着它可以由JVM调治并执行。这并不料味着线程就会当即运行。run()要领可以发生必需退出的符号来遏制一个线程。
结构器Constructor是否可被override?
结构器Constructor不能被担任，因此不能重写Overriding，但可以被重载Overloading。
是否可以担任String类?
String类是final类故不行以担任。
当一个线程进入一个工具的一个synchronized要领后，其它线程是否可进入此工具的其它要领?
不能，一个工具的一个synchronized要领只能由一个线程会见。
try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前照旧后?
会执行，在return前执行。
编程题: 用最有效率的要领算出2乘以8等於几?
有C配景的措施员出格喜欢问这种问题。
2 << 3
两个工具值沟通(x.equals(y) == true)，但却可有差异的hash code，这句话对差池?
差池，有沟通的hash code。
当一个工具被看成参数通报到一个要领后，此要领可改变这个工具的属性，并可返回变革后的功效，那么这里到底是值通报照旧引用通报?
是值通报。Java 编程语言只由值通报参数。当一个工具实例作为一个参数被通报到要领中时，参数的值就是对该工具的引用。工具的内容可以在被挪用的要领中改变，但工具的引用是永远不会改变的。
swtich是否能浸染在byte上，是否能浸染在long上，是否能浸染在String上?
switch（expr1）中，expr1是一个整数表达式。因此通报给 switch 和 case 语句的参数应该是 int、 short、 char 可能 byte。long,string 都不能浸染于swtich。
编程题: 写一个Singleton出来。
Singleton模式主要浸染是担保在Java应用措施中，一个类Class只有一个实例存在。
一般Singleton模式凡是有几各种形式:
第一种形式: 界说一个类，它的结构函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance要领获取对它的引用,继而挪用个中的要领。
public class Singleton {
private Singleton(){}
//在本身内部界说本身一个实例，是不是很奇怪？
//留意这是private 只供内部挪用
private static Singleton instance = new Singleton();
//这里提供了一个供外部会见本class的静态要领，可以直接会见
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个要领比上面有所改造，不消每次都举办生成工具，只是第一次
//利用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
其他形式:
界说一个类，它的结构函数为private的，所有要领为static的。
一般认为第一种形式要越发安详些
Hashtable和HashMap
Hashtable担任自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现
HashMap答允将null作为一个entry的key可能value，而Hashtable不答允
尚有就是，HashMap把Hashtable的contains要领去掉了，改成containsvalue和containsKey。因为contains要领容易让人引起误解。
最大的差异是，Hashtable的要领是Synchronize的，而HashMap不是，在多个线程会见Hashtable时，不需要本身为它的要领实现同步，而HashMap 就必需为之提供外同步。—www.bianceng.cn
Hashtable和HashMap回收的hash/rehash算法都或许一样，所以机能不会有很大的差别。
实践题
1.
abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
这有何错误?
谜底: 错。abstract method必需以分号末了，且不带花括号。
2.
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有错吗?
谜底: 错。局部变量前不能安排任何会见修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都长短会见修饰符，strictfp只能修饰class和method而非variable)。
3.
abstract class Something {
private abstract String doSomething ();
}
这仿佛没什么错吧?
#p#分页标题#e#
谜底: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)详细细节的，怎么可以用private把abstract method封闭起来呢? (同理，abstract method前不能加final)。
4.
public class Something {
public int addOne(final int x) {
return ++x;
}
}
这个较量明明。
谜底: 错。int x被修饰成final，意味着x不能在addOne method中被修改。
5.
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
谜底: 正确。在addOne method中，参数o被修饰成final。假如在addOne method里我们修改了o的reference
(好比: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable (成员变量)，而o的reference并没有改变。
6.
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
有什么错呢? 看不出来啊。
谜底: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。
7.
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一题只有一个处所差异，就是多了一个final。这莫非就错了吗?
谜底: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必需在constructor (结构器)竣事之前被赋予一个明晰的值。可以修改为"final int i = 0;"。
8.
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
谜底: 错。看上去在main里call doSomething没有什么问题，究竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能会见non-static instant variable。
9.
此处，Something类的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) {
System.out.println("Do something ...");
}
}
这个仿佛很明明。
谜底: 正确。从来没有人说过Java的Class名字必需和其文件名沟通。但public class的名字必需和文件名沟通。
10.
本日最难的一题:
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
这个错误不容易发明。
谜底: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可担任多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任安在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()要领中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。
