scala OOP

一个最基本的例子

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

class Student{
  //private[this] var privateAge = 0   //this分离对象，使得属性只能被当前对象使用
   var privateAge = 0   
  val name = "Scala"
  def age = privateAge  //自定义setter
  //var age = 0    //这个定义的时候，系统会自动生成getter,setter
  def isYounger(other: Student) = privateAge < other.privateAge
  //def printAge = println(privateAge)
}

object HelloOOP {

  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.increment()
    person.increment()
    println(person.current)
//    
//    val student = new Student
//    student.age = 10    // 因为定义时是val，没有setter 
//    println(student.age)
    
    val student = new Student
    student.privateAge = 20
    val student2 = new Student
    student2.privateAge = 30
    println(student.isYounger(student2))
    
    
  }

}

 构造器和内部类

//java风格的类定义
//class Teacher {
//  var name : String = _
//  private var age = 27
//  private[this] val gender = "male"
//  
//  def this(name:String){
//    this
//    this.name = name
//  }
//    
//  def sayHello(){
//    println(this.name + ":" + this.age + " : " + this.gender)
//  }
//}

//scala中类可以传如参数，这里的参数是默认构造函数的参数
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.gender = gender
  }
}

//内部类访问外部类 指定 outer =>
class Outer(val name: String) { outer =>
            class Inner(val name: String){
              def foo(b:Inner) = println("Outer: " + outer.name + 
                  " Inner: " + b.name)
            }
            
        }
object OOPInScala{
  def main(args: Array[String]) {
    
    val outer1 = new Outer("Spark")
    val outer2 = new Outer("Hadoop")
    val inner1 = new outer1.Inner("Scala")
    val inner2 = new outer2.Inner("Java")
    inner1.foo(inner1);
    inner2.foo(inner2);
    
//      val p = new Teacher
//      p.name = "Spark"
//     
//      p.sayHello
    
//      val p = new Teacher("Spark", 5)
//      println(" : " + p.age)
    
    val p = new Teacher("Spark", 5 , "male")
    println(" : " + p.age)
    
    
  }
  
  
}

类的继承 和 方法的重载

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!" //所有对象都有toString方法，复写object类的toString
}
/*
 * 复写的时候都要加上override
 */
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("School :" + w.school)
    println("Salary :" + w.salary)
    println(w.toString())
    
  }
}

//print result:
//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

抽象类

/*
 * 非抽象类中，必须给变量赋值，赋值方式有 赋给真实值 和 占位符 _
 * val变量的情况下，赋给占位符会报错
 */
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
      
      println("teacher.id" + ":" + teacher.id)
      println(teacher.name + ":" + teacher.age)
    
  }
}

 

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())
//      
  }
 
}