Assiciate Expressions to Names in Scala

Val, Lazy Val and Def

Transcript

1. ASSOCIATE EXPRESSIONS TO NAMES IN SCALA VAL, LAZY VAL, AND DEF
2. VAL LAZY VAL DEF
3. VAL LAZY VAL DEF VAR
4. VAL LAZY VAL DEF VAR
5. VAL LAZY VAL DEF
6. VAL LAZY VAL DEF IN SCOPE ACCESSED ACCESSED
7. VAL LAZY VAL DEF ONCE ONCE EVERY TIME IN SCOPE ACCESSED ACCESSED
8. 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" } }
9. 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" } } scala> Foo
10. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba
11. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v
12. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v
13. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv
14. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv
15. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv
16. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv res3: String = result of lv
17. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv res3: String = result of lv scala> Foo.d
18. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv res3: String = result of lv scala> Foo.d d evaluated res4: String = result of d
19. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv res3: String = result of lv scala> Foo.d d evaluated res4: String = result of d scala> Foo.d
20. 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" } } scala> Foo v evaluated res0: Foo.type = Foo$@32f96bba scala> Foo.v res1: String = result of v scala> Foo.lv lv evaluated res2: String = result of lv scala> Foo.lv res3: String = result of lv scala> Foo.d d evaluated res4: String = result of d scala> Foo.d d evaluated res5: String = result of d
21. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable
22. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable
23. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable
24. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable
25. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable
26. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable Only when parent Val is not implemented
27. VARIABLE OVERRIDES IN INHERITANCE AND POLYMORPHISM VAL LAZY VAL DEF LAZY VAL VAL DEF Overrides Variable Only when parent Val is not implemented Can Not Be Abstract
28. abstract class A { val v: String lazy val lv: String def d: String }
29. abstract class A { val v: String lazy val lv: String def d: String } Can Not Be Abstract
30. abstract class A { val v: String lazy val lv: String = "value of lv in A" def d: String }
31. abstract class A { val v: String lazy val lv: String = "value of lv in A" 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" }
32. abstract class A { val v: String lazy val lv: String = "value of lv in A" 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" } class C extends A { val v: String = "value of v" override lazy val lv: String = "value of lv" val d: String = "value of d" }
33. abstract class A { val v: String lazy val lv: String = "value of lv in A" 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" } class C extends A { val v: String = "value of v" override lazy val lv: String = "value of lv" val d: String = "value of d" } class D extends A { val v: String = "value of v" override lazy val lv: String = "value of lv" def d: String = "value of d" }
34. 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 }
35. 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 } scala> val c = new C c: C = C@7cfb4736
36. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultC res0: String = hello, dad
37. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultC res0: String = hello, dad scala> c.resultB res1: String = hello, null
38. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultC res0: String = hello, dad scala> c.resultB res1: String = hello, null scala> c.resultA res2: String = null, null
39. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultC res0: String = C: hello, dad scala> c.resultB res1: String = B: hello, null scala> c.resultA res2: String = null, null
40. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultC res0: String = hello, dad scala> c.resultB res1: String = hello, dad scala> c.resultA res2: String = hello, dad
41. 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.
42. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultA res0: String = null, null
43. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultA res0: String = null, null scala> c.resultB res1: String = hello, null
44. 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 } scala> val c = new C c: C = C@7cfb4736 scala> c.resultA res0: String = null, null scala> c.resultB res1: String = hello, null scala> c.resultC res2: String = hello, dad
45. abstract class D { val c: C val x3 = c.x1 } class E extends D { val c = new C } 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 }
46. abstract class D { val c: C val x3 = c.x1 } class E extends D { val c = new C } 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 } scala> new E
47. abstract class D { val c: C val x3 = c.x1 } class E extends D { val c = new C } 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 } scala> new E java.lang.NullPointerException ... 30 elided
48. FIX 1 - USE EARLY DEFINITIONS
49. 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 val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends { val x1: String = "hello" } with A { val resultB = x1 + ", " + x2 } class C extends { override val x2: String = "dad" } with B { val resultC = x1 + ", " + x2 }
50. abstract class A { val x1: String val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends { val x1: String = "hello" } with A { val resultB = x1 + ", " + x2 } class C extends { override val x2: String = "dad" } with B { val resultC = x1 + ", " + x2 } scala> val c = new C c: C = C@22d9bc14 scala> c.resultA res0: String = hello, dad scala> c.resultB res1: String = hello, dad scala> c.resultC res2: String = hello, dad
51. abstract class A { val x1: String val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends { val x1: String = "hello" } with A { val resultB = x1 + ", " + x2 } class C extends { override val x2: String = "dad" } with B { val resultC = x1 + ", " + x2 } scala> val c = new C c: C = C@22d9bc14 scala> c.resultA res0: String = hello, dad scala> c.resultB res1: String = hello, dad scala> c.resultC res2: String = hello, dad
52. FIX 2 - USE LAZY VALS
53. 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 }
54. 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 val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends A { lazy val x1: String = "hello" val resultB = x1 + ", " + x2 } class C extends B { override lazy val x2: String = "dad" val resultC = x1 + ", " + x2 }
55. 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 val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends A { lazy val x1: String = "hello" val resultB = x1 + ", " + x2 } class C extends B { override lazy val x2: String = "dad" val resultC = x1 + ", " + x2 } Only when parent Val is not implemented
56. 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 lazy val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends A { lazy val x1: String = "hello" val resultB = x1 + ", " + x2 } class C extends B { override lazy val x2: String = "dad" val resultC = x1 + ", " + x2 }
57. abstract class A { val x1: String lazy val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends A { lazy val x1: String = "hello" val resultB = x1 + ", " + x2 } class C extends B { override lazy val x2: String = "dad" val resultC = x1 + ", " + x2 } scala> val c = new C c: C = C@2f74900b scala> c.resultA res0: String = hello, dad scala> c.resultB res1: String = hello, dad scala> c.resultC res2: String = hello, dad
58. abstract class A { val x1: String lazy val x2: String = "mom" val resultA = x1 + ", " + x2 } class B extends A { lazy val x1: String = "hello" val resultB = x1 + ", " + x2 } class C extends B { override lazy val x2: String = "dad" val resultC = x1 + ", " + x2 } scala> val c = new C c: C = C@2f74900b scala> c.resultA res0: String = hello, dad scala> c.resultB res1: String = hello, dad scala> c.resultC res2: String = hello, dad
59. THANK YOU! References: https://docs.scala-lang.org/tutorials/FAQ/initialization-order.html @realstraw in/kexinxie