SOLID etc

Question 1

5 SOLID principles?

Answer 1

1. Single responsibility principle
2. Open-closed principle
3. Liskov substitution principle
4. Interface segregation principle
5. Dependency inversion principle

Question 2

Single Responsibility Principle?

Answer 2

Each class, module, or function in your program should only do one job.

Question 3

4 Principles of OOP?

Answer 3

1. Abstraction
2. Polymorphism
3. Inheritance
4. Encapsulation

Question 4

Static Polymorphism?

Answer 4

The compiler identifies which method to call based on the parameters provided.

Question 5

Dynamic Polymorphism?

Answer 5

• the subclass can override a method in the parent class that shares its name and parameters and provide a different functionality
• a subclass can be referenced as the superclass

Question 6

Inner join?

Answer 6

Selects records that have matching values in both tables.

Question 7

Outer join?

Answer 7

Returns all records when there is a match in left (table1) or right (table2) table records.

Question 8

Left join?

Answer 8

Returns all records from the left table (table1), and the matching records from the right table (table2)

Question 9

Open-closed Principle?

Answer 9

“Software entities … should be open for extension, but closed for modification.”

Entities should be able to be widely adapted but also remain unchanged.

Question 10

Liskov Substitution Principle?

Answer 10

“Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.”

In other words, each subclass must maintain all behavior from the base class along with any new behaviors unique to the subclass. The child class must be able to process all the same requests and complete all the same tasks as its parent class.

Question 11

Interface Segregation Principle?

Answer 11

“Many client-specific interfaces are better than one general-purpose interface.”

The interface segregation principle (ISP) requires that classes only be able to perform behaviors that are useful to achieve its end functionality. In other words, classes do not include behaviors they do not use.

Question 12

Dependency Inversion Principle?

Answer 12

“One should depend upon abstractions, [not] concretions.”

High-level modules should not depend on low-level modules. Instead, both should depend on abstractions (interfaces)
Abstractions should not depend on details. Details (like concrete implementations) should depend on abstractions.

Question 13

Encapsulation?

Answer 13

Encapsulation is the mechanism of hiding of data implementation by restricting access to public methods.

Instance variables are kept private and accessor methods are made public to achieve this.

Question 14

Abstraction?

Answer 14

Abstract means a concept or an Idea which is not associated with any particular instance.

Using abstract class/Interface we express the intent of the class rather than the actual implementation.

Question 15

Composition?

Answer 15

Design technique that implements a “has-a” relationship in classes (as opposed to an “is-a” relationship as in inheritance)

benefit - allows you to reuse code without modeling an is-a association, as one does with inheritance. This allows stronger encapsulation and makes your code easier to maintain.

a car is not an engine - it has one. a coffee machine has a grinder and a brewing unit, but it is neither.

ex: could have an “engine” class, then a “car” class. the car class could instantiate an engine object, then use

public Car(){
    this.engine=new Engine();
    engine.setMpg(30);
}

to change that engine’s miles per gallon

Question 16

Inheritance?

Answer 16

Inheritances expresses “is-a” and/or “has-a” relationship between two objects. Using Inheritance, In derived classes we can reuse the code of existing super classes.

Question 17

Polymorphism?

Answer 17

It means one name many forms. We can write a code that works on the superclass, and it will work with any subclass type as well.