4.8 分配块或函数给字段
- 使用代码块或者调用一个函数初始化类里的字段
4.8.1 解决方案
设置字段等于需要的代码块或者函数
class Foo { // set 'text' equal to the result of the block of code val text = { var lines = "" try { lines = io.Source.fromFile("/etc/passwd").getLines.mkString } catch { case e: Exception => lines = "Error happened" } lines } println(text) } object Test extends App { val f = new Foo }- 上面分配代码块给text字段和println语句都在类Foo的主体部分中，他们都是类的构造函数，当创建一个类的实例时他们会被执行。
同样方式。分配方法或者函数给类字段
class Foo { import scala.xml.XML // assign the xml field to the result of the load method val xml = XML.load("http://example.com/foo.xml") // more code here ... }
4.8.2 讨论
如果定义一个字段为lazy，意味着不会立马执行直到字段被获取调用：
class Foo { val text = io.Source.fromFile("/etc/passwd").getLines.foreach(println) } object Test extends App { val f = new Foo }上面代码忽略潜在错误，如果运行在Unix系统，会打印/etc/passwd文件
class Foo { lazy val text = io.Source.fromFile("/etc/passwd").getLines.foreach(println) } object Test extends App { val f = new Foo }- 上面声明成lazy字段的代码编译执行后，没有任何输出。因为text字段不会初始化直到它被获取。
4.9 设置未初始化的var字段类型
问题： 想要设置一个未初始化var字段类型，所以开始写代码如下，然后如何完成表达式。
var x =
4.9.1 解决方案
一般来说，定义字段为Option。对于具体的类型，比如String和numeric字段，可以指定默认的初始化值，下面的address字段可以定义成Option,初始化如下。
case class Person(var username: String, var password: String) { var age = 0 var firstName = "" var lastName = "" var address = None: Option[Address] } case class Address(city: String, state: String, zip: String)使用Some[Address]赋值
val p = Person("alvinalexander", "secret") p.address = Some(Address("Talkeetna", "AK", "99676"))如想要获取address字段，有很多方法可见20.6章。可以使用foreach循环打印：
p.address.foreach { a => println(a.city) println(a.state) println(a.zip) }- 如果address未赋值，那么address是一个None,调用foreach没有问题，循环会自动跳出。如果已经赋值，那么address是一个Some[Address],循环会进入然后打印。
4.9.2 讨论
很容易创建一个Int和Double字段
var i = 0 // Int var d = 0.0 // Double上面例子中编译器会自动区分需要的类型。如果需要不同的数字类型，方法如下：
var b: Byte = 0 var c: Char = 0 var f: Float = 0 var l: Long = 0 var s: Short = 0- 查看更多
- Option class
- 不要设置字段为null，更多见20.5章：“Eliminate null Values from Your Code”
- 20.6章：“Using the Option/Some/None Pattern”
4.10 当继承类时处理构造函数参数
- 问题：当继承一个基类时，需要处理基类声明的构造函数参数以及子类新的参数
4.10.1 解决方案
往常一样使用val或者var构造函数参数声明基类，当定义子类构造函数时，去掉两个类中相同字段前的val或者var声明,当定义子类新的构造函数参数时使用val或者var声明。
class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" } case class Address (city: String, state: String)子类Employee
class Employee (name: String, address: Address, var age: Int) extends Person (name, address) { // rest of the class }创建Employee实例
val teresa = new Employee("Teresa", Address("Louisville", "KY"), 25)输出
scala> teresa.name res0: String = Teresa scala> teresa.address res1: Address = Address(Louisville,KY) scala> teresa.age res2: Int = 25
4.10.2 讨论
理解Scala编译器如何转换你的代码有助于理解子类构造函数参数如何工作，下面代码放到文件Person.scala中：
case class Address (city: String, state: String) class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" }上面字段是var变量，Scala编译器生成了获取器和修改器，编译Person.scala反编译Person.class如下：
$ javap Person Compiled from "Person.scala" public class Person extends java.lang.Object implements scala.ScalaObject{ public java.lang.String name(); public void name_$eq(java.lang.String); public Address address(); public void address_$eq(Address); public java.lang.String toString(); public Person(java.lang.String, Address); }新的问题：如果定义一个Employee类继承Person，如何处理Employee构造函数里的name和address字段？假设没有新的参数，至少有两种选择：
// Option 1: define name and address as 'var' class Employee (var name: String, var address: Address) extends Person (name, address) { ... } // Option 2: define name and address without var or val class Employee (name: String, address: Address) extends Person (name, address) { ... }因为Scala已经为Person类里的name和address声明了getter和setter方法，解决方法是不使用var进行声明：
// this is correct class Employee (name: String, address: Address) extends Person (name, address) { ... }把下面代码编译反编译，文件名是Person.scala，反编译Employee.class
case class Address (city: String, state: String) class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" } class Employee (name: String, address: Address) extends Person (name, address) { // code here ... }反编译结果如下：
$ javap Employee Compiled from "Person.scala" public class Employee extends Person implements scala.ScalaObject{ public Employee(java.lang.String, Address); }- Employee继承Person，Scala不为name和address字段生成getter和setter方法，Employee类继承了Person类的行为。
4.11 调用超类构造函数
- 问题：想要控制当创建子类构造函数时调用的父类构造函数
4.11.1 解决方案
- 这有一个问题，你可以控制子类的主构造函数调用的父类构造函数，但是不可以控制子类的辅助构造函数调用的父类构造函数。
下面例子，定义一个Dog类去调用Animal类的主构造函数：
class Animal (var name: String) { // ... } class Dog (name: String) extends Animal (name) { // ... }如果Animal类有多个构造函数，那么Dog类的主构造函数可以调用任意一个
// (1) primary constructor class Animal (var name: String, var age: Int) { // (2) auxiliary constructor def this (name: String) { this(name, 0) } override def toString = s"$name is $age years old" } // calls the Animal one-arg constructor class Dog (name: String) extends Animal (name) { println("Dog constructor called") } // call the two-arg constructor class Dog (name: String) extends Animal (name, 0) { println("Dog constructor called") }
4.11.2 辅助构造函数
辅助构造函数的第一行必须调用当前类的另一个构造函数，不可能调用父类的构造函数
case class Address (city: String, state: String) case class Role (role: String) class Person (var name: String, var address: Address) { // no way for Employee auxiliary constructors to call this constructor def this (name: String) { this(name, null) address = null } override def toString = if (address == null) name else s"$name @ $address" } class Employee (name: String, role: Role, address: Address) extends Person (name, address) { def this (name: String) { this(name, null, null) } def this (name: String, role: Role) { this(name, role, null) } def this (name: String, address: Address) { this(name, null, address) } }
4.12 使用抽象类（Abstract Class）
- 问题：Scala有特质（trait），而且特质比抽象类更灵活，那么什么时候使用抽象类
4.12.1 解决方案
- 以下两点使用抽象类：
- 创建一个需要构造函数参数的基类
- Scala代码会被Java代码调用
特质不允许有构造函数参数：
// this won't compile trait Animal(name: String) // this compile abstract class Animal(name: String)- 17.7章解决特质实现的方法不能被Java代码调用的问题
4.12.2 讨论
- 一个类智能继承一个抽象类。
声明抽象方法：
def speak // no body makes the method abstract抽象方法不需要使用abstract关键词，去除方法的body就会变成抽象方法。这和在特质里定义抽象方法是一致的。
abstract class BaseController(db: Database) { def save { db.save } def update { db.update } def delete { db.delete } // abstract def connect // an abstract method that returns a String def getStatus: String // an abstract method that takes a parameter def setServerName(serverName: String) }子类继承之后需要实现抽象方法或者继续声明成抽象的，不实现方法会报出“class needs to be abstract”错误
scala> class WidgetController(db: Database) extends BaseController(db) <console>:9: error: class WidgetController needs to be abstract, since: method setServerName in class BaseController of type (serverName: String)Unit is not defined method getStatus in class BaseController of type => String is not defined method connect in class BaseController of type => Unit is not defined class WidgetController(db: Database) extends BaseController(db) ^- 因为类只能继承一个抽象类，当决定使用特质还是抽象类时一般使用特质，除非基类需要构造函数参数
4.13 在抽象基类（或特质）中定义属性
- 问题：在抽象基类（或特质）中定义抽象或具体属性可供所有子类引用
4.13.1 解决方案
- 可以在抽象类或者特质里声明val和var字段。这些字段可以是抽象或者有具体实现。
4.13.2 抽象的val和var字段
下面抽象类有抽象的val和var字段，一个简单的具体方法：
abstract class Pet (name: String) { val greeting: String var age: Int def sayHello { println(greeting) } override def toString = s"I say $greeting, and I'm $age" }子类继承抽象类，然后为抽象的字段赋值，注意这些字段还是指定成val或者var:
class Dog (name: String) extends Pet (name) { val greeting = "Woof" var age = 2 } class Cat (name: String) extends Pet (name) { val greeting = "Meow" var age = 5 }object中演示调用：
object AbstractFieldsDemo extends App { val dog = new Dog("Fido") val cat = new Cat("Morris") dog.sayHello cat.sayHello println(dog) println(cat) // verify that the age can be changed cat.age = 10 println(cat) }结果输出：
Woof Meow I say Woof, and I'm 2 I say Meow, and I'm 5 I say Meow, and I'm 10
4.13.3 讨论
- 抽象类（或特质）里抽象字段的运行如下：
- 一个抽象的var字段会自动生成getter和setter方法
- 一个抽象的val字段会自动生成getter方法
- 当在抽象类或特质里定义一个抽象字段，Scala编译器不会在结果代码里创建一个字段，只会根据val或者var生成相应的方法
上面的代码通过 scalac -Xprint:all，或者反编译Pet.class文件，会发现没有greeting或者age字段。反编译输出如下：
import scala.*; import scala.runtime.BoxesRunTime; public abstract class Pet { public abstract String greeting(); public abstract int age(); public abstract void age_$eq(int i); public void sayHello() { Predef$.MODULE$.println(greeting()); } public String toString(){ // code omitted } public Pet(String name){} }- 所以当你在具体的类里给这些字段提供具体的值时，必须重新定义字段为val或者var。因为在抽象类或者特质里这些字段实际并不存在，所以override关键词并不需要。
另一个结果，可以在抽象基类使用def定义无参取代使用val定义，然后可以在具体类里定义成val。
abstract class Pet (name: String) { def greeting: String } class Dog (name: String) extends Pet (name) { val greeting = "Woof" } object Test extends App { val dog = new Dog("Fido") println(dog.greeting) }
4.13.4 抽象类里具体的val字段
抽象类里定义一个具体的val字段可以提供一个初始化值，然后可以在具体子类重写那个值。
abstract class Animal { val greeting = "Hello" // provide an initial value def sayHello { println(greeting) } def run } class Dog extends Animal { override val greeting = "Woof" // override the value def run { println("Dog is running") } }上面例子中，两个类中都创建了greeting字段
abstract class Animal { val greeting = { println("Animal"); "Hello" } } class Dog extends Animal { override val greeting = { println("Dog"); "Woof" } } object Test extends App { new Dog }结果输出：
Animal Dog可以反编译Animal和Dog类，greeting字段声明成如下：
private final String greeting = "Hello";抽象类中字段声明成final val那么具体子类中就不能重写这个字段的值：
abstract class Animal { final val greeting = "Hello" // made the field 'final' } class Dog extends Animal { val greeting = "Woof" // this line won't compile }
4.13.5 抽象类里具体var字段
可以在抽象类或特质为var字段提供一个初始化值，然后在具体子类引用：
abstract class Animal { var greeting = "Hello" var age = 0 override def toString = s"I say $greeting, and I'm $age years old." } class Dog extends Animal { greeting = "Woof" //调用setter方法 age = 2 }这些字段在抽象基类里声明并赋值，反编译Animal类如下：
private String greeting; private int age; public Animal(){ greeting = "Hello"; age = 0; } // more code ...- 因为在Animal基类里这个字段已经声明并且初始化，所以在具体子类里没有必要重新声明字段。
Dog类使用 scalac -Xprint:all 编译：
class Dog extends Animal { def <init>(): Dog = { Dog.super.<init>(); Dog.this.greeting_=("Woof"); Dog.this.age_=(2); () } }- 因为这个字段在抽象类里是具体的，他们只需要在具体子类里重新赋值即可
4.13.6 不要使用null
使用Option/Some/None模式初始化字段:
trait Animal { val greeting: Option[String] var age: Option[Int] = None override def toString = s"I say $greeting, and I'm $age years old." } class Dog extends Animal { val greeting = Some("Woof") age = Some(2) } object Test extends App { val d = new Dog println(d) }输出如下：
I say Some(Woof), and I'm Some(2) years old.
4.14 Case类生成样本代码
- 问题： 在match表达式。actor或者其他使用case类生成样本代码的情况，生成包括获取器，修改器，apply，unapply，toString, equals和hashCode等等方法。
4.14.1 解决方案
定义一个case类如下：
// name and relation are 'val' by default case class Person(name: String, relation: String)- 定义一个case类会生成很多样本代码，有以下好处：
- 生成apply方法，所以不需要使用new关键词去创建这个类的实例
- case类构造函数参数默认声明成val,会自动生成获取器方法，声明成var会自动生成获取器和修改器
- 生成默认的toString方法
- 生成unapply方法，可以在匹配表达式轻松使用case类
- 生成equals和hashCode方法
- 生成copy方法
定义case类，创建一个新的实例时不需要使用new关键词
scala> case class Person(name: String, relation: String) defined class Person // "new" not needed before Person scala> val emily = Person("Emily", "niece") emily: Person = Person(Emily,niece)构造函数默认声明成val，所以会自动生成获取器方法，但不会生成修改器方法：
scala> emily.name res0: String = Emily scala> emily.name = "Fred" <console>:10: error: reassignment to val emily.name = "Fred" ^构造函数参数声明成var，会自动生成获取器和修改器方法:
scala> case class Company (var name: String) defined class Company scala> val c = Company("Mat-Su Valley Programming") c: Company = Company(Mat-Su Valley Programming) scala> c.name res0: String = Mat-Su Valley Programming scala> c.name = "Valley Programming" c.name: String = Valley ProgrammingCase类有一个默认的toString方法实现：
scala> emily res0: Person = Person(Emily,niece)自动生成提取器方法（unapply），当需要在匹配表达式提取信息时很好用（构造器从给定的参数列表创建一个对象， 而提取器却是从传递给它的对象中提取出构造该对象的参数）：
scala> emily match { case Person(n, r) => println(n, r) } (Emily,niece)自动生成equals和hashCode方法，实例可以如下方法比较：
scala> val hannah = Person("Hannah", "niece") hannah: Person = Person(Hannah,niece) scala> emily == hannah res1: Boolean = false自动创建copy方法，当需要clone一个对象时很有帮助，在运行过程中还可以改变一些字段：
scala> case class Employee(name: String, loc: String, role: String) defined class Employee scala> val fred = Employee("Fred", "Anchorage", "Salesman") fred: Employee = Employee(Fred,Anchorage,Salesman) scala> val joe = fred.copy(name="Joe", role="Mechanic") joe: Employee = Employee(Joe,Anchorage,Mechanic)
4.14.2 讨论
- case类主要目的是创建“不可变的记录”，这样可以很容易的在模式匹配表达式里使用。
4.14.3 生成的代码
文件Person.scala：
case class Person(var name: String, var age: Int)编译后会创建两个class文件，Person.class和Person$.class
$ scalac Person.scala反编译Person.class
$ javap Person //结果 Compiled from "Person.scala" public class Person extends java.lang.Object ↵ implements scala.ScalaObject,scala.Product,scala.Serializable{ public static final scala.Function1 tupled(); public static final scala.Function1 curry(); public static final scala.Function1 curried(); public scala.collection.Iterator productIterator(); public scala.collection.Iterator productElements(); public java.lang.String name(); public void name_$eq(java.lang.String); public int age(); public void age_$eq(int); public Person copy(java.lang.String, int); public int copy$default$2(); public java.lang.String copy$default$1(); public int hashCode(); public java.lang.String toString(); public boolean equals(java.lang.Object); public java.lang.String productPrefix(); public int productArity(); public java.lang.Object productElement(int); public boolean canEqual(java.lang.Object); public Person(java.lang.String, int); }反编译Person$.class
$ javap Person$ //结果 Compiled from "Person.scala" public final class Person$ extends scala.runtime.AbstractFunction2 ↵ implements scala.ScalaObject,scala.Serializable{ public static final Person$ MODULE$; public static {}; public final java.lang.String toString(); public scala.Option unapply(Person); public Person apply(java.lang.String, int); public java.lang.Object readResolve(); public java.lang.Object apply(java.lang.Object,java.lang.Object); }去掉case,然后编译反编译如下：
public class Person extends java.lang.Object{ public java.lang.String name(); public void name_$eq(java.lang.String); public int age(); public void age_$eq(int); public Person(java.lang.String, int); }如果不需要那么多额外的函数，考虑使用正常的类。如果只想创建一个不适用new关键词创建实例的类，如下使用：
val p = Person("Alex")此时，可以创建一个apply方法。详细看6.8章
查看更多
4.15 定义一个equals方法（对象相等）
- 问题： 类中定义一个equals方法比较对象实例
4.15.1 解决方案
和Java一样，定义一个equals（和hashCode）方法比较两个实例，和Java不同的是，然后可以使用 == 方法比较两个实例是否相等。
class Person (name: String, age: Int) { def canEqual(a: Any) = a.isInstanceOf[Person] override def equals(that: Any): Boolean = that match { case that: Person => that.canEqual(this) && this.hashCode == that.hashCode case _ => false } override def hashCode:Int = { val prime = 31 var result = 1 result = prime * result + age; result = prime * result + (if (name == null) 0 else name.hashCode) return result } }- 上面例子显示的是一个修改后的hashCode方法。
使用 == 方法比较两个实例：
import org.scalatest.FunSuite class PersonTests extends FunSuite { // these first two instances should be equal val nimoy = new Person("Leonard Nimoy", 82) val nimoy2 = new Person("Leonard Nimoy", 82) val shatner = new Person("William Shatner", 82) val ed = new Person("Ed Chigliak", 20) // all tests pass test("nimoy == nimoy") { assert(nimoy == nimoy) } test("nimoy == nimoy2") { assert(nimoy == nimoy2) } test("nimoy2 == nimoy") { assert(nimoy2 == nimoy) } test("nimoy != shatner") { assert(nimoy != shatner) } test("shatner != nimoy") { assert(shatner != nimoy) } test("nimoy != null") { assert(nimoy != null) } test("nimoy != String") { assert(nimoy != "Leonard Nimoy") } test("nimoy != ed") { assert(nimoy != ed) } }- 上面的测试创建在ScalaTest FunSuite,和JUnit单元测试类似
4.15.2 讨论
- Java中 == 操作符比较引用相等，Scala中 == 是比较两个实例是否相等的方法。
当使用继承时依旧可以继续使用上面的方法
class Employee(name: String, age: Int, var role: String) extends Person(name, age) { override def canEqual(a: Any) = a.isInstanceOf[Employee] override def equals(that: Any): Boolean = that match { case that: Employee => that.canEqual(this) && this.hashCode == that.hashCode case _ => false } //上面case that: Employee保证that是Employee类型，that.canEqual(this)保证this也是Employee类型 override def hashCode:Int = { val ourHash = if (role == null) 0 else role.hashCode super.hashCode + ourHash } }上面的代码使用canEqual,equals,hashCode相同方式，而且是一致的，尤其是比较子类实例和其父类实例
class EmployeeTests extends FunSuite with BeforeAndAfter { // these first two instance should be equal val eNimoy1 = new Employee("Leonard Nimoy", 82, "Actor") val eNimoy2 = new Employee("Leonard Nimoy", 82, "Actor") val pNimoy = new Person("Leonard Nimoy", 82) val eShatner = new Employee("William Shatner", 82, "Actor") test("eNimoy1 == eNimoy1") { assert(eNimoy1 == eNimoy1) } test("eNimoy1 == eNimoy2") { assert(eNimoy1 == eNimoy2) } test("eNimoy2 == eNimoy1") { assert(eNimoy2 == eNimoy1) } test("eNimoy != pNimoy") { assert(eNimoy1 != pNimoy) } test("pNimoy != eNimoy") { assert(pNimoy != eNimoy1) } }
4.15.3 理论
- Scaladoc表述：“这个方法的任何实现都应该是等价关系”，等价关系应该有以下3个特征：
- 自反性（reflexive）：Any类型的实例x，x.equals(x)返回true
- 对称性（symmetric）：Any类型的实例x和y，x.equals(y)和y.equals(x)返回true
- 传递性（transitive）：AnyRef的实例x，y和z，如果x.equals(y)和y.equals(z)返回true，那么x.equals(z)也返回true
因此如果重写equals方法，应该确认你的实现保留了等价关系
查看更多
4.16 创建内部类
- 希望创建一个类作为内部类并且保持在公开API之外，或者否则封装你的代码
4.16.1 解决方案
在一个类里面声明另一个类
class PandorasBox { case class Thing (name: String) var things = new collection.mutable.ArrayBuffer[Thing]() things += Thing("Evil Thing #1") things += Thing("Evil Thing #2") def addThing(name: String) { things += new Thing(name) } }PandorasBox类的使用者不需要担心Thing的实现就能获得things集合
object ClassInAClassExample extends App { val p = new PandorasBox p.addThing("Evil Thing #3") p.addThing("Evil Thing #4") p.things.foreach(println) }
4.16.2 讨论
Scala和Java不同，“不同于Java语言内部类是封闭类的成员，Scala中内部类和外部对象（object）绑定”：
object ClassInObject extends App { // inner classes are bound to the object val oc1 = new OuterClass val oc2 = new OuterClass val ic1 = new oc1.InnerClass val ic2 = new oc2.InnerClass ic1.x = 10 ic2.x = 20 println(s"ic1.x = ${ic1.x}") println(s"ic2.x = ${ic2.x}") } class OuterClass { class InnerClass { var x = 1 } }因为内部类绑定到他们的对象实例，打印如下：
ic1.x = 10 ic2.x = 20更多用法，对象里包括类，类里包括对象：
object InnerClassDemo2 extends App { // class inside object println(new OuterObject.InnerClass().x) // object inside class println(new OuterClass().InnerObject.y) } object OuterObject { class InnerClass { var x = 1 } } class OuterClass { object InnerObject { val y = 2 } }查看更多
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
