Java Programming

  1. Object-Oriented Programming (OOP) in Java
    1. Core OOP Concepts
      1. Encapsulation
        1. Data Hiding
          1. Accessors and Mutators (Getters and Setters)
          2. Inheritance
            1. Code Reuse
              1. IS-A Relationship
              2. Polymorphism
                1. Method Overriding
                  1. Dynamic Method Dispatch
                  2. Abstraction
                    1. Abstract Classes
                      1. Interfaces
                    2. Classes and Objects
                      1. Defining a Class
                        1. Class Syntax
                          1. Class Members
                          2. Fields (Instance Variables)
                            1. Declaration and Initialization
                              1. Access Modifiers
                              2. Methods (Instance Methods)
                                1. Method Declaration
                                  1. Method Invocation
                                  2. Creating Objects (Instantiation)
                                    1. Using the new Keyword
                                      1. Reference Variables
                                      2. The new Keyword
                                        1. Memory Allocation
                                      3. Constructors
                                        1. Purpose of Constructors
                                          1. Default Constructor
                                            1. Parameterized Constructors
                                              1. Constructor Overloading
                                                1. The this Keyword
                                                  1. Referring to Current Object
                                                    1. Constructor Chaining
                                                  2. Methods in Depth
                                                    1. Method Signature
                                                      1. Name, Parameters, Return Type
                                                      2. Method Overloading
                                                        1. Rules for Overloading
                                                        2. Passing Arguments
                                                          1. Pass-by-Value Semantics
                                                            1. Effects on Primitives and References
                                                            2. Returning Values
                                                              1. Return Types
                                                                1. Void Methods
                                                              2. Access Modifiers
                                                                1. public
                                                                  1. Accessibility
                                                                  2. protected
                                                                    1. Package and Subclass Access
                                                                    2. private
                                                                      1. Encapsulation
                                                                      2. Default (Package-Private)
                                                                        1. No Modifier
                                                                      3. Static Members
                                                                        1. The static Keyword
                                                                          1. Static Variables (Class Variables)
                                                                            1. Static Methods
                                                                              1. Static Blocks
                                                                                1. Static Import
                                                                                2. Inheritance (extends)
                                                                                  1. Superclass and Subclass Relationships
                                                                                    1. The super Keyword
                                                                                      1. Accessing Superclass Members
                                                                                        1. Invoking Superclass Constructors
                                                                                        2. Method Overriding
                                                                                          1. Rules and Annotations
                                                                                          2. The @Override Annotation
                                                                                            1. The final Keyword
                                                                                              1. Final Classes
                                                                                                1. Final Methods
                                                                                                  1. Final Variables (Constants)
                                                                                                2. Polymorphism
                                                                                                  1. Runtime Polymorphism
                                                                                                    1. Dynamic Method Dispatch
                                                                                                    2. The instanceof Operator
                                                                                                      1. Type Checking
                                                                                                    3. Abstraction
                                                                                                      1. Abstract Classes
                                                                                                        1. Abstract Methods
                                                                                                          1. Instantiation Rules
                                                                                                          2. Abstract Methods
                                                                                                            1. Declaration and Implementation
                                                                                                          3. Interfaces
                                                                                                            1. Defining Interfaces
                                                                                                              1. Syntax and Structure
                                                                                                              2. Implementing Interfaces
                                                                                                                1. Multiple Interface Implementation
                                                                                                                2. Default Methods in Interfaces
                                                                                                                  1. Static Methods in Interfaces
                                                                                                                    1. Marker Interfaces
                                                                                                                      1. Purpose and Examples
                                                                                                                      2. Functional Interfaces
                                                                                                                        1. Single Abstract Method
                                                                                                                          1. Use with Lambdas
                                                                                                                        2. Nested and Inner Classes
                                                                                                                          1. Member Inner Class
                                                                                                                            1. Accessing Outer Class Members
                                                                                                                            2. Static Nested Class
                                                                                                                              1. Static Context
                                                                                                                              2. Local Inner Class
                                                                                                                                1. Scope and Usage
                                                                                                                                2. Anonymous Inner Class
                                                                                                                                  1. Instantiation and Use Cases
                                                                                                                                3. The Object Class
                                                                                                                                  1. Overview and Importance
                                                                                                                                    1. equals() Method
                                                                                                                                      1. Equality Comparison
                                                                                                                                      2. hashCode() Method
                                                                                                                                        1. Hashing and Collections
                                                                                                                                        2. toString() Method
                                                                                                                                          1. String Representation
                                                                                                                                          2. clone() Method
                                                                                                                                            1. Object Cloning
                                                                                                                                            2. getClass() Method
                                                                                                                                              1. Runtime Type Information

                                                                                                                                          Previous

                                                                                                                                          2. Core Language Fundamentals

                                                                                                                                          Go to top

                                                                                                                                          Next

                                                                                                                                          4. Exception Handling