go与JAVA差异_20190312_浅谈gojava差异(二)
第二節內容概覽
循環(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
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 result = this.processObj();
LOG.info(new JSONObject(result).toString());
}
public Map processObj(){
return new HashMap(){{
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 initArr = new ArrayList(){{
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";
}
}
原文出處：https://www.cnblogs.com/funnyzpc/p/10801474.html
總結
以上是生活随笔為你收集整理的go与JAVA差异_20190312_浅谈gojava差异(二)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： dota是java中的_用java开发d
- 下一篇： java解密方法,java加密，解密方法