Object-Oriented Programming and Design

  1. Key Language Constructs and Concepts
    1. Constructors
      1. Object Initialization
        1. Purpose of Constructors
        2. Default Constructors
          1. Automatic Generation
          2. Parameterized Constructors
            1. Custom Initialization
            2. Copy Constructors
              1. Cloning Objects
                1. Deep vs Shallow Copy
              2. Destructors and Finalizers
                1. Object Cleanup and Resource Deallocation
                  1. Destructor Syntax and Usage
                    1. Finalization in Garbage-Collected Languages
                      1. Resource Management Patterns
                    2. This or Self Reference
                      1. Reference to Current Object Instance
                        1. Accessing Instance Members
                          1. Disambiguating Variable Names
                        2. Static vs Instance Members
                          1. Static Members
                            1. Class-Level Variables and Methods
                              1. Shared Data and Behavior
                                1. Static Initialization Blocks
                                2. Instance Members
                                  1. Object-Level Variables and Methods
                                    1. Unique Data per Object
                                  2. Abstract Classes
                                    1. Purpose and Use Cases
                                      1. When to Use Abstract Classes
                                      2. Abstract Methods
                                        1. Declaration and Implementation
                                        2. Instantiation Restrictions
                                          1. Abstract Class Limitations
                                        3. Interfaces
                                          1. Pure Abstraction
                                            1. Defining Method Signatures Only
                                            2. Defining Contracts
                                              1. Enforcing Implementation in Subclasses
                                              2. Implementing Interfaces
                                                1. Multiple Interface Implementation
                                                2. Interface vs Abstract Class
                                                  1. Key Differences and Use Cases

                                              Previous

                                              3. The Four Pillars of OOP

                                              Go to top

                                              Next

                                              5. Relationships Between Classes