Go语言视频零基础入门到精通

admin

1.抽象类（abstract class）
类的一个或者多个方法没有完整的定义
声明方法时只需要不写方法体，不需要关键字
子类重写父类的抽象方法时不需要加override
父类可以声明抽象字段（没有初始值的字段）
子类重写父类抽象字段时不需要加override

1. class Test3 {
3. }
5. abstract class Person{
6.   def speak
7.   val name : String
8.   var age : Int
9. }
10. class Student extends Person{
11.   def speak{
12.     println("speak!!")
13.   }
14.   
15.   var age = 100
16.   val name = "ahaha"
17. }
18. object Test3 extends App{
19.   var s = new Student;
20.   s.speak
21.   print (s.name + ":" + s.age)
22. }

复制代码

2.trait 特质 对比下Java8的借口
可以理解为包含具体实现的借口
    字段和行为的集合
混入类中，第一个要用extends
通过with关键字，一个类可以扩展多个特质
带有特质的对象
特质从左到右被构造

1. trait Logger{
2.   def log(msg:String)
3. }
4. trait ConsoleLogger extends Logger{
5.         def log(msg : String){
6.           println(msg)
7.         }
8. }
9. class loggerImpl extends ConsoleLogger{
10.         def test{
11.           log("aaa")
12.         }
13. }

复制代码

1. trait ConsoleLogger{
2.         def log(msg : String){
3.           println("sava money" + msg)
4.         }
5. }
6. trait MessageLogger extends ConsoleLogger{
7.    override def log(msg : String){
8.           println("sava money to bank" + msg)
9.         }
10. }
11. abstract class Account{
12.   def save
13. }
14. class MyAcconunt extends Account with ConsoleLogger{
15.   def save{
16.     log("100")
17.   }
18. }
19. object Test3 extends App{
20.   val a = new MyAcconunt with MessageLogger  //带有特质的对象
21.   a.save
22. }
24. class loggerImpl extends ConsoleLogger{
25.         def test{
26.           log("aaa")
27.         }
28. }

复制代码

2.apply方法和单例对象

1. class Test4 {
3. }
4. object Test4 extends App{
5.   val a = ApplyText() //类名+括号调用的是object中的apply方法
6.   a.test
7.   val b = new ApplyTest//对象+括号调用的是类中的apply方法
8.   println(b())
9. }
11. class ApplyTest{
12.   def apply() = "APPLY"
13.   def test{
14.     println("test")
15.   }
16. }
18. //object 里面的方法相当于静态方法
19. object ApplyText{ //本身就是一个单例
20.   def apply()= new ApplyTest
21.   def static{
22.     println("mmm a static method")
23.   }
24. }

复制代码

3.包

     可串联   package com.aaa{
//在这个层次不能看的bbb的成员
package.bbb{
}
}
顶部标记  package com.b
   package b
包对象  把公有的东西放在同一个包里面
包可见性
package aa.bb.cc.dd
class XXX{
private[dd] def as = {} //只能在dd包以下能使用
}
包在任何地方引入
重命名成员 import  java.unil.(HashMap => JavaHashMap)
隐藏包  （hashMap => _）
自动引入 java.lang._