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))