对照JAVA学习Rust（03）--函数

1、main函数

    java:

public class Demo {
    public static void main(String[] args) {

      System.out.println("hello world");
    }
}

rust:

fn main() {
    println!("Hello, world!");
}

 从两段main函数可看出，java任何函数必须依附于一个类，而rust无类的概念，可直接存在于rust文件中。且java的main函数必须是有String数组类型的参数，实现执行程序时的入参，而rust的执行时入参数时通过std::env::args() 的系统api获取，使用如下：

fn main() {
    for arg in std::env::args()
    {
        println!(arg);
    }

    std::process::exit(0);
}

2、函数基本定义

	Java	Rust
定义	public int getSize(){    return 0 }	pub get_size() -> i32{         return 0; }
访问权限	public，默认无修饰词，protect,private	pub、默认无修饰词
命名规范	推荐驼峰氏命名，如getSize	推荐全小写，下划线隔开如get_size

从对比表格看出，java是遵循C风格的语言，定义函数时返回值在函数名之前，而rust是在定义函数最后声明返回值类型，以“->” 指明类型。另外Rust是可以将函数作为对象，且可作为返回的结果。rust的函数访问权限只有公有（pub）和私有（默认无修饰词），而java是4个比脚细分的关键词。

3、函数参数定义 

       Java的函数参数有2种：

参数定义的方式	样例
定义普通参数	public setName (String name)
定义可变参数	public setNames (String... name)

        Rust有3种定义参数方式：

参数定义的方式	样例
定义普通参数	fn set_name(name: String)
定义默认值参数	fn set_age(age: u16 = 10)
定义可变参数	fn set_name(mut agrs:String)

在对比的两个图表里需要澄清 可变参数的定义不同，java的可变参数是值参数个数可变，Rust可变值参数可以被修改。

4、函数指针

   函数指针实际在Rust的应用就是的将函数作为参数传入其他函数，并调用。或者函数返回一个另外一个函数作为结果值。

fn inc(src: u32) -> u32 {
    src + 1
}

fn inc2(src: u32) -> u32 {
    src + 2
}

type Incrementer = fn(u32) -> u32;
fn increment_printer(inc: Incrementer) {
    println!("{}", inc(1));
}

fn main() {
    increment_printer(inc);
    increment_printer(inc2);
}

该类似能力，在java种无对应的函数指针，但是可以定义函数在一个基础类或接口，然后在其他的函数中的参数定义为改基础类或接口。将实现类的对象传入，再调用该对象的函数，即可实现类似功能。或者使用java8以后的Lamda实现，如下例子：

public class JavaMain {
    public static void main(String[] args) {

       int result =  computePointer(new AddComputer(),11,8);
        System.out.println(result);
    }
    public static int computePointer(Computer computer,int a,int b){
        return computer.compte(a,b);
    }
   interface Computer{
        int compte(int a,int b);
    }

   static class AddComputer implements Computer{
        public int compte(int a,int b){
            return a+ b;
        }
    }

   static class MultiComputer implements Computer{
        public int compte(int a,int b){
            return a* b;
        }
    }
}

5、函数注解

6、函数和方法的区别

Rust通过impl关键字在struct、enum或者trait对象上实现方法调用语法 (method call syntax)。关联函数 (associated function) 的第一个参数通常为self参数，有3种变体：

1. self，允许实现者移动和修改对象，对应的闭包特性为FnOnce。
2. &self，既不允许实现者移动对象也不允许修改，对应的闭包特性为Fn。
3. &mut self，允许实现者修改对象但不允许移动，对应的闭包特性为FnMut。

不含self参数的关联函数称为静态方法 (static method)。

7、发散函数

发散函数就是用！作为返回类型收尾，不再返回的一种函数。此功能在java不存在对应能力。

8、匿名函数或闭包

Lambda 表达式也称为闭包，是Java 8 发布的新特性；Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)

Java	Rust
Lambda 表达式也称为闭包，是Java 8 发布的新特性；Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)	|参数列表| -> 返回类型 {代码段}。用两个竖线将函数参数包裹起来，后面接返回值的类型，最后是用花括号包裹的代码段。 闭包类型分为三种：1.Fn；2.FnMut；3.FnOnce。它们的调用方法分别采用&self、&mut self和self，这意味着Fn对其捕获具有不可变的访问权限，FnMut获得可变的访问权限，FnOnce可以获得所有权。 2.Fn和FnMut类型的闭包可以执行多次，而FnOnce类型的闭包只能执行一次。

Java实例

// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
 MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };

Rust实例

//带返回值
let closure = |a: i32| -> i32 {
        println!("a={}", a);
        a
    };
//不带返回值
 let closure = |a: i32| {
        println!("a={}", a);
    };