Step into Scala - 11 - 类

目录

摘要

定义类，public，实例化对象，方法和函数，Setter 与 Getter，对象私有属性，Bean 属性，辅助构造器，主构造器，私有主构造器，定义内部类，使用内部类，内部类访问外部类的成员，this 别名

类

定义类

class Counter {
  private var value = 0

  def increment(): Unit = {     //public
    value += 1
  }

  def current = value
}

• Scala 源文件中定义的类不需要声明为 public。
• 一个 Scala 源文件中可以包含多个类，所有这些类都是 public 可见的。
• 类中的所有默认方法也都是 public 的

实例化对象

val counter = new Counter
counter.increment()
println(counter.current)

• 调用无参方法/构造方法时，可以加括号也可以不加括号。
• 一个比较好的作法是方法会改变对象状态时加上括号，如上述的 increment
• 方法不会改变对象的状态时不加括号，如上述的 current

方法与函数

函数和方法在很大程度上是可以互换的。由于函数和方法是如此的相似，你可能都不知道你调用的东西是一个函数还是一个方法。而当真正碰到的方法和函数之间的差异的时候，你可能会感到困惑。

class C {
  var acc = 0

  // a method
  def methodInc = {
    acc += 1
  }

  // a function, return value is a function
  def functionInc = { () => acc += 1 }
}

val c = new C
println(c.methodInc) //()
println(c.acc) //1

println(c.functionInc) //<function0>
println(c.acc) //1

println(c.functionInc()) //()
println(c.acc) //2

Setter 和 Getter

1. 默认定义一个属性时，编译器会自动为该属性生成拥有 public setter 和 getter 方法的 private 属性。且 setter 和 getter 方法名为 fieldName_= 和 fieldName。所以直接调用对象的属性时实际是调用对应的方法

2. 如果定义属性为private 的话，该属性的 setter 和 getter 也会变为 private，此时可以自己定义 setter 和 getter 方法。

class Person {
  //default getter and setter
  var age = 0

  //specify getter and setter
  private var privateAge = 0

  def trueAge = privateAge

  def trueAge_=(pAge: Int): Unit = {
    if (pAge > privateAge) {
      privateAge = pAge
    }
  }
}

val person = new Person
person.age = 10 //person.age_=(10)
println(person.age) //person.age()

只生成 Getter

当声明的属性为 val 时，该属性只会生成 getter 方法

val birthday = new Date()

对象私有属性

通常在一个类中的方法可以调用该类任何对象的私有方法，设置为对象私有属性时，则该属性只能被该对象本身访问。

private age = 0
//设置为对象私有属性
private[this] var selfAge = 0

//可以在一个对象中访问另一个对象的私有属性
def isYounger(other: Person) = age < other.age

//无法访问
//def isYounger2(other:Person) = selfAge < other.selfAge

Bean 属性

Scala 可以通过注解 @BeanProperty 自动生成 Java 命名规范的 setter 和 getter 方法。

import scala.beans.BeanProperty
class MyBean {

  @BeanProperty
  var name: String = _

}

该注解除了生成默认的 name 和 name_= 方法外，也会生成 getName() 和 setName() 方法。

构造器

概述

• 构造器分为主构造器和辅助构造器
• 默认一个类总会有一个无参的主构造器

辅助构造器

• 辅助构造器名为 this
• 辅助构造器可以通过 this 调用其它的辅助构造器，但是任何一个辅助构造器必须调用主构造器

def this(name: String) {
  //调用主构造器
  this(name, 0)
}
def this(age: Int) {
  //调用主构造器
  this("Default Name", age)
}
def this(){
  //调用辅助构造器
  this("Default Name")
}

主构造器

主构造器直接定义在类名后

class Man(val name: String, val age: Int, private var from: String = "USA", description: String = "none") {

  println("sentences in main constructor")
}

• 主构造器会执行类中的所有语句，所以每实例化一个对象，上述例子都会打印一条语句
• 主构造器中可以使用默认参数，如上述的 from
• 主构造器中定义的参数可以是 val 也可以是 var，定义的参数会自动转换为该类的成员属性
• 主构造器中的参数也可以不加 var 或 val，此时如果类中的方法有用到该参数，则此参数转换为成员属性，否则会被忽略
• 主构造器也可以被声明为 private，这样就只能通过辅助构造器来实例化该对象

私有主构造器

class Woman private(val name: String, val age: Int) {
  def this(name: String) {
    this(name, 0)
  }
}

内部类/嵌套类

概念

Scala 中，内部类不像 Java 属于外部类，而是属于外部类的对象，即同一个外部类的不同对象拥有的内部类也是不相同的。

定义内部类

class Outter {
  class Inner(val name: String) {
  }
}

实例化内部类

val outter1 = new Outter
val inner1 = new outter1.Inner("Outter1")

内部类访问外部类的成员

使用 外部类.this 进行访问

class Outter {
  class Inner(val name: String) {
    def desc = Outter.this.name + "-" + name
  }
}

或者也可以使用 this 的别名

class Outter {outer =>
  class Inner(val name: String) {
    def desc = outer.name + "-" + name
  }
}