java基础面试题

最新推荐文章于 2022-03-23 16:15:20 发布

FairyTale

最新推荐文章于 2022-03-23 16:15:20 发布

阅读量1.5k

点赞数

本文链接：https://blog.csdn.net/hanxinxin001/article/details/8184660

版权

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

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

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

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

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

2、Java语言的11个关键特性.

(1)Easy:Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和

类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb.

(2)分布式:Java带有很强大的TCP/IP协议族的例程库,Java应用程序能够通过URL来穿过网络来访问远程对

象,由于servlet机制的出现,使Java编程非常的高效,现在许多的大的web server都支持servlet.

(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同,在

与多重继承的处理及Java的原类模型.

(4)健壮特性:Java采取了一个安全指针模型,能减小重写内存和数据崩溃的可能性。

(5)安全:Java用来设计网路和分布系统,这带来了新的安全问题,Java可以用来构建防病毒和防攻击的

System.事实证明Java在防毒这一方面做的比较好.

(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行,编译器产生的指

令字节码(Javabytecode)实现此特性,此字节码可以在任何机器上解释执行.

(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好.

(8)多线程:Java处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成.所以多线程

是Java作为服务器端开发语言的流行原因之一

(9)Applet和servlet:能够在网页上执行的程序叫Applet,需要支持Java的浏览器很多,而applet支持动态的网

页,这是很多其他语言所不能做到的.

3．面向对象的软件开发有哪些优点？

面向对象设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，是建立在“对象”概念基础上的方法学。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。

从面向过程到面向对象是程序设计技术的一个飞跃。人们之所以要采用面向对象的程序设计技术，其目的在于：按照与人类习惯思维方法一致的原则开发系统；提高代码的可重用性(或者称为复用性)；提升程序的开发与运行效率；提高程序的可靠性与可维护性；提高程序的可扩展性；增强程序的可控制性。总之，面向对象的程序设计，能够有效分解、降低问题的难度与复杂性，提高整个求解过程的可控制性、可监视性和可维护性，从而获得较高的开发效率与可靠效果。

4．什么叫对象？什么叫类？类和对象有什么关系。

对象(Object)是一个应用系统中用来描述客观事物的实体，是具有特定属性(数据)和行为(方法)的基本运行单位，是类的一个特定状态下的实例。对象是一件事、一个实体、一个名词、一个可以想象为有自己的标识的任何东西。对象是类的实例化。概括来说：万物皆对象。对象具有状态，一个对象用数据值来描述它的状态。

类(Class)是Java代码的基本组织模块，是用以描述一组具有共同属性和行为的对象的基本原型，是对这组对象的概括、归纳与抽象表达。类是对象的模板，它定义了本类对象所应拥有的状态属性集及操作这组属性的行为方法集。是对一组有相同数据和相同操作的对象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。

类和对象之间的关系是抽象和具体的关系：类就是一种模板，表达的是一种抽象的概念，它描述了该类对象的共同特征，类是在对象之上的抽象，对象则是类的具体化，是类的实例。对象是模板的实例化，是个性的产物，是一个具体的个体；类必须通过对象才能使用，而对象中的属性和行为都必须在类中定义；类由属性和行为（方法）组成。

5、JAVA对象的创建过程？

1）、首先为对象分配内存空间

基本数据类型成员设置为默认值，其中boolean类型为false，整数类型为0小数为0.0；引用类型为null

2）、然后执行显式初始化，即执行在类成员声明时带有的简单赋值表达式

父类静态成员->子类静态成员->父类非静态成员->子类非静态成员

3）、执行构造方法，进行对象初始化。

父类构造函数->子类构造函数

请参考JAVA编程思想

6、java 和javasciprt 的区别。

JavaScript 与Java 是两个公司开发的不同的两个产品。Java 是SUN 公司推出的新一代面向对象的程序设计语言，特别适合于Internet 应用程序开发；而JavaScript 是Netscape 公司的产品，其目的是为了扩展Netscape Navigator功能,而开发的一种可以嵌入Web 页面中的基于对象和事件驱动的解释性语言,它的前身是Live Script；而Java 的前身是Oak 语言。下面对两种语言间的异同作如下比较：

1）基于对象和面向对象：

Java 是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；

JavaScript 是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用；

2）解释和编译：

Java 的源代码在执行之前，必须经过编译；

JavaScript 是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；

3）强类型变量和类型弱变量：

Java 采用强类型变量检查，即所有变量在编译之前必须作声明；

JavaScript 中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型；

4）代码格式不一样。

7．什么是包？把一个类放在包里有什么作用？

Java中的包(Package) 是一种松散的类的集合，是用来组织与管理类与接口的容器。包的作用主要是把需要协同工作的不同的类组织在一起，使得程序功能清楚、结构分明。

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

区别如下：

作用域当前类同包子孙类其他

public √ √ √ √

protected √ √ √ ×

default √ √ × ×

private √ × × ×

不写时默认为default。

9、简述条件操作(&&,||)与逻辑操作(&,|,^)的区别？

区别主要有两点：a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型b.逻辑操作不会产生短路。

数据类型：

1．试分析基本数据类型和引用数据类型的基本特点。

Java的基本数据类型都有固定的数据位，不随运行平台的变化而变化。

基本数据类型包括byte、int、char、long、float、double、boolean和short。

引用类型都是用类或对象实现的，引用数据类型包括:类,数组,接口。

基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的。不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上。

2、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;可以正确编译,自动类型提升。

3、int 和Integer 有什么区别?

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

int 是java 的原始数据类型，Integer 是java 为int 提供的封装类。

Java 为每个原始类型提供了封装类：

原始类型: boolean,char,byte,short,int,long,float,double

封装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

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

4、类型转换:

1)如何将数值型字符转换为数字？

2)如何将数字转换为字符？

3)如何取小数点前两位并四舍五入?

1)调用数值类型相应包装类中的方法parse***(String)或valueOf(String)即可返回相应基本类型或包装类型数值；

2)将数字与空字符串相加即可获得其所对应的字符串;另外对于基本类型数字还可调用String 类中的valueOf(…)方法返回相应字符串,而对于包装类型数字则可调用其toString()方法获得相应字符串；

3)可用该数字构造一java.math.BigDecimal 对象,再利用其round()方法进行四舍五入到保留小数点后两位,再将其转换为字符串截取最后两位。

变量：

1．什么是成员变量、局部变量、类变量和实例变量？

在方法外但在类声明内定义的变量叫成员变量，作用域是整个类。

在方法体中定义的变量和方法的参数被称为局部变量。

类的成员变量分为类变量和实例变量，类变量是用关键字static声明的变量。成员变量在整个类内都有效，局部变量只在定义它的方法内有效。

他们的生存期分别是：局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤销；实例变量在创建该类的实例时被创建，而其生存期和该类的实例对象的生存期相同；类变量在该类被加载时被创建，所有该类的实例对象共享该类变量，其生存期是类的生存期。任何变量在使用前都必须初始化,但是需要指出的是局部变量必须显式初始化，而实例变量不必，原始类型的实例变量在该类的构造方法被调用时为它分配的缺省的值，整型是0，布尔型是false，而浮点型是0.0f，引用类型（类类型）的实例变量的缺省值是null，类变量的规则和实例变量一样，不同的是类变量的初始化是在类被加载时。

2、静态变量和实例变量的区别？

静态变量也称为类变量，归全类共有，它不依赖于某个对象，可通过类名直接访问；而实例变量必须依存于某一实例，只能通过对象才能访问到它。

3、静态变量和实例变量的区别？

static i = 10; //常量class A a; a.i =10;//可变

4、类变量的初始化

在Java中类变量在局部中一定要初始化，因为局部变量会覆盖全局变量，否则会报错：变量未初始化。全局变量则可以不初始化，而到具体的内部方法或其他的类成员中初始化。

封装：

1、什么是封装？Java语言中的封装类有哪些？

封装是表示把数据项和方法隐藏在对象的内部，把方法的实现内容隐藏起来。Java中的封装类有Double、Integer、Float、Byte、Long、Character、Short和Boolean等类

继承：

1、什么是继承？什么是父类？什么是子类？继承的特性可给面向对象编程带来什么好处？

继承(Inheritance)：继承是指从已有的类中派生出若干个新类，是子类自动共享父类之间数据和方法的机制。已有类称为基类或父类，新类称为派生类或子类；子类将自动地获得基类的属性与方法，从而不需再重复定义这些属性与方法；当然子类还可以修改父类的方法或增加新的方法，从而使自己更适合特殊的需要。类之间的继承关系是现实世界中遗传关系的直接模拟。

如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。继承是子对象可以继承父对象的属性和行为，亦即父对象拥有的属性和行为，其子对象也就拥有了这些属性和行为。这非常类似大自然中的物种遗传。

2、下面哪些类可以被继承?

1）java.lang.Thread (T)

2）java.lang.Number (T)

3）java.lang.Double (F)

4）java.lang.Math (F)

5）java.lang.Void (F)

6）java.lang.Class (F)

7）java.lang.ClassLoader (T)

1、2、7 可以被继承。

子类Ａ继承父类B
A a = new A();
则父类B构造函数、父类B静态代码块、父类Ｂ非静态代码块、子类Ａ构造函数、子类A静态代码块、子类Ａ非静态代码块　执行的先后顺序是？

参考答案：父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

3、“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确？为什么？

这样说是不对的，因为父类的私有方法不能被继承。如果父类有N个私有域和方法而只有一个非私有的域或方法时，跟据继承的原则子类只能拥有父类的非私有域和方法。这时子类的域和方法就要小于父类了。

4、父类对象与子类对象相互转化的条件是什么？如何实现它们的相互转化？

一个子类对象也可以被合法地视为一个父类的对象，即一个父类对象的引用，其指向的内存单元可能实际上是一个子类的对象。在这种情况下，可以使用强制类型转换，将父类对象的引用转换成实际的子类对象的引用。

5．什么是方法的覆盖？与方法的重载有何不同？方法的覆盖与属性的隐藏有何不同？

子类重新定义父类中已经存在的方法，称为方法的覆盖。

方法重载指一个类中有多个方法享有相同的名字，但是这些方法的参数必须不同，或者是参数的个数不同，或者是参数类型不同。返回类型不能用来区分重载的方法。其实方法重载的最主要的作用就是实现同名的构造方法可以接受不同的参数。参数类型的区分度一定要足够，例如不能是同一简单类型的参数，如int与long。方法的重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。

方法覆盖与属性的隐藏不同：子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席之地。

多态：

1．什么是多态？面向对象程序设计为什么要引入多态的特性？

多态性：是指不同类的对象收到相同的消息时，得到不同的结果。即允许不同类的对象对同一消息作出各自的响应，以统一的风格处理已存在的数据及相关的操作。即

多态性语言具有灵活、抽象、行为共享、代码共享的优势，较好地解决了应用程序中方法同名的问题。多态的特点大大提高了程序的抽象程度和简洁性，更重要的是它最大限度地降低了类和程序模块之间的耦合性，提高了类模块的封闭性，使得它们不需了解对方的具体细节，就可以很好地共同工作。这对程序的设计、开发和维护都有很大的好处。

2、java 中实现多态的机制是什么？

方法的覆盖Overriding 和重载Overloading 是java 多态性的不同表现；覆盖Overriding 是父类与子类之间多态性的一种表现，重载Overloading 是一个类中多态性的一种表现。

3、构造器Constructor 是否可被override?

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

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

方法的重写Overriding 和重载Overloading 是Java 多态性的不同表现。重写Overriding 是父类与子类之间多态性的一种表现，重载Overloading 是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded 的方法是可以改变返回值的类型。

5、不同于方法，构造器不能是abstract, static, final, native, strictfp, 或者synchronized的.
1.构造器不是通过继承得到的，所以没有必要把它声明为final的。
2.同理，一个抽象的构造器将永远不会被实现。（所以也不能声明为abstract的）
3.构造器总是关联一个对象而被调用，所以把它声明为static是没有意义的。
4.没有实际的需要把构造器定义成同步的，因为它将会在构造的时候锁住该对象，直到所有的构造器完成它们的工作，这个构造的过程对其它线程来说，通常是不可访问的。（synchronized）
5.本地化的方法情况特别复杂，所以JVM调用起来非常麻烦，需要考虑很多种情况，没有native关键字的情况下，JVM实现起来比较容易。

String和StringBuffer：

1、String, StringBuffer StringBuilder 的区别。

String 的长度是不可变的；

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

StringBuilder 是从JDK 5 开始，为StringBuffer 该类补充了一个单个线程使用的等价类；通常应该优先使用StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

将字符串转化成整数和将整数转化成字符串的方式：

int n = Integer.parseInt("123");//将字符串转化成整形

String s = String.valueOf(int a );//将整形转化为字符串

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

可用字符串构造一StringBuffer 对象,然后调用StringBuffer 中的reverse方法即可实现字符串的反转,调用replace 方法即可实现字符串的替换。

3、以下二条语句返回值为true 的有：

A：“beijing”==“beijing”；

B：“beijing”.equalsIgnoreCase（new String（“beijing”））；

A 和B 。

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

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

5、有没有length()这个方法? String 有没有length()这个方法？

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

数组：

1、数组的定义

数组是作为一种对象实现的。数组元素可以包含任何类型值，但数组里面的每个元素的类型必须一致创建数组步聚如下：

声明

构造

初始化

抽象类和接口：

1、abstract class 和interface 有什么区别?

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。新型多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，所有成员变量都是public static final 的。一个类可以实现多个接口，当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

2．接口与抽象类有哪些异同点？

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

接口与抽象类的主要异同点如下：

(1) 接口定义了一组特定功能的对外接口与规范，而并不真正实现这种功能，功能的实现留待给实现这一接口的各个类来完成。抽象类一般作为公共的父类为子类的扩展提供基础，这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性，只考虑方法，使得子类可以自由的填补或者扩展接口所定义的方法。抽象类表示的是“is-a”关系，接口着重表示的是“can-do”关系。

(3) 接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种只包含常量与抽象方法的特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。接口里面不能有私有的方法或变量，是用于让别人使用的，接口中的所有常量必须是public static final，且必须给其初值，其实现类中不能重新定义，也不能改变其值。接口中的方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。抽象类中是可以有私有方法或私有变量的，抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

(4) 实现抽象类和接口的类必须实现其中的所有方法。在抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。而在interface中，只能够有静态的不能被修改的数据成员，所有的成员方法都是abstract的。实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法。一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

3．区分接口与抽象类分别在什么场合使用？

如果预计要创建类的多个版本，则创建抽象类。抽象类提供简单的方法来控制类版本。

如果创建的功能将在大范围的异类对象间使用，则使用接口。

如果要设计小而简练的功能块，则使用接口。

如果要设计大的功能单元，则使用抽象类。如果要向类的所有子类提供通用的已实现功能，则使用抽象类。

抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。

抽象类应主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。

接口多定义对象的行为；抽象类多定义对象的属性；

4、什么叫抽象类？抽象类跟接口有什么区别？为什么引进数据接口概念？

具有关键字abstract ，在实现内容上没有完全定义的类就叫抽象类。

抽象类和接口的区别如下：

① 在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现接口则要实现里面的全部方法。

②在接口中无成员变量，而抽象类中可有成员变量。

在Java中引进接口主要是为了解决多继承的问题。

5、abstract 的method 是否可同时是static,是否可同时是native，是否可同时是synchronized?

都不能。

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

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

7、Java 的接口和C++的虚类的相同和不同处。

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

8、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)？

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

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

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

10、说出一些常用的类，包，接口，请各举5 个。

常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer；

常用的包：java.lang java.awt java.io java.util java.sql；

常用的接口：Remote List Map Document NodeList

Object类：

1、Object类的概述

Object类是所有其他的类的超类，Object的一个变量可以引用任何其他类的对象。因为数组是作为类实现的，所以Object的一个变量也可以引用任何数组，它包括以下几种方法：

clone() equals() finalize() getClass() hashCode() notify() notifyAll() toString() wait()

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

不对，有相同的hash code。

3、== 与 equals 的区别:

"==" 比较的是两个对象的引用 (references)，并不是他们的内容.

equals(Object) 方法与 "==" 相比的特殊之处就在于它可以覆盖，所以我们可以通过覆盖的办法让它不是比较引用而是比较数据内容。当然 JDK 中也有覆盖过 equals(Object) 方法的类，如 java.lang.String，它就覆盖了从 Object 继承来的的 equals(Object) 方法，用以比较字符串内容是否相同。

4、toString方法的概述

因为每个类都继承了Object类，所以都实现了toString()方法。

通过toString()方法可以决定所创建对象的字符串表达形式。

集合：

1、你所知道的集合类都有哪些？主要方法？

最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。

Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

2、介绍Java中的Collection Framework(包括如何写自己的数据结构)？

Collection Framework 如下：

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│ └Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）

Map 提供key到value 的映射

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

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

4、说明List和Set的区别

两者主要区别如下：

List用来处理序列，而Set用来处理集。

List中的内容可以重复，而Set则不行。

5、ArrayList和Vector的区别

主要从二方面来说.

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

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

6、HashMap和Hashtable的区别

就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

7、HashMap和Hashtable的区别？

HashMap 是Hashtable 的轻量级实现（非线程安全的实现），他们都完成了Map 接口，主要区别在于HashMap 允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable 不允许。

HashMap把Hashtable 的contains 方法去掉了，改成containsvalue 和containsKey。因为contains 方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap 不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

8、Collection 和 Collections的区别

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

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

Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

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

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

11、heap 和stack 有什么区别？

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

12、堆栈的区别
I、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
II、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表
III、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 – 程序结束后有系统释放
IV、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放
V、程序代码区—存放函数体的二进制代码。
申请方式：
stack:由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
heap:需要程序员自己申请，并指明大小，在c中malloc函数
堆和栈的区别可以用如下的比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

13．什么是泛型？使用泛型有什么优点？泛型List和普通List有什么区别？

泛型是对Java语言的数据类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看做是使用参数化类型时指定的类型的一个占位符。

优点：提高Java程序的类型安全；消除强制类型转换；提高代码的重用率。

泛型List可以实例化为只能存储某种特定类型的数据，普通List可以实例化为存储各种类型的数据。通过使用泛型List对象，可以规范集合对象中存储的数据类型，在获取集合元素时不用进行任何强制类型转换。

14、什么时候用assert？

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，assertion 用于保证程序最基本、关键的正确性。

assertion 检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion 检查通常是关闭的。在实现中，断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为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 标记。还可以在包的基础上启用或者禁用断言。可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

异常处理：

1．什么是异常？什么是Java的异常处理机制？

异常是指程序运行过程中产生的错误，它出现在程序运行过程中。

异常处理机制是为程序提供错误处理的能力。根据这个机制，对程序运行时可能遇到的异常情况，预先提供一些处理的方法。在程序执行代码的时候，一旦发生异常，程序会根据预定的处理方法对异常进行处理，处理完成后，程序进行运行。

2．Java中的异常分为哪几类？

Java中的异常分为两种类型：

? 内部错误：又称为致命错误。比如：硬盘损坏、软驱中没有软盘

? 运行时异常：比如除数为0、数组下标越界

3、Java中的异常处理机制？

当JAVA 程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。

违反语义规则包括2种情况：一种是JAVA 类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访

问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的

异常，并自由选择在何时用throw 关键字引发异常。所有的异常都是java.lang.Thowable的子类。

4、java语言如何进行异常处理，关键字throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable 类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。

用 try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。

throw语句用来明确地抛出一个"异常"。

throws用来标明一个成员函数可能抛出的各种"异常"。

Finally为确保一段代码不管发生什么"异常"都被执行一段代码。

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。

5、error和exception有什么区别

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

6、谈谈final, finally, finalize 的区别？

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

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

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

7、给我一个你最常见到的runtime exception。

ArithmeticException, NullPointerException, IndexOutOfBoundsException, ClassCastException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException,

CannotUndoException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,

ImagingOpException, MissingResourceException, NegativeArraySizeException,

NoSuchElementException, ProfileDataException, ProviderException, RasterFORMatException,

SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

IO：

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

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

2、文件读写的基本类

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

3、.BufferedReader的父类是以下哪个？

A. FilterReader B. InputStreamReader C. PipedReader D. Reader
参考答案：D

4、文件和目录（I/O）操作

如何列出某个目录下的所有文件

判断一个文件或目录是否存在

如何读写文件

线程：

1: JAVA中怎么实现多线程?

单核CPU来用多线程的方式来计算1加到100000和用单线程的方式计算那个好些呢？（可以使用多线程来输出10000个string类型的和单线程相比时间上的区别）

2、请说出你所知道的线程同步的方法。

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由

JVM确定唤醒哪个线程，而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

3、多线程实现有那几种方法，同步有哪几种方法？

实现同步主要有两种方法：1.synchronized 2.wait notify

实现多线程主要继承Thread 类和实现Runnable接口。

4、启动一个线程是用run()还是start()?

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

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

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

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

线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
Java中的线程有四种状态分别是：运行、就绪、挂起、结束。

7、sleep() 和 wait() 有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

8、多线程的优点

可分两方面来答：

相对于单线程而言：

可以响应多任务的并发操作。

多线程取消了主循环和轮流检测机制，一个线程可以暂停而不阻止系统其他的部分的执行，而且当程序中一个线程阻塞时，只有那个被阻塞的线程暂停，所有其他的线程继续执行。

相对于进程而言：(可以答也可以不答)

它所要求的开销比较小，转换成本较小。

所有线程共享同一地址空间，相互协作。

彼此之间通信很容易。

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

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

10、简述synchronized和java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

序列化：

1、什么是Java序列化，如何实现Java 序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream 对象的writeObject(Object obj)方法就可以将参数为obj 的对象写出(即保存其状态)，要恢复的话则用输入流。

日期处理：

1、
1)如何取得年月日、小时分秒？
2)如何取得从1970 年到现在的毫秒数？
3)如何取得某个日期是当月的最后一天？
4)如何格式化日期？

1)创建java.util.Calendar 实例(Calendar.getInstance()),调用其get()方法传入不同的参数即可获得参数所对应的值,如：calendar.get(Calendar.YEAR);//获得年

2)以下方法均可获得该毫秒数:

Calendar.getInstance().getTimeInMillis();

System.currentTimeMillis();

3)示例代码如下:

Calendar time = Calendar.getInstance();

time.set(Calendar.DAY_OF_MONTH,

time.getActualMaximum(Calendar.DAY_OF_MONTH));

4)利用java.text.DataFormat 类中的format()方法可将日期格式化。

DateFormate df=DateFormate.getInstance();

df.Format(dat);

2、Java 编程,打印昨天的当前时刻。

public class YesterdayCurrent{

public static void main(String[] args){

Calendar cal = Calendar.getInstance();

cal.add(Calendar.DATE, -1);

System.out.println(cal.getTime());

}

JVM：

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

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

Java通信编程：

1、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 client come in!IP:"+RemoteIP+RemotePort);

in = new BufferedReader(new

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.println(line.readLine());

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

System.out.println(in.readLine());

out.close();

in.close();

socket.close();

}catch(IOException e) {

out.println("Wrong");

}

public static void main(String[] args) {

new Client();

}

2、socket通信（tcp/udp区别及JAVA的实现方式）

TCP——传输控制协议，具有极高的可靠性，保证数据包按照顺序准确到达，但其也有着很高的额外负担。UDP——使用者数据元协议，并不能保证数据包会被成功的送达，也不保证数据包到达的顺序，但其传输速度很快。

大多数我们会使用TCP，偶尔才会动用UDP，如声音讯号，即使少量遗失，也无关紧要。

3、Corba概述

通用对象请求代理，它的主要目标是解决面向对象的异构应用之间的互操作问题，并提供分布式计算所需的一些其他的服务。ORB是CORBA的核心。

CORBA重新调整了客户与服务器之间的关系。客户可以向服务器提出事务请求，同时也可以为下一个请求充当服务器角色。由于CORBA系统引入了中间件的概念，即事件代理，由中间件完成客户机与服务器之间的通信，使得服务器对于客户机的位置相对透明，取消了原有分布式计算机模型中客户机----服务器之间的一一对应关系，CORBA客户机可以在运行时动态获得服务对象的位置，并且可以对多个服务对象提交事务请求，所以它极大的推动了分布计算的发展。另外，CORBA规范约束采用面向对象的分布式方法，以接口定义语言的形式实现对象内部细节的完整封装，从而降低了软件系统的复杂度，增加了软件功能的可重用性。CORBA提供到C C++ JAVA 等高级语言的映射，极大程度地减小了程序设计语言的依赖性。

内部类：

1、

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();}

答案为C、E；说明如下：

1）静态内部类可以有静态成员，而非静态内部类则不能有静态成员；故A、B错；

2）静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；故D 错；

3）非静态内部类的非静态成员可以访问外部类的非静态变量；故C 正确。

2、Static Nested Class 和Inner Class的不同？

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

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

3、Static Nested Class 和Inner Class 的不同？

Static Nested Class 是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

内部类：

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

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

可以继承其他类或实现其他接口，在swing 编程中常用此方式。

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

匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

6、内部类可以引用他包含类的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的内容。

7、Java中的事件处理机制？

事件从事件源到监听者的传递是通过对目标监听者对象的Java 方法调用进行的。对每个明确的事件的发生，都相应地定义一个明确的Java 方法。这些方法都集中定义在事件监听者接口（EventListener Interface）中，这个接口要继承java.util.EventListener。实现了事件监听者接口中一些或全部方法的类就是事件监听者。伴随着事件的发生，相应的状态通常都封装在事件状态对象（Event State Object）中，该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。有时，事件监听者不能直接实现事件监听者接口，或者还有其它的额外动作时，就要在一个源与其它一个或多个监听者之间插入一个事件适配器类的实例，来建立它们之间的联系。

垃圾回收机制：

1、GC 是什么? 为什么要有GC?

GC 是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java 提供的GC 功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java 语言没有提供释放已分配内存的显示操作方法。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() 。

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

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

收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

3、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

对于GC 来说，当程序员创建对象时，GC 就开始监控这个对象的地址、大小以及使用情况。通常，GC 采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC 确定一些对象为"不可达"时，GC 就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC 运行，但是Java 语言规范并不保证GC 一定会执行。