Object-Oriented Programming

Through Java
Comprehensive Lecture Notes

Course Code: BTAT2302

Structured Guide: Concepts, Applications, and Implementations

UNIT I: An Overview of Java & Introducing
Classes

Topic 1: Java Basics, JVM, and Bytecode

1. Definition & Simpler Explanation

Definition: Java is a high-level, class-based, object-oriented programming language designed to have

as few implementation dependencies as possible. The JVM (Java Virtual Machine) is an abstract
machine that enables a computer to run a Java program. Bytecode is the intermediate representation of
Java source code produced by the Java compiler.

Simpler Way:
• Think of Java code as a script written in English.
• The compiler translates it into a universal language (Bytecode).
• The JVM acts as a local translator on any machine (Windows, Mac, Linux) that reads this universal
language and executes the instructions.
• This execution pipeline provides Java's "Write Once, Run Anywhere" capability.

2. Real-Life Applications

• Cross-platform desktop applications (e.g., Eclipse IDE).

• Backend systems for enterprise web applications (e.g., banking portals).
• Embedded systems in smart cards and IoT devices.

3. Example Program

public class HelloWorld {

public static void main(String[] args) {
int year = 2026;
[Link]("Welcome to Java in " + year);
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Platform independence (WORA).

• Advantages: Strong memory management and security.
• Advantages: Extensive standard library for rapid development.
• Disadvantages: Slower than natively compiled languages (like C++) due to JVM overhead.
• Disadvantages: Verbose syntax compared to modern alternatives.
5. Computer/Program Applications

• Android Application development.

• Server-side data processing architectures (Apache Hadoop).
• Automated testing frameworks execution.

Topic 2: Classes, Objects, Methods, and Keywords

1. Definition & Simpler Explanation

Definition: A class is a blueprint for creating objects, defining state (variables) and behavior (methods).
An object is an instance of a class. Keywords like static belong to the class rather than instances;
final prevents modification.

Simpler Way:
• A class acts as an architectural blueprint for a house.
• An object is the actual physical house built from that blueprint.
• Methods represent the actions the house can perform (e.g., locking doors).
• static variables mean all houses share the exact same mailbox.
• final components mean the house cannot be renovated or altered.

2. Real-Life Applications

• Modeling real-world entities in software architectures (e.g., a BankAccount class with deposit()
methods).
• Using static for universal constants like PI across calculations.

3. Example Program

class Car {
String model;
static int totalCars = 0;

Car(String m) {
model = m;
totalCars++;
}

void display() {
[Link]("Model: " + model);
}
}

public class Main {

public static void main(String[] args) {
Car c1 = new Car("Tesla");
[Link]();
[Link]("Total cars: " + [Link]);
 }
}

4. Utilization, Advantages & Disadvantages

• Advantages: Encapsulation protects sensitive internal data states.

• Advantages: Modularity allows for reusable, easily maintainable code structures.
• Disadvantages: Requires careful architectural design.
• Disadvantages: Poor class design can lead to tightly coupled, rigid codebases.

5. Computer/Program Applications

• GUI frameworks where each interactive element (button, window) is an object.

• Game development engines mapping characters and items to memory instances.
• Object-Relational Mapping (ORM) tools synchronizing database tables to application classes.

Unit I Resources:
• "Java: The Complete Reference" by Herbert Schildt (Chapters 1-7).
• Oracle Java Documentation - "Trails Covering the Basics".

UNIT II: Inheritance, Packages and Interfaces

Topic 3: Inheritance and Polymorphism

1. Definition & Simpler Explanation

Definition: Inheritance allows a new class (subclass) to inherit fields and methods from an existing class
(superclass). Polymorphism (via method overriding and dynamic method dispatch) allows a subclass to
provide a specific implementation of a method that is already provided by its parent.

Simpler Way:
• Operates conceptually like a parent and child genetic relationship.
• The child (subclass) automatically inherits traits (variables) and abilities (methods) from the parent
(superclass).
• The child can develop unique skills (new methods).
• The child can alter the execution of inherited tasks (overriding).

2. Real-Life Applications

• Classification systems: A base Employee class, with Manager and Developer subclasses
inheriting payroll logic.
• UI components: A base Widget class extended by Button and TextField.
3. Example Program

abstract class Animal {

abstract void sound();
}

class Dog extends Animal {

void sound() {
[Link]("Bark");
}
}

public class TestInheritance {

public static void main(String[] args) {
Animal myDog = new Dog();
[Link](); // Output: Bark
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Maximizes code reusability across related entities.

• Advantages: Establishes natural, logical software hierarchies.
• Disadvantages: Introduces high coupling between parent and child classes.
• Disadvantages: Deep inheritance trees become difficult to navigate and track.

5. Computer/Program Applications

• Core framework architecture within virtually all Java libraries.

• UI construction in Swing/JavaFX standard frameworks.
• Defining hierarchical data models representing business logic.

Topic 4: Packages and Interfaces

1. Definition & Simpler Explanation

Definition: A package is a namespace that organizes a set of related classes and interfaces. An
interface is a completely abstract class that groups related methods with empty bodies (pre-Java 8) or
default methods (Java 8+), defining a contract.

Simpler Way:
• A package functions exactly like a directory folder grouping related files.
• An interface acts as a strict job description or contract.
• The interface states what needs to be done, omitting how it should be executed.
• Any class assigned to the interface is mandated to perform the outlined functions.
2. Real-Life Applications

• Packages prevent naming conflicts across large systems (e.g., [Link] vs

[Link]).
• Interfaces define clear API boundaries (e.g., an EventListener dictating interaction rules).

3. Example Program

package mypack;

interface Drawable {
void draw();
}

public class Rectangle implements Drawable {

public void draw() {
[Link]("Drawing rectangle");
}

public static void main(String[] args) {

Rectangle r = new Rectangle();
[Link]();
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Interfaces bypass single-inheritance limits, allowing multiple inheritance of types.

• Advantages: Packages ensure granular access control and structural organization.
• Disadvantages: Overuse of interfaces for small, single-use logic bloats architecture unnecessarily.

5. Computer/Program Applications

• Plugin architectures where host software expects external tools to adhere to a specific interface.
• The Java Collections framework standardizing lists and sets (List, Map, Set).

Unit II Resources:
• "Core Java, Volume I-Fundamentals" by Cay S. Horstmann (Chapter 5: Inheritance).
• Java Tutorials: Interfaces and Inheritance.
UNIT III: Exception Handling and Multithreading

Topic 5: Exception Handling

1. Definition & Simpler Explanation

Definition: Exception handling is a mechanism to handle runtime errors (exceptions) disrupting the
normal flow of the program. It uses keywords: try, catch, throw, throws, and finally.

Simpler Way:
• Functions like an emergency protocol during a car journey.
• If a tire blows out (an Exception), the car naturally crashes (program terminates).
• A try/catch block acts as the spare tire and jack to intercept the crash.
• The program repairs the immediate failure and continues executing securely.

2. Real-Life Applications

• Handling unexpected network disconnections gracefully without closing the application.

• Validating user input schemas (e.g., rejecting negative age values).

3. Example Program

public class ExceptionDemo {

public static void main(String[] args) {
try {
int data = 100 / 0;
} catch (ArithmeticException e) {
[Link]("Cannot divide by zero!");
} finally {
[Link]("Cleanup protocol executed.");
}
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Isolates error-handling logic from primary execution code.

• Advantages: Propagates untraceable errors safely up the execution stack.
• Advantages: Ensures absolute resource cleanup via the finally block.
• Disadvantages: Can silently mask logical bugs if empty catch blocks are utilized.
• Disadvantages: Incurs a measurable performance penalty when exceptions are thrown frequently.

5. Computer/Program Applications

• Local file system Input/Output operations requiring fail-safes.

• Database connection pooling and query executions.
 • REST API endpoints managing unavailable or delayed resources.

Topic 6: Multithreading

1. Definition & Simpler Explanation

Definition: Multithreading is the concurrent execution of two or more parts (threads) of a program for
maximum utilization of CPU. Synchronization prevents thread interference and memory consistency
errors.

Simpler Way:
• Replaces sequential execution (one chef cooking a 3-course meal alone).
• Deploys concurrent execution (three chefs cooking different courses simultaneously).
• Synchronization acts as kitchen rules preventing two chefs from altering the same pot at the exact
same moment.

2. Real-Life Applications

• Web browsers calculating HTML rendering in one thread while downloading assets in another.
• Word processors maintaining continuous background autosave routines.

3. Example Program

class MyThread extends Thread {

public void run() {
[Link]("Thread ID " + [Link]().getId() + " active");
}
}

public class MultithreadDemo {

public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
MyThread t = new MyThread();
[Link]();
}
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Yields highly responsive graphical user interfaces.

• Advantages: Maximizes hardware utilization on modern multi-core systems.
• Disadvantages: Generates highly complex testing scenarios (race conditions, deadlocks).
• Disadvantages: Excessive threading creates severe context-switching performance degradation.
 5. Computer/Program Applications

• Enterprise server architectures processing thousands of concurrent external requests (e.g., Apache
Tomcat).
• Complex gaming engines updating physics calculations and graphics pipelines concurrently.

Unit III Resources:

• "Java: The Complete Reference" (Chapters 10 & 11).
• Brian Goetz's "Java Concurrency in Practice".

UNIT IV: I/O and Collection Framework

Topic 7: I/O Streams and Files

1. Definition & Simpler Explanation

Definition: Java I/O (Input/Output) handles the reading of data from a source and writing of data to a
destination via Streams. A stream represents a continuous flow of data.

Simpler Way:
• Visualized accurately as a direct plumbing pipe for data.
• Input Streams act as pipes pumping external data directly into application memory.
• Output Streams act as pipes exporting internal application data directly to physical files or networks.

2. Real-Life Applications

• Streaming internal application events and errors to external log files.

• Parsing static configuration parameters from `.properties` files.

3. Example Program

import [Link].*;

public class FileIODemo {

public static void main(String[] args) {
try (FileWriter fw = new FileWriter("[Link]")) {
[Link]("Hello, Stream API!");
} catch (IOException e) {
[Link]();
}
}
}
4. Utilization, Advantages & Disadvantages

• Advantages: Uniform architecture across characters, bytes, files, and networks.

• Disadvantages: Requires extensive boilerplate code for simple operations.
• Disadvantages: Legacy blocking I/O suspends thread execution if hardware transfer rates lag.

5. Computer/Program Applications

• Object serialization protocols transferring state across boundaries.

• Automated reporting pipelines dumping data to CSV or TXT.
• Synchronous network communications over TCP/IP sockets.

Topic 8: The Collections Framework

1. Definition & Simpler Explanation

Definition: A unified architecture for representing and manipulating collections (objects that group
multiple elements). Includes Interfaces (List, Set, Queue, Map) and Classes (ArrayList, HashSet,
HashMap).

Simpler Way:
• Overrides the rigid, static limitations inherent to basic arrays.
• Supplies dynamic memory structures adapting to runtime requirements.
• ArrayList supplies sequentially indexed, expandable arrays.
• HashSet algorithmically drops duplicate inputs automatically.
• HashMap securely links unique keys directly to specific values.

2. Real-Life Applications

• Holding dynamic session shopping carts in digital storefronts (ArrayList).

• Logging strictly unique visitor IP addresses tracking traffic (HashSet).

3. Example Program

import [Link].*;

public class CollectionDemo {

public static void main(String[] args) {
List<String> list = new ArrayList<>();
[Link]("Java");
[Link]("Python");

Iterator<String> itr = [Link]();

while([Link]()) {
[Link]([Link]());
}
}
 }

4. Utilization, Advantages & Disadvantages

• Advantages: Exposes highly optimized data algorithms natively.

• Advantages: Enforces standardization allowing distinct APIs to exchange generic collections.
• Disadvantages: Incapable of storing memory-efficient primitive types directly.
• Disadvantages: Incurs automatic boxing/unboxing performance overheads.

5. Computer/Program Applications

• Structuring fast, volatile in-memory databases.

• Orchestrating predictive caching engines.
• Modeling node interconnections in graph network visualizations.

Unit IV Resources:
• Oracle Collections Trail.
• "Core Java, Volume I" (Chapter 9: Collections).

UNIT V: Advanced Features of JDK8 and Data

Base Connectivity

Topic 9: JDK 8 Lambda Expressions and Streams

1. Definition & Simpler Explanation

Definition: Lambda expressions provide a clear and concise way to represent one method interface
using an expression. The Streams API provides functional-style operations on streams of elements
(map-reduce transformations).

Simpler Way:
• Lambdas deploy anonymous, single-use functions identified by the -> operator.
• Lambdas eliminate the requirement of writing full class implementations for minor tasks.
• Streams act as automated factory conveyor belts for data collections.
• Streams transport raw data through sequential modification nodes (filters, mappers) outputting
transformed results.

2. Real-Life Applications

• Rapidly extracting distinct subsets from massive data aggregates (e.g., querying high-salary records).
• Simplifying button-click event handling in interface configurations.
3. Example Program

import [Link];
import [Link];
import [Link];

public class StreamDemo {

public static void main(String[] args) {
List<Integer> numbers = [Link](1, 2, 3, 4, 5, 6);

List<Integer> processed = [Link]()

.filter(n -> n % 2 == 0)
.map(n -> n * 2)
.collect([Link]());

[Link](processed); // [4, 8, 12]

}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Yields highly legible, mathematically structured syntax formats.

• Advantages: Allows immediate conversion to multi-core parallel processing (parallelStream()).
• Disadvantages: Significantly harder to isolate and trace logic errors during debugging.
• Disadvantages: Adds processing overhead eliminating efficiency gains on minor data sets.

5. Computer/Program Applications

• Big data continuous processing pipelines.

• Aggregating metrics in modern backend architecture topologies.
• Bridging object-oriented foundations with functional programming techniques.

Topic 10: Regular Expressions and JDBC

1. Definition & Simpler Explanation

Definition: Regular Expressions (Regex) are character sequences defining a search pattern. JDBC
(Java Database Connectivity) is an API used to connect and execute queries with a database.

Simpler Way:
• Regex serves as a complex pattern-matching engine for analyzing text blocks.
• JDBC functions as the secure digital transmission line bridging Java software to external databases.
• JDBC facilitates permanent query storage, modification, and retrieval mechanisms.

2. Real-Life Applications

• Regex: Validating syntax logic behind submitted user emails or complex password schemas.
 • JDBC: Executing secure transaction records and financial commits within banking infrastructure.

3. Example Program (JDBC Concept)

import [Link].*;

public class JDBCDemo {

public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";

try (Connection conn = [Link](url, user, password);

Statement stmt = [Link]()) {

ResultSet rs = [Link]("SELECT * FROM Employees");

while ([Link]()) {
[Link]([Link]("name"));
}
} catch (SQLException e) {
[Link]();
}
}
}

4. Utilization, Advantages & Disadvantages

• Advantages: Regex executes granular parsing inaccessible to standard string methods.

• Advantages: JDBC guarantees universal connectivity across diverse RDBMS environments.
• Disadvantages: Regex logic strings become inherently difficult to interpret rapidly.
• Disadvantages: Native JDBC dictates repetitive structural code; frequently replaced by ORM
(Hibernate).

5. Computer/Program Applications

• Regex: Scraping algorithms processing raw web HTML and unformatted log dumps.
• JDBC: Core integration protocol for Enterprise Resource Planning (ERP) mainframes.
• JDBC: Baseline connection schema for distinct data analytic storage platforms.

Unit V Resources:
• "Modern Java in Action" by Raoul-Gabriel Urma.
• Oracle JDBC Basics Tutorial.