This is one of the basic principles most developers apply to build robust and maintainable software. This suggests that each software module, class, or interface should have only one (1) reason to change

S: Single Responsibility Principle (SRP)

This states that for a software to be easy to change, the software classes must be designed to allow the behavior of those classes to be changed by adding new code rather than changing existing code.

O: Open-Closed Principle (OCP)

Barbara Liskov introduced this principle which states that the derived classes should be substitutable for their base classes to build a software from interchangeable modules or classes.

L: Liskov Substitution Principle (LSP)

This principle advises software designers to avoid depending on things that they don’t use.

I: Interface Segregation Principle (ISP)

This principle suggests that flexible software are those with classes that depend on abstract classes or interfaces.

D: Dependency Inversion Principle (DIP)

Which of the following is TRUE about the help the developers will achieve using SOLID Principle

Reduce the complexity of source codes, Increase readability, extensibility, and maintenance, Reduce accidental errors and implement reusability easily, Achieve easier and better software testing

Which of the Following is NOT TRUE about Single Responsibility Principle (SRP) ?

states that software modules, interfaces, or classes should be open for extension but closed for modification. This means that when there are new requirements for the software, the new behavior must be added by deriving a new class without modifying the existing class.

Which Statement is NOT TRUE About Open-Closed Principle (OCP)

suggests that when creating a new derived class of an existing class, make sure that the derived class can be a substitute for its base class.

Which statement is NOT TRUE about Liskov Substitution Principle (LSP)

suggests avoiding depending on things that are not used. This means that clients should not be forced to implement interfaces they don’t use.

Which statement is NOT TRUE about Interface Segregation Principle (ISP)

suggests that the most flexible software systems are those in which source code dependencies refer only to abstractions, not to concretions.

Which statement is NOT TRUE about Dependency Inversion Principle (DIP)

suggests that when creating a new derived class of an existing class, make sure that the derived class can be a substitute for its base class.

These are the reusable solutions to commonly occurring problems in software design.

Design Patterns

Which statement is FALSE about design patterns?

This is the name of a pattern that can be used to describe a design problem, its solution, and consequences.

Pattern Name

This describes when to use the pattern. It explains the problem and its context.

Problem

This describes the elements that make up the design, their relationships, responsibilities, and collaborations. The pattern provides an abstract description of a design problem and how a general arrangement of element solves it.

Solution

These are the results and interchanges of applying the pattern to the problem. They include time and space tradeoffs, but also flexibility, extensibility, and portability, among others.

Consequences

These patterns deal with when and how objects are created. These provide object creation mechanisms that increase flexibility and reuse of existing codes

Creational Patterns

These describe how objects are composed into larger groups and explain how to assemble objects and classes into larger structures while keeping their structures flexible and efficient.

Structural Patterns

These describe how responsibilities are distributed between objects in the design and how communication happens between objects.

Behavioral Patterns

This design pattern lets developers ensure that a class has only one (1) instance while providing a global access point to the instance.

Singleton Pattern

This provides an interface for creating objects in a superclass but allows subclasses to alter the type of object that will be created.

Factory Method Pattern

This creational design pattern lets a developer copy existing objects without making his code dependent on their classes.

Prototype Pattern

- This allows developers to produce families of related objects without specifying their concrete classes. - A family of objects that are usually used together or a set of objects that are dependent on each other in some way.

Abstract Factory Pattern

This creational design pattern allows developers to construct complex objects step by step. The pattern allows developers to produce different types and representations of an object using the same construction code.

Builder Pattern

Which statement is NOT TRUE about Creational Patterns?

These patterns deal with the arrangement and relationship between the classes in the software system.

Which statement is NOT TRUE about Structural patterns

These patterns are concerned with how classes and objects behave in a system software and how objects communicate with each other.

This structural design pattern allows objects with incompatible interfaces to collaborate. This pattern converts the interface of a class into another interface as expected by the client application.

Adapter Pattern

This allows the developers to split a large class or a set of closely related classes into two (2) separate hierarchies, which are abstraction and implementation, that can be developed independently of each other.

Bridge Pattern

This design pattern allows developers to compose objects into tree structures and then work with these structures treating them as individual objects.

Composite Pattern

This allows developers to attach new behaviors to objects by placing these objects inside special wrapper objects that contain the behaviors.

Decorator Pattern

This allows developers to fit more objects into the available amount of RAM by sharing common parts of state between multiple objects instead of keeping all of the data in each other.

Flyweight Pattern

This design pattern allows developers to provide a substitute or placeholder for another object. This controls access to the original object, allowing developers to perform something before or after the requests gets through to the original object.

Proxy Pattern

Which statement is NOT TRUE about Behavioral Patterns

These patterns deal with the arrangement and relationship between the classes in the software system

This design pattern allows developers to traverse elements of a collection without exposing its underlying representation, such as list, stack, and tree. This pattern is used for sequentially iterating and accessing items from a collection of items.

Iterator Pattern

This design pattern allows developers to define a subscription mechanism to notify multiple objects about any events that happen to the object they are observing. This means that when an object changes state, all of its dependents are notified and updated automatically.

Observer Pattern

This allows developers to define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.

Strategy Pattern

These are a set of guidelines to be followed that helps developers arrange methods and data structures into classes, and how those classes should be interconnected, which can adapt to the changes in requirements without major code rewrites.

Design principles