我要提问
- 关于
执行方法
的搜索结果
回答
1） start： 用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。 2） run： run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.。
回答
AsyncTask是Android本身提供的一种轻量级的异步任务类。它可以在线程池中执行后台任务，然后把执行的进度和最终的结果传递给主线程更新UI。实际上，AsyncTask内部是封装了Thread和Handler。虽然AsyncTask很方便的执行后台任务，以及在主线程上更新UI，但是，AsyncTask并不合适进行特别耗时的后台操作，对于特别耗时的任务，个人还是建议使用线程池。
AsyncTask提供有4个核心方法：
1、onPreExecute():该方法在主线程中执行，在执行异步任务之前会被调用，一般用于一些准备工作。
2、doInBackground(String... params):这个方法是在线程池中执行，此方法用于执行异步任务。在这个方法中可以通过publishProgress方法来更新任务的进度，publishProgress方法会调用onProgressUpdate方法，另外，任务的结果返回给onPostExecute方法。
3、onProgressUpdate(Object... values):该方法在主线程中执行，主要用于任务进度更新的时候，该方法会被调用。
4、onPostExecute(Long aLong)：在主线程中执行，在异步任务执行完毕之后，该方法会被调用，该方法的参数及为后台的返回结果。
除了这几个方法之外还有一些不太常用的方法，如onCancelled(),在异步任务取消的情况下，该方法会被调用。
源码可以知道从上面的execute方法内部调用的是executeOnExecutor()方法，即executeOnExecutor(sDefaultExecutor, params);而sDefaultExecutor实际上是一个串行的线程池。而onPreExecute()方法在这里就会被调用了。接着看这个线程池。AsyncTask的执行是排队执行的，因为有关键字synchronized，而AsyncTask的Params参数就封装成为FutureTask类，FutureTask这个类是一个并发类，在这里它充当了Runnable的作用。接着FutureTask会交给SerialExecutor的execute方法去处理，而SerialExecutor的executor方法首先就会将FutureTask添加到mTasks队列中，如果这个时候没有任务，就会调用scheduleNext()方法，执行下一个任务。如果有任务的话，则执行完毕后最后在调用 scheduleNext();执行下一个任务。直到所有任务被执行完毕。而AsyncTask的构造方法中有一个call()方法，而这个方法由于会被FutureTask的run方法执行。所以最终这个call方法会在线程池中执行。而doInBackground这个方法就是在这里被调用的。我们好好研究一下这个call()方法。mTaskInvoked.set(true);表示当前任务已经执行过了。接着执行doInBackground方法，最后将结果通过postResult(result);方法进行传递。postResult()方法中通过sHandler来发送消息，sHandler的中通过消息的类型来判断一个MESSAGE_POST_RESULT，这种情况就是调用onPostExecute(result)方法或者是onCancelled(result)。另一种消息类型是MESSAGE_POST_PROGRESS则调用更新进度onProgressUpdate。
回答
简单的解释：方法内调用它本身。
传递和回归必须存在一个临界点：比如最内层被调用的方法内给了一个返回值，或者是最内存被调用方法结束，然后将结果返回给上一层的方法.,然后一层层结束，一层层返回。
它的使用场景，比如会用递归来解决斐波那契数列、阶乘。。的问题。
例子：给一个整数n：求1+2+3+.....+n的值
首先是执行main()方法，main()方法进栈，然后调用main()方法中的add(5)方法，add(5)方法进栈。当执行到return add(4)+5时，add(5)方法会调用add(4)方法，add(4)方法进展，然后依次递归调用，直到add(1)方法进栈为止。
当执行add(1)方法时，会首先进行判断if(n==1)，然后满足条件，该方法返回一个整数 1（临界点），（这个返回值是返回给add(2)方法的），然后add(1)方法执行完毕，出栈。
此时add(2)方法接收了add(1)方法的返回值，执行add(2)方法，最后走到return add(1)+2==return 1+2 ,add(2)方法执行完毕，将返回值返回给add(3)方法，出栈。
然后依次执行add(3)、add(4)、add(5)。。依次出栈。具体步骤看下图:
add(5)方法接受到前几个递归方法执行完毕后传来的值：1+2+3+4，执行它本身，return add(4)+5==return 1+2+3+4+5，将该结果返回给main()方法，add(5)出栈。递归结束
main()方法接受到了add(5)方法返回值，15，打印输出，main()方法结束，出栈。
回答
（一）java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候 就已经加载 可以用类名直接调用 比如main方法就必须是静态的 这是程序入口 两者的区别就是:静态代码块是自动执行的; 静态方法是被调用的时候才执行的.
静态方法 （1）在Java里，可以定义一个不需要创建对象的方法，这种方法就是静态方法。要实现这样的效果，只需要在类中定义的方法前加上static关键字。例如：
public static int maximum(int n1,int n2)
使用类的静态方法时，注意：
a在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
b 静态方法不能以任何方式引用this和super关键字，因为静态方法在使用前不用创建任何实例对象，当静态方法调用时，this所引用的对象根本没有产生。
（2）静态变量是属于整个类的变量而不是属于某个对象的。注意不能把任何方法体内的变量声明为静态，例如： fun() { static int i=0;//非法。 }
（3）一个类可以使用不包含在任何方法体中的静态代码块，当类被载入时，静态代码块被执行，且只被执行一次，静态块常用来执行类属性的初始化。例如： static { }
类装载步骤 在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的，各个步骤的主要工作如下：
装载：查找和导入类或接口的二进制数据； 链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 校验：检查导入类或接口的二进制数据的正确性； 准备：给类的静态变量分配并初始化存储空间； 解析：将符号引用转成直接引用； 初始化：激活类的静态变量的初始化Java代码和静态Java代码块。 初始化类中属性是静态代码块的常用用途，但只能使用一次。
（二）静态代码块的初始化顺序
class Parent{
static String name = "hello";
{
System.out.println("parent block");
}
static {
System.out.println("parent static block");
}
public Parent(){
System.out.println("parent constructor");
}
}
class Child extends Parent{
static String childName = "hello";
{
System.out.println("child block");
}
static {
System.out.println("child static block");
}
public Child(){
System.out.println("child constructor");
}
}
public class StaticIniBlockOrderTest {
public static void main(String[] args) {
new Child();//语句(*)
}
}
问题：当执行完语句()时，打印结果是什么顺序？为什么？ 解答：当执行完语句()时，打印结果是这样一个顺序 :
parent static block
child static block
parent block
parent constructor
child block
child constructor
行完毕之后，接着去执行子类(自己这个类)里面的静态代码块，当子类的静态代码块执行完毕之后，它接着又去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法，这个就是一个对象的初始化顺序。
总结: 对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。
注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。
原文链接：https://www.cnblogs.com/jiangyi666/p/5665130.html
回答
run()：只是调用方法
start()：开启一个线程每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
回答
输出结果：此时A的构造方法正在调用此方法：i的值为：0,j的值为：0最终i的值为：888,j的值为：999楼主这道题刚开始看确实有点诡异。所以我只能根据结果来推断。 首先在执行B b = new B();的时候，会调用B的构造函数，而B是继承A的，相当于在B的构造函数中有super();这一句，所以会执行A的构造函数。而A的构造函数又调用了init方法。可这里A的init方法已经被B给重写了，而且这里是生成的B的实例，所以会执行B的init方法。执行完后i=888，j=111.这时构造方法执行完毕，开始执行赋值操作，而成员变量i并没有赋值操作，i还是等于888，而j已经做了赋值操作,所以j被赋值为999.你可以给i一个赋值测试一下，发现i的值会是你赋的值。至于为什么先执行构造函数再执行赋值操作，你可以谷歌搜索JVM类加载子系统的执行过程。
回答
"程序无法显式释放对同步监视器的锁定，线程会在如下几种情况下释放对同步监视器的锁定。 当前线程的同步方法、同步代码块执行结束，当前线程即释放同步监视器。 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行，当前线程将会释放同步监视器。 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致了该代码块、该方法异常结束时，当前线程将会释放同步监视器。 当前线程执行同步代码块或同步方法时，程序执行了同步监视器对象的wait()方法，则当前线程暂停，并释放同步监视器。在如下所示的情况下，线程不会释放同步监视器。 线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器。 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放同步监视器。当然，我们应该尽量避免使用suspend()和resume()方法来控制线程。"
回答
1 . 静态分派: 所有依赖静态类型来定位方法执行版本的分派动作，都称为静态分派，静态分派的最典型应用就是多态性中的方法重载。静态分派发生在编译阶段，因此确定静态分配的动作实际上不是由虚拟机来执行的。动态分派 动态分派与多态性的另一个重要体现——方法覆写有着很紧密的关系。向上转型后调用子类覆写的方法便是一个很好地说明动态分派的例子。这种情况很常见，因此这里不再用示例程序进行分析。很显然，在判断执行父类中的方法还是子类中覆盖的方法时，如果用静态类型来判断，那么无论怎么进行向上转型，都只会调用父类中的方法，但实际情况是，根据对父类实例化的子类的不同，调用的是不同子类中覆写的方法，很明显，这里是要根据变量的实际类型来分派方法的执行版本的。而实际类型的确定需要在程序运行时才能确定下来，这种在运行期根据实际类型确定方法执行版本的分派过程称为动态分派。
回答
"ExecutorService代表尽快执行线程的线程池（只要线程池中有空闲线程，就立即执行线程任务），程序只要将一个Runnable对象或Callable对象（代表线程任务）提交给该线程池，该线程池就会尽快执行该任务。ExecutorService里提供了如下3个方法。 Future<?> submit(Runnable task)：将一个Runnable对象提交给指定的线程池，线程池将在有空闲线程时执行Runnable对象代表的任务。其中Future对象代表Runnable任务的返回值——但run()方法没有返回值，所以Future对象将在run()方法执行结束后返回null。但可以调用Future的isDone()、isCancelled()方法来获得Runnable对象的执行状态。
Future
submit(Runnable task,T result)：将一个Runnable对象提交给指定的线程池，线程池将在有空闲线程时执行Runnable对象代表的任务。其中result显式指定线程执行结束后的返回值，所以Future对象将在run()方法执行结束后返回result。
Future
submit(Callable
task)：将一个Callable对象提交给指定的线程池，线程池将在有空闲线程时执行Callable对象代表的任务。其中Future代表Callable对象里call()方法的返回值。"
回答
一个任务AsyncTask任务只能被执行一次。由于Handler需要和主线程交互，而Handler又是内置于AsnycTask中的，所以，AsyncTask的创建必须在主线程。AsyncTaskResult的doInBackground(mParams)方法执行异步任务运行在子线程中，其他方法运行在主线程中，可以操作UI组件。不要手动的去调用AsyncTask的onPreExecute, doInBackground, publishProgress, onProgressUpdate, onPostExecute方法，这些都是由Android系统自动调用的运行中可以随时调用cancel(boolean)方法取消任务，如果成功调用isCancelled()会返回true，并且不会执行 onPostExecute() 方法了，取而代之的是调用 onCancelled() 方法。而且从源码看，如果这个任务已经执行了这个时候调用cancel是不会真正的把task结束，而是继续执行，只不过改变的是执行之后的回调方法是 onPostExecute还是onCancelled。
答案来源于网络
回答
"如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。sleep()方法有两种重载形式。 static void sleep(long millis)：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。 static void sleep(long millis,int nanos)：让当前正在执行的线程暂停millis毫秒加nanos毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。 与前面类似的是，程序很少调用第二种形式的sleep()方法。 当当前线程调用 sleep()方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停程序的执行。 "
回答
Promise.resolve(value) 返回一个状态由给定value决定的Promise对象。
如果传入的 value 本身就是 Promise 对象，则该对象作为 Promise.resolve 方法的返回值返回。 如果该值是thenable(即，带有then方法的对象)，返回的Promise对象的最终状态由then方法执行决定 其他情况，返回一个状态已变成 resolved 的 Promise 对象。 2. Promise.reject 类方法，且与 resolve 唯一的不同是，返回的 promise 对象的状态为 rejected。 3. Promise.all 类方法，多个 Promise 任务同时执行。 如果全部成功执行，则以数组的方式返回所有 Promise 任务的执行结果。 如果有一个 Promise 任务 rejected，则只返回 rejected 任务的结果。 4. Promise.race 类方法，多个 Promise 任务同时执行，返回最先执行结束的 Promise 任务的结果，不管这个 Promise 结果是成功还是失败。 5. 其他 实例方法：
Promise.prototype.then 为 Promise 注册回调函数 Promise.prototype.catch 实例方法，捕获异常
回答
摘录周志明先生的《深入理解Java虚拟机》一书中对可达性算法的分析。首先，可达性算法基本思路是定义一些列称为"GC-Roots"的对象作为起始阶段，从这些节点向下搜索，搜索走过的路径称为引用链，当一个对象到GCRoots没有任何引用链时（即从GCRoots到这个对象不可达），则证明此对象是不可用的。其次，可达性算法中的不可达对象，在真正宣告“死亡”需要回收之前，至少要经过两轮标记过程：如果对象不可达，会被第一次标记并且进行一次筛选，筛选条件是次对象有没有必要执行finalize()方法。当对象没有覆盖finalize()方法或者这个方法以及被执行过了，那么久视为没有必要再执行。对于那些有必要执行finalize()方法的对象会被放在一个队列F-Queue中，然后稍后由虚拟机的一个线程去执行逐一执行队列中对象的finalize方法，如果线程在执行过程中发生了死循环，或者某个对象的finalize方法执行时间过长，导致队列其他对象一直处于等待，那么就会导致整个内存回收系统崩溃。第三，finalize()方法是对象逃脱死亡命运的最后一次机会，稍后GC会对F-Queue中的对象进行第二次小规模的标记，如果能在finalize中成功重新引用，第二次标记时就会将该对象从F-Queue集合中移除，而成功脱逃。所以，我理解你说的循环引用可能是想说不可达后突然又再次引用了，那么只能在finalize方法中再次引用而救活对象了。如果是普通循环中的循环操作引用，应该还没有涉及到垃圾回收、标记不可达的时候。最后，算法中的根对象通常是全局的静态成员对象，方法区中的常量引用对象，Native引用对象，线程栈中的引用对象等。
回答
multi_query()方法是完全按照在sql环境下的语句执行，所以可以一次执行多条sql语句（按sql语法拼写，每条语句以;结束）。$mysqli->multi_query($dataStr); //执行sql语句
multi_query()方法是完全按照在sql环境下的语句执行，所以可以一次执行多条sql语句（按sql语法拼写，每条语句以;结束）。$mysqli->multi_query($dataStr); //执行sql语句
multi_query()方法是完全按照在sql环境下的语句执行，所以可以一次执行多条sql语句（按sql语法拼写，每条语句以;结束）。
$mysqli->multi_query($dataStr);
回答
给一个元类添加可选关键字参数需要你完全弄懂类创建的所有步骤， 因为这些参数会被传递给每一个相关的方法。 prepare() 方法在所有类定义开始执行前首先被调用，用来创建类命名空间。 通常来讲，这个方法只是简单的返回一个字典或其他映射对象。 new() 方法被用来实例化最终的类对象。它在类的主体被执行完后开始执行。 init() 方法最后被调用，用来执行其他的一些初始化工作。
当我们构造元类的时候，通常只需要定义一个 new() 或 init() 方法，但不是两个都定义。 但是，如果需要接受其他的关键字参数的话，这两个方法就要同时提供，并且都要提供对应的参数签名。 默认的 prepare() 方法接受任意的关键字参数，但是会忽略它们， 所以只有当这些额外的参数可能会影响到类命名空间的创建时你才需要去定义 prepare() 方法。
通过使用强制关键字参数，在类的创建过程中我们必须通过关键字来指定这些参数。
使用关键字参数配置一个元类还可以视作对类变量的一种替代方式。例如：
class Spam(metaclass=MyMeta): debug = True synchronize = True pass
将这些属性定义为参数的好处在于它们不会污染类的名称空间， 这些属性仅仅只从属于类的创建阶段，而不是类中的语句执行阶段。 另外，它们在 prepare() 方法中是可以被访问的，因为这个方法会在所有类主体执行前被执行。 但是类变量只能在元类的 new() 和 init() 方法中可见。
回答
final
在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）。下面将对其详细介绍。
1.1 修饰类
当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意：
final类中所有的成员方法都会隐式的定义为final方法。
1.2 修饰方法
使用final方法的原因主要有两个：
(1) 把方法锁定，以防止继承类对其进行更改。
(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。
final方法意味着“最后的、最终的”含义，即此方法不能被重写。
注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。复制代码
class A{
private final void getName(){
}
}
public class B extends A{
public void getName(){
}
public static void main(String[]args){
System.out.println("OK");
}
}
复制代码
1.3 修饰变量
final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。
当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。
当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。
在java中，String被设计成final类，那为什么平时使用时，String的值可以被改变呢？
字符串常量池是java堆内存中一个特殊的存储区域，当我们建立一个String对象时，假设常量池不存在该字符串，则创建一个，若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候，例如 String a="A"; a="B" 。a是String对象的一个引用（我们这里所说的String对象其实是指字符串常量），当a=“B”执行时，并不是原本String对象("A")发生改变，而是创建一个新的对象("B")，令a引用它。
finally
finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）
很多人都认为finally语句块一定会执行，但真的是这样么？答案是否定的，例如下面这个例子：
当我们去掉注释的三行语句，执行结果为：
为什么在以上两种情况下都没有执行finally语句呢，说明什么问题？
只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常，所以try对应的finally语句并没有执行。
但是，在某些情况下，即使try语句执行了，finally语句也不一定执行。例如以下情况：
finally 语句块还是没有执行，为什么呢？因为我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK ！没有问题，我们不调用 System.exit(0) 这个方法，那么 finally 语句块就一定会执行吗？
再一次让大家失望了，答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。
易错点
在try-catch-finally语句中执行return语句。我们看如下代码：
答案：4,4,4 。 为什么呢？
首先finally语句在改代码中一定会执行，从运行结果来看，每次return的结果都是4（即finally语句），仿佛其他return语句被屏蔽掉了。
事实也确实如此，因为finally用法特殊，所以会撤销之前的return语句，继续执行最后的finally块中的代码。
finalize
finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。 特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。 使用finalize还需要注意一个事，调用super.finalize();
一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。
回答
"关于sleep()方法和yield()方法的区别如下。 sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。 sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而yield()不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用yield()方法暂停之后，立即再次获得处理器资源被执行。 sleep()方法声明抛出了 InterruptedException 异常，所以调用 sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常。 sleep()方法比 yield()方法有更好的可移植性，通常不建议使用 yield()方法来控制并发线程的执行。"