一 、類和物件的使用

object SimpleObjectApp{
  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:
  * @Description: 主構造器，附屬構造器，繼承 ，重寫
  * @date 2018年12月18日 09:47:11
  */
object 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:
  * @Description: 抽象類的使用
  * @date 2018年12月18日 10:37:27
  */
object 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:
  * @Description: 伴生類和伴生物件
  * @date 2018年12月18日 10:50:34
  */
/**
  * 伴生類和伴生物件
  * 如果有一個class ，還有一個與class 同名的object
  * 那麼就稱這個object 是 class的伴生物件，
  * class 是object 的伴生類
  */


object  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 方法")
  }
}

object 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:
  * @Description:
  * @date 2018年12月18日 14:08:49
  */
//case class 通常用在 模式匹配裡面
object 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.Object
  * with scala.Cloneable with org.apache.spark.internal.Logging
  * with scala.Serializable
  */

object 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
}