-
Notifications
You must be signed in to change notification settings - Fork 0
/
Classes.txt
65 lines (39 loc) · 2.25 KB
/
Classes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
Introduction
This chapter is about writing a clean code with the organized way using classes
Class Organization :
A class should start with Public variables
Then Privte variables
Then instance variables
Public functions should follow these list of variables
This gives the program read like a newspaper article
Encapsulation :
Losing encapsultaion is always a last resort even if we want a protected method to be accessed by
a test classes
Classes should be small :
Like funtions classes also should be small but like function we are not mentioning the small in
the line but a class must be small in its responsibility and the Name of the class should tell
us that what responsibility it fullfill.
The Single responsibility Principle :
This principle states that a class or module should have only one reason to change
We want our systems to be composed of many small classes, not a few large ones. Each small
class encapsulates a single responsibility, has a single reason to change, and collaborates
with a few others to achieve the desired system behaviors.
Cohesion :
A class should have small number of instane variables and all those variables should be used in
the methods of these classes
The maxium cohesion a method with variable is the maxium they are co-depended and logical
Maintaining Cohesion result in many small classes :
When a class loses cohesion ,split them
So breaking a larger functions into a smaller one also helps uss to create several small classes
as well
Organization for Change :
In a Clean system we organize our classes so as to reduce the changes
If we open a class and make changes in it we must retest them
Isolating from changes :
As long as the needs gets changed the code will also be changed as per needs
A Concreate class contains the implementation details
An abstract class only contains the concepts only
So making a change in a concreate class makes it risk
So we can crerate an interface or abstract classes to handle this changes
Dependency Inversion Principle states that our class should depend on an abstract not
concrete