20190312_淺談go&java差別(二)

時間 2020-07-22

標籤淺談 go&java java 差別欄目 Java 简体版

原文原文鏈接

轉載請註明出處：http://www.javashuo.com/article/p-ddfpnlyg-cu.htmlhtml

第二節內容概覽

循環(for、switch)
多值返回
defer & finally
init(go) 與默認構造函數(java)
常量、靜態變量(const 與 static final)
參數或方法訪問屬性

循環

go go提供了range關鍵字能夠循環各類切片和數組，同時也提供了多參，這點相比較java會靈活很多，另外switch循環也不一樣與java，默認僅進入匹配的case內不會往下循環，若須要往下循環須要用到 fallthrough關鍵字，這個也確實有利於開發，不用像java同樣寫break結束。java

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 這類集合類型中，或者構造一個新對象放入返回值後返回。this

@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,頗有意思，你們能夠試試哈～spa
```
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的倒序處理，這裏就給個簡單的例子～code

@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的時候調用的。htm
```
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文件大小寫是與與否與是否私有無關)blog

// 可被文件外函數訪問
  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";
      }

  }

原文出處：https://www.cnblogs.com/funnyzpc/p/10801474.html

1. 20190312_淺談go&java差別(二)
2. 20190312_淺談go&java差別(一)
3. 淺談 Underscore.js 中 _.throttle 和 _.debounce 的差別
4. 淺談OpenJDK 與JDK的差別
5. 20190608_淺談go&java差別(三)
6. 淺談Android和IOS系統的差別
7. 淺談協方差矩陣
8. 淺談殘差網絡——ResNet
9. 淺談GC---二
10. 淺談python（二）
更多相關文章...
• SQL 別名 - SQL 教程
• SQLite 別名 - SQLite教程
• 漫談MySQL的鎖機制
• RxJava操作符（二）Transforming Observables

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。