【Scala】Scala之Classes and Properties

class Person {
    var name = ""
    override def toString = s"name = $name"
}

p.name = "Ron Artest"

p.name_$eq("Ron Artest")

case class Person(name: String)

class Pizza (var crustSize: Int, var crustType: String) {
    // one-arg auxiliary constructor
    def this(crustSize: Int) {
        this(crustSize, Pizza.DEFAULT_CRUST_TYPE)
    }
    // one-arg auxiliary constructor
    def this(crustType: String) {
        this(Pizza.DEFAULT_CRUST_SIZE, crustType)
    }
    // zero-arg auxiliary constructor
    def this() {
        this(Pizza.DEFAULT_CRUST_SIZE, Pizza.DEFAULT_CRUST_TYPE)
    }
    override def toString = s"A $crustSize inch pizza with a $crustType crust"
}

object Pizza {
    val DEFAULT_CRUST_SIZE = 12
    val DEFAULT_CRUST_TYPE = "THIN"
    
    def main(args: Array[String]): Unit = {
        val p1 = new Pizza(Pizza.DEFAULT_CRUST_SIZE, Pizza.DEFAULT_CRUST_TYPE)
        val p2 = new Pizza(Pizza.DEFAULT_CRUST_SIZE)
        val p3 = new Pizza(Pizza.DEFAULT_CRUST_TYPE)
        val p4 = new Pizza
        println(p1)
        println(p2)
        println(p3)
        println(p4)
    }
}

A 12 inch pizza with a THIN crust
A 12 inch pizza with a THIN crust
A 12 inch pizza with a THIN crust
A 12 inch pizza with a THIN crust

def this(crustType: String) {
    this(Pizza.DEFAULT_CRUST_SIZE)
    this.crustType = Pizza.DEFAULT_CRUST_TYPE
}

class Pizza () {
    var crustSize = 0
    var crustType = ""
    def this(crustSize: Int) {
        this()
        this.crustSize = crustSize
    }
    def this(crustType: String) {
        this()
        this.crustType = crustType
    }
    
    // more constructors here ...
    override def toString = s"A $crustSize inch pizza with a $crustType crust"
}

val p = Person.apply("leesf", 25)

// the case class
case class Person (var name: String, var age: Int)

// the companion object
object Person {
    def apply() = new Person("<no name>", 0)
    def apply(name: String) = new Person(name, 0)
}

object CaseClassTest extends App {
    val a = Person() // corresponds to apply()
    val b = Person("leesf") // corresponds to apply(name: String)
    val c = Person("dyd", 25)
    println(a)
    println(b)
    println(c)
    // verify the setter methods work
    a.name = "leesf"
    a.age = 25
    println(a)
}

Person(<no name>,0)
Person(leesf,0)
Person(dyd,25)
Person(leesf,25)

class Order private { ... }
class Person private (name: String) { ... }

class Brain private {
    override def toString = "This is the brain."
}

object Brain {
    val brain = new Brain
    def getInstance = brain
}

object SingletonTest extends App {
    val brain = Brain.getInstance
    println(brain)
}

This is the brain.

object FileUtils {
    def readFile(filename: String) = {
        // code here ...
    }
    def writeToFile(filename: String, contents: String) {
        // code here ...
    }
}

class Socket (val timeout: Int = 10000)

class Socket (val timeout: Int = 10000)

class Socket(val timeout: Int) {
    def this() = this(10000)
    override def toString = s"timeout: $timeout"
}

class Socket(val timeout: Int = 1000, val linger: Int = 2000) {
    override def toString = s"timeout: $timeout, linger: $linger"
}

class Stock (var symbol: String)

class Stock (var _symbol: String) {
    def symbol = _symbol
    def symbol_= (s: String) {
        this.symbol = s
        println(s"symbol was updated, new value is $symbol")
    }
}

class Stock {
    var delayedPrice: Double = _
    private var currentPrice: Double = _
}

class Foo {
    // set ‘text‘ equal to the result of the block of code
    val text = {
        var lines = ""
        try {
            lines = io.Source.fromFile("F:/test.txt").getLines.mkString
        } catch {
            case e: Exception => lines = "Error happened"
        }
        lines
    }
    println(text)
}

object Test extends App {
    val f = new Foo
}

This is a test file.

class Foo {
    val text =
        io.Source.fromFile("F:/test.txt").getLines.foreach(println)
}

object Test extends App {
    val f = new Foo
}

This is a test file.

class Foo {
    lazy val text =
        io.Source.fromFile("F:/test.txt").getLines.foreach(println)
}

object Test extends App {
    val f = new Foo
}

var x =

case class Person(var username: String, var password: String)

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)

val p = Person("leesf", "secret")
p.address = Some(Address("WH", "HB", "43000"))

p.address.foreach { a =>
    println(a.city)
    println(a.state)
    println(a.zip)
}

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

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, var age: Int)
　　extends Person (name, address) {
    // rest of the class
}

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

val lee = new Employee("Leesf", Address("JZ", "HB"), 25)

class Person (var name: String, var address: Address) {
    override def toString = if (address == null) name else s"$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) { ... }

// this is correct
class Employee (name: String, address: Address)
    extends Person (name, address) { ... }

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

class Animal (var name: String) {
    // ...
}

class Dog (name: String) extends Animal (name) {
    // ...
}

// (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")
}

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

trait Animal(name: String) // this won‘t compile

abstract class Animal(name: String)

def speak // no body makes the method abstract

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

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 = 2
}

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

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

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

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

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

abstract class Animal {
    final val greeting = "Hello" // made the field ‘final‘
}

class Dog extends Animal {
    val greeting = "Woof" // this line won‘t compile
}

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"
    age = 2
}

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.

case class Person(name: String, relation: String)

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

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
    }
    
    override def hashCode:Int = {
        val ourHash = if (role == null) 0 else role.hashCode
        super.hashCode + ourHash
    }
}

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

object ClassInAClassExample extends App {
    val p = new PandorasBox
    p.things.foreach(println)
}

Evil Thing #1
Evil Thing #2

p.addThing("Evil Thing #3")
p.addThing("Evil Thing #4")

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