20190312_浅谈go&java差异(二)

转载请注明出处：

第二节内容概览

• 循环(for、switch)
• 多值返回
• defer & finally
• init(go) 与默认构造函数(java)
• 常量、静态变量(const 与 static final)
• 参数或方法访问属性

循环

• go
  go提供了range关键字可以循环各种切片和数组，同时也提供了多参，这点相比较java会灵活不少，
  另外switch循环也不同与java，默认仅进入匹配的case内不会往下循环，若需要往下循环需要用到
  fallthrough关键字，这个也确实有利于开发，不用像java一样写break结束。

    func main() {
        arr := []string{"a", "b", "c"}
  
        for val := range arr {
            fmt.println(arr[val])
        }
  
        for i := 0; i < 10; i++ {
            fmt.println(i)
        }
  
        caseval := "c"
        switch caseval {
        case "a":
            fmt.println("this is a")
        case "b":
            fmt.println("this is b")
        case "c":
            fmt.println("this is c")
        default:
            fmt.println("this is other word!")
        }
  
    }

• java
  java 提供了多种循环，分别是for、foreach、stream foreach(java8提供)，while、do while
  switch ，我就直接展示代码吧。

    @test
    public void fortest(){
        string[] arr = new string[]{"a","b","c"};
        for (string item:arr) {
            log.info(item);
        }
  
        for(int i=0;i<arr.length;i++){
            log.info(arr[i]);
        }
  
        string word = "b";
  
        switch (word){
            case "a":
                log.info("this is a");
                break;
            case "b":
                log.info("this is b");
                break;
            case "c":
                log.info("this is c");
                break;
            default:
                log.info("this is other word!");
        }
    }

多值返回

• go
  go提供了多参返回，当参数较少当时候可以一次性返回，不用构造结构体返回

    func main() {
        a, b, c, err := process(11, "a", true)
        fmt.println(a, b, c, err)
    }
  
    func process(aa int32, bb string, cc bool) (int32, string, bool, error) {
        var ccreturn bool
        if true == cc {
            ccreturn = false
        } else {
            ccreturn = true
        }
        return aa + 1, bb + "_return", ccreturn, nil
    }
  

• java
  java并没有提供多参返回，若要实现多参返回，一般将返回参数封装入map、list 这类集合类型中，
  或者构造一个新对象放入返回值后返回。

        @test
        public void returnobjec(){
            map<string,object> result = this.processobj();
            log.info(new jsonobject(result).tostring());
        }
  
        public map<string,object> processobj(){
            return new hashmap<string,object>(){{
                put("val1",true);
                put("val2","str");
                put("val3",999777l);
            }};
        }

defer & finally

• go
  首先 defer 和 finally 大多用于资源关闭或异常处理
  go中的defer 与 java的finally个人感觉是相似的，但是如果将defer放入到循环内的话可就像
  一个反向队列了，若一个处理逻辑内有多个defer的时候 先defer的晚于后defer,很有意思，大家可以试试哈～

    func main() {
        dosomething()
    }
  
    func dosomething() {
        fmt.println("something start")
        defer fmt.println("something defer")
        fmt.println("something end")
  
        arr := []string{"a", "b", "c"}
        for val := range arr {
            defer fmt.println(val)
        }
    }
  

• java
  java 的finally 大多用于异常处理，尤其是文件流异常处理，同时也不存在类似于defer的倒序处理，
  这里就给个简单的例子～

    @test
    public void processfinal(){
        string[] arr = new string[]{"a","b"};
  
        try{
            log.info(arr[2]);
        }catch (exception e){
            log.info("异常了：{}",e);
        }finally {
            log.info("最后进入～");
        }
    }

init 与默认构造函数

• go
  go不存在默认构造函数，但是提供了init函数；我一开始也想不起来go的init函数如何与java的初始化
  对比，灵机一动就有了无参的构造函数，虽然这样对比其实并不恰当，但是功能上是有相似的地方。另外需要
  说明的是go的init的函数是在包被引入的时候调用的 若与main函数存在同一代码块 也是init先被调用，
  而java的默认构造函数仅在对象被new的时候调用的。

    func main() {
        fmt.println("func main()")
    }
  
    func init() {
        fmt.println("func init()")
    }
  

• java
  java的默认构造方法其实并不常用，但是在每启一个类的时候都有默认的构造方法，若是定义了就会走默认的构造
  方法，若无则在编译为class文件的时候自动为所在类加入一个。

    public class constructtest {
        private static final logger log = loggerfactory.getlogger(constructtest.class);
        @test
        public void processconst(){
            log.info(">>> start");
            person person = new person();
            log.info(">>> end");
        }
    }
  
    class person{
        private static final logger logger = loggerfactory.getlogger(person.class);
        private string name;
        private integer age;
  
        public person() {
            logger.info("default constructor");
        }
  
        public string getname() {
            return name;
        }
  
        public void setname(string name) {
            this.name = name;
        }
  
        public integer getage() {
            return age;
        }
  
        public void setage(integer age) {
            this.age = age;
        }
    }

const 与 static final

• go
  go的静态(也可叫静态常量，主要用于基本数据类型)，使用关键字const指定。
  使用const定义的静态变量是不可用修改或赋值的。

    const name int = 11
  
    const (
        a = "hello"
        b = true
        c = 99
    )
  
    func main() {
        fmt.println(name)
        fmt.println(a)
        fmt.println(b)
        fmt.println(c)
    }
  

• java
  java的常量需要用两个关键字修饰 static 和 final ,前者表示静态的意思，但这个静态是可以被修改的，
  修改的前提是类型不变，而第二个关键字表示最终的意思，一旦变量被这个关键字修饰则不可重新修改变量。
  但是对于复合对象，比如list、map、自定义对象等，又是可以被修改的,对于这点个人觉得 java 的常量的定义
  并不够严谨。

  public class staticfinaltest {
      private static final logger log = loggerfactory.getlogger(staticfinaltest.class);
      private static final string name = "tom";
  
      private static string item = "first item";
  
      private static final list<string> initarr = new arraylist<string>(){{
          add("a");
          add("b");
          add("c");
      }};
  
      @test
      public void process(){
          log.info(name);
  
          item = "youth!";
  
          log.info(item);
  
          initarr.add("hello");
  
          log.info(initarr.tostring());
      }
  }
  

参数或方法访问属性

• go
  go 的方法或参数需要被外部访问，需要使用大写开头参数名或函数名(go文件大小写是与与否与是否私有无关)

    // 可被文件外函数访问
    var name string = "john"
  
    func main() {
        fmt.println(name)
        process()
    }
  
    // 可被文件外函数调用
    func process() {
        fmt.println("process()")
    }
  

• java
  java的参数或方法属性不同于go，大致分为三类：

  • private 仅当前类内访问
  • public 可公共访问
  • protect 仅可同包内访问

    public class objecttypetest {
        private static final logger log = loggerfactory.getlogger(objecttypetest.class);
  
        //私有访问（仅可同一类中）
        private string name1 = "name01";
        // 保护访问（仅可同一包内）
        protected string name2 = "name01";
        // 公共访问 (任何类均可访问)
        public string name3 = "name01";
  
        @test
        public void process(){
            log.info(this.dosomething());
            log.info(name1);
            log.info(name2);
            log.info(name3);
  
        }
  
        public string dosomething(){
            return "hello";
        }
  
    }