Encapsulation

Author: Shikha-code36

06.Encapsulation/encapsulation-1.py

@@ -0,0 +1,39 @@
+#encapsulation-1.py
+
+# Encapsulation means to preserve data in classes using methods
+# Here, we're setting the 'val' attribute through 'set_val()'.
+# See the next example, `encapsulation-2.py` for more info
+
+# In this example, we have two methods, `set_val` and `get_val`.
+# The first one sets the `val` value while the second one
+# prints/returns the value.
+
+
+class MyClass(object):
+    def set_val(self, val):
+        self.value = val
+
+    def get_val(self):
+        # print(self.value)
+        return self.value
+
+
+a = MyClass()
+b = MyClass()
+
+a.set_val(10)
+b.set_val(100)
+
+a.get_val()
+b.get_val()
+
+# NOTE: If you run this code, it won't print anything to the screen.
+# This is because, even if we're calling `a.get_val()` and `b.get_val()`,
+# the `get_val()` function doesn't contain a `print()` function.
+# If we want to get the output printed to screen, we should do any of
+# the following:
+
+# a) Either replace `return self.value` with `print(self.value)`
+# or add a print statement **above** `return` as `print(self.value)`.
+
+# b) Remove `return(self.value)` and replace it with `print(self.value)`

06.Encapsulation/encapsulation-2.py

@@ -0,0 +1,34 @@
+#encapsulation-2.py
+
+# This example builds on top of `encapsulation-1.py`.
+# Here we see how we can set values in methods without
+# going through the method itself, ie.. how we can break
+# encapsulation.
+
+# NOTE: BREAKING ENCAPSULATION IS BAD.
+
+
+class MyClass(object):
+    def set_val(self, val):
+        self.value = val
+
+    def get_val(self):
+        print(self.value)
+
+
+a = MyClass()
+b = MyClass()
+
+a.set_val(10)
+b.set_val(1000)
+a.value = 100  # <== Overriding `set_value` directly
+# <== ie..  Breaking encapsulation
+
+a.get_val()
+b.get_val()
+
+'''
+O/P-
+100
+1000
+'''

06.Encapsulation/encapsulation-3.py

@@ -0,0 +1,68 @@
+#encapsulation-3.py
+
+# Here we look at another example, where we have three methods
+# set_val(), get_val(), and increment_val().
+
+# set_val() helps to set a value, get_val() prints the value,
+# and increment_val() increments the set value by 1.
+
+# We can still break encapsulation here by calling 'self.value'
+# directly in an instance, which is **BAD**.
+
+# set_val() forces us to input an integer, ie.. what the code wants
+# to work properly. Here, it's possible to break the encapsulation by
+# calling 'self.val` directly, which will cause unexpected results later.
+# In this example, the code is written to enforce an intger as input, if we
+# don't break encapsulation and go through the gateway 'set_val()'
+
+#
+
+
+class MyInteger(object):
+    def set_val(self, val):
+        try:
+            val = int(val)
+        except ValueError:
+            return
+        self.val = val
+
+    def get_val(self):
+        print(self.val)
+
+    def increment_val(self):
+        self.val = self.val + 1
+        print(self.val)
+
+
+a = MyInteger()
+a.set_val(10)
+a.get_val()
+a.increment_val()
+print("Before Break")
+
+# Trying to break encapsulation in a new instance with an int
+c = MyInteger()
+c.val = 15
+c.get_val()
+c.increment_val()
+print("After Break")
+
+# Trying to break encapsulation in a new instance with a str
+b = MyInteger()
+b.val = "MyString"  # <== Breaking encapsulation, works fine
+b.get_val()  # <== Prints the val set by breaking encap
+b.increment_val()  # This will fail, since str + int wont work
+print("Changing DataType")
+'''
+O/P-
+10
+11
+Before Break
+15
+16
+After Break
+MyString
+Traceback (most recent call last):
+    self.val = self.val + 1
+TypeError: can only concatenate str (not "int") to str
+'''

README.md

@@ -5,7 +5,8 @@
 02. [Methods-Functions](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#02-methodsfunctions)
 03. [Objects](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#03-objects)
 04. [Constructors](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#04-constructors)
-05. [Inheritance](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#04-constructors)
+05. [Inheritance](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#05-inheritance)
+06. [Encapsulation](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#06-encapsulation)
 
 ------------
 ## What do you understand by OOPs?
@@ -131,4 +132,11 @@ ex- Man Inheriting features from his father
 
 [Detailed Explanation](05.Inheritance)
 
+------------
+#### 06. Encapsulation
+
+Encapsulation involves the bundling of data members and functions inside a single class. Bundling similar data members and functions inside a class also helps in data hiding. Encapsulation also ensures that objects are self-sufficient functioning pieces and can work independently.
+
+[Detailed Explanation](06.Encapsulation)
+
 ------------