scala语言入门（二）对象篇

一 、类和对象的使用

  Simple App{
  def main(args: Array[String]): Unit = {
    var person = new People()
    person.name = \"Messi\"
    println(person.name+\"..\"+person.age)
    println(person.eat())
    person.watchFootball(\" 火箭 \")
  }
}


/**
  * 定义一个People类
  */
class People{
  //定义属性，scala中自动生成set get 方法
  var name:String = \"\"
  //也可以使用一个 下划线占位符
//  var name:String =_
  val age:Int = 10

  //使用private [this] 修饰的属性 只能在本来中使用
  private [this] val gender = \"male\";



  //方法
  def  eat(): String ={
     name +\" eat ....\"
  }

  def  watchFootball(teamName:String): Unit ={
     println(name+\" is  watching match of\"+teamName)
  }

  def  printInfo(): Unit ={
     println(gender)
  }
}

二、主构造器、附属构造器、继承、重写

package com.dzx

/**
  * @author DuanZhaoXu
  * @ClassName:
  * @De ion: 主构造器，附属构造器，继承 ，重写
  * @date 2018年12月18日 09:47:11
  */
  ConstructorApp {

  def main(args: Array[String]): Unit = {
    val zhangSan = new People1(\"张三\",20)
    println(zhangSan.name+\",\"+zhangSan.age+\",\"+zhangSan.school)


    val liSi = new People1(\"李四\",20,\"100\")
    println(liSi.name+\",\"+liSi.age+\",\"+liSi.gender)


    var student = new Student(\"王五\",10,\"英文\")
    println(student.name +\",\"+student.age+\",\"+student.major)

    println(student.toString)
  }


}

//主构造器
class  People1(var name:String,var age:Int){

   println(\"enter  start。。。。\")

   var school = \"ustc\"

  var gender:String =_

  //附属构造器
  def  this(name:String,age:Int,gender:String){
     this(name,age)  //附属构造器的第一行代码必须要调用主构造器或者其他的附属构造器
     this.gender =gender
  }

   println(\"leave end 。。。。\")

  //使用override 重写 toString 方法
  override def toString = s\"People1($school, $gender, $name, $age)\"
}

//子类集成父类，继承的属性，不再需要写var 或者 val，自身特有的属性 才需要加上var 或者 val
class  Student (name: String,age:Int,val major:String) extends  People1(name ,age){
  println(\"student enter  start。。。。\")


  println(\"student leave end 。。。。\")

  //使用override 重写toString 方法
  override def toString = s\"Student($major)\"
}

 三、抽象类的使用

package com.dzx

/**
  * @author DuanZhaoXu
  * @ClassName:
  * @De ion: 抽象类的使用
  * @date 2018年12月18日 10:37:27
  */
  AbstractApp {


  def main(args: Array[String]): Unit = {
    var xiaoming = new Student2
    xiaoming.name = \"小明\"
    xiaoming.age = 12
    println(xiaoming.name + \",\" + xiaoming.age)
  }

}


/**
  * 类的一个或者多个方法 没有完整的实现（只有定义，没有实现）
  */

abstract class Person2 {

  def speak(say: String)
  var name: String
  var age: Int

}


class Student2 extends Person2 {
  override def speak(say: String): Unit = {
    println(name + \" speaking ...\")
  }

  override var name: String = \"\"
  override var age: Int = 0
}

 四、伴生类、伴生对象、apply方法的用法

package com.dzx

/**
  * @author DuanZhaoXu
  * @ClassName:
  * @De ion: 伴生类和伴生对象
  * @date 2018年12月18日 10:50:34
  */
/**
  * 伴生类和伴生对象
  * 如果有一个class ，还有一个与class 同名的 
  * 那么就称这个  是 class的伴生对象，
  * class 是  的伴生类
  */


   ApplyTest{
  def main(args: Array[String]): Unit = {
         //伴生对象的使用
          ApplyApp.incr
          println(ApplyApp.count)

        for (i<-1 to 10){
           ApplyApp.incr
        }

        println(ApplyApp.count)

    var b =  ApplyApp()   //类名() 调用的是 伴生对象的 apply 方法

    var c = new ApplyApp()

    c()  //对象名() 调用的是伴生类 的 apply方法
  }
}

class ApplyApp {
  def apply() = {
    println(\"走了伴生类的apply 方法\")
  }
}

  ApplyApp{

  println(\"start\")

   var count = 0

  def  incr ={
     count +=1
  }

  println(\"end\")

  //最佳实践，在伴生对象的 apply 方法
  def apply():ApplyApp =  {
      println(\"走了伴生对象的apply 方法\")
     new ApplyApp
  }

}

 五、case class 

package com.dzx

/**
  * @author DuanZhaoXu
  * @ClassName:
  * @De ion:
  * @date 2018年12月18日 14:08:49
  */
//case class 通常用在 模式匹配里面
  CaseClassApp {
  def main(args: Array[String]): Unit = {
    println(Dog(\"小狗\").name) //case  class 不需要new 就可以声明一个 dog对象
  }
}

case class Dog(name: String) {
  var age: Int = _
}

六、trait 的用法（类似于java中的interface接口）

package com.dzx


/**
  *  train 定义一个 接口，类似于java中的interface
  *  当我们需要 实现接口的 时候 ,第一个接口 使用 extends，后面的需要实现的trait 则使用 with 连接
  *  extends  Atrait  with  Btrait
  *
  * class SparkConf(loadDefaults : scala.Boolean)
  * extends java.lang. 
  * with scala.Cloneable with org.apache.spark.internal.Logging
  * with scala.Serializable
  */

  TraitApp{
  def main(args: Array[String]): Unit = {
         val  traitApp = new TraitApp()
        println(traitApp.add(2,3))
        println(traitApp.decr(10,5))
  }
}


class TraitApp  extends userDao with personDao {
  override def add(x: Int, y: Int): Int = {
     x + y
  }

  override def decr(x: Double, y: Double): Double ={
     x-y
  }
}

trait userDao extends  Serializable{

 def  add(x:Int,y:Int):Int
}

trait  personDao extends   Serializable{
  def  decr(x:Double,y:Double):Double
}