Assiciate Expressions to Names in Scala

ASSOCIATE EXPRESSIONS TO NAMES IN
SCALA
VAL, LAZY VAL, AND DEF

VAL
LAZY VAL
DEF
IN SCOPE
ACCESSED
ACCESSED

VAL
LAZY VAL
DEF
ONCE
ONCE
EVERY TIME
IN SCOPE
ACCESSED
ACCESSED

object Foo {
val v: String = {
println("v evaluated")
"result of v"
}
lazy val lv: String = {
println("lv evaluated")
"result of lv"
}
def d: String = {
println("d evaluated")
"result of d"
}
}

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
res0: Foo.type = Foo$@32f96bba

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
res1: String = result of v

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
res2: String = result of lv

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
scala> Foo.lv

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
scala> Foo.lv
scala> Foo.d

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
scala> Foo.lv
scala> Foo.d
d evaluated
res4: String = result of d

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
scala> Foo.lv
scala> Foo.d
d evaluated
scala> Foo.d

object Foo {
val v: String = {
"result of v"
}
"result of lv"
}
def d: String = {
"result of d"
}
}
scala> Foo
v evaluated
scala> Foo.v
scala> Foo.lv
lv evaluated
scala> Foo.lv
scala> Foo.d
d evaluated
scala> Foo.d
d evaluated

VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM
VAL
LAZY VAL
DEF
LAZY VAL VAL DEF
Overrides
Variable

VAL
LAZY VAL
DEF
LAZY VAL VAL DEF
Overrides
Variable
Only when parent Val is
not implemented

VAL
LAZY VAL
DEF
LAZY VAL VAL DEF
Overrides
Variable
not implemented
Can Not Be Abstract

abstract class A {
val v: String
lazy val lv: String
def d: String
}

abstract class A {
val v: String
lazy val lv: String
def d: String
}
Can Not Be Abstract

abstract class A {
val v: String
lazy val lv: String = "value of lv in A"
def d: String
}

abstract class A {
val v: String
def d: String
}
class B extends A {
lazy val v: String = "value of v"
override lazy val lv: String = "value of lv"
lazy val d: String = "value of d"
}

abstract class A {
val v: String
def d: String
}
class B extends A {
}
class C extends A {
val v: String = "value of v"
val d: String = "value of d"
}

abstract class A {
val v: String
def d: String
}
class B extends A {
}
class C extends A {
val d: String = "value of d"
}
class D extends A {
def d: String = "value of d"
}

abstract class A {
val x1: String
val x2: String = "mom"
val resultA = x1 + ", " + x2
}
class B extends A {
val x1: String = "hello"
val resultB = x1 + ", " + x2
}
class C extends B {
override val x2: String = "dad"
val resultC = x1 + ", " + x2
}

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
scala> val c = new C
c: C = C@7cfb4736

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultC
res0: String = hello, dad

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultC
scala> c.resultB
res1: String = hello, null

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultC
scala> c.resultB
scala> c.resultA
res2: String = null, null

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultC
res0: String = C: hello, dad
scala> c.resultB
res1: String = B: hello, null
scala> c.resultA

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultC
scala> c.resultB
scala> c.resultA

INITIALIZATION ORDERS IN OVERRIDES
▸ Superclasses are fully initialized before subclasses.
▸ Otherwise, in declaration order
▸ When a `val` is overriden, it is not initialized more than once.

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultA

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultA
scala> c.resultB

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
c: C = C@7cfb4736
scala> c.resultA
scala> c.resultB
scala> c.resultC

abstract class D {
val c: C
val x3 = c.x1
}
class E extends D {
val c = new C
}
abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}

abstract class D {
val c: C
val x3 = c.x1
}
class E extends D {
val c = new C
}
abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
scala> new E

abstract class D {
val c: C
val x3 = c.x1
}
class E extends D {
val c = new C
}
abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
scala> new E
java.lang.NullPointerException
... 30 elided

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
abstract class A {
val x1: String
}
class B extends {
} with A {
}
class C extends {
} with B {
}

abstract class A {
val x1: String
}
class B extends {
} with A {
}
class C extends {
} with B {
}
c: C = C@22d9bc14
scala> c.resultA
scala> c.resultB
scala> c.resultC

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
abstract class A {
val x1: String
}
class B extends A {
lazy val x1: String = "hello"
}
class C extends B {
override lazy val x2: String = "dad"
}

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
not implemented

abstract class A {
val x1: String
}
class B extends A {
}
class C extends B {
}
abstract class A {
val x1: String
lazy val x2: String = "mom"
}
class B extends A {
}
class C extends B {
}

abstract class A {
val x1: String
lazy val x2: String = "mom"
}
class B extends A {
}
class C extends B {
}
c: C = C@2f74900b
scala> c.resultA
scala> c.resultB
scala> c.resultC

THANK YOU!
References: https://docs.scala-lang.org/tutorials/FAQ/initialization-order.html
@realstraw
in/kexinxie

Assiciate Expressions to Names in Scala

More Related Content

Similar to Assiciate Expressions to Names in Scala (20)

Recently uploaded (20)

Assiciate Expressions to Names in Scala