android开发中Final、finally、finanlize()的区别是什么?

finalize：[动词] 收尾，终结，使结束，将......定案

finalize_百度翻译finalize 英[u02c8fau026anu0259lau026az] 美[u02c8fau026anu0259u02cclau026az] vt. 完成; 使结束; 使落实; vi. 定案; 把…最后定下来; [例句]Negotiators from the three countries finalized the agreement in August8月里三国谈判人员最终敲定了协议。[其他] 第三人称单数：finalizes 现在分词：finalizing 过去式：finalized过去分词：finalized

finalize的形容词形式是final。一、读音英[u02c8fau026anu0259lau026az]，美[u02c8fau026an(u0259)lu02ccau026az]。二、释义使落实；使完成；把…最后定下来。网络释义：定稿；定案；把最后定下来。三、词性作动词：把（计划、旅行、项目等）最后定下来；定案。四、同义词settle v.解决（分歧、纠纷等）；定居；结束（争论、争端等）；（最终）决定，确定，安排好；使处于舒适的位置。n.高背长椅（老式木家具，有扶手，座下多带柜）。confirm v.（尤指提供证据来）证实，证明；使感觉更强烈；使确信；批准（职位、协议等）；确认；认可；施放坚振，施坚信礼。decide v.决定；对...作出抉择；选定；裁决；判决；成为（某人）做某事的原因。五、反义词start v.开始；启动，发动，开动；着手（做或使用）；（使）发生；（使）出现；出发；起身走向。n.开头，开端，开始；起始优势；良好的基础条件；起点；起跑的提前量（时间或距离）；（参加的）比赛。finalize的例句：1、The Argentinean finalizes contract to end of the present campaign and the club not yet has made him a supply of renovation.阿根廷人的合同将在本赛季末到期，俱乐部还没有为他提供一份新的合同没消模。2、Changes made during a transaction are tentative;to make them permanent,a transaction ends with a commit action that finalizes the changes.为使事务持久，在事务的试验期所做的变更，最终必须用提交操作作为事务的结尾。3、This indicates that it received the previous acknowledgment and finalizes the connection process for this session.这表示它己接收先前的桥姿确认且完成此交谈的连线程序。4、Cooperate with China Telecom IT suppliers to finalize system fundamental design installation drawings.与中国电信和IT供应商完成系统原理设计和安装图纸设计。5、A couple finalizes their Las Vegas wedding after a quick ceremony at the Little White Wedding Chapel,which features drive-through service.拉斯维加斯婚礼图片。一对夫妇快速完成他们的拉斯维加斯婚礼在那小白婚礼教堂，其特征是驾车联营业务。6、Meanwhile,it finalizes targeted measures by analysing the problems.同时，分析形成了问题解决的枯缓针对性措施。

三个虽然很相似 但是完全出于不同的概念和领域，也就是风马牛不相及的三个东西.final修饰符 修饰常量finally 用于捕获异常的最后输出finalize是垃圾回收机制里面的方法，目前基本所有公司都不用

设计一个对象重生的代码来演示，如下：具体解析如下：为方便起见, 把a,b两个变量所指的内存空间就叫做a和b。A a = new A(new B("allen" , 20))　 ; //此时a和b都是reachable, unfinalized状态。a = null ;这之后, a和b的状态会在某一个时刻变成unreachable, unfinalized或者a和b直接变成f-reachable, unfianlized。然后在某个时刻，GC检测到a和b处于unfinalized状态，就将他们添加到F-queue，并将状态改为f-reachable finalizable。之后分两种情况:1、 GC从F-queue中首先取出a, 并被某个线程执行了finalize(), 也就相当于被某个活动的线程持有, a状态变成了reachable, finalized.。此时由于a被c对象所引用,所以之后不会变成unreachable finalized而被销毁(重生) 与此同时，b由于一直被a所引用,，所以b的状态变成了reachable, finalizable.。然后在某个时刻被从F-queue取出, 变成reachable, finalized状态。2、GC从F-queue中首先取出b,并被某个线程执行了finalize(), 状态变成reachable finalized. 然后a也类似, 变成reachable finalized状态, 并被c引用，重生。扩展资料：尽量避免使用finalize()：1、finalize()不一定会被调用, 因为java的垃圾回收器的特性就决定了它不一定会被调用。2、就算finalize()函数被调用, 它被调用的时间充满了不确定性, 因为程序中其他线程的优先级远远高于执行finalize（）函数线程的优先级。也许等到finalize()被调用, 数据库的连接池或者文件句柄早就耗尽了。3、如果一种未被捕获的异常在使用finalize方法时被抛出，这个异常不会被捕获，finalize方法的终结过程也会终止，造成对象出于破坏的状态。被破坏的对象又很可能导致部分资源无法被回收, 造成浪费。4、finalize()函数和垃圾回收器的运行本身就要耗费资源, 也许会导致程序的暂时停止。参考资料：百度百科--finalize

final做形容词意思是最终的，还有期末考试的意思。例：This is the final decision.这是最终的觉得。finally最后地，例：Finally we arrived.最后我们到达了。finalize动词，意思是敲定，例：Can we finalize the travel plan by tomorrow?我们明天之前能敲定旅行计划吗？

当垃圾回收器认为一个对象没有存在意义时，会调用该对象的这个方法，释放该对象在堆中占用的内存。此方法继承于始祖Object。

无论是否抛出异常，finally代码块都会执行，它主要是用来释放应用占用的资源。finalize()方法是Object类的一个protected方法，它是在对象被垃圾回收之前由Java虚拟机来调用的。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等

Finish表示过去某个时候着手做的事已经做完，或者表示对已经做完的事进行精密加工。例：As soon as he had finished, Jenny told him she wanted to go home. 他一讲完，珍妮就告诉他说她想回家。 This machine part needs surface finishing. 这个机械零件需要精密加工。 Finalize 词根fin＝to end（结束） v.把(计划,稿件等)最后定下来,定案，主要用于官方文字，意思是把办理了很久或搁置了了的事情做一了结。例如：to finalize a budge estimate（完成预算估计.例：同时，工业设计师和工程师一道来完成部件和组装部分的工作。At the same time, industrial designers work with engineers to finalize components and assembly.他说，关于拟议中访问的计划还需作最后肯定。He said he had got to finalize the plan for the proposed visit.一个现成的例子就是，在欧洲央行最近的一项协议中，跨国界交易和资本流动的成本和银行佣金率降低的最后期限被。The recent agreement clinched by the ECB to finalize the deadline for lowering the charges and commission rates for trans-border transactions and capital transfer can serve as a case in point.

在 Java 中，垃圾回收器在回收无用对象内存时，会调用对象的 finalize() 方法以便在对象释放内存之前完成一些清理工作。在 finalize() 方法中，可以对对象进行一些资源清理、关闭等操作，但是不能对其它对象进行引用，否则可能会导致对象复活。对象复活是指在对象的 finalize() 方法中，对该对象进行了一些操作，使得该对象重新被引用，从而避免了垃圾回收器对该对象的回收。如果在 finalize() 方法中对该对象进行了引用，则该对象不会被垃圾回收器回收，而是被认为是活动对象，从而继续存在于内存中。需要注意的是，对象复活并不是一种推荐的编程方式，因为它会导致内存泄漏和性能问题。在 Java 中，应该尽量避免使用 finalize() 方法，并使用 try-with-resources 或手动关闭资源等方式来进行资源清理和释放。

final是形容词，表示最终的，后加名词做修饰对象，作为名词时表示决赛或期末考试；finally是副词，是在final的形式上加-ly变成副词， 1. 表示先后顺序的“最后”、“终于”，通常放在句首。如：The carwouldn"t start, so finally we decided to go on foot. 汽车不能发动，所以我们最后决定走路去。此用法尤其用于在列举时引出最后一项。如：He lived in Turkey, France, Norway and finally Mexico. 他曾在土耳其、法国、挪威等国住过，最后还在墨西哥住过.2. 表示等了好久才“终于”，此时通常放在谓语动词之前 (若有助动词放在助词后)。如：After several long delays, the plane finallyleft at 6 o"clock. 在几次长时间的耽误之后，飞机终于在6点钟起飞。When he finally arrived he explained he had lost hisway. 他最后赶到时，他解释说他迷路了。 3. 表示决定性的或不再更改的“最后”。如：It is not finallysettled yet. 这事还未最后解决最后一个是finalize吧。是及物动词，表示完成，结束，最终化，把......确定下来。

你好！finalise 和 finalize用法和意思没什么区别，但在英国人们基本用finalise，而在美国则大多用finalize。所以从这点来说，finalise 是 finalize 的根，finalize 是从 finalise 发展出来的。以上仅供参考！

这个方法不是给你调的，是给GC回收垃圾时调的你没发现它是protected的么？！

对。一个类被声明为final,意味着它不能再派生出新的子类,不能作为父类被继承.因此一个类不能既被声明为 abstract的,又被声明为final的.将变量或方法声明为final,可以保证它们在使用中不被改变.被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改.被声明为final的方法也同样只能使用,不能重载finally?再异常处理时提供 finally 块来执行任何清除操作.如果抛出一个异常,那么相匹配的 catch 子句就会执行,然后控制就会进入 finally 块（如果有的话）.finalize?方法名.Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作.这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的.它是在 Object 类中定义的,因此所有的类都继承了它.子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作.从这些描述就可以看出来，final可以用在变量上，自然可以用在类内部。finally本来就是处理异常的，用哪里都行，另外那个也是这样

一个对象被判定符合GC条件以后，在GC之前finalize（）方法会被调用，所以基本可以说其被回收了。但是有种特殊情况：就是在finalize（）中重新让对象不符合GC条件，这样对象就避开了一次GC，这时对象就没有被回收，下次对象再次符合条件的时候finalize（）也不会被调用，但是它还是被回收了ps：finalize（）只能被调用一次

不能重写只是编译器干的事儿，实际上它就是想让你只能写析构函数，而写析构函数就相当于重写了Finalize。这只是一种设计方式。你可以改Assembly的代码，直接写IL，会发现是可以override的。你可以上网搜索一下Mono.cecil，有相关的内容。举个例子，按照C#的规范，一个类里面是不可能有两个方法名相同，参数相同，而仅仅是返回值不同的方法的，例如：publicclassMyClass{publicstringFoo(){}publicintFoo(){}}直接写上述C#代码，编译无法通过，编译器会告诉你这两个方法签名是不明确的。但是如果是IL（即Assembly中编译后的内容），是可以有这么两个方法的。因为IL中描述的方法其实就是个方法的地址，根本不管你的方法是叫啥名字。只要知道地址，就能调用。================================再补充一下，你可以自己做这个实验：首先写一个类：publicclassSampleClass{publicSampleClass(){}~SampleClass(){}}编译。然后使用VisualStudio自带的工具ILDisassembler，一般位于开始菜单的MicrosoftVisualStudio2010（看你自己的安装版本）MicrosoftWindowsSDKTools下面打开刚才编译好的dll或者exe,在左边会有一个类型列表，找到刚才写的SampleClass，点开"+"，会看到下面有两个方法，一个是：.ctor:void()这个其实就是构造函数另一个是：Finalize:void()这个就是我们刚才写的析构函数。这说明什么呢？说明其实析构函数就是重载的Finalize。也就是编译器给我们玩儿的小把戏而已。再双击这个Finalize:void(),可以看到里面的IL代码：.methodfamilyhidebysigvirtualinstancevoidFinalize()cilmanaged{//Codesize14(0xe).maxstack1.try{IL_0000:nopIL_0001:nopIL_0002:leave.sIL_000c}//end.tryfinally{IL_0004:ldarg.0IL_0005:callinstancevoid[mscorlib]System.Object::Finalize()IL_000a:nopIL_000b:endfinally}//endhandlerIL_000c:nopIL_000d:ret}//endofmethodSampleClass::Finalize注意这一句：[mscorlib]System.Object::Finalize()IL_000a:nopIL_000b:endfinally其实就是在调用基类的（即object）的Finalize方法

gc 只能清除在堆上分配的内存(纯java语言的所有对象都在堆上使用new分配内存),而不能清除栈上分配的内存（当使用JNI技术时,可能会在栈上分配内 存,例如java调用c程序，而该c程序使用malloc分配内存时）.因此,如果某些对象被分配了栈上的内存区域,那gc就管不着了,对这样的对象进行 内存回收就要靠finalize().举个例子来说,当java 调用非java方法时（这种方法可能是c或是c++的）,在非java代码内部也许调用了c的malloc()函数来分配内存，而且除非调用那个了 free() 否则不会释放内存(因为free()是c的函数),这个时候要进行释放内存的工作,gc是不起作用的,因而需要在finalize()内部的一个固有方法 调用它(free()).finalize的工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存.所以如果使用finalize()，就可以在垃圾收集期间进行一些重要的清除或清扫工作.

回收机制就是 当一些资源被创建使用之后或不在调用的话 就会变成垃圾，垃圾的话会占用空间，这时候就需要释放空间给其他程序使用，所以JAVA拥有自动垃圾回收机制，会在适当的时候自动调用垃圾回收 释放资源，程序员也可以手动调用释放资源等等。如：public class A {String str;public A(String str){ this.str=str;} public String toString(){ return str; } @Override protected void finalize() throws Throwable { System.out.println("我是"+str+".我被回收了.."); } public static void main(String[] args) { A a=new A("李四"); a=null; System.gc(); //运行结果 我是李四.我被回收了.. }}

同意楼下的说法。java垃圾回收机制好好去理解理解。

首先，finalize（）一定会被执行，但是并不总是那么及时，原因有二： 1、垃圾回收器并不总是工作，只有当内存资源告急时，垃圾回收器才会工作； 2、即使垃圾回收器工作，finalize方法也不一定得到执行，这是由于程序中的其他线程的优先级远远高于执行finalize（）函数线程的优先级。 因此，当finalize还没有被执行时，系统的其他资源，比如文件句柄、数据库连接池等已经消耗殆尽，造成系统崩溃。第二，如果一种未被捕获的异常在使用finalize方法时被抛出，这个异常不会被捕获，finalize方法的终结过程也会终止，造成对象出于破坏的状态。第三，第二种情况已经是一种特例，还有其他的情况也会造成对象不会被销毁，从而浪费内存。第四，垃圾回收和finalize方法的执行本身就是对系统资源的消耗，有可能造成程序的暂时停止，因此在程序中尽量避免使用finalize方法。

finalize是会执行的，不过不是在你的方法执行完后，通常这样认为是错误的。那个方法的执行是在GC回收那个对象时执行。你的方法执行完了GC不一定就会回收那个对象。所以不能说不执行，而是不能控制它在什么时候执行。

在f对象的finalize方法里重新将当前对象赋值，变成可达对象，当这个f对象再次变成不可达时还会执行finalize方法吗？答案是否定的，因为在执行完第一次finalize方法后，这个f对象已经和之前的Finalizer对象剥离了，也就是下次GC的时候不会再发现Finalizer对象指向该f对象了，自然也就不会调用这个f对象的finalize方法了。

MSDN建议按照下面的模式实现IDisposable接口： 1 public class Foo: IDisposable2 {3 public void Dispose()4 {5 Dispose(true);6 GC.SuppressFinalize(this);7 }8 9 protected virtual void Dispose(bool disposing)10 {11 if (!m_disposed)12 {13 if (disposing)14 {15 // Release managed resources16 }17 18 // Release unmanaged resources19 20 m_disposed = true;21 }22 }23 24 ~Foo()25 {26 Dispose(false);27 }28 29 private bool m_disposed;30 }31 在.NET的对象中实际上有两个用于释放资源的函数：Dispose和Finalize。Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的。在这个模式中，void Dispose(bool disposing)函数通过一个disposing参数来区别当前是否是被Dispose()调用。如果是被Dispose()调用，那么需要同时释放 托管和非托管的资源。如果是被~Foo()（也就是C#的Finalize()）调用了，那么只需要释放非托管的资源即可。这是因为，Dispose()函数是被其它代码显式调用并要求释放资源的，而Finalize是被GC调用的。在GC调用的时候Foo所引用的其它 托管对象可能还不需要被销毁，并且即使要销毁，也会由GC来调用。因此在Finalize中只需要释放非托管资源即可。另外一方面，由于在 Dispose()中已经释放了托管和非托管的资源，因此在对象被GC回收时再次调用Finalize是没有必要的，所以在Dispose()中调用 GC.SuppressFinalize(this)避免重复调用Finalize。然而，即使重复调用Finalize和Dispose也是不存在问题的，因为有变量m_disposed的存在，资源只会被释放一次，多余的调用会被忽略过去。因此，上面的模式保证了：1、 Finalize只释放非托管资源；2、 Dispose释放托管和非托管资源；3、 重复调用Finalize和Dispose是没有问题的；4、 Finalize和Dispose共享相同的资源释放策略，因此他们之间也是没有冲突的。在C#中，这个模式需要显式地实现，其中C#的~Foo()函数代表了Finalize()。而在C++/CLI中，这个模式是自动实现的，C++的类析构函数则是不一样的。按照C++语义，析构函数在超出作用域，或者delete的时候被调用。在Managed C++（即.NET 1.1中的托管C++）中，析构函数相当于CLR中的Finalize()方法，在垃圾收集的时候由GC调用，因此，调用的时机是不明确的。在.NET 2.0的C++/CLI中，析构函数的语义被修改为等价与Dispose()方法，这就隐含了两件事情：1、 所有的C++/CLI中的CLR类都实现了接口IDisposable，因此在C#中可以用using关键字来访问这个类的实例。2、 析构函数不再等价于Finalize()了。对于第一点，这是一件好事，我认为在语义上Dispose()更加接近于C++析构函数。对于第二点，Microsoft进行了一次扩展，做法是引入了“！”函数，如下所示：1 public ref class Foo2 {3 public:4 Foo();5 ~Foo(); // destructor6 !Foo(); // finalizer7 };8“！”函数（我实在不知道应该怎么称呼它）取代原来Managed C++中的Finalize()被GC调用。MSDN建议，为了减少代码的重复，可以写这样的代码：1 ~Foo()2 {3 //释放托管的资源4 this->!Foo();5 }6 7 !Foo()8 {9 //释放非托管的资源10 }11对于上面这个类，实际上C++/CLI生成对应的C#代码是这样的：1 public class Foo2 {3 private void !Foo()4 {5 // 释放非托管的资源6 }7 8 private void ~Foo()9 {10 // 释放托管的资源11 !Foo();12 }13 14 public Foo() 15 {16 }17 18 public void Dispose()19 {20 Dispose(true);21 GC.SuppressFinalize(this);22 }23 24 protected virtual void Dispose(bool disposing)25 {26 if (disposing)27 {28 ~Foo();29 }30 else31 {32 try33 {34 !Foo();35 }36 finally37 {38 base.Finalize();39 }40 }41 }42 43 protected void Finalize()44 {45 Dispose(false);46 }47 }48由于~Foo()和!Foo()不会被重复调用（至少MS这样认为），因此在这段代码中没有和前面m_disposed相同的变量，但是基本的结构是一样的。并且，可以看到实际上并不是~Foo()和!Foo()就是Dispose和Finalize，而是C++/CLI编译器生成了两个Dispose 和Finalize函数，并在合适的时候调用它们。C++/CLI其实已经做了很多工作，但是唯一的一个问题就是依赖于用户在~Foo()中调 用!Foo()。关于资源释放，最后一点需要提的是Close函数。在语义上它和Dispose很类似，按照MSDN的说法，提供这个函数是为了让用户感觉舒服一点，因为对于某些对象，例如文件，用户更加习惯调用Close()。然而，毕竟这两个函数做的是同一件事情，因此MSDN建议的代码就是：1 public void Close()2 {3 Dispose(();4 }5 6 这里直接调用不带参数的Dispose函数以获 得和Dispose相同的语义。这样似乎就圆满了，但是从另外一方面说，如果同时提供了Dispose和Close，会给用户带来一些困惑。没有看到代码 细节的前提下，很难知道这两个函数到底有什么区别。因此在.NET的代码设计规范中说，这两个函数实际上只能让用户用一个。因此建议的模式是：1 public class Foo: IDisposable2 {3 public void Close()4 {5 Dispose();6 }7 8 void IDisposable.Dispose()9 {10 Dispose(true);11 GC.SuppressFinalize(this);12 }13 14 protected virtual void Dispose(bool disposing)15 {16 // 同前17 }18 }19这里使用了一个所谓的接口显式实现：void IDisposable.Dispose()。这个显式实现只能通过接口来访问，但是不能通过实现类来访问。因此：1 Foo foo = new Foo();2 3 foo.Dispose(); // 错误4 (foo as IDisposable).Dispose(); // 正确5----------------------------------以下是CSDN上一位高手的总结----------------------------------------------1、Finalize方法（C#中是析构函数，以下称析构函数）是用于释放非托管资源的，而托管资源会由GC自动回收。所以，我们也可以这样来区分 托管和非托管资源。所有会由GC自动回收的资源，就是托管的资源，而不能由GC自动回收的资源，就是非托管资源。在我们的类中直接使用非托管资源的情况很 少，所以基本上不用我们写析构函数。 2、大部分的非托管资源会给系统带来很多负面影响，例如数据库连接不被释放就可能导致连接池中的可用数据库连接用尽。文件不关闭会导致其它进程无法读写这个文件等等。 实现模型： 1、由于大多数的非托管资源都要求可以手动释放，所以，我们应该专门为释放非托管资源公开一个方法。实现IDispose接口的Dispose方法是最好的模型，因为C#支持using语句快，可以在离开语句块时自动调用Dispose方法。 2、虽然可以手动释放非托管资源，我们仍然要在析构函数中释放非托管资源，这样才是安全的应用程序。否则如果因为程序员的疏忽忘记了手动释放非托管资源， 那么就会带来灾难性的后果。所以说在析构函数中释放非托管资源，是一种补救的措施，至少对于大多数类来说是如此。 3、由于析构函数的调用将导致GC对对象回收的效率降低，所以如果已经完成了析构函数该干的事情（例如释放非托管资源），就应当使用SuppressFinalize方法告诉GC不需要再执行某个对象的析构函数。 4、析构函数中只能释放非托管资源而不能对任何托管的对象/资源进行操作。因为你无法预测析构函数的运行时机，所以，当析构函数被执行的时候，也许你进行操作的托管资源已经被释放了。这样将导致严重的后果。 5、（这是一个规则）如果一个类拥有一个实现了IDispose接口类型的成员，并创建（注意是创建，而不是接收，必须是由类自己创建）它的实例对象，则 这个类也应该实现IDispose接口，并在Dispose方法中调用所有实现了IDispose接口的成员的Dispose方法。 只有这样的才能保证所有实现了IDispose接口的类的对象的Dispose方法能够被调用到，确保可以手动释放任何需要释放的资源。

嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯嗯

　　 Java终止函数是什么? 　　对于对象而言 Java 终止函数履行最后的确认工作 这与Java 构造函数是相反的 Java 构造函数创建以及初始化了一个Java类实例 当一个对象不在被需要以及这些资源必须被用于其它对象的时候 在一个类实例或者发行的系统资源 比如说文件描述符或者网络 <;接口连接上 Java 终止函数可以被用来清除任务 你不需要证据或者为终止函数返回任何值 遗憾的是当一个类或者接口被载入的时候 目前的Java语言的介绍中没有任何关于终止函数用于Java类或者接口的解释 让我们进一步研究一下java lang对象的终止函数finalize()方法 提供一个方法实例 (如何使用PHP 中的Clone函数) 　　protected void finalize() throws Throwable 　　当一个Java对象不再被需要的时候 这个对象原先占有的空间就会期望能够自动的由Java回收工具进行回收利用 这在Java中有着显著的差异 并且在大多数的结构性程序语言 比如说C语言中 是不常见的 如果一个类实例实施终止函数finalize()方法 它所占用的空间就不能及时的被回收工具重新回收利用 最坏的情况是也许它根本就不再被回收了 任何实施终止函数finalize() 方法的类实例都经常调用终止对象 当它们不再被引用的时候 它们不能立即被Java回收工具回收 为最终程序Java回收工具将对象附加到指定的队列 通常是由一个指定的线性程序执行的 在一些Java虚拟机上被称为 参考句柄 在最终程序阶段 终止函数 线性程序会执行每一个对象的终止函数finalize()方法 finalize() 成功执行之后Java回收工具将会交付对象 将它所占用的空间由 future 碎片收集功能再生 我没有说 现有 这意味着至少两个碎片收集周期必须被要求用来回收终止对象 听起来这像是有一些消耗的?正确 我们需要一些方法使得空间能够重新利用 (Java新的垃圾回收器需购买支持后才能用) 　　线性终止函数在系统中没有被给予最大优先权 优先级更高的线程导致终止对象被排列 如果一个线性 终止函数 无法与这个效率保持一致 终止函数队列就会持续增长 导致Java堆不停的被堆积 最终Java堆将会被耗尽 并且java lang OutOfMemoryError将会被抛出 　　对于任何对象而言 一个Java虚拟机将不会超过一次的引用终止函数finalize()方法 如果finalize()方法抛出了什么例外现象 对象的终止程序就会停止下来 　　对于类的finalize()方法你几乎可以自由的做任何事情 当你这样做的时候 当对象不再被引用或者不再需要的时候 请不要期望存储 <;空间会被任何一个由Java回收程序回收再生的对象占领 为什么? finalize()方法将要完整的按进度完成的这种情况是不可控的 最坏的情况是 当这里没有更多涉及到对象的时候 也许它甚至不会被解决 这意味着任何具有finalize()方法的对象被回收都是无法被保障的 这是内存 <>管理发展的一个潜在危险 不必多说 有相当大的开销是花费在队列排列 运行finalize()方法以及将对象反射到下一个碎片整理环节上的 　　如果你想在对象上运行函数 考虑到终止函数作为最后一个方法 执行你自己的清理垃圾方法 这将会更加的平稳 完全信任终止函数来进行事后的垃圾清理工作是非常危险的 特别是当你的终止对象涉及到本地资源的时候 　　 Java 终止函数的实际操作体验 　　ObjectWYieldFinalizer内 我们可以伴随着线性yield()执行finalize()方法 这样finalize()就不能完全执行 见代码表一 线性yield()方法从正在运行的程序中阻止现有的线性程序执行 以及允许其它的线性程序执行 如果终止函数线性程序调用这种finalize()方法 它将会暂停执行 　　代码表一 　　/* 　　* @Author : Jinwoo Hwang 　　* (C) Copyright IBM Corp All Rights Reserved 　　*/ 　　public class ObjectWYieldFinalizer { 　　protected void finalize() throws Throwable { 　　Thread yield(); 　　} 　　} 　　public class TestObjectWYieldFinalizer { 　　public static void main(String[] args) { 　　while(true){ 　　ObjectWYieldFinalizer o = new ObjectWYieldFinalizer(); 　　} 　　} lishixinzhi/Article/program/Java/hx/201311/27113

finalize的作用是释放类的相关资源，比如打开的文件，内存中占用的空间等等如果是子类直接覆盖了父类，那么父类的资源可能得不到有效释放，所以要求调用一次父类的finalize方法之所以放到最后调用，是考虑可能子类的逻辑中还需要实用父类的方法，如果提前释放了，子类的执行可能出错

当对一个对象使用过GC.SuppressFinalize(xxx)之后，在这个对象被销毁时，GC将不会调用这个对象的析构方法。如果希望对象被销毁时GC调用析构方法，则使用GC.ReRegisterForFinalize(xxx)这个方法重新将对象添加到析构队列中。

.net的垃圾回收不是在aa = Nothing后马上进行的，它在满足以下条件之一时将发生垃圾回收：1.系统具有低的物理内存。2.由托管堆上已分配的对象使用的内存超出了可接受的阈值。 这意味着可接受的内存使用的阈值已超过托管堆。 随着进程的运行，此阈值会不断地进行调整。 3.调用 GC.Collect 方法。 几乎在所有情况下，您都不必调用此方法，因为垃圾回收器会持续运行。 此方法主要用于特殊情况和测试。所以要达到你的目的你要调用GC.Collect 方法：Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click Dim aa As New Class1("点击了按钮1") aa = Nothing GC.Collect() End Sub另外我在用Debug.Print时没有在VS的输出窗口看到输出，我把它改成了Console.WriteLine：Public Class Class1 Dim dteTimer As DateTime Dim strProcName As String Protected Overrides Sub Finalize() Console.WriteLine("进程结束了") MyBase.Finalize() End Sub Public Sub New(strName As String) dteTimer = DateTime.Now strProcName = strName Console.WriteLine(strProcName & " 开始于: " & dteTimer) End Sub下面是我点了再次Button1后VS输出窗口的内容：点击了按钮1 开始于: 2012/3/16 19:26:41进程结束了点击了按钮1 开始于: 2012/3/16 19:26:43进程结束了

at last,at length,eventually,finally,in the end,lastly这些词或词组均含有“最后，终于”之意。 at last多指经主观努力，克服各种困难后才终于达到目的。 at length强调经历一段长时间后终于完成，侧重在时间部分。 eventually侧重于动作或行为的结果。 finally常与at last换用，都可用于对往事的描述，但finally不带感情色彩，指一系列事情的最后结局。 in the end与at last同义，但in the end不仅可指“过去”还可表示对“未来”的预计。 lastly指连续顺序的最后，通常用在列举事情的场合。

一般都会问 String,StringBuffer,StringBudilder区别ArrayList,vector 等的区别hashMap,hashTable 的区别多线程的实现方式和方法了传参数方面的 考传的是本身还是副本 如 a(String value); a方法的value参数是传本身还是副本其它的问题都是最基本的,基本能答上来还有就是框架的知识了,比如spring 依赖注入,事务深入点的话 拦截器等考其它框架的话 基本上问的都是比较基础的 难的话很少问到db方面的话 简单考下你的sql , 可能会写几个表 要查什么让你写sql 主要考 多表连接查询,分组,分组后的查询,排序,取最大最小之类的 看你sql熟练否

1．clone方法 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。 主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，我们有时候不希望在方法里讲参数改变，这是就需要在类中复写clone方法。 2．getClass方法 final方法，获得运行时类型。 3．toString方法 该方法用得比较多，一般子类都有覆盖。 4．finalize方法 该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。 finalize方法在垃圾回收时一定会被执行，而如果在此之前显示执行的话，也就是说finalize会被执行两次以上，而在第一次资源已经被释放，那么在第二次释放资源时系统一定会报错，因此一般finalize方法的访问权限和父类保持一致，为protected。 5．equals方法 该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。 6．hashCode方法 该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。 一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。 如果不重写hashcode(),在HashSet中添加两个equals的对象，会将两个对象都加入进去。 7．wait方法 wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。 调用该方法后当前线程进入睡眠状态，直到以下事件发生。 （1）其他线程调用了该对象的notify方法。 （2）其他线程调用了该对象的notifyAll方法。 （3）其他线程调用了interrupt中断该线程。 （4）时间间隔到了。 此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。 8．notify方法 该方法唤醒在该对象上等待的某个线程。 9．notifyAll方法 该方法唤醒在该对象上等待的所有线程。

finalizing adj. 最後的Negotiators from the three countries finalized the agreement in August.3个国家的谈判代表在8月最终确定了协议。

问题一：纺织上用语：定型 用英文怎么说 定型的英语： finalize the design； sizing； set； fixation； 定型产品：finalized product； 定型长度：modular length； 定型设备：modular syatem； 定型化：type standardized； 问题二：面料定型英语该怎么说 面料定型 Fabric setting 问题三：面料定型英文怎么说 Finalize the design 问题四：丝光，定型，预缩的英文怎么说 丝光（动词：mercerize，名词mercerizing, mercerization）定型（动词：set，名词：setting）预缩（动词：preshrink，名词：preshrinking）。 问题五：头发定型产品 英文怎么说 卷发定型 curl defining products， 头发整形 hair styling products 但是这些产品许多都是暂时性的，如定型水之类，洗洗就没用了。要想找持久性的，一定要看清楚说明书，或问清楚店员。 也可先上ebay，amazon之类的英文综合购物网站的hair care 分类下先查一查，看看哪种最接近你想要的，再到店里去找。估计上beauty supply店去找会更容易找到些，因为那里的产品种类一般更全。 问题六：面料定型英语怎么说 shape the outside material 问题七：定型机用英文怎么说？ 英文是： Heat setter 问题八：半定型包包英文怎么说才准确 Semi fixed bag半定型包包 Semi fixed bag半定型包包

java没听说过释放final修饰的对象，这要大神才能解答。

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。 finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。 finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

碰到小白头都大，你们以为考CET啊！ James Gosling告诉我们它们一个比一个长。

final,finally,finallze的区别为：意思不同、用法不同、词性不同。一、意思不同1、final：最终的。2、finally：终于，最终。3、finallze：最终确定。二、用法不同1、final：final用作形容词的基本意思是“最后的，最终的”，在句中常作定语，还可指“决定性的，确定性的”，在句中多用作表语。final是表示极限意义的形容词，没有比较级和最高级形式。2、finally：finally在列举事物时可以用来引出最后一项内容，或者是直接放在动词之前，finally常与at last换用，都可用于对往事的描述，但finally不带感情色彩，指一系列事情的最后结局。3、finallze：基本意思是划清事物间的界限，以免混淆造成矛盾或重复，可依据上下文译成“界定”“规定”“确定”。三、词性不同1、final：final是形容词，后加名词做修饰对象。2、finally：finally是副词，通常放在句首。3、finallze：finalize是及物动词。

【答案】：无论是否抛出异常，finally代码块都会执行，它主要是用来释放应用占用的资源。finalize()方法是Object类的一个protected方法，它是在对象被垃圾回收之前由Java虚拟机来调用的。

finalize英 [u02c8fau026anu0259lau026az] 美 [u02c8fau026anu0259u02cclau026az]vt.完成; 使结束; 使落实vi.定案; 把…最后定下来网络结束; 方法; 定妥第三人称单数： finalizes 现在分词： finalizing过去式： finalized 过去分词： finalized这句话应该少了主语，我就先补个　it　吧。It will be finalized after you are on boardIt will be finalized是主句；after you are on board做时间主语从句。翻译就是：等你上船/上飞机/上火车，它（根据你实际要描述的主语来翻译）就将结束/完成。draft的英语例句1. Officials have now been delegated to start work on a draft settlement.现在已经委派官员着手起草解决方案。2. When the first draft was completed, Nichols typed it up.当初稿完成以后，尼科尔斯将它打印了出来。3. The money was payable by a draft drawn by the home.这笔钱可凭国内承兑的汇票支付。4. Ten days later Carmen received a bank draft for a plane ticket.10天后卡门收到了一张用于购买机票的银行汇票。5. You pay for the car by banker"s draft in the local currency.以本币银行汇票支付车款。6. I"m supposed to have handed in a first draft of my dissertation.我本该把论文的初稿交上去了。

finalize()在什么时候被调用?有三种情况1.所有对象被Garbage Collection时自动调用,比如运行System.gc()的时候.2.程序退出时为每个对象调用一次finalize方法。3.显式的调用finalize方法

【答案】：在释放对象占用的内存之前，垃圾收集器会调用对象的finalize()方法。一般建议在该方法中释放对象持有的资源。

finally副词finalize动词finalization名词

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。finalize—方法名。java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

有ize后缀的单词有： 　　deemphasize 降低重要性； 　　dehumanize v. 使失掉人性； 　　demobilize v. 遣散(军人)，复员； 　　demonetize 非货币化； 　　desalinize v. 除去盐份； 　　disorganize vt. 破坏阻织,搅乱秩序的,使混乱 扩展资料 　　dramatize vt. 改编成戏剧,编写剧本； 　　economize v. 节省（钱、时间等）； 　　emphasize vt.强调，着重； 　　energize vt.给与…能量；电压； 　　equalize vt. 使相等,补偿； 　　eulogize v. 颂扬；赞美； 　　exorcize v. 驱魔，去除(坏念头等)； 　　extemporize v. 即席演说；即席发言； 　　familiarize vt. 使熟悉,使熟知,使通俗化； 　　fertilize vt. 使受精； 　　finalize v. 落实，定下来；定妥； 　　fraternize vi. 结有深交,友善； 　　galvanize v. 电镀，通电，激励； 　　generalize vt.概括出vi.形成概念。

更甚者你写的代码，GC根本就回收不了，直接系统挂掉。GC是一段程序，不是智能，他只回收他认为的垃圾，而不是回收你认为的垃圾。GC垃圾回收:Grabage Collection相信学过JAVA的人都知道这个是什么意思.但是他是如何工作的呢?首先，JVM在管理内存的时候对于变量的管理总是分新对象和老对象。新对象也就是开发者new出来的对象，但是由于生命周期短，那么他占用的内存并不是马上释放，而是被标记为老对象，这个时候该对象还是要存在一段时间。然后由JVM决定他是否是垃圾对象，并进行回收。所以我们可以知道，垃圾内存并不是用完了马上就被释放，所以就会产生内存释放不及时的现象，从而降低了内存的使用。而当程序浩大的时候。这种现象更为明显，并且GC的工作也是需要消耗资源的。所以，也就会产生内存浪费。JVM中的对象生命周期里谈内存回收:对象的生命周期一般分为7个阶段：创建阶段，应用阶段，不可视阶段，不可到达阶段，可收集阶段，终结阶段，释放阶段。创建阶段：首先大家看一下,如下两段代码:test1:for( int i=0; i10000; i++)Object obj=new Object();test2:Object obj=null;for( int i=0; i10000; i++)obj=new Object();这两段代码都是相同的功能，但是显然test2的性能要比test1性能要好，内存使用率要高，这是为什么呢?原因很简单，test1每次执行for循环都要创建一个Object的临时对象，但是这些临时对象由于JVM的GC不能马上销毁，所以他们还要存在很长时间，而test2则只是在内存中保存一份对象的引用，而不必创建大量新临时变量，从而降低了内存的使用。另外不要对同一个对象初始化多次。例如:public class A{private Hashtable table = new Hashtable();public A(){ table = new Hashtable();// 这里应该去掉,因为table已经被初始化.}}这样就new了两个Hashtable，但是却只使用了一个。另外一个则没有被引用.而被忽略掉.浪费了内存.并且由于进行了两次new操作.也影响了代码的执行速度。应用阶段：即该对象至少有一个引用在维护他.不可视阶段：即超出该变量的作用域。这里有一个很好的做法,因为JVM在GC的时候并不是马上进行回收,而是要判断对象是否被其他引用在维护.所以,这个时候如果我们在使用完一个对象以后对其obj=null或者obj.doSomething()操作,将其标记为空,可以帮助JVM及时发现这个垃圾对象.不可到达阶段：就是在JVM中找不到对该对象的直接或者间接的引用。可收集阶段,终结阶段,释放阶段：此为回收器发现该对象不可到达,finalize方法已经被执行,或者对象空间已被重用的时候。JAVA的析构方法:可能不会有人相信,JAVA有析构函数? 是的,有。因为JAVA所有类都继承至Object类,而finalize就是Object类的一个方法,这个方法在JAVA中就是类似于C++析构函数.一般来说可以通过重载finalize方法的形式才释放类中对象.如:public class A{public Object a;public A(){ a = new Object ;}protected void finalize() throws java.lang.Throwable{a = null; // 标记为空,释放对象super.finalize(); // 递归调用超类中的finalize方法.}}当然,什么时候该方法被调用是由JVM来决定的一般来说,我们需要创建一个destory的方法来显式的调用该方法.然后在finalize也对该方法进行调用,实现双保险的做法.由于对象的创建是递归式的,也就是先调用超级类的构造,然后依次向下递归调用构造函数,所以应该避免在类的构造函数中初始化变量,这样可以避免不必要的创建对象造成不必要的内存消耗.当然这里也就看出来接口的优势.数组的创建:由于数组需要给定一个长度,所以在不确定数据数量的时候经常会创建过大,或过小的数组的现象.造成不必要的内存浪费,所以可以通过软引用的方式来告诉JVM及时回收该内存.(软引用,具体查资料).例如:Object obj = new char[10000000000000000];SoftReference ref = new SoftReference(obj);共享静态存储空间:我们都知道静态变量在程序运行期间其内存是共享的,因此有时候为了节约内存工件,将一些变量声明为静态变量确实可以起到节约内存空间的作用.但是由于静态变量生命周期很长,不易被系统回收,所以使用静态变量要合理,不能盲目的使用.以免适得其反。因此建议在下面情况下使用:1,变量所包含的对象体积较大,占用内存过多.2,变量所包含对象生命周期较长.3,变量所包含数据稳定.4,该类的对象实例有对该变量所包含的对象的共享需求.(也就是说是否需要作为全局变量).对象重用与GC:有的时候,如数据库操作对象,一般情况下我们都需要在各个不同模块间使用,所以这样的对象需要进行重用以提高性能.也有效的避免了反复创建对象引起的性能下降.一般来说对象池是一个不错的注意.如下:public abstarct class ObjectPool{private Hashtable locked,unlocked;private long expirationTime;abstract Object create();abstract void expire( Object o);abstract void validate( Object o);synchronized Object getObject(){...};synchronized void freeObject(Object o){...};}这样我们就完成了一个对象池,我们可以将通过对应的方法来存取删除所需对象.来维护这快内存提高内存重用.当然也可以通过调用System.gc()强制系统进行垃圾回收操作.当然这样的代价是需要消耗一些cpu资源.不要提前创建对象:尽量在需要的时候创建对象,重复的分配,构造对象可能会因为垃圾回收做额外的工作降低性能.JVM内存参数调优:强制内存回收对于系统自动的内存回收机制会产生负面影响,会加大系统自动回收的处理时间,所以应该尽量避免显式使用System.gc(),JVM的设置可以提高系统的性能.例如:java -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8 -Xms512m -Xmx512m具体可以查看java帮助文档.我们主要介绍程序设计方面的性能提高.JAVA程序设计中有关内存管理的其他经验:根据JVM内存管理的工作原理,可以通过一些技巧和方式让JVM做GC处理时更加有效.,从而提高内存使用和缩短GC的执行时间.1,尽早释放无用对象的引用.即在不使用对象的引用后设置为空,可以加速GC的工作.(当然如果是返回值.....)2,尽量少用finalize函数,此函数是JAVA给程序员提供的一个释放对象或资源的机会,但是却会加大GC工作量.3,如果需要使用到图片,可以使用soft应用类型,它可以尽可能将图片读入内存而不引起OutOfMemory.4,注意集合数据类型的数据结构,往往数据结构越复杂,GC工作量更大,处理更复杂.5,尽量避免在默认构造器(构造函数)中创建,初始化大量的对象.6,尽量避免强制系统做垃圾回收.会增加系统做垃圾回收的最终时间降低性能.7,尽量避免显式申请数组,如果不得不申请数组的话,要尽量准确估算数组大小.8,如果在做远程方法调用.要尽量减少传递的对象大小.或者使用瞬间值避免不必要数据的传递.9,尽量在合适的情况下使用对象池来提高系统性能减少内存开销,当然,对象池不能过于庞大,会适得其反.

呵呵``

size,prize,quize,seize,assize,braize,dualize,elegize,realize,reseize,....太多了

actualize v.实现, 实施, 实行aggrandize vt.增大agonize vt.极度痛苦apologize vi.道歉，认错，谢罪authorize vt.授权，批准baptize vt.给…施洗礼；命名canonize v.正式宣布(死者)为圣徒,赞扬 cauterize v.烧灼, 腐蚀characterize vt.成为…的特征，以…为特征；描述civilize vt.使文明，使开化colonize vt.建立殖民地computerize v.用电脑处理, 使电脑化 crystalize v.明确,结晶,使成形departmentalize vt. 把 ... 分成部门dogmatize v. 独断, 独断地主张energize v.使活跃,赋予能量,激励,使精力充沛extemporize vi.即兴创作finalize vt.完成, 确定formalize v.使正式化fraternize vi. 结有深交, 友善generalize v.概括，归纳，推断harmonize v.使调和，使一致Hellenize v. 使成希腊格调, 使用希腊语法humanize v.赋予人性,教化,使通人情imperialize v. 帝制化, 帝国主义化individualize vt. 使具有个性, 个别对待, 具体化legalize vt.合法化methodize v. 定顺序, 定组织moralize v. 教化, 解说道德, 用道德意义解释neutralize v.使无效，中和paganize v. 异教化patronize vt.以高人一等的态度对待；惠顾；赞助philosophize v.从哲学观点思考,从哲学上来看,思索popularize vt.普及, 使流行, 使通俗化pulverize v.压成细粉，彻底击败quantize vt. 使量化, 数字转换randomize vt. 形成不规则分布, 使 ... 随机化realize vt.认识，明白；实现，使变为现实recognize vt.认出；确认，认可；赏识，表彰satirize vt.讽刺specialize vi.(in)专门研究，专攻standardize vt.使标准化stigmatize v.污蔑，玷污symbolize vt.用符号表示；作为...象征tranquilize v. (使)平静, (使)镇定tyrannize v. 施行虐政, 压制, 欺压urbanize v.使都市化utilize vt.利用vocalize v. 发声weatherize vt. 使适应气候条件womanize v. 玩弄女性, 使女性化......

JAVA相关基础知识1、面向对象的特征有哪些方面 1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。4. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。2、String是最基本的数据类型吗?基本数据类型包括byte、int、char、long、float、double、boolean和short。java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类3、int 和 Integer 有什么区别Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。原始类型封装类booleanBooleancharCharacterbyteByteshortShortintIntegerlongLongfloatFloatdoubleDouble引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。4、String 和StringBuffer的区别JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。5、运行时异常与一般异常有何异同？异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。6、说出Servlet的生命周期，并说出Servlet和CGI的区别。Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。7、说出ArrayList,Vector, LinkedList的存储性能和特性ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。8、EJB是基于哪些技术实现的？并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。9、Collection 和 Collections的区别。 Collection是集合类的上级接口，继承与他的接口主要有Set 和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。10、&和&&的区别。 &是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。11、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算法都大概一样，所以性能不会有很大的差异。12、final, finally, finalize的区别。 final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。finally是异常处理语句结构的一部分，表示总是执行。finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。13、sleep() 和 wait() 有什么区别? sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。14、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。15、error和exception有什么区别?error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。16、同步和异步有何异同，在什么情况下分别使用他们？举例说明。如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。17、abstract class和interface有什么区别?声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。18、heap和stack有什么区别。栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素19、forward 和redirect的区别forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。20、EJB与JAVA BEAN的区别？Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat）的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。21、Static Nested Class 和 Inner Class的不同。 Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。22、JSP中动态INCLUDE与静态INCLUDE的区别？动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面 23、什么时候用assert。 assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。24、GC是什么? 为什么要有GC? GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。 25、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;（可以正确编译）26、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? Math.round(11.5)==12Math.round(-11.5)==-11round方法返回与参数最接近的长整数，参数加1/2后求其floor.27、String s = new String("xyz");创建了几个String Object? 两个28、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。public class ThreadTest1{private int j;public static void main(String args[]){ThreadTest1 tt=new ThreadTest1();Inc inc=tt.new Inc();Dec dec=tt.new Dec();for(int i=0;i<2;i++){Thread t=new Thread(inc);t.start();t=new Thread(dec);t.start();}}private synchronized void inc(){j++;System.out.println(Thread.currentThread().getName()+"-inc:"+j);}private synchronized void dec(){j--;System.out.println(Thread.currentThread().getName()+"-dec:"+j);}class Inc implements Runnable{public void run(){for(int i=0;i<100;i++){inc();}}}class Dec implements Runnable{public void run(){for(int i=0;i<100;i++){dec();}}}}29、Java有没有goto?java中的保留字，现在没有在java中使用。30、启动一个线程是用run()还是start()?启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。31、EJB包括（SessionBean,EntityBean）说出他们的生命周期，及如何管理事务的？SessionBean：Stateless Session Bean 的生命周期是由容器决定的，当客户机发出请求要建立一个Bean的实例时，EJB容器不一定要创建一个新的Bean的实例供客户机调用，而是随便找一个现有的实例提供给客户机。当客户机第一次调用一个Stateful Session Bean 时，容器必须立即在服务器中创建一个新的Bean实例，并关联到客户机上，以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。EntityBean：Entity Beans能存活相对较长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。EJB通过以下技术管理实务：对象管理组织（OMG）的对象实务服务（OTS），Sun Microsystems的Transaction Service（JTS）、Java Transaction API（JTA），开发组（X/Open）的XA接口。32、应用服务器有那些？BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat33、给我一个你最常见到的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, UnsupportedOperationException34、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。35、List, Set, Map是否继承自Collection接口?List，Set是，Map不是36、说出数据连接池的工作机制是什么?J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。37、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?都不能38、数组有没有length()这个方法? String有没有length()这个方法？数组没有length()这个方法，有length的属性。String有有length()这个方法。39、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。40、构造器Constructor是否可被override?构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。41、是否可以继承String类?String类是final类故不可以继承。42、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。43、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?会执行，在return前执行。44、编程题: 用最有效率的方法算出2乘以8等於几? 2 << 345、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?不对，有相同的hash code。46、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。47、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?不能，一个对象的一个synchronized方法只能由一个线程访问。48、编程题: 写一个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的。一般认为第一种形式要更加安全些 49、Java的接口和C++的虚类的相同和不同处。由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。50、Java中的异常处理机制的简单原理和应用。当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。51、垃圾回收的优点和原理。并考虑2种回收机制。Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。52、请说出你所知道的线程同步的方法。wait():使一个线程处于等待状态，并且释放所持有的对象的lock。sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。53、你所知道的集合类都有哪些？主要方法？最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。54、描述一下JVM加载class文件的原理机制?JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。55、char型变量中能不能存贮一个中文汉字?为什么?