SOLID principles

Question 1

What is the DRY principle?

Answer 1

DRY (Do not Repeat Yourself)
- avoid duplication: a piece of data has a single value stored on the system. Don’t want to store duplicated data
- centralise logic to make it easier to update/test/understand
- write concise, reusable code, this saves time

Question 2

What are some violations of the DRY principle?

Answer 2

• storing repeated data across db tables
• storing derived data across db tables
• storing same data at client and server

Question 3

What are the 5 SOLID principles?

Answer 3

1) Single Responsibility
2) Open Closed principle
3) Liskov substitution principle
4) interface segregation principle
5) Dependency inversion principle

Question 4

What do the SOLID principles help do?

Answer 4

They are design principles for creating OO code code that is likely to have less problems with rigidity, fragility, immobility and viscosity

Question 5

Explain the first principle of the SOLID principles:

Answer 5

Single responsibility: a class should only have one responsibility
- why? if it has multiple, changes to one responsibility could impact the other

Question 6

When detecting a breach of the single responsibility principle, what should you look for:

Answer 6

When a class is handling multiple things:
e.g the word processor class is responsible for saving a document, loading a document and spell checking a document, these should be separated into a SpellChecker class and a fileHandler class

Question 7

What are the benefits of single responsibility?

Answer 7

• Reduces coupling
• easier to test, understand and maintain code
• improves code reusability
• several developers can work on coding classes simultaneously (due to low coupling)

Question 8

What is the Open Closed principle:

Answer 8

Classes are 1) open for extension and 2) closed for modification
- why? you should be able to add new functionality to a class without altering it’s existing code

Question 9

How is the open closed principle achieved?

Answer 9

Through abstraction, abstract classes and interfaces, and dynamic or static polymorphism
(inheritance and overriding methods)
- Use the word final in constructors/method definitions

Question 10

When detecting a breach of the open closed principle, what should you look for:

Answer 10

class DiscountCalculator:
def calculate_discount(self, customer_type, amount):
if customer_type == “Regular”:
return amount * 0.05
elif customer_type == “Premium”:
return amount * 0.10
elif customer_type == “VIP”:
return amount * 0.20
else:
return 0

Having if, elif, elif and else that all return different values
- if a new customer_type needs to be added another elif statement is added, this violated the OC principle, because the class should just be extended to add another customer type

Question 11

What are the benefits of the open closed principle?

Answer 11

• ## The current code base is kept stable and bug free but allows it to be used for future code development

Question 12

What does the final keyword mean?

Answer 12

That a method or class can’t be overridden

Question 13

What would be the structure for a correct implementation of the open closed principle:

Answer 13

• public interface IcardProvider {
  public boolean makePayment(string number)
  }
• public class cardProviderBase implements IcardProvider { //closed for modification
  public final boolean makePayment(string number) {
  return number }
  }
  protected boolean onMakePayment(String number) { //open for extension
  return(false)
  }
  }
• public class natwestCardProvider extends CardProviderBase{
  protected boolean
  onMakePayment(String number) {
  return(true);}
  }

Question 14

What are signs that the open closed principle has been breached?

Answer 14

• Adding new if/elif conditions to existing methods to handle new cases.
• Modifying existing classes to add new functionality instead of creating new classes or methods.

Question 15

What is the Liskov substitution principle:

Answer 15

Classes must be substitutable for their bases classes
- why: subclasses should adhere to the behaviour expected of their parent class

Question 16

What are the benefits of the liskov principle?

Answer 16

• prevents unexpected behavior in inheritance hierarchies
• improves code reliability

Question 17

When detecting a breach of the liskov substitution principle, what should you look for:

Answer 17

A subclass that doesn’t have the method of a superclass or doesn’t make use of that method.

e.g. a Class Bird has method fly() is extended by Class Penguin which can’t fly

Question 18

How can a class the breaches the liskov substitution principle be fixed?

Answer 18

By having the subclass match the superclasses methods or by splitting the superclass into more classes with differing functionality and having the subclass inherit from the correct one

e.g. Class bird should become classes flyingBird and nonFlyingBird and class penguin should then inherit from nonFlyingBird which won’t have method fly()

Question 19

What is the Interface segregation principle:

Answer 19

a class should not be forced to implement interfaces it doesn’t use
- because interfaces should be small and specific to avoid classes implementing unnecessary methods

Question 20

When detecting a breach of the interface segregation principle, what should you look for:

Answer 20

An interface with lots of methods, and a class implementing the interface and defining the method though it’s irrelevant

e.g a Bird interface having method fly() and a penguin class defining fly when it can’t fly

Question 21

What are the benefits of the interface segregation principle?

Answer 21

• low coupling
• codes is more flexible
• makes classes easier to understand and implement

Question 22

How can a bad implementation of the interface segregation principle be fixed?

Answer 22

Splitting a large interface into two or more smaller interfaces, so base classes that implement the interface actually require all the methods they need to define

e.g. split Bird interface into nonflyingBird interface with methods eat() and flyingBird interface with methods eat() and fly()

Question 23

What is the dependency inversion principle:

Answer 23

• high level modules should not depend on low level modules.
• Both should depend on details
• details should depend on abstractions
  why: means low and high level modules will communicate through interfaces/abstract classes instead of concrete implementation
• if low level modules change, it won’t break high level modules

Question 24

What are the benefits of dependency inversion principle?

Answer 24

• increases flexibility
• easier to test
• reduces coupling/dependency issues

Question 25

What should a bad implementation of the dependency

Answer 25

• Instead of a DatabaseService class directly depending on a MySQLDatabase
• it should depend on an interface like Database.
• This allows switching to another database with minimal changes.

Question 26

What is polymorphism?

Answer 26

It allows objects of different types to be treated as instances of the same class through a common interface

Question 27

What is dynamic polymorphism?

Answer 27

• achieved by method overriding
• in method override a subclass provides it’s own implementation of a method that’s defined in the superclass
• if a method is final it can’t be overridden in the subclass
• resolved at runtime
• open closed principle

Question 28

What is static polymorphism?

Answer 28

• resolved at compile time
• achieved through method overloading
• in method overloading, classes have multiple methods with the same name but different parameter types or counts
• the complier determines which method is used
• open closed principle

Question 29

What are generics?

Answer 29

• Allow you to write code without defining the object type being accessed
• when the code is compiled it uses the ‘object’ type instead of the unknown type

Question 30

What is type erasure?

Answer 30

Removing the type of a generic class when it compiles, and replacing it with the object type
- then at runtime it replaces the object type with the type of the instance called

Question 31

What do the first 3 principles of SOLID focus on and what do the last 2 principles focus on?

Answer 31

• The first 3 principles focus on designing code to stop things going wrong
• the last 2 principles focus on designing code well

Question 32

What is design by contract?

Answer 32

• methods have a contract which is checked. For each method you state things that must be true before that method is allowed to be called, and when that method is returned.
• use keyword assert to say you want / expect something to be the case, e.g. you want the type to be equal to something or the value of a variable to equal something

Question 33

What is the top down approach structure for OO design:

Answer 33

Interface
|
abstract sub class
| |
concrete class concrete class