Programming Languages and Techniques II Unit 2 ReviewClass Design & Inheritance Fundamentals

Key Concepts

• Classes are user-defined data types that encapsulate data and behavior into a single unit
• Objects are instances of a class that have their own unique state and can perform actions defined by the class
• Inheritance enables the creation of hierarchical relationships between classes, allowing for code reuse and specialization
• Polymorphism allows objects of different classes to be treated as instances of a common superclass or interface
• Encapsulation hides the internal details of a class and provides a controlled interface for interacting with its data and behavior
• Abstraction focuses on defining essential characteristics and behavior of objects while ignoring implementation details
• Modularity involves breaking down a complex system into smaller, more manageable and reusable components (classes)
• Coupling refers to the degree of interdependence between classes, with loose coupling being desirable for maintainability and flexibility

Class Basics

• A class is a blueprint or template that defines the structure and behavior of objects
• Classes consist of data members (fields or attributes) that represent the state of an object and member functions (methods) that define its behavior
• Access modifiers (public, private, protected) control the visibility and accessibility of class members
• Constructors are special methods used to initialize objects when they are created, ensuring they start in a valid state
• Destructors are methods that are automatically called when an object is destroyed, allowing for cleanup and resource deallocation
• The this keyword refers to the current instance of a class within its own methods, allowing access to its data members
• Static members (fields and methods) belong to the class itself rather than individual instances and can be accessed without creating an object

Inheritance Fundamentals

• Inheritance is a mechanism that allows a class to inherit properties and behavior from another class, promoting code reuse and extensibility
• A derived class (subclass) inherits from a base class (superclass), inheriting its non-private data members and member functions
• Single inheritance involves a class inheriting from a single base class, forming a linear hierarchy
• Multiple inheritance allows a class to inherit from multiple base classes, combining their features (supported in languages like C++)
• Hierarchical inheritance occurs when multiple derived classes inherit from a single base class, forming a tree-like structure
• Override methods in the derived class to provide a specialized implementation that differs from the base class
• Call the base class constructor from the derived class constructor using the super keyword (Java) or the base class name (C++)

Polymorphism and Interfaces

• Polymorphism allows objects of different classes to be treated as instances of a common superclass or interface
• Method overriding enables derived classes to provide their own implementation of methods inherited from the base class
• Virtual methods in the base class can be overridden in derived classes, allowing for runtime polymorphism (dynamic dispatch)
• Interfaces define a contract specifying a set of methods that a class must implement, enabling polymorphism based on behavior
• Implement multiple interfaces in a class to achieve a form of multiple inheritance based on behavior rather than implementation
• Use the instanceof operator (Java) or dynamic_cast (C++) to check the actual type of an object at runtime
• Polymorphic references can refer to objects of the declared type or any of its derived types, enabling flexibility and extensibility

Design Principles

• The Open-Closed Principle (OCP) states that classes should be open for extension but closed for modification, promoting code reuse and maintainability
• The Liskov Substitution Principle (LSP) ensures that objects of a derived class can be substituted for objects of the base class without affecting program correctness
• The Dependency Inversion Principle (DIP) encourages depending on abstractions (interfaces) rather than concrete implementations, promoting loose coupling
• The Single Responsibility Principle (SRP) states that a class should have only one reason to change, focusing on a single responsibility or concern
• The Interface Segregation Principle (ISP) advises against creating large, monolithic interfaces and instead promotes smaller, more focused interfaces
• Composition over inheritance favors object composition (has-a relationship) over class inheritance (is-a relationship) for greater flexibility and reusability
• Favor abstract base classes or interfaces to define common behavior and promote polymorphism

Implementation Techniques

• Use access modifiers (public, private, protected) to control the visibility and encapsulation of class members
• Implement constructors to initialize objects with default or parameterized values, ensuring a valid initial state
• Utilize destructors to release resources (memory, file handles) when an object is destroyed, preventing resource leaks
• Override the toString() method (Java) or define the << operator (C++) to provide a string representation of an object for debugging and logging purposes
• Implement the equals() and hashCode() methods (Java) or the == and != operators (C++) to define equality comparison between objects
• Use the final keyword (Java) or const (C++) to create immutable classes or prevent method overriding in derived classes
• Employ the abstract keyword to define abstract classes and methods that must be implemented by derived classes
• Utilize the interface keyword to define contracts specifying a set of methods that a class must implement

Common Pitfalls

• Avoid deep inheritance hierarchies that can lead to complexity, fragility, and the "yo-yo problem" (navigating up and down the hierarchy)
• Be cautious of the "diamond problem" in multiple inheritance, where a class inherits from two or more classes that have a common ancestor
• Prevent object slicing when assigning a derived class object to a base class reference, which can lead to loss of derived class-specific data and behavior
• Be mindful of the order of constructor and destructor calls in inheritance hierarchies to ensure proper initialization and cleanup
• Avoid tightly coupling classes, as it reduces flexibility, reusability, and maintainability of the codebase
• Prevent naming conflicts between base class and derived class members by using appropriate access modifiers and naming conventions
• Be cautious of overriding non-virtual methods in derived classes, as it can lead to unexpected behavior and violate the Liskov Substitution Principle

Practical Applications

• Use inheritance to model real-world hierarchical relationships (Animal -> Mammal -> Dog) and promote code reuse
• Implement polymorphism to write generic algorithms that can operate on objects of different classes through a common interface (Shape -> Circle, Rectangle)
• Apply the Template Method pattern to define the skeleton of an algorithm in a base class and allow derived classes to fill in the details
• Utilize the Strategy pattern to encapsulate interchangeable algorithms or behaviors into separate classes and enable dynamic selection at runtime
• Employ the Decorator pattern to add new responsibilities to objects dynamically by wrapping them in decorator classes
• Use the Composite pattern to treat individual objects and compositions of objects uniformly, forming a tree-like structure (GUI components)
• Implement the Observer pattern to establish a one-to-many dependency between objects, allowing observers to be notified automatically of state changes in the subject