SOLID Principles

S.O.L.I.D is an acronym for the first five object-oriented design(OOD)** principles** by Robert C. Martin, popularly known as Uncle Bob.

These principles, when combined together, make it easy for a programmer to develop software that is easy to maintain and extend. They also make it easy for developers to avoid code smells, easily refactor code, and are also a part of the agile or adaptive software development.

Transcript

1. SOLID Principles @xsahil03x
2. S.O.L.I.D is an acronym for the first five object-oriented design(OOD)** principles** by Robert C. Martin, popularly known as Uncle Bob. These principles, when combined together, make it easy for a programmer to develop software that is easy to maintain and extend. They also make it easy for developers to avoid code smells, easily refactor code, and are also a part of the agile or adaptive software development.
3. S.O.L.I.D. STANDS FOR: S - Single responsibility principle O - Open closed principle L - Liskov substitution principle I - Interface segregation principle D - Dependency Inversion principle
4. # Single-responsibility Principle A class should have one and only one reason to change, meaning that a class should have only one job.
5. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); }
6. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); User getUser() => DB.getUser(this.id); void saveUser() => DB.saveUser(this); }
7. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); User getUser() => DB.getUser(this.id); void saveUser() => DB.saveUser(this); } Oops due to change in requirements, we have to change our DB.
8. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); User getUser() => DB.getUser(this.id); void saveUser() => DB.saveUser(this); }
9. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); }
10. class User { final int id; final String name; final int age; User(this.id, this.name, this.age); } class UserRepository { User getUser(int id) => DB.getUser(id); void saveUser(User user) => DB.saveUser(user); }
11. # Open-closed Principle Objects or entities should be open for extension, but closed for modification.
12. class Burger { void prepareBurger() { print(‘Preparing Burger); } void addCheese() { print('Adding Chesse'); } }
13. class Burger { final String customerName; Burger(this.customerName); void prepareBurger() => print(‘Preparing Burger); void addCheese() { If (customerName == ‘Amit’) print('Adding Chesse'); else print(‘Cheese not needed’); } }
14. class Burger { final String customerName; Burger(this.customerName); void prepareBurger() => print(‘Preparing Burger); void addCheese() { If (customerName == ‘Amit’) print('Adding Chesse'); If (customerName == ‘Sahil’’) print('Adding extra Chesse'); else print(‘Cheese not needed’); }
15. class Burger { final String customerName; Burger(this.customerName); void prepareBurger() => print(‘Preparing Burger); void addCheese() { If (customerName == ‘Amit’) print('Adding Chesse'); If (customerName == ‘Sahil’’) print('Adding extra Chesse'); else print(‘Cheese not needed’); } We have to add another condition everytime a new customer requests a burger
16. class Burger { void prepareBurger() { print(‘Preparing Burger’); } void addCheese() { print('Adding Chesse'); } }
17. abstract class Burger { void prepareBurger() { print(‘Preparing Burger’); } void addCheese() { print('Adding Chesse'); } }
18. class AmitBurger extends Burger{ @override void addCheese() { print("Adding extra cheese for amit"); } }
19. class AmitBurger extends Burger{ @override void addCheese() { print("Adding extra cheese for amit"); } } class SahilBurger extends Burger{ @override void addCheese() { print("Adding cheese for sahil"); } }
20. # Liskov substitution principle Let q(x) be a property provable about objects of x of type T. Then q(y) should be provable for objects y of type S where S is a subtype of T.
21. # Liskov substitution principle Let q(x) be a property provable about objects of x of type T. Then q(y) should be provable for objects y of type S where S is a subtype of T. More generally it states that the object of a derived class should be able to replace an object of the base class without bringing any errors in the system or modifying the behavior of the base class"
22. class TransportationDevice { final String name; final double speed; TransportationDevice(this.name, this.speed); void startEngine() => print('Starting engine of $name'); }
23. class Car extends TransportationDevice { Car(String name, double speed, this.engine) : super(name, speed); @override void startEngine() { } }
24. class Car extends TransportationDevice { final Engine engine; Car(String name, double speed, this.engine) : super(name, speed); @override void startEngine() { } }
25. class Car extends TransportationDevice { final Engine engine; Car(String name, double speed, this.engine) : super(name, speed); @override void startEngine() { engine.start(); } }
26. class Bicycle extends TransportationDevice { Bicycle(String name, double speed) : super(name, speed); @override void startEngine() { } }
27. class Bicycle extends TransportationDevice { // Engine…. What’s that ? Bicycle(String name, double speed) : super(name, speed); @override void startEngine() { // Cannot start an engine in Bicycle } }
28. class TransportationDevice { final String name; final double speed; TransportationDevice(this.name, this.speed); void startEngine() => print('Starting engine of $name'); }
29. class TransportationDevice { final String name; final double speed; TransportationDevice(this.name, this.speed); }
30. class DevicesWithEngines extends TransportationDevice { final Engine engine; DevicesWithEngines(String name, double speed,this.engine) : super(name,speed); void startEngine() { ... } }
31. class DevicesWithEngines extends TransportationDevice { final Engine engine; DevicesWithEngines(String name, double speed,this.engine) : super(name,speed); void startEngine() { ... } } class DevicesWithoutEngines extends TransportationDevice { DevicesWithoutEngines(String name, double speed,this.engine) : super(name,speed); void startMoving() { ... } }
32. # Interface segregation principle A client should never be forced to implement an interface that it doesn’t use or clients shouldn’t be forced to depend on methods they do not use.
33. class RestaurantEmployee { final String name; final String designation; final double salary; RestaurantEmployee(this.name, this.designation, this.salary); }
34. class Chef extends RestaurantEmployee { Chef(String name, String designation, double salary) : super(name, designation, salary); }
35. class Chef extends RestaurantEmployee { Chef(String name, String designation, double salary) : super(name, designation, salary); } class Waiter extends RestaurantEmployee { Waiter(String name, String designation, double salary) : super(name, designation, salary); }
36. abstract class IEmployeeTasks { void takeOrder(); void cookFood(); }
37. class Chef extends RestaurantEmployee { Chef(String name, String designation, double salary) : super(name, designation, salary); }
38. class Chef extends RestaurantEmployee implements IEmployeeTasks { Chef(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} }
39. class Chef extends RestaurantEmployee implements IEmployeeTasks { Chef(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} } Hey, I can’t take orders
40. class Waiter extends RestaurantEmployee { Waiter(String name, String designation, double salary) : super(name, designation, salary); }
41. class Waiter extends RestaurantEmployee implements IEmployeeTasks { Waiter(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} }
42. class Waiter extends RestaurantEmployee implements IEmployeeTasks { Waiter(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} } Hey, If i can cook i won’t be working here as a waiter
43. abstract class IEmployeeTasks { void takeOrder(); void cookFood(); }
44. abstract class IEmployeeTasks { void takeOrder(); void cookFood(); } abstract class IChefTasks{ void cookFood(); }
45. abstract class IEmployeeTasks { void takeOrder(); void cookFood(); } abstract class IChefTasks{ void cookFood(); } abstract class IWaiterTasks{ void takeOrder(); }
46. class Chef extends RestaurantEmployee implements IEmployeeTasks { Chef(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} }
47. class Chef extends RestaurantEmployee implements IChefTasks{ Chef(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} }
48. class Waiter extends RestaurantEmployee implements IEmployeeTasks { Waiter(String name, String designation, double salary) : super(name, designation, salary); @override void cookFood() {} @override void takeOrder() {} }
49. class Waiter extends RestaurantEmployee implements IWaiterTasks{ Waiter(String name, String designation, double salary) : super(name, designation, salary); @override void takeOrder() {} }
50. # Dependency inversion principle • High-level modules should not depend on low-level modules. Both should depend on abstractions. • Abstractions should not depend on details. Details should depend on abstractions.
51. class VegChef { Food getFood(Order order) { print('Preparing Veg Food'); return Food(order.orderName); } }
52. class Waiter { VegChef _chef = VegChef(); final Order order; Waiter(this.order); void serveOrder() { final orderName = _chef.getFood(order).name; print("Serving $orderName to the customer"); } }
53. class VegChef { Food getFood(Order order) { print('Preparing Veg Food'); return Food(order.orderName); } }
54. class NonVegChef { Food getFood(Order order) { print('Preparing NonVeg Food'); return Food(order.orderName); } }
55. class Waiter { VegChef _chef = VegChef(); final Order order; Waiter(this.order); void serveOrder() { final orderName = _chef.getFood(order).name; print("Serving $orderName to the customer"); } }
56. class Waiter { NonVegChef _chef = NonVegChef(); final Order order; Waiter(this.order); void serveOrder() { final orderName = _chef.getFood(order).name; print("Serving $orderName to the customer"); } }
57. abstract class Chef { Food getFood(Order order); }
58. class NonVegChef { Food getFood(Order order) { print('Preparing NonVeg Food'); return Food(order.orderName); } }
59. class NonVegChef implements Chef { @override Food getFood(Order order) { print('Preparing NonVeg Food'); return Food(order.orderName); } }
60. class VegChef { Food getFood(Order order) { print('Preparing Veg Food'); return Food(order.orderName); } }
61. class VegChef implements Chef { @override Food getFood(Order order) { print('Preparing Veg Food'); return Food(order.orderName); } }
62. class Waiter { VegChef _chef = VegChef(); final Order _order; Waiter(this._order); void serveOrder() { final orderName = _chef.getFood(_order).name; print("Serving $orderName to the customer"); } }
63. class Waiter { final Chef _chef; final Order _order; Waiter(this._order, this._chef); void serveOrder() { final orderName = _chef.getFood(_order).name; print("Serving $orderName to the customer"); } }
64. Thank You.