Java程序员面试宝典 - 最常用的编程风格

第一篇：Java程序员面试宝典 - 最常用的编程风格

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

(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文档里找出有用信息时碰到的挫折，这样或许能将你说服。

第二篇：Java程序员面试宝典

第3章

Java语法基础

基础类型和语法

1、变量及其作用范围

Java变量可以分为：静态变量、成员变量和局部变量3种。

静态变量：在类中用static修饰的变量，它的生存周期是由类来决定的。

成员变量：在类中没有用static修饰的变量，它的生存周期由对象来决定。

局部变量：定义在方法里的变量、方法的参数或代码块里定义的变量，它们的作用范围用大括号{}来界定。

2、Java的变量分哪两种大的数据类型

Java的变量分为基本数据类型和引用数据类型。它们最大的区别在于，引用数据类型存 放的是数据所在的地址，而基本数据类型则是直接存放数据的值。

其他知识点：引用数据类型的变量存的值是一个内存地址。对象一般是通过new语句创

建出来的，它保存在堆空间中，可以被多个引用类型的变量所引用。当引 用a修改了对象的数据以后，其他的引用也是可以看到这些改变的。

3、Java包含哪些基本数据类型及其包装类

Java一共有8种基本数据类型，分别是byte、short、int、long、float、double、boolean、char；存储的数据量比较小，用二进制保存。其馐类分别是：Byte、Short、Integer、Float、Double、Boolean、Character。

Eg.Integer itg=new Integer.valueOf(100);

Itg.intValue();

4、如何理解Java中的装箱和拆箱

从Java 5.0开始，有一种自动装箱和拆箱的功能，就可以不必显式的进行类型转换，系统会自动的按照需要进行数据类型的转换。

Java中的装箱和拆箱指的是基本数据类型和包装类型的自动相互的转换。

装箱：基本数据类型——>包装类型 拆箱：包装类型——>基本数据类型

5、Java中equal和==的区别是什么

“==”运用在基本数据类型的时候，通过比较它们实际的值来判定是否相同；而用于比较引用类型的时候，则是比较两个引用的地址是否相等，也就是是否指向同一个对象。

Equal方法是java.lang.Object的方法，也就是所有的Java类都会有的方法。它可以被程序员覆盖重写，通过自定义的方式来判定两个对象是否相等。对于字符串java.lang.String类来说，它的equal方法用来比较字符串的字符序列是否相等。

6、Java中的注释有哪些

行注释：//

块注释：/* */，这种注释不会出现在HTML文档中。

文档注释：/** /，它的注释信息可以进入到javadoc文档中。注释文档将用来生成HTML 格式的代码API报告，还可以用@开头的关键字进行注释，以达到说明方法参数、返回 值、异常等各种详细信息。

Annotation:它会进入到编译层，并对程序结果产生影响。它最变通的作用就是用来替代 XML提供一些配置信息，例如，JPA、Spring等框架的配置信息就可以通过Annotation 来提供。

7、Java的引用和C++的指针有什么区别

Java的引用和C++的指针本质上，它们两者都是想通过一个叫做引用或者指针的东西，找到要操作的目标，方便在程序中操作。所不同的是Java的办法更安全、方便，但失去了C++的灵活，也算是对指针的一种包装和改进。

主要区别是：

对象和类型

1、类和对象有什么区别

类是一种抽象，而对象是类的实现。

Java的类通过class关键字进行定义，它代表了一种抽象的集合。在它的里面可以定义各种属性和方法，它们代表了每个类实例的特定的数据和动作。Java虚拟机对类只加载一次，对它的静态成员也只加载一次。

对象，指的是某一个特定抽象的实例，它属于某一种类型，也就是对象是通过类来创建的。它必须从属于某一个类，通过new关键字进行创建，它代表一个特定类型的实例，对象可以被多次创建。

2、Java中如何使用继承来重用代码

Java采用的是单继承制，使用extends关键字。通过继承之后，子类就拥有了父类除开私有成员以外的所有成员，从而达到代码重用的目的。在继承过程中，可以通过方法的覆盖来实现多态，让子类拥用自己独特的方法实现方式。

方法的覆盖（或重写）和重载是两个不同的概念。重载是创建一个方法名相同，但参数列表不同的方法；而方法覆盖则是子类对父类方法的覆盖和重写，定义一个名字、参数、返回值一样的方法即可。

3、简述Java中的多态

多态是建立在继承的基础之上的。

“多态”的本质是，发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

4、Java中静态成员的特点

类的静态成员是通过static关键字修饰的成员，主要包括：静态成员变量、静态方法和静态代码块，它们具有以下一些特点：

1、在类加载的时候，就进行创建和初始化或执行代码。

2、它们对于一个类来说，都只有一份。

3、类的所有实例都可以访问到它们。

静态代码块先执行。

5、Java派生类中的构造方法如何为父类传递参数

在Java中，使用super（）的形式来为父类的构造方法提供参数，通过参数的数目和类型来决定调用哪一个构造方法。如果调用的是父类的默认的无参数构造方法，则可以不必显式地使用super()。super()的使用必须放在子类构造方法的第一行，否则编译时会有语法错误。

6、接口和抽象类的区别

包含抽象（abstract）方法的类，就是抽象类。抽象类不能够实例化。Abstract class 接口所有的方法都是抽象的，它可以包含静态的变量，这些变量的值不能修改。interface 抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。从某种意义上说，接口是一种特殊形式的抽象类，在Java语言中，抽象类表示一种继承关系，一个类吸能继承一个抽象类，而一个类却可以实现多个接口。

Class A extends B implements C,D { }

7、简述一下内部类的实质

包和访问控制

1、包应该如何被创建及使用

包是Java程序中关于命名空间的一种手段，它可以有效的解决类重名的问题。当需要把一个类定义在某个包下的时候，需要使用package关键字进行定义；当需要使用其他包下的类的时候，则需要使用import关键字进行导入。

2、说明private、protected、public、default（friendly）的区别

第4章

数据类型及类型转换

整型数据

1、int 和Integer有什么区别

所有的整型字面量默认为int 型。

装箱：创建Integer对象：Integer a=new Integer(20);Integer b=Integer.valueOf(30);拆箱：int c=a.intValue();

2、Java中的八制字面量采用0开头，十六进制采用0x开头。

3、Int型数据采用4个字节进行存储，一共是32位。第一位用于表示正负号，这的取值范围是：-2^31~(2^31-1)。

Long型数据采用8个字节进行存储，一共是64位。第一位用于表示正负号，这的取值范围是：-2^63~(2^63-1)。

实型(浮点型)数据

1、float 和double的取值范围各是多少

Float型定义的数据末尾必须有“f”或“F”，为了和double区别。而double末尾可以有“d”或“D”，也可以不写。Java的浮点型数默认为double型。

2、如何用BigDecimal类进行精确运算

布尔型数据

1、Java可以用非0来代表true吗?

Java不能用非0代表true，也不能用0代表 false，只能用布尔型的true和false来进行条件判断。

2、boolean和它的包装类的区别在哪里

Boolean变量一般初始化为false。

字符型数据

1、char的取值范围

Java中的char采用Unicode编码格式，用两个字节来表示一个字符，一共16位（bit），它所能表示的范围是:0~2^16。

2、char能否存储汉字

char是可以存储汉字的，每个中文字符都有对应的Unicode编码。对于英文字母，它们所处的范围是0~127之间，与ASCII码相同，这是因为Unicode兼容ASCII码。

3、如何使用转义字符

在Java中，使用反斜线“”来代表转义，它与紧跟在它后面的字符一起组成了转义字符，从而达到转义的目的。

String型数据

1、字符串字面量是否自动生成一个String对象

肯定会自动生成。字符串类具有一定的特殊性，JVM在执行双引号操作符的时候，会自动的创建一个String对象，并返回这个对象的引用。

2、字符串对象池的作用是什么？

Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别且来存储8种基本类型的包装类对象和String对象，主要是为了效率问题。

对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能。当JVM在运行用双引号引起来的一个字符串的代码时，会到String的对象池中去检查是否有一个字符序列相同的对象。如果有，就取现成的对象，如果没有，则在对象池中创建一个对象，并返回。

3、StringBuffer和StringBuilder存在的作用是什么？

Java的字符串String对象，有一个特性：不变性，它只能被创建，不能改变其中的值。

在Java程序中，如果有大量拼接字符串的需要的话，应该使用StringBuffer和StringBuilder类，它们可以避免不必要的String对象的产生，以提高程序的性能。它们的作用类似，只不过StringBuilder线程是安全的。

StringBuffer sb=new StringBuffer();

Sb.append(a);//用append方法追加字符串

4、如何输出反转过后的字符串

实现字符串的反转一般来说有两种手段，第一是利用字符串存储字符数据的原理，取出它的char数组，进行重新排列并保存；第二则是生成StringBuffer对象，直接使用StringBuffer的reverse()方法。

第三篇：Java程序员面试宝典

本文由 tonhhssy 贡献 pdf 文档可能在 WAP 端浏览体验不佳。建议您优先选择 TXT，或下载源文件到本机查看。编辑推荐 揭开知名 IT 企业面试、笔试的核心机密； 传授程序员岗位求职的关键技巧。《Java 程序员面试宝典》 不同于其他 Java 程序书籍的主要特点如下。唯一性 本书是国内 市场上唯一介绍 Java 程序员求职面试技巧的图书和案例库。本书从实际出发，将 Java 程序 员面试中常会考到的一些编程基础性问题，比如 final、super 类、构造函数等最易考到的基 础 考点，放在第 2 部分 Java 程序设计里面，希望能切切实实解决实际问题。深入性 面试题通过一道题考一个专类方面的能力。说起 Java，人们首先想到的是 Java 编程语言，然而事 实上，Java 是一种技术，它由 4 个方面组成： Java 编程语言、Java 类文件格式、Java 虚拟机和 Java 应用程 序接口（Java API）。从面试者的角度来讲，一个测试也许能从多方面 揭示应试者的素质，至少你能 了解应试者所掌握类的水平。市面上流行的面试书籍在 此专业性的分类方面做得不够，正因为如此，《Java 程序员面试宝典 》 一书中追求的是程序员求职背后的一些东西： 对于技术的本质理解，而不仅限于对 Java 技术的单 纯讲解。广泛性 本书包括但不仅限于 Java 程序员面试。对求职市场面 试做了妥善分类后，将面试对象分为软件 开发人员、网络工程师、测试工程师和系统管理员（又包括操作系统管理员和数据库管理员等）实际上市面上流行的面试书籍仅对软件开发。人员比较侧重，而忽略网络工程师和测试工程师，而现 实情况是在诸如趋势科技、思科等公 司的面试中，对网络方面的考题日趋增加，在银行、金融公司 的面试中对系统管理员方面的 考题也占很大的比重。本书就这一方面给出详细论断，并结合大量考 题分析题目特点给出应 试方案。本书将在这些方面做出改进，以适应市场需求。同时本书对外企经常考到的 UML 及设计模式内容也做了深入的分析，并在上一本书《程序员面 试宝典》的基础上从本质 上诠释面试的真谛。真实性 本书的所有面试题都来自 2005—2006 年各大公司的面 试题及培训资料，内容非常新，可以算做 面试者求职前的一份全真模拟。我们希望营造一种 真实的面试氛围，同时作者希望把如何做好一个 职业人，以及作者在职场上所获得的实际感 悟融会在书中，通过真情实感，娓娓道来，指引读者走 上理想的工作岗位。本书不是一本万 能书籍，但却肯定是你工作求职的好助手、好伙伴！本书是程序员面试宝典系列中的一 部，也是上一本《程序员面试宝典》的姊

妹丛书。本书对程 序设计面试中 Java 常见的题型 和常用解答技巧进行了介绍，它不仅能帮助求职者快速复习有相关知 识点，也对现代职业人 如何有效求职、面试考官如何关注求职者动态等做了详细解说。本书通过详 解各大知名公司 技术类（开发、测试、系统管理）面试中的常见 Java 试题，深入浅出地对其解答思 路进行 了分析和指导。希望能把在技术面试中取得的宝贵经验毫无保留地传授给读者，以便使求职 者对程序设计面试中的常见题型应付自如。通过对本书的学习，你会发现和完善有关试题的 最佳解 决方案，以应对不利局面的情况。本书简介 本书是程序员面试宝典系列中的一部，也是上一本《程序员面试宝典》的姊妹丛书。本 书对程序设 计面试中 Java 常见的题型和常用解答技巧进行了介绍，它不仅能帮助求职者快 速复习有相关知识点，也对现代职业人如何有效求职、面试考官如何关注求职者动态等做了 详细解说。本书通过详解各大知名公司技术类（开发、测试、系统管理）面试中的常见 Java 试题，深入浅 出地对其解答思路进行了分析和指导。希望能把在技术面试中取得的宝 贵经验毫无保留地传授给读 者，以便使求职者对程序设计面试中的常见题型应付自如。通过 对本书的学习，你会发现和完善有 关试题的最佳解决方案，以应对不利局面。本书适 合（但不限于）将要找工作的程序和高校计算机类应曲毕业生，以及其他计算机爱好者。目录

第 1 部分 求职过程 第 1 章 应聘求职 第 2 章 简历书写 第 3 章 3 种考试 第 4 章 职业生涯发展规划 第 5 章 3 个求职技巧 第 2 部分 Java 程序设计 第 6 章 Java 程序设计基本概念 第 7 章 异常与反射 第 8 章 传递与引用 第 9 章 循环、条件、概率 第 10 章 Java 内存管理 第 11 章 面向对象 第 12 章 继承与接口 第 13 章 JavaScript 第 14 章 Java 架构技术及相关中间件 第 3 部 分 数据结构和设计模式 第 15 章 字符串 第 16 章 设计模式 第 4 部分 UNIX、Oracle、网络 第 17 章 操作系统 第 18 章 数据库和 SQL 语言 第 19 章 计算机网 络及分布式系统 第 6 部分 Java 开源 第 20 章 J2EE 技术 第 21 章 数据相关 第 22 章 Java 中的 Web 设计 第 23 章 Java 中的网页设计 第 24 章 Struts 结构设计 第 25 章 Java 安全性 第 6 部分 综合面试题 第 26 章 英语面试 第 27 章 电话面试 第 28 章 智力测试 附录 A 简历模板 附录 B 面试经历总结 下载后 点击此处查看更多内容 1

第四篇：java程序员面试宝典_java程序员面试经验

java程序员面试宝典_java程序员面试经验

一些Java软件工程师求职者们，可能因为种种原因，对Java语言及其深层原理掌握不牢固，以至于在面试中犯各种错误。本期乔布简历小编将为大家带来的主题是java程序员面试经验，一起来了解一下java程序员面试宝典吧~

关键词：java程序员面试宝典,java程序员面试经验

以下是一些java程序员面试需要注意的地方：

1、对于此类岗位而言，具体的项目是用人单位招聘时最看重的参考因素。即便是没有工作经验的应届生，也要准备可作为自己能力参考的具体作品。如果从未参加过任何项目，可以准备自己在相关领域的课程设计，如有必要还可以将其修改为完整的项目。对于这份具体作品，求职者要有相当的了解。通过求职者对于该作品的讲解，招聘官会判断求职者的技术能力到底如何。

2、Java程序员要求掌握的技能会比较多，求职者在简历上可以分类依次列举出自己所掌握的专业技能，有证书的列出自己所持有的证书名称。在面试的时候，可以对自己所掌握的技能做出介绍，并辅以实例证明，这样会更具有说服力。

3、基础很重要，不要生疏了。不管应聘什么程序员岗位，基础永远都是最重要的。只有有了踏实的基础，再辅以较好的学习能力，这样才不会被互联网日新月异的变化甩开。很多程序员在面试时往往是因为答不出最基础的问题才会错失工作机会。面试前巩固一下基础知识，永远不要轻视了基础。

程序员要时刻关注技术前沿，将新技术与自己所从事的工作联系到一起，做一些深入思考，面试时谈谈这样的问题也是向面试官展现自己学习能力的好机会~

本文来源简历http://cv.qiaobutang.com/knowledge/articles/5652f8b30cf2a980ccfbcec2

第五篇：Java程序员面试宝典 - Java代码查错

JAVA代码查错

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();}这好像没什么错吧? 答案: 错。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.javaclass Something {

private static void main(String[] something_to_do){ System.out.println(”Do something...“);} } 这个好像很明显。

答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

10.interface A{

int x = 0;} class B{ int x =1;}

class C extends B implements A { public void pX(){ System.out.println(x);}

public static void main(String[] args){ new C().pX();} } 答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

11.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”);“这里显示有错。

JAVA编程题 1．现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset import java.util.*;public class bycomma{

public static String[] splitStringByComma(String source){ if(source==null||source.trim().equals(”“))

return null;

StringTokenizer commaToker=new tringTokenizer(source,”,“);String[] result = new String[commaToker.countTokens()];int i=0;

while(commaToker.hasMoreTokens()){ result[i] = commaToker.nextToken();i++;} return result;} public static void main(String args[]){

String[] s = splitStringByComma(”5,8,7,4,3,9,1“);int[] ii = new int[s.length];for(int i = 0;i

for(int i=(s.length-1);i>=0;i--){ System.out.println(ii[i]);} } }

2．金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。package test.format;import java.text.NumberFormat;import java.util.HashMap;public class SimpleMoneyFormat { public static final String EMPTY = ”“;public static final String ZERO = ”零“;public static final String ONE = ”壹“;public static final String TWO = ”贰“;public static final String THREE = ”叁“;public static final String FOUR = ”肆“;public static final String FIVE = ”伍“;public static final String SIX = ”陆“;public static final String SEVEN = ”柒“;public static final String EIGHT = ”捌“;public static final String NINE = ”玖“;public static final String TEN = ”拾“;public static final String HUNDRED = ”佰“;public static final String THOUSAND = ”仟“;public static final String TEN_THOUSAND = ”万“;public static final String HUNDRED_MILLION = ”亿“;public static final String YUAN = ”元“;public static final String JIAO = ”角“;public static final String FEN = ”分“;public static final String DOT = ”.“;

private static SimpleMoneyFormat formatter = null;private HashMap chineseNumberMap = new HashMap();private HashMap chineseMoneyPattern = new HashMap();private

NumberFormat

numberFormat NumberFormat.getInstance();private SimpleMoneyFormat(){

numberFormat.setMaximumFractionDigits(4);numberFormat.setMinimumFractionDigits(2);

= numberFormat.setGroupingUsed(false);chineseNumberMap.put(”0“, ZERO);chineseNumberMap.put(”1“,ONE);chineseNumberMap.put(”2“, TWO);chineseNumberMap.put(”3“, THREE);chineseNumberMap.put(”4“, FOUR);chineseNumberMap.put(”5“, FIVE);chineseNumberMap.put(”6“, SIX);chineseNumberMap.put(”7“, SEVEN);chineseNumberMap.put(”8“, EIGHT);chineseNumberMap.put(”9“, NINE);chineseNumberMap.put(DOT, DOT);chineseMoneyPattern.put(”1“, TEN);chineseMoneyPattern.put(”2“, HUNDRED);chineseMoneyPattern.put(”3“, THOUSAND);chineseMoneyPattern.put(”4“, TEN_THOUSAND);chineseMoneyPattern.put(”5“, TEN);chineseMoneyPattern.put(”6“, HUNDRED);chineseMoneyPattern.put(”7“, THOUSAND);chineseMoneyPattern.put(”8“, HUNDRED_MILLION);} public static SimpleMoneyFormat getInstance(){ if(formatter == null)

formatter = new SimpleMoneyFormat();return formatter;} public String format(String moneyStr){

checkPrecision(moneyStr);String result;

result = convertToChineseNumber(moneyStr);result = addUnitsToChineseMoneyString(result);

return result;}

public String format(double moneyDouble){

return format(numberFormat.format(moneyDouble));}

public String format(int moneyInt){

return format(numberFormat.format(moneyInt));}

public String format(long moneyLong){

return format(numberFormat.format(moneyLong));} public String format(Number moneyNum){

return format(numberFormat.format(moneyNum));

private String convertToChineseNumber(String moneyStr){ String result;

StringBuffer cMoneyStringBuffer = new StringBuffer();for(int i = 0;i < moneyStr.length();i++){

cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i + 1)));

//拾佰仟万亿等都是汉字里面才有的单位，加上它们

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);int moneyPatternCursor = 1;for(int i = indexOfDot1)

cMoneyStringBuffer.delete(cMoneyStringBuffer.length()1, JIAO);

cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN);if(cMoneyStringBuffer.indexOf(”零角零分“)!=-1)//没有零头，加整 cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(”零角零分“), cMoneyStringBuffer.length(), ”整“);

else if(cMoneyStringBuffer.indexOf(”零分“)!=-1)//没有零分，加

整

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(”零分“), cMoneyStringBuffer.length(), ”整“);else { if(cMoneyStringBuffer.indexOf(”零角“)!=-1)

cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf(”零角“),cMoneyStringBuffer.indexOf(”零角“)+2);

tmpBuffer.append(”整“);

} result = cMoneyStringBuffer.toString();return result;} private void checkPrecision(String moneyStr){ int

fractionDigits

=

moneyStr.length()

-moneyStr.indexOf(DOT)-1;

if(fractionDigits > 2)throw new RuntimeException(”金额“ + moneyStr + ”的小数位多于两位。“);//精度不能比分低

} public static void main(String args[]){ System.out.println(getInstance().format(new Double(10010001.01)));} }

3、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么? 答:父类：

package test;

public class FatherClass { public FatherClass(){

System.out.println(”FatherClass Create“);} } 子类: package test;

import test.FatherClass;

public class ChildClass extends FatherClass { public ChildClass(){

System.out.println(”ChildClass Create“);}

public static void main(String[] args){ FatherClass fc = new FatherClass();ChildClass cc = new ChildClass();} }

输出结果： C:>java test.ChildClass FatherClass FatherClass Create

ChildClass Create

4、内部类的实现方式? 答：示例代码如下：

package test;

public class OuterClass { private class InterClass { public InterClass(){

System.out.println(”InterClass Create“);} }

public OuterClass(){

InterClass ic = new InterClass();System.out.println(”OuterClass Create“);}

public static void main(String[] args){ OuterClass oc = new OuterClass();}

Create }

输出结果: C:>java test/OuterClass InterClass Create

OuterClass Create 再一个例题：

public class OuterClass { private double d1 = 1.0;//insert code here }

You need to insert an inner class declaration at line 3.Which two inner class declarations are valid?(Choose two.)

A.class InnerOne{ public static double methoda(){return d1;} } B.public class InnerOne{ static double methoda(){return d1;} } C.private class InnerOne{ double methoda(){return d1;} } D.static class InnerOne{ protected double methoda(){return d1;} } E.abstract class InnerOne{ public abstract double methoda();} 说明如下： 一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。故 A、B 错 二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。故 D 错 三.非静态内部类的非静态成员可以访问外部类的非静态变量。故 C 正确 四.答案为C、E

5、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？

答:Server端程序: package test;import java.net.*;import java.io.*;public class Server { private ServerSocket ss;private Socket socket;private BufferedReader in;private PrintWriter out;public Server(){ try {

ss=new ServerSocket(10000);while(true){

socket = ss.accept();String

RemoteIP

= socket.getInetAddress().getHostAddress();String RemotePort = ”:“+socket.getLocalPort();System.out.println(”A in!IP:“+RemoteIP+RemotePort);in

=

new

BufferedReader(new client

come InputStreamReader(socket.getInputStream()));String line = in.readLine();

System.out.println(”Cleint send is :“ + line);out

=

new PrintWriter(socket.getOutputStream(),true);out.println(”Your Message Received!“);out.close();in.close();socket.close();}

}catch(IOException e){ out.println(”wrong“);} }

public static void main(String[] args){ new Server();} }

Client端程序: package test;import java.io.*;import java.net.*;public class Client { Socket socket;BufferedReader in;PrintWriter out;public Client(){ try {

System.out.println(”Try to Connect to 127.0.0.1:10000“);socket = new Socket(”127.0.0.1“,10000);System.out.println(”The Server Connected!“);System.out.println(”Please enter some Character:");BufferedReader

line

=

new

BufferedReader(new InputStreamReader(System.in));

out = new PrintWriter(socket.getOutputStream(),true);Out

3、接口和内部类、抽象类的特征答：接口：在一个类里，只有申明没有实现。内部类：是在一个类的内部定义的一个类；抽象类：是以abstract 定义的，里面至少有一个抽象方法。

4、文件读写的基本类

答：File Reader 类和FileWriter类分别继承自Reader类和Writer类。FileReader类用于读取文件，File Writer类用于将数据写入文件，这两各类在使用前，都必须要调用其构造方法创建相应的对象，然后调用相应的read()或 write()方法。

6、线程的基本概念、线程的本状态以及状态之间的关系 ?新建(Born): 新建的线程处于新建状态?就绪(Ready): 在创建线程后，它将处于就绪状态，等待 start()方法被调用?运行(Running): 线程在开始执行时进入运行状态?睡眠(Sleeping): 线程的执行可通过使用 sleep()方法来暂时中止。在睡眠后，线程将进入就绪状态?等待(Waiting): 如果调用了 wait()方法，线程将处于等待状态。用于在两个或多个线程并发运行时。?挂起(Suspended): 在临时停止或中断线程的执行时，线程就处于挂起状态。?恢复(Resume): 在挂起的线程被恢复执行时，可以说它已被恢复。?阻塞(Blocked)– 在线程等待一个事件时（例如输入/输出操作），就称其处于阻塞状态。?死亡(Dead)– 在 run()方法已完成执行或其 stop()方法被调用之后，线程就处于死亡状态。

5、串行化的注意事项以及如何实现串行化答：如果有循环引用是不可以串行化的。对象输出流的WriteObject方法和 对象输入流的ReadObect 方法

7、线程的同步、如何实现线程的同步答：当两个或多个线程同时访问同一个变量，并且以个线程需要修改这个变量。就要用到线程同步。在Java 中，同步是通过 synchronized 关键字来定义的。诺是想同步化某程序段，可以使用 synchronized(object){}方法，其中{}内的程序语句被同步化。

9、socket通信（tcp/udp区别及JAVA的实现方式）TCP——传输控制协议，具有极高的可靠性，保证数据包按照顺序准确到达，但其也有着很高的额外负担。UDP——使用者数据元协议，并不能保证数据包会被成功的送达，也不保证数据包到达的顺序，但其传输速度很快。大多数我们会使用TCP，偶尔才会动用UDP，如声音讯号，即使少量遗失，也无

关紧要。

10、JAVA的事件委托机制和垃圾回收机制

java 事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处理这个事件，然后返回。垃圾回收机制 垃圾收集是将分配给对象但不在使用的内存回收或释放的过程。如果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收

11、JDBC调用数据库的基本步骤导入必要的类，装入JDBC驱动程序，识别数据源，分配一个Connection对象，分配一个Statement对象，使用Statement执行一个查询，从返回的ResultSet对象中检索数据，关闭ResultSet，关闭Statement对象，关闭Connection对象

12、解析XML文件的几种方式和区别答：Dom解析 在内存中创建一个DOM树，能随机访问文件内容，也可以修改原文件内容SAX解析 线性解析，不能随机访问，也无法修改原文件Dom解析要先用SAX解析创建DOM树

13、JAVA的四种基本权限的定义public private protected 默认

14、JAVA的国际化 答：Java 中提供了诺干国际化明感类，来实现国际化的。例如：dateformat timezone 等等。