9Scala面向对象(三)

2.8 特质

特质,样例类,样例对象的构建语法和使用方法

2.8.1 特质定义

特质语法:
继承特质语法:
案例1:类继承一个特质

trait Person {
  var NAME:String
  def area:Unit
}
class Teacher extends Person {
  override var NAME: String = "jake"
  override def area: Unit = {
    println("test......")
  }
}
object traitTest1 {
  def main(args: Array[String]): Unit = {
    var tea = new Teacher
    tea.area
    println(tea.NAME)
    var tea1 = new Person {
      override var NAME: String = "rose"
      override def area: Unit = {
        println("test2....")
      }
    }
    tea1.area
    println(tea1.NAME)
  }
}

案例2:类继承多个特质

trait Person1 {
  def say:Unit
}

class Teacher2 extends Person with Person1 {
  override var NAME: String = "jake"
  override def area: Unit = {
    println("test....")
  }
  override def say: Unit = {
    println("say....")
  }
}
object traitT2 {
  def main(args: Array[String]): Unit = {
    var tea = new Teacher2
    tea.area
    tea.say
    println(tea.NAME)
  }
}

案例3:对象继承特质

object Teacher3 extends Person with Person1 {
  override var NAME: String = "jake"
  override def area: Unit = {
    println("test....")
  }
  override def say: Unit = {
    println("say....")
  }
}
object traitT3 {
  def main(args: Array[String]): Unit = {
    Teacher3.area
    Teacher3.say
    println(Teacher3.NAME)
  }
}

2.8.2 特质具体方法和字段

trait Person3 {
  var NAME:String = "jack"
  def area:Unit
  def say:Unit = {
    println("say....")
  }
}
class Teacher4 extends Person3 {
  override def area: Unit = {
    println("test....")
  }
}
object traitT4 {
  def main(args: Array[String]): Unit = {
    var tea:Teacher4 = new Teacher4
    tea.area
    tea.say
    println(tea.NAME)
  }
}

2.8.3 对象混入特质

class Teacher5
//对象混入特质时,对象构建声明类型应该是特质类型,如果构建对象时
object traitT5 {
  def main(args: Array[String]): Unit = {
    var tea:Person3 = new Teacher5 with Person3 {
      override def area: Unit = println("area.....")
    }
    tea.area
    tea.say
    println(tea.NAME)
  }
}

2.8.4 特质的构造

trait Log {
  println("Log....")
}
trait MyLog {
  println("MyLog....")
}
trait YouLog {
  println("YouLog....")
}
class noLog {
  println("noLog....")
}
class Tea extends noLog with Log with MyLog with YouLog {
  println("tea.....")
}
object traitT6 {
  def main(args: Array[String]): Unit = {
    var tea = new Tea
  }
}

2.8.5 特质继承类

class Log1 {
  var name:String = "tom"
  def area = println("test....")
}
trait MyLog1 extends Log1
class newLog extends MyLog1
object traitT7 {
  def main(args: Array[String]): Unit = {
    var n1 = new newLog
    n1.area
    println(n1.name)
  }
}

3.2.1 定义

case class CasePerson()

case class CasePerson1(name:String, age:Int)

case class CasePerson2(name:String="lisi",age:Int)

case class CasePerson3(var name:String="tom",var age:Int=40)

object ccT1 {
  def main(args: Array[String]): Unit = {
    var c = CasePerson
    var c1 = CasePerson1
    var c2 = CasePerson2
    var c3 = CasePerson3
//    print(c3.name)  //不允许
    var v = CasePerson2(age=30)
//    v.name="jake"     //不允许
    println(v.name + " " + v.age)

    var y = CasePerson3()
    var y1 = CasePerson3("briup",36)
    println(y.name + " " + y.age)
  }
}

3.2.2 方法

object ccT2{
  def main(args: Array[String]): Unit = {
    //apply
    var y1 = CasePerson1("briup",36)
    //toString
    println(y1.toString)
    //equals
    var y2 = CasePerson1("briup",36)
    println(y1 == y2) //true
    println(y1.equals(y2))  //true
    //hashcode
    var y3 = CasePerson1("briup",35)
    println(y1.hashCode())
    println(y2.hashCode())
    println(y3.hashCode())
  }
}

3.3 样例对象 定义枚举

object SexEnum {
  trait Sex;
  case object Male extends Sex
  case object Female extends Sex
  case class Person(var name:String,sex:Sex)

  def main(args: Array[String]): Unit = {
    val person = Person("tom",Male)
    person.name = "briup"
    println(person)
  }
}

//消息的定义
case class startSparkMessage(msg:String)
case object StopSparkMessage
case object PauseSparkMessage
case object ResumeSparkMessage

实验总结:通过本次实验的学习,能够熟练地掌握特质构建的相关语法和使用方法,掌握样例类、样例对象的构建语法和使用方法。scala中没有Java的接口，使用特质trait替换，与Java的接口使用方法一样，是代码复用的基础，一个类只能继承一个超类，但能够同时extends任意数量的特质。特质可以有具体的方法和字段，只能有一个无参构造器，特质也可以继承类，能将类中的成员都继承下来。样例类。。。样例对象。。。

10

object funT1 {
  def main(args: Array[String]): Unit = {
    var list = List(1, 2, 3, 4)

    //值函数
    val func_num2star = (num: Int) => "*" * num
    println(list.map(func_num2star))

    //匿名函数
    list.map(num => "*" * num).foreach(println)
    list.map("*" * _).foreach(println)
  }
}