2016-04-09-scala

Veröffentlicht am

构造方法

默认情形：(主构造方法)

1
2
3
class Teacher {

}

它的等价形式：

1
2
3
class Teacher(){

}

私有形式：

1
2
3
class Teacher private {

}

由此可以看到scala与java类型都会有一个默认的无参构造方法,但有一点不同的是,在java当中,当对构造方法进行重载时,那么jvm就不会再添加默认的构造方法。辅助构造方法也只需写自己的实现即可，而在scala当中,所有的辅助构造方法都要调用其它的辅助构造方法或主构造方法,而且在最终形态上体现对主构造方法的调用。
例如下面的这个例子,当没有使用this对主构造方法进行调用时,则会报错：

1
2
3
4
5
6
7
8
9
10
class Teacher {

  private var name : String = _

  def this(name : String){ //这里相当于重载一个构造方法
    //this 注释掉则会报错
    this.name = name;
  }

}

有参的主构造方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Teacher private (name : String){

  private var age : Integer = 0

  def this(name : String, age : Integer){
    this(name)
    this.age = age
  }

  def showInfo(): Unit ={
    println(this.name + " " + this.age)
  }

}

内部类

1
2
3
4
5
6
7
8
9
10
11
class OuterAndInter(name : String) { outer => //outer相当于外部类的别名,用于让内部类访问外部类的内容
  class Inter(name : String){
    println("wrong outer: " + name + " inner: " + this.name)
    println("outer: " + outer.name + " inner: " + this.name)
}

  class Inter2(name : String){
    println("outer: " + outer.name + " inner2: " + this.name)
    
  }
}
1
2
3
4
5
6
7
object OuterAndInterTest{
  def main(args: Array[String]) {
    val outer = new OuterAndInter("outer")
    val inner = new outer.Inter("inner")
    val inner2 = new outer.Inter2("inner2")
  }
}

注意：
在创建内部类A对象的时候要注意,内部类A是依附于外部类B的实例上的,因而如果内部类中有一个方法的参数类型为A,那么当调用该方法时要注意只能传递用于调用该方法的对象的引用或者与其类型相同的引用,否是会报错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class OuterAndInter(name : String) { outer => //outer相当于外部类的别名,用于让内部类访问外部类的内容
  class Inter(name : String){
    println("wrong outer: " + name + " inner: " + this.name)
    println("outer: " + outer.name + " inner: " + this.name)
}

  /*
  class Inter2(name : String){
    println("outer: " + outer.name + " inner2: " + this.name)
  }
  */
  class Inter2(val name : String){
    def showName(inter2: Inter2): Unit ={
      println("showName : " + inter2.name)
    }
  }
}

object OuterAndInterTest{
  def main(args: Array[String]) {
    val outer = new OuterAndInter("outer")
    val outer2 = new OuterAndInter("outer2")
    val inner = new outer.Inter2("inner")
    val inner2 = new outer2.Inter2("inner2")
    inner2.showName(inner2) //这里的类型是outer2.Inter2,报错信息为:Type mismatch, expected: outer2.Inter2 actual: outer.Inter2
    inner2.showName(inner2)
  }
}