欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-03-20 20:10:51
转载请注明出处: "https://www.cnblogs.com/funnyzpc/p/10801474.html" 第二节内容概览 + 循环(for、switch) + 多值返回 + defer & finally + init(go) 与默认构造函数(java) + 常量、静态变量(const ......

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的常量需要用两个关键字修饰 staticfinal ,前者表示静态的意思,但这个静态是可以被修改的,
    修改的前提是类型不变,而第二个关键字表示最终的意思,一旦变量被这个关键字修饰则不可重新修改变量。
    但是对于复合对象,比如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";
          }
    
      }