如果想用非Java代码来编写程序，或者需要直接操纵硬件，此时，你可以编写本机方法(native method)。

native关键字就是用来声明本机方法(native method)的。一旦声明，这些本机方法可以在Java程序中被调用，就像调用其他Java方法一样。
  
native method 用C/C++语言实现，并且被编译成DLL，这些函数的实现体在DLL中，在Java中本机方法体只是一个分号。

例如向操作系统请求机器的CPU编号方法，如下：

      public native int getCPUID();

native method 以可以被重载或者覆盖，也可以是final, static, synchronized, public, protected, private 的。但是本机方法不能声明为abstract或者strictfp类型。

“10个人围一圈，编号为1的人开始数数，数到能被3整除的编号的人退出，然后再往下数。问最后剩几个人？
如第一圈后：3，6，9退出，还剩7人下一圈从第11开始数。求算法”

看到过这个题目很多次，从来都没有仔细想过写过代码。

下面的方法是我今天看到题目后的第一反应，应该有更好的吧。

你们都是怎么做的啊，学习一下，谢谢啦！
我算法很弱的。。。

一、数组实现

1.    for循环初始化每个人的值为0

2.    开始报数，如果所报之数能被3整除，设置此人的值为1

3.    如此循环下去，直到只有一个人的值为0

4.    获得此人在数组中的下标，加1之后输出，即为所求

• Java十大事件之一：Java源起

• Java十大事件之二：Java香浓世界

• Java十大事件之三：盟主地位就此定

• Java十大事件之四：微软与Sun的Java官司

• Java十大事件之五：Java 2平台发布   

• Java十大事件之六：Java开源社群开始蓬勃发展

• Java十大事件之七：WebLogic打开J2EE的魔匣

• Java十大事件之八：官司最终以喜剧收场

• Java十大事件之九：JBoss和Eclipse

• Java十大事件之十：Java 5.0

                              在Java中使用循环定义会出现哪些问题  

在上一篇文章《 inconstant constants ( 变化无常的常量 )   》的基础上,我们再来研究一下在 Java 中使用循环定义会出现哪些问题。

老规矩，代码伺候 ^+^

代码中的static final变量X，Y，Z，循环定义。

你可以先想一下，这个值会是多少？看看与实际结果是否一致。

输出结果：

15

现在对ClassTest.java进行一点修改，如下：

两次的输出结果会一样么？
我既然这么问了，你肯定会说不一样，那你知道原因么？你知道这次的输出结果么？
可以先思考一下。

输出结果：

8

让我来告诉你这是怎么回事。

我们可以看见，对于三个staitc final 变量 X，Y，Z，他们的初始化表达式是循环定义的。在编译期间不能确定它们的值，所以它们是运行期间常量( runtime constants )，编译器不会进行常量替换。
而且每个表达式的计算将会依赖于类装载的顺序。

例如，为了计算出例1中的 ClassTest 结果，我们可以预见，ClassX 是第一个被装载的类，但是第一个完成初始化的类却是 ClassZ.

让我们一步一步看看都发生了什么。

1.   X = 2 * ClassY.Y;      计算X，需要知道ClassY.Y的值，下一步计算Y值
2.   Y = ClassZ.Z + 1;      计算Y，需要知道ClassZ.Z的值，下一步计算Z值
3.   Z = X + 3;                计算Z，需要知道X的值，而此时X的值还没有被计算出来(又转回来了，居然是个圈，呵呵^+^)，所以我们使用X的默认值0。

因此：
      Z = 3;
      Y = 4;
      X = 8;

所以 ClassX.X + ClassY.Y + ClassZ.Z  =  15

例2当中，也是同一道理
不同的是，ClassZ是第一个被装载的类，ClassX是第一个完成初始化的类
1. Z = X + 3;
2. X = 2 * ClassY.Y;
3. Y = ClassZ.Z + 1;(此时使用Z的默认值0)

因此：
      Y = 1;
      X = 2;
      Z = 5;

所以 ClassZ.Z + ClassY.Y + ClassX.X = 8

只是简单的改变的输出顺序，结果却截然不同。哪一个才是你想要得结果呢？

我的例子看起来有点挖空心思钻牛角尖，但是在大型项目当中，也许就会出现与例子当中相同的循环定义，如果真的存在的话，那么在纷繁的代码当中想要发现循环定义可不是件容易的事情。

如果独立看每一个定义的话，似乎都可以进行常量替换，看不出任何问题。但是这样的代码在不久的将来就会引发问题，而且不易被我们所察觉。

在你的应用程序当中不经意的代码改变（例如示例代码中我们只是改变了输出顺序，却产生了截然不同的结果），就会导致不同的类装载顺序和计算顺序，或者在并发的线程调度中，可能也会导致致不同的类装载顺序和计算顺序。不幸的是，大多数编译器不认为这种代码是错误，也不会对编程人员给出任何警告。

我只是讲了一下循环定义会引发的问题，我暂时也想不出什么好的解决办法，只能在编程的过程当中尽量注意啦。


注：有错误请告诉我，非常感谢！

注：部分内容在《 使用Java中的final变量需要注意的地方 》有提到，不过我转载的原文不够详细深入，这才重新写一下。

我们还是来先看一段代码，由代码引出问题：

输出结果：

2

结果是显而易见的，这里需要说明的是：
根据Java语言规范，对于java中的static final变量，如果用一个在编译期间(complie time)可以计算出结果的表达式进行初始化，则用到此变量的地方会被该表达式的结果所替代。本例中，在编译期间，ClassTest.main() 函数中 ClassX.X 将被2所替代。

此时，在类ClassTest main()中不再有指向ClassX的动态链接，告诉ClassTest在运行的时候从ClassX获得X的值，你可以通过使用javap反编译器帮助你理解。

1. 先编译ClassTest.java文件
            javac ClassTest.java
2. 使用javap
            javap -c ClassTest

屏幕输出：

可以看出，在调用System.out.println()之前，整数2已经被放在JVM的堆栈中，不再有指向ClassX.X的链接。如果此时，改变ClassX.X的值为1,并且重新编译ClassX.X文件，但是并不重新编译ClassTest.java文件，运行ClassTest，输出结果仍然是2.

这么做(常量替换)的一个原因是为了在编译期间检查switch case语句。switch语句中的每一个case都需要一个常量值，而且每两个之间都不能相同，编译器在编译期间将会做检查。

如果用来给static final变量进行初始化的表达式，只能在运行时刻才可以计算出值，那么常量替换就不会发生.例如：

ClassX 改变了，我们再来看一下Main.main():

此时我们可以看见有个引用指向了Field X。
( 如果把类ClassX改成Interface，仍然会出现上面的结果 )

当然有方法可以使你避免出现"inconstant constants"问题。

第一种方法：
当你要声明一个编译期间常量的时候，一定要保证此变量不会或者不太可能改变，或者尽量少使用声明为static final的变量。当然这只能治标不能治本，所以我推荐使用第二种方法。

第二种方法：
将变量声明为private，同时声明一个方法来获得此变量的值

此时再改变ClassX.X的值为1，重新编译ClassX.java，而不编译ClassTest，结果就会显示1，而非2。这就避免了"inconstant constants"的问题。

下一篇准备讲一下 《在java中使用循环定义会出现哪些问题？》