Scala入门之面向对象

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中的Object是一个单例对象,没办法new
  * object中定义的成员变量和方法都是静态的
  */
object ScalaStatic {
  val name: String = "liyitian"
  var age: Int = 22

  def saySomething(msg: String) = {
    println(msg)
  }

  def apply(food: String) = {
    println("米饭 " + food)
  }
}

object TestMain {
  def main(args: Array[String]): Unit = {
    println(ScalaStatic.name)
    ScalaStatic.age = 18
    println(ScalaStatic.age)
    ScalaStatic.saySomething("你好")
    ScalaStatic.apply("西红柿")
    ScalaStatic("鸡蛋") //语法糖 suger
  }
}

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中定义类用class关键字修饰
  * 这个类默认有一个空参构造器
  * 定义在类名称后面的构造器叫主构造器
  * 类的主构造器中的属性会定义成类的成员变量
  * 如果主构造器中的成员属性没有val|var修饰的话,该属性不能被访问,相当于对外没有提供get方法
  * 如果成员属性使用var修饰的话,相当于对外提供了get和set方法
  * 如果成员属性使用val修饰的话,相当于对外提供了get方法
  */
class Teacher(var name: String,val age: Int) {
  var sex: String = _
  var prov: String = _
  //定义个辅助构造器,def this()
  def this(name: String,age: Int,sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name,age)
    this.sex = sex
  }
  def this(name: String,age: Int,sex: String,prov: String) = {
    this(name,age,sex) //在上面一个构造器中调用了主构造器
    this.prov = prov
  }
}

object TestApp extends App{
  private val techer = new Teacher("天天",23)
  techer.name = "花花"
  println(techer.name,techer.age)
  private val teacher1 = new Teacher("大大",45,"男","湖南")
  println(teacher1.name,teacher1.age,teacher1.sex,teacher1.prov)
}

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中定义类用class关键字修饰
  * 这个类默认有一个空参构造器
  * 定义在类名称后面的构造器叫主构造器
  * 类的主构造器中的属性会定义成类的成员变量
  * 如果主构造器中的成员属性没有val|var修饰的话,该属性不能被访问,相当于对外没有提供get方法
  * 如果成员属性使用var修饰的话,相当于对外提供了get和set方法
  * 如果成员属性使用val修饰的话,相当于对外提供了get方法
  * 类的构造器访问权限,在构造器前加修饰权限
  * private在主构造器之前,这说明该类的主构造器是私有的,外部类或者外部对象不能访问
  * 也适用于辅助构造器
  */
class Teacher private (var name: String,val age: Int) {
  var sex: String = _
  var prov: String = _
  //定义个辅助构造器,def this()
  def this(name: String,age: Int,sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name,age)
    this.sex = sex
  }
  private def this(name: String,age: Int,sex: String,prov: String) = {
    this(name,age,sex) //在上面一个构造器中调用了主构造器
    this.prov = prov
  }
}

object TestApp extends App{
//  private val techer = new Teacher("天天",23)
//  techer.name = "花花"
//  println(techer.name,techer.age)
  //此时只能访问3参数的构造器
  private val teacher1 = new Teacher("大大",45,"男")
  println(teacher1.name,teacher1.age,teacher1.sex)
}

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中定义类用class关键字修饰
  * 这个类默认有一个空参构造器
  * 定义在类名称后面的构造器叫主构造器
  * 类的主构造器中的属性会定义成类的成员变量
  * 如果主构造器中的成员属性没有val|var修饰的话,该属性不能被访问,相当于对外没有提供get方法
  * 如果成员属性使用var修饰的话,相当于对外提供了get和set方法
  * 如果成员属性使用val修饰的话,相当于对外提供了get方法
  * 类的构造器访问权限,在构造器前加修饰权限
  * private在主构造器之前,这说明该类的主构造器是私有的,外部类或者外部对象不能访问
  * 也适用于辅助构造器
  * 类的成员属性访问权限,如果类的主构造器中成员属性是private修饰的,它的set和get方法是私有的,外部不能访问
  */
class Teacher (private var name: String,val age: Int) {
  var sex: String = _
  var prov: String = _
  //定义个辅助构造器,def this()
  def this(name: String,age: Int,sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name,age)
    this.sex = sex
  }
  private def this(name: String,age: Int,sex: String,prov: String) = {
    this(name,age,sex) //在上面一个构造器中调用了主构造器
    this.prov = prov
  }
}

package test

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中定义类用class关键字修饰
  * 这个类默认有一个空参构造器
  * 定义在类名称后面的构造器叫主构造器
  * 类的主构造器中的属性会定义成类的成员变量
  * 如果主构造器中的成员属性没有val|var修饰的话,该属性不能被访问,相当于对外没有提供get方法
  * 如果成员属性使用var修饰的话,相当于对外提供了get和set方法
  * 如果成员属性使用val修饰的话,相当于对外提供了get方法
  * 类的构造器访问权限,在构造器前加修饰权限
  * private在主构造器之前,这说明该类的主构造器是私有的,外部类或者外部对象不能访问
  * 也适用于辅助构造器
  * 类的成员属性访问权限,如果类的主构造器中成员属性是private修饰的,它的set和get方法是私有的,外部不能访问
  * 类的访问权限,类的前面加上private[this]标识这个类在当前包下都可见,当前包下的子包不可见
  * 类的前面加上private[包名]表示这个类在当前包及其子包下都可见
  */
private[test] class Teacher (var name: String,val age: Int) {
  var sex: String = _
  var prov: String = _
  //定义个辅助构造器,def this()
  def this(name: String,age: Int,sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name,age)
    this.sex = sex
  }
  private def this(name: String,age: Int,sex: String,prov: String) = {
    this(name,age,sex) //在上面一个构造器中调用了主构造器
    this.prov = prov
  }
}

package test

/**
  * Created by Administrator on 2018/9/27.
  * 在Scala中定义类用class关键字修饰
  * 这个类默认有一个空参构造器
  * 定义在类名称后面的构造器叫主构造器
  * 类的主构造器中的属性会定义成类的成员变量
  * 如果主构造器中的成员属性没有val|var修饰的话,该属性不能被访问,相当于对外没有提供get方法
  * 如果成员属性使用var修饰的话,相当于对外提供了get和set方法
  * 如果成员属性使用val修饰的话,相当于对外提供了get方法
  * 类的构造器访问权限,在构造器前加修饰权限
  * private在主构造器之前,这说明该类的主构造器是私有的,外部类或者外部对象不能访问
  * 也适用于辅助构造器
  * 类的成员属性访问权限,如果类的主构造器中成员属性是private修饰的,它的set和get方法是私有的,外部不能访问
  * 类的访问权限,类的前面加上private[this]标识这个类在当前包下都可见,当前包下的子包不可见
  * 类的前面加上private[包名]表示这个类在当前包及其子包下都可见
  */
private[test] class Teacher (private var name: String,val age: Int) {
  var sex: String = _
  var prov: String = _
  //定义个辅助构造器,def this()
  def this(name: String,age: Int,sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name,age)
    this.sex = sex
  }
  private def this(name: String,age: Int,sex: String,prov: String) = {
    this(name,age,sex) //在上面一个构造器中调用了主构造器
    this.prov = prov
  }
}

/**object Teacher叫类的伴生对象
  * 在伴生对象中可以访问类的私有成员方法和属性
  */
object Teacher {
  def apply(name: String,age: Int): Teacher = {
    //初始化工作
    new Teacher(name,age,"女","山东")
  }
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher("大海",33)
    println(teacher.name)
    val halen = Teacher("海伦",23)
    println(halen.sex,halen.prov)
  }
}

/**
  * Created by Administrator on 2018/9/28.
  * 特质(interface)
  * 在Scala中特质可以定义有实现的方法,也可以定义没有实现的方法
  */
trait ScalaTrait {
  //没有任何实现的方法
  def hello(name: String)
  def small(name: String) = {
    println(s"对$name 笑")
  }
}

object ScalaTraitImpl extends ScalaTrait{
  override def hello(name: String): Unit = {
    println(s"hello $name")
  }

  def main(args: Array[String]): Unit = {
    ScalaTraitImpl.hello("hanmeini")
    ScalaTraitImpl.small("haoga")
  }
}

trait ScalaTrait {
  def hello(name: String) = {
    println(s"$name")
  }
  def small(name: String) = {
    println(s"对$name 笑")
  }
}

trait Fly {
  def fly(name: String) ={
    println(s"$name 在飞")
  }

}

class Student {

}
object Person {
  def main(args: Array[String]): Unit = {
    /**
      * 在scala中可以动态混入N个特质
      */
    val student = new Student with ScalaTrait with Fly
    student.hello("大东")
    student.fly("牛牛")
  }
}

object ScalaTraitImpl extends ScalaTrait with Fly{
  override def hello(name: String): Unit = {
    println(s"hello $name")
  }

  def main(args: Array[String]): Unit = {
    ScalaTraitImpl.hello("hanmeini")
    ScalaTraitImpl.small("haoga")
    ScalaTraitImpl.fly("liuda")
  }
}

/**
  * Created by Administrator on 2018/9/28.
  * 使用abstract定义一个抽象类
  * 可以没有具体实现的方法
  * 也可以有具体实现的方法
  */
abstract class AbsClass {
  def eat(food: String): String
  def swimming(style: String) = {
    println(s"$style 游")
  }
}

/**
  * Created by Administrator on 2018/9/28.
  * 在scala中第一个继承抽象类或者特质,只能使用关键字extends
  * 如果想继承多个特质的话,可以在extends之后使用with关键字
  */
object AbsClassImpl extends AbsClass with Fly{
  override def eat(food: String): String = {
    s"$food 炸着吃"
  }

  def main(args: Array[String]): Unit = {
    println(AbsClassImpl.eat("牛杂"))
    AbsClassImpl.swimming("自由")
    AbsClassImpl.fly("高斯")
  }
}

/**
  * Created by Administrator on 2018/9/28.
  * 在scala中,final修饰的类不能被继承
  * 方法不能被重写
  * 成员变量不能被重新修改(赋值)
  */
trait Fly {
  final def fly(name: String) ={
    println(s"$name 在飞")
  }

}

trait Bird {
  type T
  def learn(s: T) ={
    println(s)
  }
}

object FireBird extends Bird{
  override type T = String

  def main(args: Array[String]): Unit = {
    FireBird.learn("火鸟")
    WaterBird.learn(34)
  }
}

object WaterBird extends Bird {
  override type T = Int
}

/**
  * Created by Administrator on 2018/9/28.
  * 支持模式匹配,默认实现了Serializable接口
  * 样例类:case class 类名(属性...)
  */
case class Message(sender: String,messageContent: String)

/**
  * 默认实现了Serializable接口
  * 样例对象:case object 对象名
  * 模式匹配
  * 样例对象不能封装数据
  */
case object CheckHeartBeat