scala学习小记2

类：

示例1：用var声明变量，会自动为变量生成getter和setter，而用val声明变量，则只会为其生成getter方法
class  Person{
  var name:String=_//_是个placeholder，必须注明name的类型String
  val age:Int=10
  private [this] val gender="male"//gender只能在类内部使用，即便是它的实例，也不能使用该量
}
调用：

def main(args: Array[String]) {
val p=new Person()
   p.name="mlj"
   println(p.name+p.age)
 }
-------------------------
构造(器)函数：
   主构造器：

class  Person(val name:String,val age:Int){
  println("这是主构造器")
}
实例化：val p=new Person("mlj",10)

   1.直接跟在类名后面，主构造器中的参数最终都被编译成了字段；
   2.主构造器执行的时候，会执行类中所有语句；
   3.当主构造器的参数前面没有val或var的时候，相当于private[this]

 附属构造器：

class  Person(val name:String,val age:Int){
  println("this is primary constrcutor")
  var gender:String=_
  def this(name:String,age:Int,gender:String){
    this(name,age)//必须先执行主构造器
    this.gender=gender
  }
}

实例化：val p=new Person("mlj",10,"male")
  1.名称为this
  2.每个附属构造器必须首先调用已经存在的构造器

继承

class Student(name:String,age:Int,val major:String) extends Person(name,age){//针对已经存在的字段可以不用val,var,对新增字段仍需声明val var
  println("this is subclass of person,major is:"+major)

   override def toString=name+age+major//重写父类方法override

}
实例化：val s= new Student("mlj",10,"computer") 调用重写的方法：println(s.toString)

 抽象类
  1.类的一个或多个方法没有完整定义
  2.不需要abstract关键字，只不写方法体即可
  3.子类重写父类抽象方法或抽象字段时不用override
  4.父类可以声明不初始化的字段

abstract class person1{
  def speak
  val name:String
  var age:Int
}
class stu extends person1{
  def speak: Unit ={
    println("speaking")
  }
   val name="mlj"
   var age=10
}
调用：var s=new stu
  
    s.speak

----------------------------------
Trait:可以带有实现方法的接口

trait logger{
  def log(msg:String): Unit ={
    println("log"+msg)
  }
}
class test_log extends logger{//第二个以后就用with关键字
  def test: Unit ={
    log("aaa")
  }
}

   调用：var t=new test_log

           t.test
-----------------------

trait consoleLogger{
  def log(msg:String): Unit ={
    println("save money"+msg)
  }
}
trait messageLogger extends consoleLogger{
  override def log(msg:String): Unit ={
    println("save mony in the bank"+msg)
  }
}
abstract class Account{
  def save
}
class myAccount extends Account with consoleLogger{
  def save: Unit ={
    log("100")
  }
}
调用：

val acc=new myAccount
val acc2=new myAccount with messageLogger//可以为对象添加特质
acc.save
acc2.save

----------------------------------------

Apply方法：

class applyTest{
  def apply()="apply in the class"//不常用
  def test: Unit ={
    println("test")
  }
}
object applyTest{
  def apply()=new applyTest//常用来实例化对象
  var count=0
  def inc ={
    count+=1
  }

}

调用：

val a=applyTest()//类名+()就可以实例化一个对象，用到的是object 里面定义的apply方法
  a.test

val b=new applyTest
println(b())//对象+()调用的是类中定义的apply方法
---------------------------------------------------
单例对象（静态）
object中的对象就是单例（静态）的

object applyTest{
  def apply()=new applyTest
  var count=0
  def inc ={
    count+=1
  }

}
调用：

for(i<- 1 to 10)
  applyTest.inc
println(applyTest.count)