go与JAVA差异_20190312_浅谈gojava差异(二)
第二節(jié)內(nèi)容概覽
循環(huán)(for、switch)
多值返回
defer & finally
init(go) 與默認構(gòu)造函數(shù)(java)
常量、靜態(tài)變量(const 與 static final)
參數(shù)或方法訪問屬性
循環(huán)
go go提供了range關(guān)鍵字可以循環(huán)各種切片和數(shù)組，同時也提供了多參，這點相比較java會靈活不少， 另外switch循環(huán)也不同與java，默認僅進入匹配的case內(nèi)不會往下循環(huán)，若需要往下循環(huán)需要用到 fallthrough關(guān)鍵字，這個也確實有利于開發(fā)，不用像java一樣寫break結(jié)束。 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 提供了多種循環(huán)，分別是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提供了多參返回，當參數(shù)較少當時候可以一次性返回，不用構(gòu)造結(jié)構(gòu)體返回 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并沒有提供多參返回，若要實現(xiàn)多參返回，一般將返回參數(shù)封裝入Map、List 這類集合類型中， 或者構(gòu)造一個新對象放入返回值后返回。 @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 大多用于資源關(guān)閉或異常處理 go中的defer 與 java的finally個人感覺是相似的，但是如果將defer放入到循環(huán)內(nèi)的話可就像 一個反向隊列了，若一個處理邏輯內(nèi)有多個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 與默認構(gòu)造函數(shù)
go go不存在默認構(gòu)造函數(shù)，但是提供了init函數(shù)；我一開始也想不起來go的init函數(shù)如何與java的初始化 對比，靈機一動就有了無參的構(gòu)造函數(shù)，雖然這樣對比其實并不恰當，但是功能上是有相似的地方。另外需要 說明的是go的init的函數(shù)是在包被引入的時候調(diào)用的 若與main函數(shù)存在同一代碼塊 也是init先被調(diào)用， 而java的默認構(gòu)造函數(shù)僅在對象被new的時候調(diào)用的。 func main() {
fmt.Println("func main()")
}
func init() {
fmt.Println("func init()")
}
java java的默認構(gòu)造方法其實并不常用，但是在每啟一個類的時候都有默認的構(gòu)造方法，若是定義了就會走默認的構(gòu)造 方法，若無則在編譯為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的靜態(tài)(也可叫靜態(tài)常量，主要用于基本數(shù)據(jù)類型)，使用關(guān)鍵字const指定。 使用const定義的靜態(tài)變量是不可用修改或賦值的。 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的常量需要用兩個關(guān)鍵字修飾 static 和 final ,前者表示靜態(tài)的意思，但這個靜態(tài)是可以被修改的， 修改的前提是類型不變，而第二個關(guān)鍵字表示最終的意思，一旦變量被這個關(guān)鍵字修飾則不可重新修改變量。 但是對于復合對象，比如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());
}
}
參數(shù)或方法訪問屬性
go go 的方法或參數(shù)需要被外部訪問，需要使用大寫開頭參數(shù)名或函數(shù)名(go文件大小寫是與與否與是否私有無關(guān)) // 可被文件外函數(shù)訪問
var Name string = "John"
func main() {
fmt.Println(Name)
Process()
}
// 可被文件外函數(shù)調(diào)用
func Process() {
fmt.Println("Process()")
}
java java的參數(shù)或方法屬性不同于go，大致分為三類：
private 僅當前類內(nèi)訪問
public 可公共訪問
protect 僅可同包內(nèi)訪問 public class ObjectTypeTest {
private static final Logger LOG = LoggerFactory.getLogger(ObjectTypeTest.class);
//私有訪問(僅可同一類中)
private String name1 = "name01";
// 保護訪問(僅可同一包內(nèi))
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
總結(jié)
以上是生活随笔為你收集整理的go与JAVA差异_20190312_浅谈gojava差异(二)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： dota是java中的_用java开发d
- 下一篇： linux安装多版本php_Linux系