Inheritance and Visibility Modifiers in Java

Classes and Objects

• A class defines a blueprint for creating objects.
• Inheritance is a mechanism for creating new classes based on existing ones.
• The original class is called a parent, superclass, or base class.
• The derived class is known as a child or subclass.
• Inheritance relationships are depicted with an arrow pointing to the parent class.
• Inheritance creates an "is-a" relationship.
• Inheritance promotes code reuse and reduces development time.
• The extends keyword establishes an inheritance relationship in Java.

Visibility Modifiers

• Visibility modifiers control access to class members.
• public: Accessible from anywhere.
• protected: Accessible within the same package and by subclasses in other packages.
• private: Accessible only within the defining class.

Inheritance & Relationships

• Siblings share the same parent class but are not derived from each other.
• Common features should be defined as high up in the class hierarchy as possible.
• Inheritance is transitive: Features are passed down through multiple levels of inheritance.

Interfaces

• An interface defines a contract for a class by specifying abstract methods and constants.
• Interfaces enforce specific behaviors on classes that implement them.
• The implements keyword allows a class to implement an interface.

Abstract Classes

• An abstract class cannot be instantiated.
• They serve as placeholders in a class hierarchy to represent generic concepts.

Polymorphism

• Polymorphism translates to "having many forms."
• It allows methods to be invoked in different ways based on the object type.
• Two types: Compile-time and runtime polymorphism.

Compile-time Polymorphism

• Achieved through method overloading.
• Occurs when multiple methods with the same name but different signatures (parameter lists) exist within the same class.

Runtime Polymorphism

• Achieved through method overriding.
• Occurs when a subclass provides its own implementation of a method inherited from its parent class.

Binding

• Binding connects a method call to its corresponding definition.
• Dynamic binding (late binding) occurs at runtime, allowing flexibility in method execution.

Interfaces & Polymorphism

• Interface references can refer to objects of any class that implements that interface.
• This further enhances polymorphism's capabilities.

Casting

• Used to convert object references to specific types.
• Employed when the compiler requires a certain type but a more general reference is available.

Sorting & Search Algorithms

• Sorting rearranges elements in a specific order.
• Searching involves finding a target element within a set of elements.

Selection Sort

• Works by repeatedly selecting the smallest unsorted element and swapping it with the element in its correct position.
• The algorithm iterates through the array, selecting the smallest element and placing it at the beginning of the unsorted portion.

Comparable Interface

• Provides a standardized way to compare objects.
• Defines the compareTo() method for comparing objects.

Insertion Sort

• Iteratively builds a sorted sublist by inserting each element into its correct position within the sorted portion.
• It picks an element and inserts it into its proper location in the sorted sublist, repeatedly until all elements are sorted.

Searching

• Linear search sequentially examines each element in the search pool until the target is found.
• Binary search works on sorted arrays.

Binary Search

• Efficiently searches sorted arrays by repeatedly halving the search interval.
• Starts at the middle element, compares it to the target, and eliminates half of the array based on the comparison.

Exceptions

• represent problems or unusual situations that may occur during program execution.
• Exceptions are objects that define an error.
• Errors represent unrecoverable situations.

Exception Throwing

• Exception throwing interrupts the normal flow of program execution.
• It occurs when a predefined condition or error arises.

Exception Handling

• The try-catch statement provides a mechanism to handle exceptions.
• The try block contains code that might throw an exception.
• The catch block catches and handles the exception.

Exception Propagation

• If an exception is not caught within a method, it propagates up the call stack until a suitable catch block is encountered.
• The throws clause in a method declaration specifies exceptions that may be thrown by the method.

Defining Custom Exceptions

• Create custom exception classes by extending the Exception class.

Checked Exceptions

• Checked exceptions must be handled (caught) or declared in the throws clause.

Unchecked Exceptions

• Unchecked exceptions (including runtime exceptions) do not require explicit handling.

Throwable Class

• Superclass of both Error and Exception classes.
• Provides methods for handling exceptions, including getMessage() and printStackTrace().
• The throw keyword is used to explicitly throw an exception.

Finally Clause

• The finally clause is executed regardless of whether an exception is thrown or caught.
• Useful for cleanup actions, closing resources, and other essential tasks.

This quiz covers the fundamental concepts of classes, inheritance, and visibility modifiers in Java. Understand how classes serve as blueprints for objects, the role of the extends keyword, and the implications of different visibility modifiers like public, protected, and private. Test your knowledge of these key principles that enhance code organization and reuse.