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