本文是「far 语言」系列文档之一，总目录见《【far 语言】语言文档目录》。

方法与匿名函数

方法定义

class App {
    // 静态方法：默认返回 0，可不写 return
    static long sum(long a, long b){
        return a + b;
    }

    // 实例方法（不加 static，用 this 访问）
    long doubleIt(long v){
        return v * 2;
    }

    static long main(string args[]){
        long r = this::sum(3, 4);      // 静态方法用 :: 调用
        App app = new App();
        long d = app.doubleIt(5);      // 实例方法用 . 调用
        return 0;
    }
}

• 静态成员：用 ::（this::method() / this::field / 类名::field）。
• 实例成员：用 .（this.method() / this.field / obj.method()）。
• :: 仅用于静态；实例字段用 :: 会编译报错。

参数默认值

// 带默认值的参数必须放在最后
static long greet(string name, long times = 1){
    for(long i = 0; i < times; i++){
        println("你好，" + name);
    }
    return 0;
}

this::greet("far");       // times = 1
this::greet("far", 3);    // times = 3

数组参数与返回

static long first(int x[3]){ return x[0]; }          // 定长
static long second(string s[]){ return s[1]; }       // 未定长
static int[] getList(){ return [1,2,3]; }            // 返回数组
static long pick(int x[] = [7,8,9]){ return x[0]; }  // 数组默认值

匿名函数

f := (x, y)-> println(x + y);        // 单行
g := (x, y)->{ return x + y; };      // 块体，最后一条表达式隐式返回

f(3, 4);    // 输出 7

• 可捕获外部变量。
• 修改外部变量仅对象类型生效，基本类型无法修改。

参数解构（可变参数效果）

static long test(string type, {string name, long age}){
    println(fmt("%s %s %s", type, name, age));
}

// 传 map 或数组均可
this::test("大学生", {"name":"张三", "age":21});
this::test("大学生", {"张三", 21});

// 支持默认值
static long test2(string type, {string name="far", long ok=123456}){
    println(fmt("%s %s", name, ok));
}

方法重载

同名方法可依参数列表（个数与类型）区分，编译器按实参类型择优绑定：

class Calc {
    long add(long a, long b){ return a + b; }
    string add(string a, string b){ return a + b; }   // 同名同个数、不同类型
    long add(long a, long b, long c){ return a + b + c; }  // 同名不同个数
}

Calc c = new Calc();
c.add(1, 2);          // → long 版本，3
c.add("a", "b");      // → string 版本，ab
c.add(1, 2, 3);       // → 三参版本，6

• 判定范围仅参数列表；返回值类型不参与重载（但各重载可以返回不同类型）。
• far 不做隐式数值转换，按精确类型匹配优先。
• 覆写父类方法时建议加 @Override，签名写错会立刻报错（见 inherit.md）。

可变参数

形参写成 T... name（Java 风格），只能放在形参列表最后，方法体内当作普通 T[] 使用：

class Util {
    long sum(long... nums){
        long t = 0;
        long i = 0;
        while(i < nums.size()){ t = t + nums[i]; i++; }
        return t;
    }
    string join(string sep, string... parts){ /* parts 是 string[] */ }
}

Util u = new Util();
u.sum();                  // 空数组，0
u.sum(1, 2, 3);           // 打包成 [1,2,3]，6
u.sum(1, 2, 3, 4);        // 10

long arr[4] = [1, 2, 3, 4];
u.sum(arr);               // 末实参本身已是 T[] ⇒ 整体直传，不二次打包，10
u.join("-", "a", "b");    // a-b

• 零实参 ⇒ 长度 0 的空数组。
• 末实参本身已是 T[] 时整体直传（Java 语义）。
• 变长方法与「接受同类型数组的同名方法」不能共存（内部签名相同）。