Packages, interfaces and exception handling notes — Unit 2

An abstract class is a class that is declared with the `abstract` keyword. It represents a conceptual template that cannot be instantiated directly.

⇒1.1 Key Characteristics

• You cannot create an object using `new AbstractClass()`.
• It can contain both abstract methods (methods without a body) and concrete methods (normal methods with a body).
• If a class contains even one abstract method, the class itself MUST be declared abstract.
• Any subclass inheriting from an abstract class MUST override and provide bodies for all of its abstract methods, or else the subclass must also be declared abstract.

An interface is a pure contract. It tells a class what to do, but not how to do it. It is declared using the `interface` keyword.

⇒2.1 Interface Rules (Pre-Java 8)

• All methods are implicitly `public` and `abstract`. They cannot have bodies.
• All variables are implicitly `public`, `static`, and `final` (they are constants).
• A class implements an interface using the `implements` keyword.
• A class can implement multiple interfaces, bypassing Java's restriction on multiple inheritance.

Historically, adding a new method to an interface would break all thousands of classes worldwide that implemented it. Java 8 introduced a massive change to solve this.

⇒3.1 Default Methods

Interfaces can now contain methods with bodies, provided they are marked with the `default` keyword. Implementing classes inherit this default behavior but can override it if desired.

⇒3.2 Static Methods

Interfaces can also contain `static` methods with bodies. These act as utility methods belonging to the interface itself.

⇒3.3 Abstract Class vs Interface

Abstract classes describe an 'is-a' relationship (Dog is an Animal) and hold state (instance variables). Interfaces describe a 'can-do' relationship (Document can be Printable) and cannot hold state.

A package is a mechanism to encapsulate a group of classes, interfaces, and sub-packages. They are physically represented as folders in the file system.

⇒4.1 Purpose

• Namespace Management: Prevents naming conflicts. You can have two classes named `Date` as long as they are in different packages (e.g., `java.util.Date` vs `java.sql.Date`).
• Access Protection: Allows classes to be visible only within their own package.

⇒4.2 Creating and Importing

To use this class elsewhere, use `import com.mycompany.utils.MathHelper;`. Note: `java.lang` is imported automatically in every file.

Java provides four levels of access control for classes, variables, and methods to enforce encapsulation.

⇒5.1 The Protected Keyword

`protected` is specifically designed for inheritance. It hides the data from the outside world, but allows child classes (even if they live in a completely different package/folder) to inherit and use the data.

An Exception is an unwanted or unexpected event occurring during program execution that disrupts the normal flow of instructions. Exception handling provides a robust way to gracefully catch these events instead of crashing the program.

⇒6.1 The Exception Hierarchy

The root class is `java.lang.Throwable`, which splits into two main branches:

• `Error`: Severe, unrecoverable problems caused by the JVM environment (e.g., `OutOfMemoryError`, `StackOverflowError`). You should not try to catch these.
• `Exception`: Recoverable problems caused by the program logic or external resources (e.g., missing files, bad network).

⇒7.1 Checked Exceptions

Exceptions checked at Compile-Time. The Java compiler forces the programmer to handle these, or the code will not compile. These generally represent external conditions outside the programmer's control.

• `IOException`: Trying to read a file that might have been deleted.
• `SQLException`: Trying to query a database that might be offline.

⇒7.2 Unchecked Exceptions (Runtime Exceptions)

Exceptions checked at Run-Time. They inherit from `RuntimeException`. The compiler does not force you to handle them. They generally represent logical programming bugs that should be fixed in the code, rather than caught.

• `NullPointerException`: Calling a method on a null reference.
• `ArithmeticException`: Dividing by zero.
• `ArrayIndexOutOfBoundsException`: Accessing index 5 in a size 3 array.

The core mechanism for catching exceptions.

The `finally` block is crucial for closing resources (like database connections or file streams) to prevent memory leaks.

While `try-catch` handles exceptions, `throw` and `throws` are used to generate and declare them.

⇒9.1 `throw`

Used to explicitly throw an exception object from within a method block.

⇒9.2 `throws`

Appended to a method signature. It warns the caller: 'I might throw this Checked Exception, so you are forced to handle it.' It passes the buck up the call stack.

Java allows you to create your own exception classes tailored to your specific application domain (e.g., `InsufficientFundsException`).

⇒10.1 Creating a Custom Exception

To create a Checked exception, extend `Exception`. To create an Unchecked exception, extend `RuntimeException`.

Before Java 7, closing resources (files, network sockets) in the `finally` block was extremely verbose and prone to errors. Try-with-resources provides automatic resource management.

⇒11.1 Syntax

Resources are declared inside parentheses immediately after the `try` keyword.

Any object that implements the `java.lang.AutoCloseable` interface can be used in this manner.

In Java, `String` is not a primitive type; it is an Object. It is the most heavily used class in all of Java.

⇒12.1 Immutability

String objects are immutable. Once a String object is created in memory, its data cannot be changed. If you perform an operation like `str.concat(" world")`, the JVM does not alter the original string; it creates an entirely new String object in memory and returns its reference.

⇒12.2 The String Pool

To conserve memory, Java maintains a special area in the heap called the String Constant Pool. If you define `String s1 = "Hello";` and `String s2 = "Hello";`, the JVM only creates one object. Both `s1` and `s2` point to the exact same memory location.

Because Strings are immutable, concatenating strings inside a loop creates thousands of discarded objects, severely lagging the Garbage Collector. Java provides mutable alternatives.

⇒13.1 StringBuffer

Mutable string sequences. It is Thread-Safe (synchronized), meaning multiple threads cannot access it simultaneously. Because of this lock-checking, it is slower.

⇒13.2 StringBuilder (Java 5+)

Identical to StringBuffer, but Not Thread-Safe. Without the synchronization overhead, it is significantly faster. It is the standard choice for string manipulation in single-threaded scenarios.

The Collections framework (like ArrayLists) strictly requires Objects; they cannot store primitive types (like `int` or `double`). Wrapper classes solve this by 'wrapping' primitives into Objects.

⇒14.1 The Wrappers

`int` -> `Integer`
`char` -> `Character`
`double` -> `Double`
`boolean` -> `Boolean`

⇒14.2 Autoboxing and Unboxing

Since Java 5, the compiler automatically converts between primitives and wrappers.

• Autoboxing: Automatic conversion of primitive to wrapper (e.g., `Integer num = 5;`).
• Unboxing: Automatic conversion of wrapper to primitive (e.g., `int prim = num;`).

Annotations provide metadata about the program. They do not directly affect the operation of the code they annotate, but can be read by the compiler or runtime environments.

⇒15.1 Built-in Annotations

• `@Override`: Instructs the compiler to verify that the method actually overrides a parent method. If you mistyped the method name, the compiler throws an error.
• `@Deprecated`: Marks a method as obsolete and triggers a compiler warning if developers try to use it.
• `@SuppressWarnings`: Instructs the compiler to ignore specific warnings (e.g., `@SuppressWarnings("unchecked")`).

Custom annotations can also be created and are heavily used in modern frameworks like Spring Boot (`@RestController`, `@Autowired`).

Java allows defining a class inside another class. This logically groups classes that are only used in one place and increases encapsulation.

⇒16.1 Non-static Nested Class (Inner Class)

An Inner Class has access to all members (even private) of the enclosing outer class. To instantiate it, you must first instantiate the outer class.

⇒16.2 Static Nested Class

Does not require an instance of the outer class. It can only access the static members of the outer class.

⇒16.3 Local Inner Classes

A class defined inside a method block. Its scope is restricted to that method.

An inner class without a name. It is declared and instantiated in a single expression. It is exclusively used when you need to override methods of a class or interface for a one-time use.

⇒17.1 Syntax

Historically used heavily in GUI programming (Swing/AWT) for event listeners. Today, most anonymous classes containing a single method are replaced by Lambda Expressions.

Lambdas introduced Functional Programming concepts to Java. They provide a clear and concise way to represent one-method interfaces (Functional Interfaces).

⇒18.1 Functional Interfaces

An interface with exactly one abstract method (often marked with `@FunctionalInterface`). Examples: `Runnable`, `Comparator`.

⇒18.2 Lambda Syntax

Format: `(parameters) -> expression` or `(parameters) -> { statements; }`

Sometimes a lambda expression does nothing but call an existing method. In those cases, you can use a Method Reference for even cleaner syntax.

⇒19.1 The `::` Operator

Types of references: Static method (`Math::max`), Instance method of specific object (`System.out::println`), Constructor (`ArrayList::new`).

In C++, programmers must manually allocate and free memory using `malloc` and `free`. Forgetting to free memory causes Memory Leaks. Java automates this.

⇒20.1 How it Works

The JVM runs a background daemon thread called the Garbage Collector (GC). It periodically scans the Heap memory.

• If an object in memory no longer has any active reference variables pointing to it (it is unreachable), it is considered 'Garbage'.
• The GC destroys the object and reclaims the memory.

⇒20.2 `System.gc()` and `finalize()`

You can suggest the JVM run the garbage collector using `System.gc()`, but the JVM ignores it if it decides it isn't necessary. Before destroying an object, the GC historically called the `finalize()` method on it, but this is now deprecated as it was highly unpredictable.