4_scala_类相关

//primary constructor
class Person(var firstName: String, var lastName: String) {
    println("the constructor begins")

    //some class field
    private val HOME = System.getProperty("user.home")
    var age = 0

    //some method
    override def toString = s"$firstName $lastName is $age years old"
    def printHome { println(s"HOME=$HOME") }
    def printFullName { println(this) }

    printHome
    printFullName
    println("still in the constructor")
}

val p = new Person("Eric", "Chan")
p.firstName = "vince"
p.printFullName
p.lastName_$eq("Dan")
p.printFullName
println()

//visibility of construct fields
//If a field is declared as a var, Scala generates both getter and setter methods for that field
//If the field is a val, Scala generates only a getter method for it
//If a field doesn't have a  varor  valmodifier, Scala gets conservative, and doesn't
// generate a getter or setter method for the field. Expect "case class"
//var and val fields can be modified with the privatekeyword, which
// prevents getters and setters from being generated

class Person1(private var name: String = "whoami") { def getName = name }
val p1 = new Person1
//println(p1.name)
println(p1.getName)

//Case classes
//Case class constructor parameters are val by default
//An apply method is generated, so you don’t need to use the newkeyword to create
// a new instance of the class
//Accessor methods are generated for the constructor parameters because case class
// constructor parameters are val by default. Mutator methods are also generated for
// parameters declared as var
//A good, default toString method is generated
//An unapply method is generated, making it easy to use case classes in match expressions
//equals and hashCode methods are generated
//A copymethod is generated
//not constructor, but companion object apply method
case class Person2(name: String, age: Int)
object Person2 {
    def apply() = new Person2("<no name>", 0)
    def apply(name: String) = new Person2(name, 0)
}

println(Person2())
println(Person2("Pam"))
val p2 = Person2("whoami", 82)
println(p2)
println()

//auxiliary constructor
class Pizza(var size: Int, var pType: String) {
    def this(size: Int) {
        this(size, Pizza.DEFAULT_TYPE)
    }

    def this(pType: String) {
        this(Pizza.DEFAULT_SIZE)
        this.pType = pType
    }

    def this() {
        this(Pizza.DEFAULT_SIZE, Pizza.DEFAULT_TYPE)
    }

    override def toString = s"A $size pizza with a $pType crust"
}

object Pizza {
    val DEFAULT_SIZE = 12
    val DEFAULT_TYPE = "thin"
}

println(new Pizza(Pizza.DEFAULT_SIZE, Pizza.DEFAULT_TYPE))
println(new Pizza(Pizza.DEFAULT_SIZE))
println(new Pizza(Pizza.DEFAULT_TYPE))
println(new Pizza)
println()

//private constructor
class Order private (id: String) {
    override def toString = s"Order id: $id"
}

object Order {
    private val order = new Order("0000")
    def getInstance = order
}
//val order = new Order("111")
println(Order.getInstance)
//println(Order.order)
println()

//default value for constructor parameter
class Socket(timeout: Int = 3000, linger: Int = 200) {
    override def toString = s"timeout: $timeout, linger: $linger"
}
println(new Socket())
println(new Socket(10000))
println(new Socket(linger=500))
println()

//preventing getter and setter generated
class Stock {
    private var price: Double = _
    private[this] var newPrice: Double = _
    def setPrice(p: Double) { price = p }
    def setNewPrice(p: Double) { newPrice = p }
    def isHigher(that: Stock): Boolean = this.price > that.price
    //error: this method won't compile because newPrice is now object-private
    //def isNewHigher(that: Stock): Boolean = this.newPrice > that.newPrice
}

val s1 = new Stock
s1.setPrice(20)
val s2 = new Stock
s2.setPrice(100)
println(s2.isHigher(s1))

//assign field to a block or function
class Foo {
    //the text  field isn't initialized until it’s accessed
    lazy val text = {
        try {
            io.Source.fromFile("/etc/passwd").getLines.filter(_.contains("root")).foreach(println)
        }
        catch {
            case e: Exception => println("Error happened")
        }
    }
}

val foo = new Foo
foo.text
println()

//uninitialized var field type
case class Login(var userName: String, var password: String) {
    var age = 0
    var firstName = ""
    var lastName = ""

    var addr:Option[Address] = None
}

case class Address(city: String, state: String, zip: String)

val l = new Login("whoami","123456")
if (l.addr == None)
    println("No address")

l.addr = Some(Address("BJ", "HB", "010000"))

l.addr.foreach { a =>
    println(a.city)
    println(a.state)
    println(a.zip)
}
println()

//extending class constructor parameters
class Employee(firstName: String, lastName: String, var addr: Address) extends Person(firstName, lastName) {
    override def toString = if (addr == null) lastName else s"$firstName @ $addr"
}

val employee = new Employee("Eric", "Chan", Address("BJ", "HB", "010000"))
println(employee)
println()

//when to use an abstract class
//You want to create a base class that requires constructor arguments
//The code will be called from Java code
abstract class Controller(c: String) {
    def update = c.toUpperCase

    def connect
    def getStatus: String
    def setServerName(serverName: String)
}

//need abstract keyword or define superclass's abstract methods
//class MyController(c: String) extends Controller(c)

//define properties in an abstract class (or trait)
//An abstract varfield results in getter and setter methods being generated for the field
//An abstract valfield results in a getter method being generated for the field
//When you define an abstract field in an abstract class or trait, the Scala compiler
// does not create a field in the resulting code; it only generates the methods that
// correspond to the val or var field
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"
}

class Dog(name: String) extends Pet(name) {
    val greeting = "Woof"
    var age = 5
}

class Cat(name: String) extends Pet(name) {
    val greeting = "Meow"
    var age = 2
}

val dog = new Dog("Fido")
val cat = new Cat("Morris")

dog.sayHello
cat.sayHello

println(dog)
println(cat)

cat.age = 3
println(cat)
println()

//Object equality
class Person3(name: String, age: Int) {
    def canEqual(a: Any) = a.isInstanceOf[Person3]

    override def equals(that: Any):Boolean = {
        that match {
            case that: Person3 => that.canEqual(this) && that.hashCode == this.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
    }

    override def toString = s"I am $name, and I'm $age"
}

// these first two instances should be equal
val nimoy = new Person3("Leonard Nimoy", 82)
val nimoy2 = new Person3("Leonard Nimoy", 82)
val shatner = new Person3("William Shatner", 82)
val ed = new Person3("Ed Chigliak", 20)
println(nimoy)
println(nimoy2)
println(shatner)
println(ed)
// all tests pass
println("nimoy == nimoy is " + (nimoy == nimoy))
println("nimoy == nimoy2 is " + (nimoy == nimoy2))
println("nimoy2 == nimoy is " + (nimoy2 == nimoy))
println("nimoy != shatner is " + (nimoy != shatner))
println("shatner != nimoy is " + (shatner != nimoy))
println("nimoy != null is " + (nimoy != null))
println("nimoy != String is " + (nimoy != "Leonard Nimoy"))
println("nimoy != ed is " +  (nimoy != ed))