Scala学习 2 Scala面向对象

object Scala_study3 {
  def main(args: Array[String]): Unit = {

    /*
    * 2.1 Scala面对对象详解
    *
    * 2.1.1 Scala中class和object初介紹
    * scala中class的定义与java类似,区别是在Scala中,类名不是必须和文件名相同,且一个文件中可以定义多个class.
    * Scala中的class不存在静态成员,Java中的静态成员由Scala中的object对象替代,
    * 当object对象名与class名相同时称object为class的[伴生对象]
    * */

    //2-1 Scala类的定义实战
    class HiScala{
      private val name:String = "zhangsan"
      def sayName(): Unit ={
        println(name)
      }
      def getName = name
    }

    val hiScala = new HiScala
    hiScala.sayName()
    println(hiScala.getName)


    //2-2 object定义实战
    object Person{
      println("构造函数调用一次")
      val age = 10
      def getAge = age
    }
    Person.getAge
    Person.getAge

    //2-3 继承

    abstract class Animal{
      def eat = {
        println("Eat food !!!")
      }
      def run
    }

    class Cat extends Animal{
      override def eat: Unit = {
        println("Eat mouse!!!")
      }

      override def run: Unit = {
        println("cat is running...")
      }

    }

    class Dog extends Animal{
      override def run: Unit = {
        println("dog is running")
      }
    }

    val c = new Cat
    c.eat
    c.run
    val d = new Dog
    d.eat
    d.run
  }

  /*
  * Eat mouse!!!
    cat is running...
    Eat food !!!
    dog is running
  * */

  //2-4 子类不能重写父类中被final修饰的方法和属性

  /*
  * 2.1.2 主构造器和辅助构造器
  * */

  //2-5 Scala默认构造器在类上
  class Person1{

  }//默认无参构造器

  class Person2(name:String){
    println(name)
  }//默认带一个字符串参数的构造器

  //2-6 构造器重载(辅助构造器)
  class Person3(name:String){
    println(name)
    def this(name:String,age:Int)
    {
      this(name)
      println(name + ":" + age)
    }
    def this(name:String,age:Int,sex:String)
    {
      this(name,age)
      println(name + ":" + age + ":" + sex)
    }
  }

  //2-7 构造器重载(多参数默认构造器)
  class Student1(name:String,age:Int,sex:String){
    println(name + ":" + age + ":" + sex)
  }
  val s = new Student1("chenjie",23,"male")


  /*
  * 2.1.3 类的字段和方法彻底精通
  * */
  class Person4{
    var name : String = "zhangsan"
    var age = 30
    val sex = "famale"
    def seyHi = println("Hi!!!")
    def increase(age:Int):Int = this.age + age
  }

  val p = new Person4
  println(p.name)
  println(p.sex)
  p.name = "lisi"


  //2-9 复写setter
  class Person5{
    private var myName = "Flink"
    def name = this.myName
    def name_=(newName:String){//等号两边不能有空格
      myName = newName
      println("hi:" + myName)
    }
  }

  //2-10 自定义setter
  class Person6{
    private var myName = "Flink"
    def name = this.myName
    def update(newName:String): Unit ={
      myName = newName
    }
  }


  //2-11 private[this]实战,用此修饰的字段或方法只能被当前对象访问,当前对象的其他实例无法访问.




  /*
  * 2.1.4 抽象类 接口的实战详解
  * */

  abstract class Person7(name:String){
    println(this.name)
    private var age = 20
    val sex : String = "male" //抽象类中的字段不能用abstract修饰
  }

  //Scala的特质相当于Java中的接口,不过特质中可以有实现的方法
  //在Scala中实现特质被成为混入,混入的第一个特质用关键字extends,混入更多的用with

  trait Person8{
    val name : String
    val age = 30
    def eat(str:String): Unit ={
      println(str)
    }
  }

  trait Worker{
    val age = 25
    def work: Unit ={
      println("Working....")
    }
  }

  class Student2 extends Worker with Person8{
    val name : String = "zhangsan"
    override val age: Int = 15  //两个特质中的相同字段发生冲突时必须重写该字段
  }



  /*
  * 2.1.5 Scala Option类详解
  * Scala中的Option[T]可以是一些[T]或者None对象,它代表一个缺失值
  * 例如hashMap的get方法,可能找到则返回值,可能找不到则返回null,这就是一个Option
  * */

  /*
  * 2.1.6 objetc的提取器
  * objetc中提供了apply方法,作用是在创建对象时不直接用new,而是直接用对象加参数,这时调用类伴生对象的apply方法
  * */
  var arr1 = Array(1,2,3)
  arr1 = Array.apply(1,2,3)


  //2-18 提取器

  object ExtractorTest{
    def apply(user:String,domain:String)={
      user + "@" + domain
    }

    def unapply(str: String): Option[(String,String)] = {
      val parts = str.split("@")
      if(parts.length == 2){
        Some(parts(0),parts(1))
      }
      else
        {
          None
        }
    }
  }


}