20131215-20140107XP、Win7下第一个Java程序（2014-01-18）

第十一个例子：Java通过JNI计算复正弦函数
C:\>javac Foo.java
C:\>java Foo
sin(1.0+4.0i)=22.979085577886128+14.744805188558725i
public native static double[] csin(double[] xy);
Foo foo = new Foo();
double xy[]=new double[]{1.0f,4.0f};
double uv[]=new double[]{0.f,0.f};
uv=foo.csin(xy);
System.out.println("sin("+xy[0]+"+"+xy[1]+"i)="+uv[0]+"+"+uv[1]+"i");
JNIEXPORT jdoubleArray JNICALL Java_Foo_csin(JNIEnv *env, jclass, jdoubleArray xy)
{
 jdouble* pxy = (env)->GetDoubleArrayElements(xy, 0 );
 double x=pxy[0];
 double y=pxy[1];
 double p,q,u,v;
 p=exp(y); q=exp(-y);
 u=sin(x)*(p+q)/2.0;
 v=cos(x)*(p-q)/2.0;
 double puv[2]={0};
 puv[0]=u;
 puv[1]=v;
 jdoubleArray uv=NULL;
 uv=env->NewDoubleArray(2);
 env->SetDoubleArrayRegion(uv,0,2,(jdouble*)puv);
 (env)->ReleaseDoubleArrayElements(xy, pxy, 0 );
 return uv;
}
第十个例子：Java计算实伽马函数
C:\>javac Gamma.java
C:\>java Gamma
1.7724540592304685
1.00000999975
1.00000999975
2.0000199995
 
第九个例子：Java计算定积分∫[0,1]e^xdx
C:\>javac DefiniteIntegral.java
C:\>java DefiniteIntegral
1.7183090114267447
1.7183176029717737
1.7183004198816596
 
第七~八个例子：
C:\>javac Birthday.java
C:\>java Birthday
您所输入的年份是闰年吗？true
C:\>javac Birthday1.java
C:\>java Birthday1
您所输入的年份是闰年吗？不是
C:\>javac AlogMath.java
C:\>java AlogMath
平均数为：5.5
标准差为：2.8722813232690143
平均数为：2.4
标准差为：1.5620499351813308 
 
第六个例子：
Java矩阵类（带加法及乘法）http://www.hqhome.net/java/297.html
C:\>javac Matrix.java
C:\>java Matrix
请输入第1个矩阵的行数：
2
请输入第1个矩阵的列数：
2
请依次输入第1个矩阵的元素：
1
2
3
4
请输入第2个矩阵的行数：
2
请输入第2个矩阵的列数：
3
请依次输入第2个矩阵的元素：
1
2
3
4
5
6
请选择运算方法（1表示加法，2表示乘法）：2
结果是：
| 9.0  12.0  15.0 |
| 19.0  26.0  33.0 |
 
 
第五个例子：
a=[1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
6 7 8 9]
a =
[ 1.00000000000000    2.00000000000000    3.00000000000000    4.00000000000000
  2.00000000000000    3.00000000000000    4.00000000000000    5.00000000000000
  3.00000000000000    4.00000000000000    5.00000000000000    6.00000000000000
  4.00000000000000    5.00000000000000    6.00000000000000    7.00000000000000
  5.00000000000000    6.00000000000000    7.00000000000000    8.00000000000000
  6.00000000000000    7.00000000000000    8.00000000000000    9.00000000000000 ]
b=[9 8 7 6 5 4
8 7 6 5 4 3
7 6 5 4 3 2
6 5 4 3 2 1]
b =
[ 9.00000000000000    8.00000000000000    7.00000000000000    6.00000000000000    5.00000000000000    4.00000000000000
  8.00000000000000    7.00000000000000    6.00000000000000    5.00000000000000    4.00000000000000    3.00000000000000
  7.00000000000000    6.00000000000000    5.00000000000000    4.00000000000000    3.00000000000000    2.00000000000000
  6.00000000000000    5.00000000000000    4.00000000000000    3.00000000000000    2.00000000000000    1.00000000000000 ]
c=mul(a,b)
c =
[ 70.0000000000000    60.0000000000000    50.0000000000000    40.0000000000000    30.0000000000000    20.0000000000000
  100.000000000000    86.0000000000000    72.0000000000000    58.0000000000000    44.0000000000000    30.0000000000000
  130.000000000000    112.000000000000    94.0000000000000    76.0000000000000    58.0000000000000    40.0000000000000
  160.000000000000    138.000000000000    116.000000000000    94.0000000000000    72.0000000000000    50.0000000000000
  190.000000000000    164.000000000000    138.000000000000    112.000000000000    86.0000000000000    60.0000000000000
  220.000000000000    190.000000000000    160.000000000000    130.000000000000    100.000000000000    70.0000000000000 ]
d=a'
d =
[ 1.00000000000000    2.00000000000000    3.00000000000000    4.00000000000000    5.00000000000000    6.00000000000000
  2.00000000000000    3.00000000000000    4.00000000000000    5.00000000000000    6.00000000000000    7.00000000000000
  3.00000000000000    4.00000000000000    5.00000000000000    6.00000000000000    7.00000000000000    8.00000000000000
  4.00000000000000    5.00000000000000    6.00000000000000    7.00000000000000    8.00000000000000    9.00000000000000 ]
f=b'
f =
[ 9.00000000000000    8.00000000000000    7.00000000000000    6.00000000000000
  8.00000000000000    7.00000000000000    6.00000000000000    5.00000000000000
  7.00000000000000    6.00000000000000    5.00000000000000    4.00000000000000
  6.00000000000000    5.00000000000000    4.00000000000000    3.00000000000000
  5.00000000000000    4.00000000000000    3.00000000000000    2.00000000000000
  4.00000000000000    3.00000000000000    2.00000000000000    1.00000000000000 ]
g=mul(d,f)
g =
[ 119.000000000000    98.0000000000000    77.0000000000000    56.0000000000000
  158.000000000000    131.000000000000    104.000000000000    77.0000000000000
  197.000000000000    164.000000000000    131.000000000000    98.0000000000000
  236.000000000000    197.000000000000    158.000000000000    119.000000000000 ]
第四个例子：
C:\>javac Factorial.java
C:\>java Factorial
0!=1
1!=1
2!=2
3!=6
4!=24
5!=120
6!=720
7!=5040
8!=40320
9!=362880
10!=3628800
11!=39916800
12!=479001600
13!=6227020800
14!=87178291200
15!=1307674368000
16!=20922789888000
17!=355687428096000
18!=6402373705728000
19!=121645100408832000
20!=2432902008176640000
21!=-4249290049419214848
22!=-1250660718674968576
23!=8128291617894825984
24!=-7835185981329244160
25!=7034535277573963776
26!=-1569523520172457984
27!=-5483646897237262336
28!=-5968160532966932480
29!=-7055958792655077376
30!=-8764578968847253504
 /*
*Factorial.java 
*/
public class Factorial
{ 
private long result=1; 
public Factorial()
{  this(0); } 
public Factorial(int n)
{  for(int i=2;i<=n;i++)
{   result*=i;  }  
System.out.println(n+"!="+result); } 
public static void main(String[] args)
{  for(int i=0;i<=30;i+=1)
{   Factorial myFactorial=new Factorial(i);  }   
}}
第一个例子：
C:\>javac Test1.java
C:\>java Test1
1
0.060000002
0.060000000000000005
0.06
0.06
Java代码如下：
import java.math.BigDecimal;
public class Test1 {
public static void main(String[] args) {
double x = Math.log(5);
System.out.println(x);//1.6094379124341003
double x1 = Math.log10(5);
System.out.println(x1);//0.6989700043360189
System.out.println(3/2);//1
float float_a = 0.05f;
float float_b = 0.01f;
System.out.println(float_a+float_b);//0.060000002
double double_a = 0.05d;
double double_b = 0.01d;
System.out.println(double_a+double_b);//0.060000000000000005
BigDecimal bigDecimal_a1 = new BigDecimal(float_a+"");
BigDecimal bigDecimal_b1 = new BigDecimal(float_b+"");
System.out.println(bigDecimal_a1.add(bigDecimal_b1));//0.06
BigDecimal bigDecimal_a2 = new BigDecimal(double_a+"");
BigDecimal bigDecimal_b2 = new BigDecimal(double_b+"");
System.out.println(bigDecimal_a2.add(bigDecimal_b2));//0.06
}
}
第二个例子：
C:\>javac MathTool.java
C:\>java MathTool
0.06
0.04
0.0005
5
Java代码：
import java.math.BigDecimal;
public class MathTool {
/*
* 加法运算
*/
public static String jia(double d1,double d2){
BigDecimal b1 = new BigDecimal(d1+"");
BigDecimal b2 = new BigDecimal(d2+"");
return b1.add(b2).toPlainString();
}
/*
* 减法运算
*/
public static String jian(double d1,double d2){
BigDecimal b1 = new BigDecimal(d1+"");
BigDecimal b2 = new BigDecimal(d2+"");
return b1.subtract(b2).toPlainString();
}
/*
* 乘法运算
*/
public static String cheng(double d1,double d2){
BigDecimal b1 = new BigDecimal(d1+"");
BigDecimal b2 = new BigDecimal(d2+"");
return b1.multiply(b2).toPlainString();
}
/*
* 除法运算
*/
public static String chu(double d1,double d2,int point){
BigDecimal b1 = new BigDecimal(d1+"");
BigDecimal b2 = new BigDecimal(d2+"");
return b1.divide(b2,point,BigDecimal.ROUND_HALF_UP).toPlainString();
}
public static void main(String[] args) {
double double_a = 0.05d;
double double_b = 0.01d;
System.out.println(MathTool.jia(double_a, double_b));//0.06
System.out.println(MathTool.jian(double_a, double_b));//0.04
System.out.println(MathTool.cheng(double_a, double_b));//0.0005
System.out.println(MathTool.chu(double_a, double_b,0));//5
}
}
第三个例子：java实现复数运算
C:\>javac book.java
C:\>java Book
请输入数据：
请输入第一个复述的实部：
1
请输入第一个复数的虚部：
2
请输入第二个复述的实部：
3
请输入第二个复述的虚部：
4
您输入的一个数为：
结果为：1.0+2.0*i
您输入的二个数为：
结果为：3.0+4.0*i
请选择您要进行的计算：
1 ：进行加法运算
2 ：进行减法运算
3 ：进行修改
4 ：进行乘法运算
5 ：进行除法运算
6 ：查看修改结果
1
加法成功：
加法成功：
计算结果的实部为：4.0
计算结果的虚部为：6.0
结果为：4.0+6.0*i
请问您是否还要继续 y/n：
Java代码：
import java.io.*;
public class Book{
double sb;
double xb;
Book(double x,double y){
   this.sb=x;
   this.xb=y;
   }
Book(){
 }
public static void main(String args[]){
 System.out.println("请输入数据：");
 double a=0;
 double b=0;
 double c=0;
 double d=0;
 String s;
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  System.out.println("请输入第一个复述的实部：");
  try{
 s = in.readLine();
 a=Double.parseDouble(s);
}
  catch(IOException e)
{ System.out.println("抛掷异常");}
  System.out.println("请输入第一个复数的虚部：");
  try{
 s = in.readLine();
 b =Double.parseDouble(s);
}
  catch(IOException e)
{ System.out.println("抛掷异常");}
  System.out.println("请输入第二个复述的实部：");
  try{
  s = in.readLine();
 c =Double.parseDouble(s);
}
  catch(IOException e)
{ System.out.println("抛掷异常");}
  System.out.println("请输入第二个复述的虚部：");
  try{
  s = in.readLine();
 d =Double.parseDouble(s);
}
  catch(IOException e)
{ System.out.println("抛掷异常");}
  Book h;
  h=new Book(a,b);
  Book j;
  j=new Book(c,d);
 System.out.println("您输入的一个数为：");
 toString(h);
 System.out.println("您输入的二个数为：");
 toString(j);
 Book k;
 k=new Book();
 
 char z='y';
do{
 System.out.println("请选择您要进行的计算：");
   System.out.println("1 ：进行加法运算");
   System.out.println("2 ：进行减法运算");
   System.out.println("3 ：进行修改");
   System.out.println("4 ：进行乘法运算");
   System.out.println("5 ：进行除法运算");
   System.out.println("6 ：查看修改结果");
 int i=0;
 try{
 i= Integer.parseInt(in.readLine());
}
 catch(IOException e)
{ System.out.println("抛掷异常");}
 switch(i)
{
 case 1:
    k.sb=jia(h.sb,j.sb);
        k.xb=jia(h.xb,j.xb);
        System.out.println("计算结果的实部为："+k.sb);
        System.out.println("计算结果的虚部为："+k.xb);
        toString(k);
        break ;
 case 2:
       k.sb=jian(h.sb,j.sb);
        k.xb=jian(h.xb,j.xb);
        System.out.println("计算结果的实部为："+k.sb);
        System.out.println("计算结果的虚部为："+k.xb);
        toString(k);
    break ;
 case 3:
       System.out.println("请输入您要修改哪个实数：");
       int l=0;
    try{
    l= Integer.parseInt(in.readLine());
}
    catch(IOException e)
    { System.out.println("抛掷异常");}
    if(l==1)
    {
     h.xiugais(h);
     h.xiugaix(h);
     }
    else
     {
      xiugais(j);
      xiugaix(j);
     }
    break ;
 case 4:
       double f=0;
       double e=0;
       f=cheng(h.sb,j.sb)+cheng(h.xb,j.xb);
       e=cheng(h.sb,j.xb)+cheng(h.xb,j.sb);
       k.sb=(double)(Math.round(f*100)/100.0);
       k.xb=(double)(Math.round(e*100)/100.0);
       System.out.println("计算结果的实部为："+k.sb);
        System.out.println("计算结果的虚部为："+k.xb);
        toString(k);
   break ;
   case 5:
        double chushu=cheng(j.sb,j.sb)-cheng(j.xb,-j.xb);
        double beichushus=jian(cheng(h.sb,j.sb),cheng(h.xb,-j.xb));
        double beichushux=jia(cheng(h.sb,-j.xb),cheng(h.xb,j.sb));
        k.sb=chu(beichushus,chushu);
        k.xb=chu(beichushux,chushu);
        System.out.println("计算结果的实部为："+k.sb);
        System.out.println("计算结果的虚部为："+k.xb);
        toString(k);
        break ;
   case 6:
          System.out.println("修改后的结果为：");
          System.out.println("第一个复数："+toString(h));
          System.out.println("第二个复数："+toString(j));
          break ;
}
    System.out.println("请问您是否还要继续 y/n：");
    try{
    z=(char)System.in.read();
      System.in.skip(2); //忽略回车换行
}
         catch(IOException e){}
} while(z=='y');
}
  public static double gets(Book a){
   return a.sb;
 }
 public static double getx(Book b){
  return b.xb;
  }
 public static double xiugais(Book a)
{
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 System.out.println("请输入您要修改的实部：");
 double m=0;
    try{
    m= Double.parseDouble(in.readLine());
}
    catch(IOException e)
    { System.out.println("抛掷异常");}
 a.sb=m;
  System.out.println("修改成功：");
  return 0;
}
  public static double xiugaix(Book b)
{
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 System.out.println("请输入您要修改的虚部：");
 double n=0;
    try{
    n= Double.parseDouble(in.readLine());
}
    catch(IOException e)
    { System.out.println("抛掷异常");}
 b.xb=n;
  System.out.println("修改成功：");
  return 0;
}
 public static double jia(double a,double b)//
{
 double c=0;
 c=a+b;
  System.out.println("加法成功：");
   return c ;
}
 public static double jian(double a,double b)
{
 double c=0;
 c=a-b;
  System.out.println("减法成功：");
   return c;
}
 public static double cheng(double a,double b)
{
 double c=0;
 c=a*b;
 System.out.println("乘法成功：");
  return  c;
}
 public static double chu(double a,double b)
{
 double d=0;
 double c=0;
 d=a/b;
 c=(double)(Math.round(d*100)/100.0);
  System.out.println("除法成功：");
   return c ;
}
  public  static double toString(Book a){
   System.out.println("结果为："+a.sb+"+"+a.xb+"*i");
   return 0;
   }
}
 
XP下安装jdk-6u10-rc2-bin-b32-windows-i586-p-12_sep_2008.exe
C:\Documents and Settings\Administrator>java -version
java version "1.6.0_10-rc2"
Java(TM) SE Runtime Environment (build 1.6.0_10-rc2-b32)
Java HotSpot(TM) Client VM (build 11.0-b15, mixed mode, sharing)
在“系统变量”中，设置3项属性，JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击“编辑”，不存在则点击“新建”：
JAVA_HOME指明JDK安装路径，就是刚才安装时所选择的路径C:\Program Files\Java\jdk1.6.0_10，此路径下包括lib，bin，jre等文件夹（此变量最好设置，因为以后运行tomcat，eclipse等都需要依靠此变量）；
Path使得系统可以在任何路径下识别java命令，设为：
%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别，设为：
.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar (要加.表示当前路径)
%JAVA_HOME%就是引用前面指定的JAVA_HOME。

备注：
2008年定下的技术发展规划：
1.java、汇编暂时不学
2.基础设施建设，也就是代码仓库（data.mdb）的积累：c/c++/vb/Delphi/C#/ASP.NET/vb.net/JavaScript/JSP/PHP/MFC/STL/Socket/Winsock/ODBC API/ADO/DirectX/其他DLL/COM/OCX/vb/vb.net（gui/cui）/vc（sdk/mfc/stl/atl/托管c++）/delphi/c#（gui/cui）
2009-2010技术发展规划调整：
重视c++ DirectX端游技术，这一块投入了很大精力，但目前工作履历中缺乏2d、3d引擎开发经验。
2012-2013年的技术发展规划调整：
淡化微软的技术，除非工作中确实需要；强调开源复用、强调轻型可裁剪复用
2013年
重视MFC编程技术，原因是工作中用到了。
2014年的技术发展规划调整：
掌握java和Android手游开发技术
第五个例子：
c:\>javac Int2Str.java
c:\>java Int2Str
黄宝石 的整数形式为：5
整数2转化成字符串：战士
Java代码为：
/** *//**
 * 文件名：Int2Str.java
 */
public class Int2Str{
   
    //1,粮食;2,木材;3,铁;4,皮 5,黄宝石,6,红宝石,7,绿宝石,8,黑铁
    public static int GetResourceSaleIDFromResName(String strRes)
   {
 if(strRes.equals("粮食"))
  return 1;
 if(strRes.equals("木材"))
  return 2;
 if(strRes.equals("铁"))
  return 3;
 if(strRes.equals("皮"))
  return 4;
 if(strRes.equals("黄宝石"))
  return 5;
 if(strRes.equals("红宝石"))
  return 6;
 if(strRes.equals("绿宝石"))
                return 7;
 if(strRes.equals("黑铁"))
  return 8;
 return 0;
    }
    //通过职业ID获取英雄职业
    public static String GetHeroOccupationByOccupationID(int nOccupationID)
    {
 String strOccupation;
 switch(nOccupationID)
 {
 case 1:
  strOccupation ="圣骑士";
  break;
 case 2:
  strOccupation ="战士";
  break;
 case 3:
  strOccupation ="弓箭手";
  break;
 case 4:
  strOccupation ="法师";
  break;
 case 5:
  strOccupation="牧师";
  break;
 default :
  strOccupation ="未知";
 }
 return strOccupation;
    }
    public static void main(String[] args)
    {
        String Str = "黄宝石";
        int id = Int2Str.GetResourceSaleIDFromResName(Str);
        System.out.println("黄宝石 的整数形式为：" + id);
        int nOccupationID=2;
        System.out.println("整数" + nOccupationID + "转化成字符串："+ Int2Str.GetHeroOccupationByOccupationID(nOccupationID));
    }
}
第四个例子的扩展
c:\>javac javacall.java
c:\>java javacall
16
5
21.2
21.2
数组1的平均数为：5.0
土著
联盟
部落
土著
销毁装备成功!
3
javacall.java中添加Add函数、Abc函数、DAbc函数、mean函数、GetCountryStr函数、GetDestroyEquipStateStr函数、GetResourceSaleIDFromResName函数
public class javacall
{
static
{
System.loadLibrary("calldll");
}
public native static int shanfei(int i);
public native static int Add(int a,int b);
public native static float Abc(float a, float b, float c);
public native static double DAbc(double a, double b, double c);
public native static float mean(float[] data,int num);
public native static String GetCountryStr(int nCountry);
public native static String GetDestroyEquipStateStr(boolean isSuccess);
public native static int GetResourceSaleIDFromResName(String ResName);
 
public static void main(String[] args)
{
javacall jc = new javacall();
int j;
j = jc.shanfei(4);
System.out.println(j);
j = jc.Add(3,2);
System.out.println(j);
float k=jc.Abc(2,3,4);
System.out.println(k);
double kk=jc.DAbc(2,3,4);
System.out.println(kk);
float arr1[]=new float[]{2,4,4,4.6f,5,5.2f,5.6f,6,6.6f,7};
for(int i=0;i<5;i++)
{
//String p= new String(GetCountryStr(i).getBytes("ISO8859-1"),"GB2312"); // 这里是关键
String p=GetCountryStr(i);
System.out.println(p);
}
boolean bool=true;
String p1=jc.GetDestroyEquipStateStr(bool);
System.out.println(p1);
String strResName="铁";
int ResID=jc.GetResourceSaleIDFromResName(strResName);
System.out.println(ResID);
}
}
calldll.cpp中GetCountryStr函数的代码：
//将windows类型转换成jstring类型
jstring WindowsTojstring( JNIEnv* env, char* str )
{
 jstring rtn = 0;
 int slen = strlen(str);
 unsigned short * buffer = 0;
 if( slen == 0 )
  rtn = (env)->NewStringUTF(str );
 else
 {
  int length = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, NULL, 0 );
  buffer = (unsigned short *)malloc( length*2 + 1 );
  if( MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, (LPWSTR)buffer, length ) >0 )
   rtn = (env)->NewString( (jchar*)buffer, length );
 }
 if( buffer )
  free( buffer );
 return rtn;
}
JNIEXPORT jstring JNICALL Java_javacall_GetCountryStr(JNIEnv *env, jclass, jint nCountry)
{
 string strCountry="";
 if(nCountry==3||nCountry==0)
 {
  strCountry="土著";
 }
 else if(nCountry==1)
 {
  strCountry="联盟";
 }
 else if(nCountry==2)
 {
  strCountry="部落";
 }
 //jstring result = env->NewStringUTF(strCountry.c_str());
 //jstring result =stoJstring(env,strCountry.c_str());
 jstring result =WindowsTojstring(env,(char *)strCountry.c_str());
 return result;
}
calldll.cpp中GetResourceSaleIDFromResName函数的代码：
//将jstring类型转换成windows类型
char* jstringToWindows( JNIEnv *env, jstring jstr )
{
 int length = (env)->GetStringLength(jstr );
 const jchar* jcstr = (env)->GetStringChars(jstr, 0 );
 char* rtn = (char*)malloc( length*2+1 );
 int size = 0;
 size = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)jcstr, length, rtn,(length*2+1), NULL, NULL );
 if( size <= 0 )
  return NULL;
 (env)->ReleaseStringChars(jstr, jcstr );
 rtn[size] = 0;
 return rtn;
}
JNIEXPORT jint JNICALL Java_javacall_GetResourceSaleIDFromResName(JNIEnv *env, jclass, jstring jstr)
{
 char *pszSTR = NULL;
 pszSTR =jstringToWindows(env, jstr);
 std::string strRes=pszSTR;
 if(pszSTR!=NULL)
 {
  free(pszSTR);
 }
 if( !strcmp( strRes.c_str(), "粮食" ) )
  return 1;
 if( !strcmp( strRes.c_str(), "木材" ) )
  return 2;
 if( !strcmp( strRes.c_str(), "铁" ) )
  return 3;
 if( !strcmp( strRes.c_str(), "皮" ) )
  return 4;
 if( !strcmp( strRes.c_str(), "黄宝石" ) )
  return 5;
 if( !strcmp( strRes.c_str(), "红宝石" ) )
  return 6;
 if( !strcmp( strRes.c_str(), "绿宝石" ) )
  return 7;
 if( !strcmp( strRes.c_str(), "黑铁" ) )
  return 8;
 return 0;
}
第四个例子——Win7下用JNI调用了VC2010编译的64位的DLL：calldll.dll，导出函数：Java_javacall_shanfei
c:\>javac javacall.java
c:\>javah javacall
c:\>java javacall
16
先介绍一下jni：Java Native Interface，它能够使java和其他编程语言编写的应用程序和库进行相互操作。
java中调用c函数，主要是通过本地化接口jni来实现的，在windows下，调用的是dll文件，在unix下，调用的是so文件。这里先介绍编写调用c函数的基本步骤：
（1）：编写.java文件，其中c中的函数要用public native static修饰。
（2）：编译.java文件为.class文件，使用javah生成.h文件。
（3）：按照.h文件中的函数形式在c中实现函数。
（4）：生成.dll文件，拷贝到java工程中。
（5）：运行java文件。
编写java程序javacall.java，如下：
public class javacall
{
static
{
System.loadLibrary("calldll");
}
public native static int shanfei(int i);
public static void main(String[] args)
{
javacall jc = new javacall();
int j;
j = jc.shanfei(4);
System.out.println(j);
}
}
编译
javac javacall.java
生成头文件
javah javacall
生成javacall.h文件
制作calldll.dll
建立新DLL工程，程序中添加：
#include "javacall.h"
JNIEXPORT jint JNICALL Java_javacall_shanfei (JNIEnv *, jclass, jint p)
{
int j = p*p;
return j;
｝
附加包含目录添加：
C:\Program Files\Java\jdk1.6.0_43\include;C:\Program Files\Java\jdk1.6.0_43\include\win32;
用x64编译
java调用
将生成的calldll.dll文件复制到javacall.java所在的目录中，运行
java javacall，应该可以看到运行结果。
第三个例子：
c:\>javac DPoint2.java
c:\>java DPoint2
7.0710678118654755
//java求两点距离
//范数：‖x‖定义为内积的开根号，也即<x,x>^(1/2)
//范数‖x-y‖表示向量x与向量y的线段长度
//内积：满足三条性质
//内积空间：定义了内积的线性空间
public class DPoint2
{
private double x;
private double y;
public DPoint2(double x, double y)
{
this.x = x;
this.y = y;
}
public double getDistance(DPoint2 p)
{
double _x = Math.abs(this.x - p.x);
double _y = Math.abs(this.y - p.y);
return Math.sqrt(_x*_x+_y*_y);
}
public static void main(String[] args)
{
DPoint2 p1 = new DPoint2(5, 5);
DPoint2 p2 = new DPoint2(10, 10);
System.out.println(p2.getDistance(p1));
}
}
第一个例子：
C:\Users\Administrator>cd c:\
c:\>javac Temp.java
c:\>java Temp
2
7
5
-8
-1
7
Java代码：
 public class Temp {
 public static void main (String args[]) {
  int x = 3; //3的二进制为00000000 00000000 00000000 00000011
  int y = 6; //6的二进制为00000000 00000000 00000000 00000110
  System.out.println(x & y); //输出2
  System.out.println(x | y); //输出7
  System.out.println(x ^ y); //位相同为0，不同为1.输出5
  
  x = -3; //-3的二进制为10000000 00000000 00000000 00000011, 反码为11111111 11111111 11111111 11111100, 补码为11111111 11111111 11111111 11111101
  y = -6; //-6的二进制为10000000 00000000 00000000 00000110, 反码为11111111 11111111 11111111 11111001, 补码为11111111 11111111 11111111 11111010
  System.out.println(x & y); //补码与之后为11111111 11111111 11111111 11111000, 反码（补码减1）为11111111 11111111 11111111 11110111, 原码（反码取反，如果第一位为1，则表明是负数，负数符号位不取反）为10000000 00000000 00000000 00001000.因此输出-8
  System.out.println(x | y); //输出-1
  System.out.println(x ^ y); //输出7（注意：符号位也进行运算。由于前面29为预算后都为0，所以结果变成正数）
 }
}
第二个例子：
public class Temp2{
 public static void main (String args[]) {
                 //int []aBGR = {0x56, 0x78, 0x9A, 0xBC};   // 是用16进制保存的4种颜色值
                 //int []aBGR = {0,42,227,230};
                 //int []aBGR = {0,255,195,198};
                 int []aBGR = {0,255,0,0};
                 int color_val = aBGR[3];  
                 color_val = color_val | (aBGR[2] << 8);  // 为了压缩，需要放置到color_val值的第二个字节位置上：将aRGB[2] 左移到第二个byte，同时与color_val
进行或操作，下面同理
                 color_val = color_val | (aBGR[1] << 16); 
                 color_val = color_val | (aBGR[0] << 24);
                
                 //ff0000=16711680=(0,0,255)
                 //ffc3c6=16761798=(198,195,255)
                
                 //2ae3e6=2810854
                 //RGB(230,227,42),COLORREF rgb=2810854,BYTE r=230,g=227,b=42;r=2810854%256;g=(2810854/256)%256;b=2810854/256/256;Mod=%
                 //操作完的结果是56789abc=1450744508
                 System.out.println(Integer.toHexString(color_val));
   System.out.println(color_val);
 }
}