add '_035_mutable_objects' section and update ReadMe file

Author: mohnoor94

README.md

@@ -26,7 +26,4 @@ I'm using multiple resources to study and apply what I learn here with examples.
     * [GitHub Repository](https://github.com/julian-t/EssentialScala) for this course.
 * [Scala 101](https://cognitiveclass.ai/learn/scala/#course2000). Free online course on [Cognitive Class](https://cognitiveclass.ai/).
 * [Programming in Scala, Third Edition](https://www.oreilly.com/library/view/programming-in-scala/9780981531687/). A book by Bill Venners, Lex Spoon, and Martin Odersky.
-* [Scala for Java Developers: A Practical Primer](https://www.apress.com/us/book/9781484231074). A book by Toby Weston.
-#
-#### Note:
-The order of packages and/or files do not always reflect the natural order of learning these specific topics, but the order I used to learn this piece of information. 
+* [Scala for Java Developers: A Practical Primer](https://www.apress.com/us/book/9781484231074). A book by Toby Weston.

src/main/scala/_035_mutable_objects/_01_MutationAndVars.scala

@@ -0,0 +1,34 @@
+package _035_mutable_objects
+
+/**
+  * From Chapter 18 - Mutable Objects
+  * Programming in Scala, Third Edition
+  *
+  * > Mutation and vars usually go hand in hand, but things are not always so clear cut. For instance,
+  * >> a class might be mutable without defining or inheriting any vars because it forwards method calls to other
+  * objects that have mutable state.
+  * >> The reverse is also possible: A class might contain vars and still be purely functional.
+  * >>> An example would be a class that caches the result of an expensive operation in a field for optimization purposes.
+  * >>> To pick an example, assume the following unoptimized class Keyed with an expensive operation computeKey:
+  */
+object _01_MutationAndVars {
+
+  class Keyed {
+    def computeKey: Int = 10 // this will take some time (given that we make an action to compute the value).
+  }
+
+  /** > Provided that computeKey neither reads nor writes any vars, you can make Keyed more efficient by adding a cache:
+    * ...
+    * > Using MemoKeyed instead of Keyed can speed things up because the second time the result of the computeKey
+    * operation is requested, the value stored in the keyCache field can be returned instead of running computeKey once
+    * again. But except for this speed gain, the behavior of class Keyed and MemoKeyed is exactly the same.
+    * Consequently, if Keyed is purely functional, then so is MemoKeyed, even though it contains a reassignable variable.
+    * */
+  class MemoKeyed extends Keyed {
+    private var keyCache: Option[Int] = None
+    override def computeKey: Int = {
+      if (keyCache.isEmpty) keyCache = Some(super.computeKey)
+      keyCache.get
+    }
+  }
+}

src/main/scala/_035_mutable_objects/_02_ReassignableVarsAndProperties.scala

@@ -0,0 +1,68 @@
+package _035_mutable_objects
+
+/**
+  * From Chapter 18 - Mutable Objects
+  * > 18.2 REASSIGNABLE VARIABLES AND PROPERTIES
+  * Programming in Scala, Third Edition
+  *
+  *
+  */
+object _02_ReassignableVarsAndProperties {
+
+  // var hour generates a getter, "hour", and setter, "hour_=", in addition to a reassignable field.
+  // The field is always marked private[this], which means it can be accessed only from the object that contains it.
+  // The getter and setter, on the other hand, get the same visibility as the original var.
+  class Time1 {
+    var hour = 12
+    var minute = 0
+  }
+
+  // is equivalent to
+  class Time2 {
+
+    private[this] var h = 12
+    private[this] var m = 0
+
+    def hour: Int = h
+
+    def hour_=(x: Int): Unit = h = x
+
+    def minute: Int = m
+
+    def minute_=(x: Int): Unit = m = x
+  }
+
+  class Time3 {
+
+    private[this] var h = 12
+    private[this] var m = 0
+
+    def hour: Int = h
+
+    def hour_=(x: Int): Unit = {
+      require(0 <= x && x < 24)
+      h = x
+    }
+
+    def minute: Int = m
+
+    def minute_=(x: Int): Unit = {
+      require(0 <= x && x < 60)
+      m = x
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    val time1 = new Time1
+    val time2 = new Time2
+    val time3 = new Time3
+
+    time1.hour = 10
+    time2.hour = 10
+    time3.hour = 10 // here we have a check in setter method
+
+    println(time1.hour)
+    println(time2.hour)
+    println(time3.hour)
+  }
+}

src/main/scala/_035_mutable_objects/_03_GetterAndSetterWithoutField.scala

@@ -0,0 +1,36 @@
+package _035_mutable_objects
+
+/**
+  * > It's also possible, and sometimes useful, to define a getter and a setter without an associated field.
+  * >> For example, the Thermometer class below, which encapsulates a temperature variable that can be read and updated.
+  * >> Temperatures can be expressed in Celsius or Fahrenheit degrees.
+  * >> This class allows you to get and set the temperature in either measure.
+  */
+object _03_GetterAndSetterWithoutField {
+
+  class Thermometer {
+
+    /**
+      * > Note that you cannot simply leave off the "= _" initializer in Scala.
+      * > If you did that, this would declare an abstract variable, not an uninitialized one.
+      */
+    var celsius: Float = _ // default value (0.0)
+
+    def fahrenheit: Float = celsius * 9 / 5 + 32
+
+    def fahrenheit_=(f: Float): Unit = {
+      celsius = (f - 32) * 5 / 9
+    }
+
+    override def toString: String = fahrenheit + "F/" + celsius + "C"
+  }
+
+  def main(args: Array[String]): Unit = {
+    val thermometer = new Thermometer
+    println(thermometer)
+    thermometer.fahrenheit = 100
+    println(thermometer)
+    thermometer.celsius = 100
+    println(thermometer)
+  }
+}