1、scala類構造的時候，內部所有的成員除了方法以外，全部會被執行。

class Person {
  var name = "anonymous"
  println("My name is " + this.name)

  def sayHello(): Unit = {
    println("Hello!")
  }
}

2、scala類除了主構造器以外的其他構造器內部首行必須用this來呼叫類的預設主構造器。

class Student {
  var name : String = _

  def this(name : String) {
    this
    this
 
.name = name
  }
｝

3、如果主構造器不想讓別人呼叫，則在類後面加private。

class Teacher private (val name : String, val age : Int) {
  var gender : String =_
  println("Teacher:" + gender)

  def this(name : String, age : Int, gender : String) {
    this(name, age)
    this.gender = gender
    println("Teacher:" + name + ":"
 
 + age + ":" + gender)
  }
}

4、scala的內部類是從屬於物件的。java的內部類從屬外部類。

5、內部類呼叫外部類成員的兩種方法。

object OopDemo3 {

  def main(args: Array[String]) {
    val outer = new Outer("Max")
    new outer.Inner("Alpha").info
    val outer2 = new Outer2("Tom")
    new outer2.Inner2("Dolphin").info
  }

}

class Outer(val name : String)
 
 {
  outer =>
  class Inner(val name : String) {
    def info = println("outer name:" + outer.name + ", Inner Name :" + name)
  }
}

class Outer2(val name : String) {
  class Inner2(val name : String) {
    def info = println("Outer2 name :" + Outer2.this.name + ", Inner Name:" + name)
  }
}

6、scala中沒有像java一樣的靜態類和靜態方法，但是給我們提供了object物件，這個物件裡面的所有成員都是靜態的，包括欄位和方法。

7、伴生物件：伴生物件本身是一個單例，它有一個與之同名的類。並且同名類和伴生物件之間可以互相訪問私有成員。

class University {
  private var number = 0
  def increaseNumber(number: Int): Int = {
    this.number += number
    this.number += University.num
    this.number
  }
}

object University {
  private var num = 0
  def increaseNums = {
    num += 1
    num
  }
}

8、通常我們使用val arr = Array(1, 2, 3)這種方式建立一個數組，實際上呼叫的也是Array類的伴生物件的apply方法。

9、類和object中都有apply方法。呼叫object中apply可以通過這個object名字後面加（）來呼叫。

object OopDemo5 {

  def main(args: Array[String]) {
    val a = ApplyClass()
    a.sayHello
    val b = new ApplyClass
    b.apply
  }
}

class ApplyClass {
  def apply() = println("execute apply function!")

  def sayHello: Unit ={
    println("hello world")
  }
}

object ApplyClass {
  def apply(): ApplyClass = {
    println("object apply")
    new ApplyClass
  }
}

10、scala抽象類也是在類名前加abstract。重寫抽象類的欄位或者方法可以在欄位或者方法前面加override或者也可以不加。一般情況下最後加上override,表明這個欄位被重寫。

abstract class Teacher(val name : String) {
  var id : Int
  var age : Int
  def teach
}

class MathTeacher(name : String) extends Teacher(name) {
  override var id = name.hashCode
  override var age = 29
  override def teach = {println("Teaching math")}
}

11、介面用trait來標識，與java不同的是，scala的trait中允許有非抽象方法。java的介面用Interface來標識，並且接口裡只允許有抽象方法。java的抽象類裡既允許有抽象方法，又允許有非抽象方法。注意兩者的區別。

trait SuperTeacher {
  def teach(content : String)

  def sleep(): Unit = {
    println("sleep")
  }

}

12、實現介面用extends 介面名 如果實現多個介面，用with連線。

class EnglishTeacher1 extends SuperTeacher with Cloneable {
  override def teach(content : String) = println("teaching " + content)

  def eat(): Unit = {
    println("eat fast foot")
  }
}

13、物件中混入trait。應用比較廣泛，通過給物件混入工具trait使得物件可以呼叫工具trait中得方法。

object ScalaDemo8 {

  def main(args: Array[String]) {
    val teacher = new EnglishTeacher1 with NormalPerson
    teacher.teach("English")
    teacher.walk
  }

}

trait NormalPerson{
  def walk: Unit ={
    println("walking")
  }
}

trait SuperTeacher {
  def teach(content : String)

  def sleep(): Unit = {
    println("sleep")
  }

}

class EnglishTeacher1 extends SuperTeacher with Cloneable {
  override def teach(content : String) = println("teaching " + content)

  def eat(): Unit = {
    println("eat fast foot")
  }

}

14、scala包和包物件。以及scala隱式引入的包。

package com.qihoo.oop   //作用範圍是整個檔案

//隱式引入的包
import java.lang._
import scala._
import Predef._

//可通過給類起別名來避免java和scala中類命名衝突
import java.util.{HashMap => JavaHashMap}
//如果不想用包內某個類，可用"_"去掉
import scala.{StringBuilder => _}

/**
 * 包物件
 */
package object people {
  val defaultName = "tom"
}

//包
package people {
  class Person1 {
    var name = defaultName  //包中的類可以任意引用此包物件內容
  }
}

15、包訪問許可權

package country {

  package provice{

    private[country] class City { //將City的可見度擴充套件

      protected[provice] def show() {} //被protected修飾，可以被provice包中所有內容訪問，包括City的子類

      private[this] var nums = 1000000 //只有本物件能訪問，該類的其他例項不能訪問

    }
  }

  package specialCity {
    import provice._
  }
}

16、內部函式：在函式內部定義函式就叫內部函式或者本地函式。