Impact of Program Design - AP Computer Science A

Ability of different classes to be treated as instances of the same class. Enables method overriding and dynamic method dispatch at runtime.

Modularity. Breaking programs into independent, manageable components.

To initialize the object's state when it is created. Sets up initial values and prepares object for use.

Provides proven solutions to common design problems. Reusable templates that reduce development time and errors.

Hiding complex realities while exposing only essential parts. Simplifies interfaces by focusing on what matters to users.

Makes the system harder to change and maintain. High interdependence creates fragile, inflexible systems.

To enhance code readability and understanding. Documentation helps future developers understand design decisions.

Decreases code readability and maintainability. Hard-coded values make code difficult to modify.

Promotes code reuse by allowing new classes to inherit properties. Saves development time by building upon existing class functionality.

Polymorphism. Same interface handles different object types appropriately.

Increases the module’s maintainability and understandability. Elements work together toward a single, well-defined purpose.

Limits the ability to efficiently handle growth and changes. Poor architecture creates bottlenecks and performance issues.

Increases the risk of unintended side effects. Shared state creates unpredictable program behavior.

To hide the internal state and require all interaction through methods. Data hiding ensures controlled access and maintains object integrity.

Provides proven solutions to common design problems. Reusable templates that reduce development time and errors.

Hiding complex realities while exposing only essential parts. Simplifies interfaces by focusing on what matters to users.

Makes the system harder to change and maintain. High interdependence creates fragile, inflexible systems.

To define a contract that classes can implement. Ensures consistent behavior across implementing classes.

Allows multiple inheritance of type. Supports multiple inheritance without implementation conflicts.

The system is difficult to understand, maintain, and extend. Components are tightly coupled and poorly organized.

Ability of different classes to be treated as instances of the same class. Enables method overriding and dynamic method dispatch at runtime.

Modularity. Breaking programs into independent, manageable components.

Reduces dependency and increases module independence. Modules can be modified independently without affecting others.

To initialize the object's state when it is created. Sets up initial values and prepares object for use.

Improves code structure and readability without changing behavior. Continuous improvement keeps code clean and efficient.

Increases maintenance effort and error potential. Duplicate code multiplies bugs and maintenance work.

Enhances thread safety and reduces bugs. Unchangeable objects prevent accidental state modification.

Encapsulation. Public access to internals breaks data hiding.

Increases flexibility and reusability of code. Clear contracts enable modular, interchangeable components.