Scala进阶源码实战之二——面向对象

类的属性与私有字段

package OOP


class Person {
  private var age = 0
  def increment(){age += 1}
  def current = age


  def act(person: Person){
    person.age
  }

}

class Student{
  private var privateAge = 0    //指定私有，则生成私有getter setter
  private[this] val gender = "male"   //更强的约束，只能类内访问，外部无法访问

  val name = "Scala"
//  def age = privateAge  
  var age = 0      //必须初始化，默认为私有字段，生成公有setter getter

  def isYounger(other: Student) = privateAge < other.privateAge

    def sayHello(){
    println(this.name + ":" + this.age + " : " + this.gender)
  }
}

object HelloOOP {

  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.increment()
    person.increment()
    println(person.current)   // 2

    val student = new Student
    student.age = 10  
    println(student.age)    //10

    println(student.name)      //Scala

    println(student.gender)  //报错

  }

}

构造器

class Teacher private (val name : String, val age : Int){ //默认构造器
  println("This is the primary constructor!!!")     //默认构造器
  var gender : String = _                           //默认构造器
  println(gender)                                   //默认构造器
  def this(name : String, age : Int, gender : String){
    this(name, age)                                //必须加上this
    this.gender = gender
  }
}

内部类

  class Outer(val name: String) { outer =>
            class Inner(val name: String){
              def foo(b:Inner) = println("Outer: " + outer.name +
                  " Inner: " + b.name)
            }
   }

    val outer1 = new Outer("Spark")               //> outer1  : OOP.OPP.Outer = OOP.OPP$$anonfun$main$1$Outer$1@1e643faf
    val outer2 = new Outer("Hadoop")              //> outer2  : OOP.OPP.Outer = OOP.OPP$$anonfun$main$1$Outer$1@6e8dacdf
    val inner1 = new outer1.Inner("Scala")        //> inner1  : OOP.OPP.outer1.Inner = OOP.OPP$$anonfun$main$1$Outer$1$Inner@7a79b
                                                  //| e86
    val inner2 = new outer2.Inner("Java")         //> inner2  : OOP.OPP.outer2.Inner = OOP.OPP$$anonfun$main$1$Outer$1$Inner@34ce8
                                                  //| af7
    inner1.foo(inner1);                           //> Outer: Spark Inner: Scala
    inner2.foo(inner2);                           //> Outer: Hadoop Inner: Java

伴生对象

class University{
  val id = University.newStudenNo
  private var number =0
  def aClass(number:Int){this.number += number}
}

object University{
  private var studentNo = 0
  def newStudenNo = {
    studentNo += 1
    studentNo
  }
}


object ObjecOps {

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

    println(University.newStudenNo)
    println(University.newStudenNo)


  }

}

apply

class ApplyTest{
  def apply() = println("I am into Spark so much!!!")

  def haveATry{
    println("Have a try on apply!")
  }
}
object ApplyTest{
  def apply() = {
    println("I am into Scala so much!!!")
    new ApplyTest
  }
}
object ApplyOperation {
  def main(args: Array[String]) {
    val array = Array(1,2,3,4,5)
    val a = ApplyTest()
    a.haveATry
//    val a = new ApplyTest
//    a.haveATry
      println(a())
//I am into Scala so much!!!
//Have a try on apply!
//I am into Spark so much!!!
//()

  }

}

继承

class OverrideOperations 

class Person1(val name : String, var age : Int){
  println("The primary constructor of Person")

  val school = "BJU"

  def sleep = "8 hours"

  override def toString = "I am a Person1!"
}

// 子类继承父类在构造器上的构造
class Worker(name : String, age : Int, val salary : Long) extends Person1(name, age){
  println("This is the subClass of Person, Primary constructor of Worker")
  override val school = "Spark"   //重写字段

  override def toString = "I am a Worker!" + super.sleep


}

object OverrideOperations{
  def main(args: Array[String]) {

    val w = new Worker("Spark", 5, 100000)  //会打印子类和父类的构造器 println
    println("School :" + w.school)
    println("Salary :" + w.salary)
    println(w.toString())


//The primary constructor of Person
//This is the subClass of Person, Primary constructor of Worker
//School :Spark
//Salary :100000
//I am a Worker!8 hours

  }


}

抽象类

class AbstractClassOps{
  // 相比而言，非抽象类字段必须赋值
    var id : Int = _
}
abstract class SuperTeacher(val name : String){
  // 声明时不给字段赋值
  var id : Int
  var age : Int
  // 抽象类中的方法不写方法实现体
  def teach
}

class TeacherForMaths(name : String) extends SuperTeacher(name){

  // 虽然可以不写，但还是建议养成复写的习惯
  override var id = name.hashCode()
  override var age = 29
//  实现方法
  override def teach{
    println("Teaching!!!")
  }
}


object AbstractClassOps{
  def main(args: Array[String]) {
      val teacher = new TeacherForMaths("Spark")
      teacher.teach      //Teaching!!!

      println("teacher.id" + ":" + teacher.id)  //teacher.id:80085693
      println(teacher.name + ":" + teacher.age)  //Spark:29

  }
}

trait

class UseTrait {

}
 // 作为接口
trait Logger{
  // 方法可以实现也可以不实现
//  def log (msg : String)
  def log (msg : String){}
}

class ConcreteLogger extends Logger with Cloneable{

//  override def log(msg : String) = println("Log: " + msg)

  def concreteLog{
    log("It's me !!!")
  }
}

trait TraitLogger extends Logger{
  override def log (msg : String){
    println(" TraitLogger Log content is : " + msg)
  }
}

trait TraitLoggered{
    def loged (msg : String){
        println("TraitLoggered Log content is : " + msg)
    }
}

trait ConsoleLogger extends TraitLogger{
  override def log(msg : String){
    println("Log from Console :" +msg)
  }
}

class Test extends ConsoleLogger{
  def test{
    log("Here is Spark!!!")
  }

}

abstract class Account{
  def save
}

class MyAccount extends Account with ConsoleLogger{
  def save{
    log("11")
  }
}

class Human{
  println("Human")
}
trait TTeacher extends Human {  
  println("TTeacher")
  def teach 
}  
trait PianoPlayer extends Human {  
  println("PianoPlayer")
  def playPiano = {println("I'm playing piano. ")} 
}  
//从左往右构造  已构造的Human不会重复构造
class PianoTeacher extends Human with TTeacher with PianoPlayer {  
    override def teach = {println("I'm training students. ")} 
}


//AOP
trait Action {  
    def doAction  
}
trait TBeforeAfter extends Action {  
    abstract override def doAction {  
        println("Initialization") 
        super.doAction 
        println("Destroyed") 
    }  
}

class Work extends Action{
 override def doAction = println("Working...")
}

object UseTrait extends App{
   val t1 = new PianoTeacher 
   t1.playPiano  
   t1.teach  
   val t2 = new Human with TTeacher with PianoPlayer {  
  //必须要重写 
      def teach = {println("I'm teaching students.")} } 
   t2.playPiano
   t2 teach 
   val work = new Work with TBeforeAfter
   work.doAction


//  val logger = new ConcreteLogger with TraitLogger
////  val logger = new ConcreteLogger
//  logger.concreteLog
//  val logger = new Test
//  logger.test;
//  
//  val account = new MyAccount with TraitLoggered
//  account.save

//Human
//TTeacher
//PianoPlayer
//I'm playing piano. 
//I'm training students. 
//Human
//TTeacher
//PianoPlayer
//I'm playing piano. 
//I'm teaching students.
//Initialization
//Working...
//Destroyed


}