Scala:面向对象

类

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的坐标点: " + x);
      println ("y 的坐标点: " + y);
   }
}

val pt = new Point(10, 20);
pt.move(10, 10);

getter与setter

class Student {
  var name = "leo"
}

定义不带private的var field，此时scala生成的面向JVM的类时，会定义为private的name字段，并提供public的getter和setter方法

class Student {
  val name = "leo"
}

如果定义val field，则只会生成getter方法

class Student {
   private val name = "leo"
}

使用private修饰field，则生成的getter和setter也是private的

class Student {
  private[this] val name = "leo"
}

如果不希望生成setter和getter方法，则将field声明为private[this]

调用getter和setter方法，分别叫做name和name_=

val leo = new Student
print(leo.name)
leo.name = "leo1"

自定义getter与setter
自定义setter方法的时候一定要注意scala的语法限制，签名、=、参数间不能有空格

class Student{
  private var myName = "leo"
  def name = "your name is " + myName
  def name_=(newValue:String){
      print("you cannot edit your name!!!")
  }
}

仅暴露field的getter方法
如果希望能够仅仅暴露出一个getter方法，并且还能通过某些方法更改field的值，那么需要综合使用private以及自定义getter方法

class Student{
   private var myName = "leo"

   def updateName(newName:String){
	    if(newName == "leo1") myName = newName
	    else print("not accept this new name !!!")
	 }
	 
   def name = "your name is " + myName
 }

private[this]的使用

Java风格的getter和setter方法
如果要让scala自动生成java风格的getter和setter方法，只要给field添加@BeanProperty注解即可

import scala.reflect.BeanProperty
class Student {
  @BeanProperty var name: String = _
}

class Student(@BeanProperty var name: String)

辅助constructor
Scala中，可以给类定义多个辅助constructor，类似于java中的构造函数重载

辅助constructor之间可以互相调用，而且必须第一行调用主constructor

class Student{
   private var name =""
   private var age=0
   def this(name:String){
     this()
     this.name = name
    }
   def this(name:String,age:Int){
      this(name)
      this.age = age
    }
}

主constructor
Scala中，主constructor是与类名放在一起的，还可以通过使用默认参数，来给参数默认的值

class Student(val name:String = "name" , val age:Int = 0){
       println("your name is " + name + ", your age is " + age)
}

如果主constrcutor传入的参数什么修饰都没有，比如name: String，那么如果类内部的方法使用到了，则会声明为private[this] name；否则没有该field，就只能被constructor代码使用而已

内部类
Scala中，同样可以在类中定义内部类

import scala.collection.mutable.ArrayBuffer
class Class{
   class Student(val name:String)
   def students = new ArrayBuffer[Student]
   def getStudent(name:String) = {
         new Student(name)
    }
}

每个外部类的对象的内部类，都是不同的类

对象

object
在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。

Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。

object的constructor只会在其第一次被调用时执行一次，以后再次调用就不会再次执行constructor了

object Person{
   private var eyeNum = 2
   println("this Person object ! constructor is executing !")
   def getEyeNum = eyeNum
}

伴生对象
当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员

class Person(val name:String, val age:Int){
 def sayHello = println("Hi, " + name + ", I guess you are " + age + " years old!" + ", and usually you must have " + Person.eyeNum + " eyes.")
}

object Person{
    private val eyeNum = 2
    def getEyeNum = eyeNum
}

让object继承抽象类
Scala继承一个基类跟Java很相似, 但我们需要注意以下几点：

• 重写一个非抽象方法必须使用override修饰符。
• 只有主构造函数才可以往基类的构造函数里写参数
• 在子类中重写超类的抽象方法时，你不需要使用override关键字。

abstract class Hello(var message:String){
  def sayHello(name:String):Unit
}

object HelloImpl extends Hello("hello"){
   override def sayHello(name:String) = {
      println(message + "," + name)
   }
}

apply方法
object中非常重要的一个特殊方法，就是apply方法

通常在伴生对象中实现apply方法，并在其中实现构造伴生类的对象的功能

class Foo(foo: String) {
}

object Foo {
    def apply(foo: String) : Foo = {
        new Foo(foo)
    }
}

val foo = Foo("Hello")

用Foo(“Hello”)的方式，就得到了一个Foo类型的对象，这一切就是apply方法的功劳(隐式地调用伴生对象得apply方法)。如果没有apply方法，我们将需要使用new关键字来得到Foo对象。

main方法

object HelloWorld {
  def main(args: Array[String]) {
    println("Hello World!!!")
  }
}

用object来实现枚举功能
object继承Enumeration类，并且调用Value方法来初始化枚举值

object Season extends Enumeration{
    val SPRING = Value(0, "spring")
    val SUMMER = Value(1, "summer")
    val AUTUMN = Value(2, "autumn")
    val WINTER = Value(3, "winter")
}

Season(0)
Season.withName("spring")

使用枚举object.values可以遍历枚举值

for (ele <- Season.values) println(ele)

继承

extends
子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，field和method是无法被覆盖的

class Person{
 private var name = "leo"
 def getName = name
}
class Student extends Person {
  private var score = "A"
  def getScore = score
}

override和super
Scala中，如果子类要覆盖一个父类中的非抽象方法，则必须使用override关键字
使用super关键字，显式地指定要调用父类的方法

class Person {
  private var name = "leo"
  def getName = name
}

class Student extends Person{
  private var score = "A"
  def gerScore = score
  override def  getName = " Hi, Im " + super.getName
}

override field
Scala中，子类可以覆盖父类的val field，而且子类的val field还可以覆盖父类的val field的getter方法；只要在子类中使用override关键字即可

class Person {
  val name:String = "Person"
  def age:Int = 0
}
class Student extends Person {
  override val name:String = "leo"
  override val age:Int = 30
}

isInstanceOf和asInstanceOf
需要使用isInstanceOf判断对象是否是指定类的对象，如果是的话，则可以使用asInstanceOf将对象转换为指定类型

如果对象是null，则isInstanceOf一定返回false，asInstanceOf一定返回null

class Person
class Student extends Person

val p:Person = new Student

var s:Student = null
if(p.isInstanceOf[Student]) s = p.asInstanceOf[Student]

如果没有用isInstanceOf先判断对象是否为指定类的实例，就直接用asInstanceOf转换，则可能会抛出异常

getClass和classOf
要求精确地判断对象就是指定类的对象，那么就只能使用getClass和classOf了
对象.getClass可以精确获取对象的类，classOf[类]可以精确获取类，然后使用==操作符即可判断

使用模式匹配进行类型判断
使用模式匹配，功能性上来说，与isInstanceOf一样，也是判断主要是该类以及该类的子类的对象即可，不是精准判断的。

class Person
class Student extends Person

val p:Person = new Student

p match {
   case per:Person =>println("it's Person's object")
   case _ => println("unknown type")
}

protected
scala中同样可以使用protected关键字来修饰field和method，这样在子类中就不需要super关键字，直接就可以访问field和method

class Person {
  protected var name:String = "leo"
}

class Student extends Person {
  def sayHello = println("Hello , " +name)
}

使用protected[this]，则只能在当前子类对象中访问父类的field和method，无法通过其他子类对象访问父类的field和method

调用父类的constructor
Scala中，每个类可以有一个主constructor和任意多个辅助constructor，而每个辅助constructor的第一行都必须是调用其他辅助constructor或者是主constructor；因此子类的辅助constructor是一定不可能直接调用父类的constructor的，只能在子类的主constructor中调用父类的constructor

class Person(val name:String, val age:Int)

class Student(name:String,age:Int,val score:Double) extends Person(name,age){
     def this(name:String){
          this(name,0,0.0)
      }
     def this(age:Int){
          this("leo",age,0)
     }
}

如果是父类中接收的参数，比如name和age，子类中接收时，就不要用任何val或var来修饰了，否则会认为是子类要覆盖父类的field

匿名内部类
匿名子类，也就是说，可以定义一个类的没有名称的子类，并直接创建其对象，然后将对象的引用赋予一个变量。之后甚至可以将该匿名子类的对象传递给其他函数。

class Person(protected val name:String){
   def sayHello = "Hello，I'm " + name
}

val p = new Person("leo"){
  override def sayHello = " Hi , I'm " +name
}

def greeting(p:Person { def sayHello:String}){
   println(p.sayHello)
}

抽象类
如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现自己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这种方法就是抽象方法。

而一个类中如果有一个抽象方法，那么类就必须用abstract来声明为抽象类，此时抽象类是不可以实例化的

abstract class Person(val name:String){
   def sayHello:Unit
}

class Student(name:String) extends Person(name){
   def sayHello:Unit = println("Hello , " + name)
}

在子类中覆盖抽象类的抽象方法时，不需要使用override关键字

抽象field
如果在父类中，定义了field，但是没有给出初始值，则此field为抽象field

抽象field意味着，scala会根据自己的规则，为var或val类型的field生成对应的getter和setter方法，但是父类中是没有该field的

abstract class Person{
  val name:String
}

class Student extends Person {
  val name:String = "Leo"
}

子类必须覆盖field，以定义自己的具体field，并且覆盖抽象field，不需要使用override关键字