finalize

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

final修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承例如：String类、Math类等。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重写，但是能够重载。 使用final修饰的对象，对象的引用地址不能变，但是对象的值可以变！finally在异常处理时提供 finally 块来执行任何清除操作。如果有finally的话，则不管是否发生异常，finally语句都会被执行。一般情况下，都把关闭物理连接(IO流、数据库连接、Socket连接)等相关操作，放入到此代码块中。finalize方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器删除对象之前被调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。 一般情况下，此方法由JVM调用，程序员不要去调用！

final、finally和finalize的区别中，下述说法正确的有?（A、B、C）A.final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。B.finally是异常处理语句结构的一部分，表示总是执行。C.finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。D.引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

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

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

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

date mc finalized corrections日期确定更正更正corrections[英][ku0259"reku0283nz][美][ku0259"reku0283nz]n.修改( correction的名词复数 ); 改[纠]正; 惩罚; 有待改正; 形近词：directionserectionscorrectives

你是有可能是直接引用了项目文件，这不是模块化的方式，所以浏览器也就很直接报错误UncaughtReferenceError:defineisnotdefinedecharts.js:18UncaughtReferenceError:requireisnotdefinedtest.html:13前一个是说define方法没有导入,后一个是说require方法没有导入。问题的关键有可能是没有导入，这是因为echarts是架设在efe团队的esl框架基础上的,文档里面没有讲明白。导入后，你有可能还缺少zrender，ECharts是基于zrender这个html5画图组件。如果没有，需要去下载。

private void Dispose(bool disposing){ ... etc.}public void Dispose(){ this.Dispose(true); //告诉系统，我已释放过了，不要在释放。 //因为Object.Finalize需要额外的性能消耗。 GC.SuppressFinalize(this);}

代码没问题，编译运行都没错。编译：mpicc test.c运行：mpiexec -np 5 ./a.out结果：lark: Hello world from process 3 number of processes: 5lark: Hello world from process 0 lark: Hello world from process 1 lark: Hello world from process 2 lark: Hello world from process 4

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

没有问题 你的第一个 new Test() 没有赋name的值

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

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

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.我本该把论文的初稿交上去了。

没有，javascript是一种弱类型语言，没有finalize。

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

final 最后的，最终的，是形容词，用来修饰Be动词，名词等finally 最后地，最终地，是副词，用来修饰副词，动词finalize 完成，结束，使……完成，是动词

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

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

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

Me.Close() frm.Show()调换两句.因me.close已把后面的frm.show给忽略了.

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

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方法能够被调用到，确保可以手动释放任何需要释放的资源。

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

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

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

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

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

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

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

finalize()存在以下问题：1.就算是重写了finalize()，并且不被你的程序引用到的情况下，也不能立即就被GC回收掉。 这是因为，GC后，为了执行finalize()方法，它被JavaVM的引用还残留着。2.不能保证GC后finalize()被执行。3.finalize()执行的顺序是不定的。举个极端的例子java.lang.System.gc();java.lang.System.runFinalization();java.lang.System.gc();就算这样也并不能保证Object被彻底回收。所以，一定一定不要去重写finalize()，然后期待Object被回收，这样反而容易内存泄漏。因为它并不能达到你想要的结果。

不能重写只是编译器干的事儿，实际上它就是想让你只能写析构函数，而写析构函数就相当于重写了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条件以后，在GC之前finalize（）方法会被调用，所以基本可以说其被回收了。但是有种特殊情况：就是在finalize（）中重新让对象不符合GC条件，这样对象就避开了一次GC，这时对象就没有被回收，下次对象再次符合条件的时候finalize（）也不会被调用，但是它还是被回收了ps：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,意味着它不能再派生出新的子类,不能作为父类被继承.因此一个类不能既被声明为 abstract的,又被声明为final的.将变量或方法声明为final,可以保证它们在使用中不被改变.被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改.被声明为final的方法也同样只能使用,不能重载finally?再异常处理时提供 finally 块来执行任何清除操作.如果抛出一个异常,那么相匹配的 catch 子句就会执行,然后控制就会进入 finally 块（如果有的话）.finalize?方法名.Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作.这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的.它是在 Object 类中定义的,因此所有的类都继承了它.子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作.从这些描述就可以看出来，final可以用在变量上，自然可以用在类内部。finally本来就是处理异常的，用哪里都行，另外那个也是这样

final 就是最终的意思～final类就不能被继承，final函数就不能被重写，final变量就不变。finally 就是try catch 后必须执行的语句finalize 是在GC工作清理对象时执行的东西

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()，就可以在垃圾收集期间进行一些重要的清除或清扫工作.

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

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.

Object的中的方法finalize（），格式如下protected void finalize( ) throws Throwable{...............}不能用的原因是它使用了修饰符protected，从下面可以看出protected在不同包内是不能用的，你可以在类中调用方法，但是实例化的对象是肯定不用想了。作用域 当前类 同一package 子孙类 其他package public √ √ √ √ protected √ √ √ × friendly √ √ × × private √ × × ×

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

final修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承例如：String类、Math类等。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重写，但是能够重载。 使用final修饰的对象，对象的引用地址不能变，但是对象的值可以变！finally在异常处理时提供 finally 块来执行任何清除操作。如果有finally的话，则不管是否发生异常，finally语句都会被执行。一般情况下，都把关闭物理连接(IO流、数据库连接、Socket连接)等相关操作，放入到此代码块中。finalize方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器删除对象之前被调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。 一般情况下，此方法由JVM调用，程序员不要去调用！