我要评论
转载请注明出处：
第二节内容概览
- 循环(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"; } }
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论