下边将使用 Haxe/HL 平台来和 Java 对比.因为都是虚拟机。

HelloWorld

public class Helo {
  public static void main(String arg[]) {
    System.out.println("Hello,Java");
  }
}
//文件保存为: Helo.java

//编译: > javac Helo.java

//运行: > java Helo

//输出: > Hello,Java

class Helo {
  public static function main() {
    Sys.println("Hello,Haxe/HashLink");
  }
}
//文件保存为: Helo.hx

//编译: > haxe -main Helo.hx -hl Helo.hl

//运行: > hl Helo.hl

//输出: > Hello,Haxe/HashLink

• java 和 haxe 一样, 类名必须以大写字母开始, 文件名需要与类名一致, 并且都可以在一个同一个文件内定义多个类。

  同一个文件内， java 仅允许一个类为可标注为 public。

• 在 java 中 package 和 improt 二个关键字的行为与 haxe 一模一样,

  唯一的区别是 java 可能需要将目录中的类(class)显示地声明为 public, 否则外部的类(class) 无法访问它, 而在 haxe 中类(class)默认的是 public

  因此 java 和 haxe 都有相同编译参数 -cp

  还有就是 haxe 中允许一个空的（不带标识符的） package;, 而在 java 中这是不允许的。

构造函数和方法重载

public class TheClass {
    // 和 C++ 一样.构造方法绝对不能写 void,

    public TheClass(){
        return;
    }
    // 方法重载

    public TheClass(int n){}

    // 这只是一个 void 普通方法,而"非构造函数"

    public void TheClass(){ }

    public static void main(String[]a){
        TheClass n = new TheClass();
        n.TheClass(); //调用 定义为 void 的普通方法

    }
}

class TheClass {
    public function new(){
    }
    // haxe 使用 new 方法作为构造函数

    // 为了避免混乱 haxe 在语言设计上没有方法重载, 而是支持"匹配模式"


    public static function main(){
        var inst = new TheClass();
    }
}

基础类型

byte    // 8  -128 ~ 127

short   // 16 -32768 ~ 32767

int     // 32 -2^31 ~ 2^31-1

long    // 64

float   // 32

double  // 64

boolean
char
void

Bool
Int
Float
Void

初使化类

public class Test {

    public Test() {
        System.out.println("new instance");
        System.out.println(num + "\n");
	}

    // 和 haxe 不一样的是 num 会先被赋值为 100, 然后再被 static 块中的代码改为 200, 最后为 200

    public static int num = 100;

    // static 代码块, 同样只运行一次

    static {
        num = 200;
        System.out.println("static code block");
    }

    public static void main(String arg[]) {
        new Test();
        new Test();
    }
    /* 输出:
     static code block
     new instance
     200

     new instance
     200
    */
}

class Test{
    public function new(){
        trace("new instance");
        trace(num + "\n");
    }

    //  num 会被 __init__ 先赋值为 200, 然后被赋值为 100; 即最后的值为 100;

    static var num:Int = 100;

    // __init__ 方法　只会运行一次

    static function __init__(){
        trace("static __init__");
        num = 200;
    }

    public static function main(){
        new Test();
        new Test();
    }

    /* 输出:
     static __init__
     new instance
     100

     new instance
     100
    */
}

加载源生方法

// 使用 native 关键字描述方法体, 经常用于加载 c 语言库

public class HelloJni{

	public native String  stringFromJNI();

	static{
		System.loadLibrary("hello-jni");
	}
}

// 使用　extern　关键字描述外部类

extern class Fs {
    static function rename(oldPath:String, newPath:String, callback:Error->Void):Void;
}

// 注: 对于不同的平台，调用源生类或方法有着各自需要注意的细节...

// 目前用在源生 JS 或 CPP 的库比较多.

空的

// 替换这里的内容

// 替换这里的内容

空的

// 替换这里的内容

// 替换这里的内容

NDK

留空以后再添加…

Java 速记

15分钟　java 快速入门

• 变量定义

  // 感觉和 C 语言很像
  int i = 10;
  char c = 'A';
  char [] cs = {'A','B','C'};
  String str = "Helo";
  Object [] obj = new Object[3]; // 初使化后数组长度必须为已知;
  obj[0] = new Object();
  // java 中需要明确的声明变量的类型，没有 "自动推导" 的语法糖
  

• java.lang 这个包不需要导入就可以直接使用.

• java.lang.Object

  除了Java的基础类型,所有类型都是继承于 Object,包括 String. 很多数据类型必须为 Object.

  感觉很像 AS3. 在 AS3 中 Object 是所有 类 的基类.

• final 关键字

  // final 除了 有 const 的行为
  // 还可以改变 一个变量作用域,叫做 final local variable
  // 下边示例中的 @Override run 方法,并不可以访问 其所在的局部变量
  // 但是局部变量加上 finnal 关键字后.就可以了
  public void foo() {
  	final String x = "hello";
  	String y = "there";
  	Runnable runnable = new Runnable() {
  		@Override public void run() {
  			System.out.println(x); // This is valid
  			System.out.println(y); // This is not
  		}
  	};
    runnable.run();
  }
  // 这个示例同样展示了 Java 可以在 实例化时,写 override 方法
  

• 将函数作为参数传递。

  // 在 haxe 中定义一个函数类型的方式有:
  var max: Int -> Int -> Int;
  var min: (a: Int, b: Int) -> Int;  // since haxe 4.0+
  var sum: (Int, Int) -> Int;        // 同上
  
  // java 中不可以把函数作为参数传递, 只能将参数类型定义成类或接口。
  java.lang.Runnable;
  java.util.concurrent.Callable;
  java.security.PrivilegedAction;
  java.util.Comparator;
  java.io.FileFilter;
  java.beans.PropertyChangeListener;
  

  lambda

  // 在 haxe 可随意定义一个方法, 就像 Javascript 中的一样
  var sum = function(a, b) {return a + b;}
  // haxe 箭头语法: （感觉箭头语法可读性不太好）
  var sum = (a, b) -> areturn a + b;
  
  // java 箭头语法和 haxe 也一致，细节参考: https://www.cnblogs.com/figure9/archive/2014/10/24/4048421.html
  (int x, int y) -> x + y;
  (String s) -> { System.out.println(s); }
  

• 迭代器 iterator

  haxe

  var a = [1, 2, 3, 4, 5];
  for(v in a) {
    trace(v);
  }
  for(i in 0...a.length) {
    trace(a[i]);
  }
  

  java:

  int[] a = {1, 2, 3, 4, 5};
  for(int v: a) {
    System.out.println(v);
  }
  for(int i = 0, len = a.length; i < len; i++) {
    System.out.println(a[i]);
  }
  

• abstract

  在 haxe 中 abstract 的形为有点类似于别名 typedef

  在 java 中, 在方法上则表示必须重写这个方法，在类则不可以直接实例，只能用 extends 扩展它。

• enum, java 和 haxe 一样，都不允许给像 c 语言那样给枚举赋值。

  haxe: 使用 “;” 号分隔，（这种在 haxe 中称为 FlatEnum）

  enum Color {
    red;
    green;
    blue;
  }
  

  java: 使用 “,” 号分隔每一项。

  enum Color {
    red,
    green,
    blue,
  }
  

• try/catch, java 中有 finally 块，而 haxe 无。