csci 363 midterm review

Single Responsibility Principle (SRP)

A class should have only one reason to change.

Open/Closed Principle (OCP)

Classes should be open for extension but closed for modification.

Liskov Substitution Principle (LSP)

Subtypes must be substitutable for their base types.

Interface Segregation Principle (ISP)

A class should not be forced to implement interfaces it doesn’t use.

Dependency Inversion Principle (DIP)

High-level modules should depend on abstractions, not concrete implementations.

Encapsulation

Restricting direct access to object data while exposing necessary parts.

Inheritance

Uses 'is-a' relationships.

Composition

Uses 'has-a' relationships.

Abstraction

Hiding implementation details while exposing only essential functionality.

Singleton pattern

Ensures only one instance of a class exists.

Factory Method pattern

Encapsulates object creation, letting subclasses decide which class to instantiate.

Abstract Factory pattern

Creates families of related objects without specifying concrete classes.

Builder pattern

Separates object construction from representation by building it step by step.

Adapter pattern

Converts one interface into another to make incompatible systems work together.

Bridge pattern

Separates abstraction from implementation.

Flyweight pattern

Shares objects to reduce memory usage.

Strategy pattern

Encapsulates multiple interchangeable behaviors.

Observer pattern

Defines a dependency where multiple objects listen and react to changes in a subject.

Command pattern

Encapsulates a request as an object, allowing parameterization, queuing, and logging.

State pattern

Allows an object to change behavior when its internal state changes.

Chain of Responsibility pattern

Passes a request through a chain of handlers until one processes it.

Strategy vs State patterns

Strategy lets the client choose the behavior; State changes behavior based on internal state.

When to use Observer pattern

When multiple objects need to react to state changes in a subject.

Chain of Responsibility pattern flexibility

Requests are passed through multiple handlers, allowing different handlers to process them dynamically.

Builder pattern benefits

Helps construct complex objects while keeping the creation process flexible.

When to use Adapter pattern

When you need to make an existing class compatible with another interface.

Fixing Singleton thread safety

Use synchronized getInstance() or double-checked locking.

Primary benefit of the Bridge pattern

Decouples abstraction from implementation.

How Command pattern aids in undo/redo

Commands can be stored in a history log, allowing undo and redo operations.

Flyweight pattern drawback

Managing shared state can be complex.

Factory Method and Open/Closed Principle

New types can be added without modifying existing code.

Observer pattern coupling

Subjects and observers are loosely coupled.

Tight vs Loose coupling

Tight coupling makes changes harder, while loose coupling improves flexibility.

High cohesion

A class focuses on a single responsibility, making it easier to maintain.

Low cohesion

A class has multiple unrelated behaviors, making it difficult to maintain.

Aggregation vs Composition

Aggregation is a weak relationship; composition is a strong relationship where the contained object cannot exist independently.

Composition preference over inheritance

It avoids deep inheritance hierarchies and helps achieve loose coupling.