副标题#e#

【常晤口试问题总结目次】

1、面向工具的特征有哪些方面？

答：面向工具的特征主要有以下几个方面： 

– 抽象：抽象是将一类工具的配合特征总结出来结构类的进程，包罗数据抽象和行为抽象两方面。抽象只存眷工具有哪些属性和行为，并不存眷这些行为的细节是什么。 

– 担任：担任是从已有类获得担任信息建设新类的进程。提供担任信息的类被称为父类（超类、基类）；获得担任信息的类被称为子类（派生类）。担任让变革中的软件系统有了必然的延续性，同时担任也是封装措施中可变因素的重要手段。 

– 封装：凡是认为封装是把数据和操纵数据的要领绑定起来，对数据的会见只能通过已界说的接口。面向工具的本质就是将现实世界描画成一系列完全自治、关闭的工具。我们在类中编写的要领就是对实现细节的一种封装；我们编写一个类就是对数据和数据操纵的封装。可以说，封装就是埋没一切可埋没的对象，只向外界提供最简朴的编程接口。 

– 多态性：多态性是指答允差异子范例的工具对同一动静作出差异的响应。简朴的说就是用同样的工具引用挪用同样的要领可是做了差异的工作。多态性分为编译时的多态性和运行时的多态性。假如将工具的要领视为工具向外界提供的处事，那么运行时的多态性可以表明为：当A系统会见B系统提供的处事时，B系统有多种提供处事的方法，但一切对A系统来说都是透明的。要领重载（overload）实现的是编译时的多态性（也称为前绑定），而要领重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向工具最精华的对象，要实现多态需要做两件事： 

1). 要领重写（子类担任父类并重写父类中已有的或抽象的要领）； 

2). 工具造型（用父范例引用引用子范例工具，这样同样的引用挪用同样的要领就会按照子类工具的差异而表示出差异的行为）。

2、会见修饰符public,private,protected,以及不写（默认）时的区别？

答：类的成员不写会见修饰时默认为default。默认对付同一个包中的其他类相当于果真（public），对付不是同一个包中的其他类相当于私有（private）。受掩护（protected）对子类相当于果真，对不是同一包中的没有父子干系的类相当于私有。Java中，外部类的修饰符只能是public或默认，类的成员（包罗内部类）的修饰符可以是以上四种。

3、String 是最根基的数据范例吗？

答：不是。Java中的根基数据范例只有8个：byte、short、int、long、float、double、char、boolean；除了根基范例（primitive type），剩下的都是引用范例（reference type），列举范例（enumeration type）也是引用范例。

4、float f=3.4;是否正确？

答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制范例转换float f =(float)3.4; 可能写成float f=3.4F;。

5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

答：对付short s1 = 1; s1 = s1 + 1;由于1是int范例，因此s1+1运算功效也是int 型，需要强制转换范例才气赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);个中有隐含的强制范例转换。

6、Java有没有goto？

答：goto 是Java中的保存字，在今朝版本的Java中没有利用。（按照James Gosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java要害字列表，个中有goto和const，可是这两个是今朝无法利用的要害字，因此有些处所将其称之为保存字，其实保存字这个词应该有更遍及的意义，因为熟悉C语言的措施员都知道，在系统类库中利用过的有非凡意义的单词或单词的组合都被视为保存字）

7、int和Integer有什么区别？

答：Java是一个近乎纯洁的面向工具编程语言，可是为了编程的利便照旧引入了根基数据范例，可是为了可以或许将这些根基数据范例当成工具操纵，Java为每一个根基数据范例都引入了对应的包装范例（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以彼此转换。 

Java 为每个原始范例提供了包装范例： 

– 原始范例: boolean，char，byte，short，int，long，float，double 

– 包装范例：Boolean，Character，Byte，Short，Integer，Long，Float，Double 

class AutoUnboxingTest { 

public static void main(String[] args) { 

Integer a = new Integer(3); 

Integer b = 3; // 将3自动装箱成Integer范例 

int c = 3; 

System.out.println(a == b); // false 两个引用没有引用同一工具 

System.out.println(a == c); // true a自动拆箱成int范例再和c较量 

} 

} 

最近还碰着一个口试题，也是和自动装箱和拆箱有点干系的，代码如下所示： 

public class Test03 { 

public static void main(String[] args) { 

Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; 

System.out.println(f1 == f2); 

System.out.println(f3 == f4); 

} 

} 

#p#分页标题#e#

假如不明就里很容易认为两个输出要么都是true要么都是false。首先需要留意的是f1、f2、f3、f4四个变量都是Integer工具引用，所以下面的==运算较量的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer工具赋一个int值的时候，会挪用Integer类的静态要领valueOf。（讲valueOf的浸染） 

简朴的说，假如整型字面量的值在-128到127之间，那么不会new新的Integer工具，而是直接引用常量池中的Integer工具，所以上面的口试题中f1==f2的功效是true，而f3==f4的功效是false。

8、&和&&的区别？

答：&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的不同长短常庞大的，固然二者都要求运算符阁下两头的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，假如&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会举办运算。许多时候我们大概都需要用&&而不是&，譬喻在验证用户登录时鉴定用户名不是null并且不是空字符串，该当写为：username != null &&!username.equals(“”)，二者的顺序不能互换，更不能用&运算符，因为第一个条件假如不创立，基础不能举办字符串的equals较量，不然会发生NullPointerException异常。留意：逻辑或运算符（|）和短路或运算符（||）的不同也是如此。

9、表明内存中的栈(stack)、堆(heap)和静态区(static area)的用法。

答：凡是我们界说一个根基数据范例的变量，一个工具的引用，尚有就是函数挪用的现场生存都利用内存中的栈空间；而通过new要害字和结构器建设的工具放在堆空间；措施中的字面量（literal）如直接书写的100、”hello”和常量都是放在静态区中。栈空间操纵起来最快可是栈很小，凡是大量的工具都是放在堆空间，理论上整个内存没有被其他历程利用的空间甚至硬盘上的虚拟内存都可以被当成堆空间来利用。 

String str = new String(“hello”); 

上面的语句中变量str放在栈上，用new建设出来的字符串工具放在堆上，而”hello”这个字面量放在静态区。 

增补：较新版本的Java（从Java 6的某个更新开始）中利用了一项叫”逃逸阐明”的技能，可以将一些局部工具放在栈上以晋升工具的操纵机能。

10、Math.round(11.5) 便是几多？Math.round(-11.5)便是几多？

答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的道理是在参数上加0.5然后举办下取整。

11、swtich 是否能浸染在byte 上，是否能浸染在long 上，是否能浸染在String上？

答：在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。从Java 5开始，Java中引入了列举范例，expr也可以是enum范例，从Java 7开始，expr还可以是字符串（String），可是长整型（long）在今朝所有的版本中都是不行以的。

12、用最有效率的要领计较2乘以8？

答： 2 << 3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）。 

增补：我们为编写的类重写hashCode要领时，大概会看到如下所示的代码，其实我们不太领略为什么要利用这样的乘法运算来发生哈希码（散列码），并且为什么这个数是个素数，为什么凡是选择31这个数？前两个问题的谜底你可以本身百度一下，选择31是因为可以用移位和减法运算来取代乘法，从而获得更好的机能。说到这里你大概已经想到了：31 * num 等价于(num << 5) – num，左移5位相当于乘以2的5次方再减去自身就相当于乘以31，此刻的VM都能自动完成这个优化。

13、数组有没有length()要领？String有没有length()要领？

#p#分页标题#e#

答：数组没有length()要领，有length 的属性。String 有length()要领。JavaScript中，得到字符串的长度是通过length属性获得的，这一点容易和Java夹杂。

14、在Java中，如何跳出当前的多重嵌套轮回？

答：在最外层轮回前加一个标志如A，然后用break A;可以跳出多重轮回。（Java中支持带标签的break和continue语句，浸染有点雷同于C和C++中的goto语句，可是就像要制止利用goto一样，应该制止利用带标签的break和continue，因为它不会让你的措施变得更优雅，许多时候甚至有相反的浸染，所以这种语法其实不知道更好）

15、结构器（constructor）是否可被重写（override）？

答：结构器不能被担任，因此不能被重写，但可以被重载

16、两个工具值沟通(x.equals(y) == true)，但却可有差异的hash code，这句话对差池？

答：差池，假如两个工具x和y满意x.equals(y) == true，它们的哈希码（hash code）该当沟通。Java对付eqauls要领和hashCode要领是这样划定的：(1)假如两个工具沟通（equals要领返回true），那么它们的hashCode值必然要沟通；(2)假如两个工具的hashCode沟通，它们并不必然沟通。虽然，你未须要凭据要求去做，可是假如你违背了上述原则就会发此刻利用容器时，沟通的工具可以呈此刻Set荟萃中，同时增加新元素的效率会大大下降（对付利用哈希存储的系统，假如哈希码频繁的斗嘴将会造成存取机能急剧下降）。 

首先equals要领必需满意自反性（x.equals(x)必需返回true）、 

对称性（x.equals(y)返回true时，y.equals(x)也必需返回true）、 

通报性（x.equals(y)和y.equals(z)都返回true时，x.equals(z)也必需返回true） 

一致性（当x和y引用的工具信息没有被修改时，多次挪用x.equals(y)应该获得同样的返回值），并且对付任何非null值的引用x，x.equals(null)必需返回false。 

实现高质量的equals要领的诀窍包罗： 

1. 利用==操纵符查抄”参数是否为这个工具的引用”； 

2. 利用instanceof操纵符查抄”参数是否为正确的范例”； 

3. 对付类中的要害属性，查抄参数传入工具的属性是否与之相匹配； 

4. 编写完equals要领后，问本身它是否满意对称性、通报性、一致性； 

5. 重写equals时老是要重写hashCode； 

6. 不要将equals要领参数中的Object工具替换为其他的范例，在重写时不要忘掉@Override注解。

17、是否可以担任String类？

答：String 类是final类，不行以被担任。 

增补：担任String自己就是一个错误的行为，对String范例最好的重用方法是关联干系（Has-A）和依赖干系（Use-A）而不是担任干系（Is-A）。

URL：http://www.bianceng.cn/Programming/Java/201608/50402.htm

18、当一个工具被看成参数通报到一个要领后，此要领可改变这个工具的属性，并可返回变革后的功效，那么这里到底是值通报照旧引用通报？

答：是值通报。Java语言的要领挪用只支持参数的值通报。当一个工具实例作为一个参数被通报到要领中时，参数的值就是对该工具的引用。工具的属性可以在被挪用进程中被改变，但对工具引用的改变是不会影响到挪用者的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。在C#中可以编写如下所示的代码，可是在Java中却做不到。

 System;
namespace CS01 {
    class Program {
           (  x,   y) {
             temp = x;
            x = y;
            y = temp;
        }
            ([] args) {
             a = , b = ;
            swap ( a,  b);
            
            Console.WriteLine (, a, b);
        }
    }
}

说明：Java中没有传引用实在长短常的不利便，这一点在Java 8中仍然没有获得改造，正是如此在Java编写的代码中才会呈现大量的Wrapper类（将需要通过要领挪用修改的引用置于一个Wrapper类中，再将Wrapper工具传入要领），这样的做法只会让代码变得臃肿，尤其是让从C和C++转型为Java措施员的开拓者无法容忍。

20、重载（Overload）和重写（Override）的区别。重载的要领可否按照返回范例举办区分？

#p#分页标题#e#

答：要领的重载和重写都是实现多态的方法，区别在于前者实现的是编译时的多态性，尔后者实现的是运行时的多态性。重载产生在一个类中，同名的要领假如有差异的参数列表（参数范例差异、参数个数差异可能二者都差异）则视为重载；重写产生在子类与父类之间，重写要求子类被重写要领与父类被重写要领有沟通的返回范例，比父类被重写要领更好会见，不能比父类被重写要领声明更多的异常（里氏代换原则）。重载对返回范例没有非凡的要求。 

口试题：华为的口试题中曾经问过这样一个问题 – “为什么不能按照返回范例来区分重载”，快说出你的谜底吧！因为要领在挪用时可以不将返回值赋值给一个对应的变量，这样就没有特征区分。

#p#副标题#e#

21、描写一下JVM加载class文件的道理机制？

答：JVM中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它认真在运行时查找和装入类文件中的类。 

由于Java的跨平台性，颠末编译的Java源措施并不是一个可执行措施，而是一个或多个类文件。当Java措施需要利用某个类时，JVM会确保这个类已经被加载、毗连（验证、筹备息争析）和初始化。类的加载是指把类的.class文件中的数据读入到内存中，凡是是建设一个字节数组读入.class文件，然后发生与所加载类对应的Class工具。加载完成后，Class工具还不完整，所以此时的类还不行用。当类被加载后就进入毗连阶段，这一阶段包罗验证、筹备（为静态变量分派内存并配置默认的初始值，根基变量是0，引用变量是null）息争析（将标记引用替换为直接引用）三个步调。最后JVM对类举办初始化，包罗：1)假如类存在直接的父类而且这个类还没有被初始化，那么就先初始化父类；2)假如类中存在初始化语句，就依次执行这些初始化语句。 

类的加载是由类加载器完成的，类加载器包罗：启动类加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自界说类加载器（java.lang.ClassLoader的子类）。从Java 2（JDK 1.2）开始，类加载进程采纳了双亲委托机制（PDM）。它更好的担保了Java平台的安详性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java措施提供对Bootstrap的引用。下面是关于几个类加载器的说明： 

Bootstrap：一般用当地代码实现，认真加载JVM基本焦点类库（rt.jar）； 

Extension：jre/ext可能java.ext.dirs系统属性所指定的目次中加载类库，它的父加载器是Bootstrap； 

System：又叫应用类加载器，其父类是Extension。它是应用最遍及的类加载器。它从情况变量classpath可能系统属性java.class.path所指定的目次中记实类，是用户自界说加载器的默认父加载器。

22、char 型变量中能不能存贮一其中文汉字，为什么？

答：char范例可以存储一其中文汉字，因为Java中利用的编码是Unicode（不选择任何特定的编码，直接利用字符在字符会合的编号，这是统一的独一要领），一个char范例占2个字节（16比特），所以放一其中文是没问题的。 

增补：利用Unicode意味着字符在JVM内部和外部有差异的表示形式，在JVM内部都是Unicode，当这个字符被从JVM内部转移到外部时（譬喻存入文件系统中），需要举办编码转换。所以Java中有字节约和字符流，以及在字符流和字节约之间举办转换的转换流，如InputStreamReader和OutputStreamReader，这两个类是字节约和字符流之间的适配器类，包袱了编码转换的任务；对付C措施员来说，要完成这样的编码转换恐怕要依赖于union（连系体/共用体）共享内存的特征来实现了。

23、抽象类（abstract class）和接口（interface）有什么异同？

答：抽象类和接口都不可以或许实例化，但可以界说抽象类和接口范例的引用。一个类假如担任了某个抽象类可能实现了某个接口都需要对个中的抽象要领全部举办实现，不然该类仍然需要被声明为抽象类。接口比抽象类越发抽象，因为抽象类中可以界说结构器，可以有抽象要领和详细要领，而接口中不能界说结构器并且个中的要领全部都是抽象要领。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以界说成员变量，而接口中界说的成员变量实际上都是常量。有抽象要领的类必需被声明为抽象类，而抽象类未须要有抽象要领。

24、静态嵌套类(Static Nested Class)和内部类（Inner Class）的差异？

#p#分页标题#e#

答：Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而凡是的内部类需要在外部类实例化后才气实例化，其语法看起来挺诡异的。 

留意：Java中非静态内部类工具的建设要依赖其外部类工具，静态要领中没有this，也就是说没有所谓的外部类工具，因此无法建设内部类工具，假如要在静态要领中建设内部类工具，可以这样做：new Outer().new Inner();

25、Java 中会存在内存泄漏吗，请简朴描写。

答：理论上Java因为有垃圾接纳机制（GC）不会存在内存泄露问题（这也是Java被遍及利用于处事器端编程的一个重要原因）；然而在实际开拓中，大概会存在无用但可达的工具，这些工具不能被GC接纳，因此也会导致内存泄露的产生。譬喻Hibernate的Session（一级缓存）中的工具属于耐久态，垃圾接纳器是不会接纳这些工具的，然而这些工具中大概存在无用的垃圾工具，假如不实时封锁（close）或清空（flush）一级缓存就大概导致内存泄露。 

在支持垃圾接纳的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的工具保持。假如一个工具引用被无意识的保存起来了，那么垃圾接纳器不会处理惩罚这个工具，也不会处理惩罚该工具引用的其他工具，纵然这样的工具只有少数几个，也大概会导致许多的工具被解除在垃圾接纳之外，从而对机能造成重大影响，极度环境下会激发Disk Paging（物理内存与硬盘的虚拟内存互换数据），甚至造成OutOfMemoryError。

26、抽象的（abstract）要领是否可同时是静态的（static）,是否可同时是当处所法（native），是否可同时被synchronized修饰？

答：都不能。抽象要领需要子类重写，而静态的要领是无法被重写的，因此二者是抵牾的。当处所法是由当地代码（如C代码）实现的要领，而抽象要领是没有实现的，也是抵牾的。synchronized和要领的实现细节有关，抽象要领不涉及实现细节，因此也是彼此抵牾的。

27、叙述静态变量和实例变量的区别。

答：静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个工具，一个类不管建设几多个工具，静态变量在内存中有且仅有一个拷贝；实例变量必需依存于某一实例，需要先建设工具然后通过工具才气会见到它。静态变量可以实现让多个工具共享内存。 

增补：在Java开拓中，上下文类和东西类中凡是会有大量的静态成员。

28、是否可以从一个静态（static）要领内部发出对非静态（non-static）要领的挪用？

答：不行以，静态要领只能会见静态成员，因为非静态要领的挪用要先建设工具，在挪用静态要领时大概工具并没有被初始化。

29、如何实现工具克隆？

答：有两种方法： 

1). 实现Cloneable接口并重写Object类中的clone()要领； 

2). 实现Serializable接口，通过工具的序列化和反序列化实现克隆，可以实现真正的深度克隆。 

留意：基于序列化和反序列化实现的克隆不只仅是深度克隆，更重要的是通过泛型限定，可以查抄出要克隆的工具是否支持序列化，这项查抄是编译器完成的，不是在运行时抛出异常，这种是方案明明优于利用Object类的clone要领克隆工具。让问题在编译的时候袒暴露来老是优于把问题留到运行时。 

30、GC是什么？为什么要有GC？ 

答：GC是垃圾收集的意思，内存处理惩罚是编程人员容易呈现问题的处所，健忘可能错误的内存接纳会导致措施或系统的不不变甚至瓦解，Java提供的GC成果可以自动监测工具是否高出浸染域从而到达自动接纳内存的目标，Java语言没有提供释放已分派内存的显示操纵要领。Java措施员不消担忧内存打点，因为垃圾收集器会自动举办打点。要请求垃圾收集，可以挪用下面的要领之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉显示的垃圾接纳挪用。 

#p#分页标题#e#

垃圾接纳可以有效的防备内存泄露，有效的利用可以利用的内存。垃圾接纳器凡是是作为一个单独的低优先级的线程运行，不行预知的环境下对内存堆中已经灭亡的可能长时间没有利用的工具举办排除和接纳，措施员不能及时的挪用垃圾接纳器对某个工具或所有工具举办垃圾接纳。在Java降生初期，垃圾接纳是Java最大的亮点之一，因为处事器端的编程需要有效的防备内存泄露问题，然而明日黄花，如今Java的垃圾接纳机制已经成为被诟病的对象。移动智能终端用户凡是以为iOS的系统比Android系统有更好的用户体验，个中一个深条理的原因就在于Android系统中垃圾接纳的不行预知性。 

增补：垃圾接纳算法有许多种，包罗：标志排除算法、复制算法、标志整理算法，分代接纳算法等方法。尺度的Java历程既有栈又有堆。栈生存了原始型局部变量，堆生存了要建设的工具。Java平台对堆内存接纳和再操作的根基算法被称为标志和排除，可是Java对其举办了改造，回收“分代式垃圾收集”。这种要了解跟Java工具的生命周期将堆内存分别为差异的区域，在垃圾收集进程中，大概会将工具移动到差异区域： 

新生代：可以再分别为Eden(伊甸)、From Survivor(存活者)和To Survivor三个逻辑区域， 工具优先存放在新生代的Eden区域。 

伊甸区（Eden）：这是工具最初降生的区域，而且对大大都工具来说，这里是它们独一存在过的区域。 

幸存区（Survivor）：从伊甸园幸存下来的工具会被挪到这里。 

暮年月：新生代的工具颠末屡次垃圾接纳之后，仍然存活的将存放到暮年月，而且大工具可以不颠末新生代而直接存放在暮年月 

年青代收集（Minor-GC）进程是不会触及这个处所的。当年青代收集不能把工具放进终身颐养园时，就会触发一次完全收集（Major-GC），这里大概还会牵扯到压缩，以便为大工具腾出足够的空间。 

永久代：要领区利用永久代作为存储区域，在逻辑上，永久代是Java堆的一部门、但凡是称之为“非堆”(Non-Heap)内存以示区别。要领区(Method Area)凡是用来存放类的相关信息 (类加载器所加载的类的字段、要领签名等)、运行时常量池(如字符串常量池)、静态引用变量等 

与垃圾接纳相关的JVM参数： 

-Xms/-Xmx — 堆的初始巨细 / 堆的最大巨细 

-Xmn — 堆中年青代的巨细 

-XX:-DisableExplicitGC — 让System.gc()不发生任何浸染 

-XX:+PrintGCDetails — 打印GC的细节 

-XX:+PrintGCDateStamps — 打印GC操纵的时间戳 

-XX:NewSize/XX:MaxNewSize — 配置新生代巨细/新生代最大巨细 

-XX:NewRatio — 可以配置老生代和新生代的比例 

-XX:PrintTenuringDistribution — 配置每次新生代GC后输出幸存者乐土中工具年数的漫衍 

-XX:InitialTenuringThreshold/-XX:MaxTenuringThreshold：配置暮年月阀值的初始值和最大值 

-XX:TargetSurvivorRatio：配置幸存区的方针利用率

31、String s = new String(“xyz”);建设了几个字符串工具？

答：两个工具，一个是静态区的”xyz”，一个是用new建设在堆上的工具。

32、接口是否可担任（extends）接口？抽象类是否可实现（implements）接口？抽象类是否可担任详细类（concrete class）？

答：接口可以担任接口，并且支持多重担任。抽象类可以实现(implements)接口，抽象类可担任详细类也可以担任抽象类。

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

答：可以，但一个源文件中最多只能有一个果真类（public class）并且文件名必需和果真类的类名完全保持一致

34、Anonymous Inner Class(匿名内部类)是否可以担任其它类？是否可以实现接口？

#p#分页标题#e#

答：可以担任其他类或实现其他接口，在Swing编程和Android开拓中常用此方法来实现事件监听和回调。

35、内部类可以引用它的包括类（外部类）的成员吗？有没有什么限制？

答：一个内部类工具可以会见建设它的外部类工具的成员，包罗私有成员。

36、Java 中的final要害字有哪些用法？

答：(1)修饰类：暗示该类不能被担任；(2)修饰要领：暗示要领不能被重写；(3)修饰变量：暗示变量只能一次赋值今后值不能被修改（常量）。

37、指出下面措施的运行功效。

class A {
     {
        System.out.print();
    }
     () {
        System.out.print();
    }
}
class B extends A{
     {
        System.out.print();
    }
     () {
        System.out.print();
    }
}
   {
       (String[] args) {
        A ab =  B();
        ab =  B();
    }
}

答：执行功效：1a2b2b。建设工具时结构器的挪用顺序是：先初始化静态成员，然后挪用父类结构器，再初始化非静态成员，最后挪用自身结构器。

38、数据范例之间的转换：- 如何将字符串转换为根基数据范例？ – 如何将根基数据范例转换为字符串？

答： 挪用根基数据范例对应的包装类中的要领parseXXX(String)或valueOf(String)即可返回相应根基范例； 一种要领是将根基数据范例与空字符串（”“）毗连（+）即可得到其所对应的字符串；另一种要领是挪用String 类中的valueOf()要领返回相应字符串。

39、如何实现字符串的反转及替换？

答：要领许多，可以本身写实现也可以利用String或StringBuffer/StringBuilder中的要领。有一道很常见的口试题是用递归实现字符串反转，代码如下所示：

      String (String originStr) {
        (originStr ==  || originStr.length() <= ) 
             originStr;
         reverse(originStr.substring()) + originStr.charAt();
}

40、奈何将GB2312编码的字符串转换为ISO-8859-1编码的字符串？

答：代码如下所示： 

String s1 = “你好”; 

String s2 = new String(s1.getBytes(“GB2312”), “ISO-8859-1”);