Scala总结（二）

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、内部函数：在函数内部定义函数就叫内部函数或者本地函数。