Commit @45329da66f2aecdf07a40ac2e091244a6d556b6b

dboyliao 2015-11-25

Add sample code for interface segregation principle. Update README.md

@45329da66f2aecdf07a40ac2e091244a6d556b6b

8081292

45329da

README.md

--- README.md

+++ README.md


         - [Circle-Ellipse Problem](https://en.wikipedia.org/wiki/Circle-ellipse_problem)
         - **Moral of the story: model your classes based on behaviours not on properties; model your data based on properties and not on behaviours. If it behaves like a duck, it's certainly a bird.**
         - **This strongly suggests that inheritance should never be used when the sub-class restricts the freedom implicit in the base class, but should only be used when the sub-class adds extra detail to the concept represented by the base class as in 'Monkey' is-an 'Animal'.**
-    - `I`:
+    - `I`: Interface Segregation Principle
+        - [link](http://www.oodesign.com/dependency-inversion-principle.html)
+        - [Wiki](https://en.wikipedia.org/wiki/Interface_segregation_principle)
     - `D`:
 
 ## Other Interesting Articles

8081292

45329da

python_code/bad/ISP.py

--- python_code/bad/ISP.py

+++ python_code/bad/ISP.py

...	...	@@ -1,0 +1,84 @@
	1	+#!/usr/bin/env python
	2	+# -- coding: utf-8 --
	3	+
	4	+from abc import ABCMeta, abstractmethod
	5	+import time
	6	+
	7	+class AbstractWorker(object):
	8	+ __metaclass__ = ABCMeta
	9	+
	10	+ @abstractmethod
	11	+ def work(self):
	12	+ pass
	13	+
	14	+ @abstractmethod
	15	+ def eat(self):
	16	+ pass
	17	+
	18	+class Worker(AbstractWorker):
	19	+
	20	+ def work(self):
	21	+ print "I'm normal worker. I'm working."
	22	+
	23	+ def eat(self):
	24	+ print "Lunch break....(5 secs)"
	25	+ time.sleep(5)
	26	+
	27	+class SuperWorker(AbstractWorker):
	28	+
	29	+ def work(self):
	30	+ print "I'm super worker. I work very hard!"
	31	+
	32	+ def eat(self):
	33	+ print "Lunch break....(3 secs)"
	34	+ time.sleep(3)
	35	+
	36	+
	37	+class Manager(object):
	38	+
	39	+ def __init__(self):
	40	+ self.worker = None
	41	+
	42	+ def set_worker(self, worker):
	43	+ assert isinstance(worker, AbstractWorker), "`worker` must be of type {}".format(AbstractWorker)
	44	+
	45	+ self.worker = worker
	46	+
	47	+ def manage(self):
	48	+ self.worker.work()
	49	+
	50	+ def lunch_break(self):
	51	+ self.worker.eat()
	52	+
	53	+# Implement the `Robot` class. However, due to the api defined by `AbstractWorker`,
	54	+# we have to reimplement `eat` method which is not necessary for a `Robot`.
	55	+
	56	+class Robot(AbstractWorker):
	57	+
	58	+ def work(self):
	59	+ print "I'm a robot. I'm working...."
	60	+
	61	+ def eat(self):
	62	+ print "I don't need to eat...." # This code doing nothing but it is a must. (Bad!)
	63	+
	64	+def main():
	65	+
	66	+ manager = Manager()
	67	+ manager.set_worker(Worker())
	68	+ # Make normal worker works.
	69	+ manager.manage()
	70	+ # lunch break
	71	+ manager.lunch_break()
	72	+
	73	+ # super worker
	74	+ manager.set_worker(SuperWorker())
	75	+ manager.manage()
	76	+ manager.lunch_break()
	77	+
	78	+ manager.set_worker(Robot())
	79	+ manager.manage()
	80	+ # However, a robot can eat.....
	81	+ manager.lunch_break()
	82	+
	83	+if __name__ == '__main__':
	84	+ main()

8081292

45329da

python_code/good/ISP.py

--- python_code/good/ISP.py

+++ python_code/good/ISP.py

...	...	@@ -1,0 +1,105 @@
	1	+#!/usr/bin/env python
	2	+# -- coding: utf-8 --
	3	+
	4	+# In this implementation, we break `AbstractWorker` into two seperate abstract
	5	+# classes, `Workable` and `Eatable`, then we can seperate normal worker from
	6	+# robot. As a result, we don't need to implement `eat` method in robot anymore.
	7	+
	8	+from abc import ABCMeta, abstractmethod
	9	+import time
	10	+
	11	+class Workable(object):
	12	+ __metaclass__ = ABCMeta
	13	+
	14	+ @abstractmethod
	15	+ def work(self):
	16	+ pass
	17	+
	18	+class Eatable(object):
	19	+ __metaclass__ = ABCMeta
	20	+
	21	+ @abstractmethod
	22	+ def eat(self):
	23	+ pass
	24	+
	25	+class AbstractWorker(Workable, Eatable):
	26	+ pass
	27	+
	28	+class Worker(AbstractWorker):
	29	+
	30	+ def work(self):
	31	+ print "I'm normal worker. I'm working."
	32	+
	33	+ def eat(self):
	34	+ print "Lunch break....(5 secs)"
	35	+ time.sleep(5)
	36	+
	37	+class SuperWorker(AbstractWorker):
	38	+
	39	+ def work(self):
	40	+ print "I'm super worker. I work very hard!"
	41	+
	42	+ def eat(self):
	43	+ print "Lunch break....(3 secs)"
	44	+ time.sleep(3)
	45	+
	46	+
	47	+class Manager(object):
	48	+
	49	+ def __init__(self):
	50	+ self.worker = None
	51	+
	52	+class WorkManager(Manager):
	53	+
	54	+ def set_worker(self, worker):
	55	+ assert isinstance(worker, Workable), "`worker` must be of type {}".format(Workable)
	56	+
	57	+ self.worker = worker
	58	+
	59	+ def manage(self):
	60	+ self.worker.work()
	61	+
	62	+class BreakManager(Manager):
	63	+
	64	+ def set_worker(self, worker):
	65	+ assert isinstance(worker, Eatable), "`worker` must be of type {}".format(Eatable)
	66	+ self.worker = worker
	67	+
	68	+ def lunch_break(self):
	69	+ self.worker.eat()
	70	+
	71	+class Robot(Workable):
	72	+
	73	+ def work(self):
	74	+ print "I'm a robot. I'm working...."
	75	+
	76	+ # No need for implementation of `eat` which is not neccessary for a `Robot`.
	77	+
	78	+def main():
	79	+
	80	+ work_manager = WorkManager()
	81	+ break_manager = BreakManager()
	82	+ work_manager.set_worker(Worker())
	83	+ break_manager.set_worker(Worker())
	84	+ # Make normal worker works.
	85	+ work_manager.manage()
	86	+ # lunch break
	87	+ break_manager.lunch_break()
	88	+
	89	+ # super worker
	90	+ work_manager.set_worker(SuperWorker())
	91	+ break_manager.set_worker(SuperWorker())
	92	+ work_manager.manage()
	93	+ break_manager.lunch_break()
	94	+
	95	+ work_manager.set_worker(Robot())
	96	+ work_manager.manage()
	97	+ try:
	98	+ break_manager.set_worker(Robot())
	99	+ break_manager.lunch_break()
	100	+ except:
	101	+ pass
	102	+
	103	+if __name__ == '__main__':
	104	+ main()
	105	+

8081292

python_code/good/__init__.pyc (Binary) (deleted)

--- python_code/good/__init__.pyc

Binary file is not shown

Add a comment

Open 0
Closed 0

List

...	...	@@ -14,7 +14,9 @@
14	14	- [Circle-Ellipse Problem](https://en.wikipedia.org/wiki/Circle-ellipse_problem)
15	15	- Moral of the story: model your classes based on behaviours not on properties; model your data based on properties and not on behaviours. If it behaves like a duck, it's certainly a bird.
16	16	- This strongly suggests that inheritance should never be used when the sub-class restricts the freedom implicit in the base class, but should only be used when the sub-class adds extra detail to the concept represented by the base class as in 'Monkey' is-an 'Animal'.
17		- - `I`:
	17	+ - `I`: Interface Segregation Principle
	18	+ - [link](http://www.oodesign.com/dependency-inversion-principle.html)
	19	+ - [Wiki](https://en.wikipedia.org/wiki/Interface_segregation_principle)
18	20	- `D`:
19	21
20	22	## Other Interesting Articles

Delete comment