BCA 4th Semester

JAVA PROGRAMMING
Complete Exam Notes
Units I–IV | All Topics Covered

📋📋 Quick Topic Index

Unit Topics Key Areas
Unit I Java Basics, OOP, Classes, Features, Data Types, Operators,
Inheritance Polymorphism
Unit II Java I/O and Files Streams, File R/W, String,
StringBuffer
Unit III Multithreading & Exceptions Thread lifecycle, Synchronization,
try-catch-finally
Unit IV Database Connectivity (JDBC) Connection, Statement,
ResultSet, Queries
 UNIT I — Java Language Basics
1.1 Features of Java
★ Mnemonic: SIMPLE PORTABLE ROARS = Simple, Platform-Independent, Object-Oriented, Robust,
Typed-Safe, Architecture Neutral, Interpreted, Multithreaded, High-Performance, Distributed, Dynamic

Feature Meaning
Simple Easy syntax, no pointers, automatic garbage
collection
Object-Oriented Everything is an object; supports OOP principles
Platform Independent Compiled to bytecode; runs on any OS with JVM
Robust Strong type checking, exception handling, no
pointers
Secure Bytecode verification, no explicit pointer access
Multithreaded Built-in support for concurrent programming
Interpreted Bytecode is interpreted by JVM at runtime
High Performance JIT compiler improves execution speed
Distributed Supports networking with [Link] package
Dynamic Loads classes at runtime; supports reflection

1.2 Object Oriented Concepts

Concept Definition Java Keyword
Class Blueprint/template for objects class
Object Instance of a class new
Encapsulation Wrapping data + methods; hiding private, public, protected
implementation
Inheritance Deriving new class from existing extends
class
Polymorphism Same name, different behavior Override / Overload
Abstraction Hiding complexity, showing only abstract, interface
essentials

1.3 Java Virtual Machine (JVM)

JVM is the engine that runs Java programs. It converts bytecode (.class files) into machine code at runtime.
Component Role
Class Loader Loads .class files into memory
Bytecode Verifier Checks bytecode for security/validity
Interpreter Executes bytecode line by line
JIT Compiler Compiles frequently-used bytecode to native code for
speed
Garbage Collector Automatically frees unused memory
Runtime Data Areas Heap (objects), Stack (methods), Method Area, PC
Register
 ★ Remember: JDK (dev tools + JRE) > JRE (JVM + libraries) > JVM (runtime engine)

1.4 Primitive Data Types

Type Size Range / Default Example
byte 1 byte -128 to 127 / 0 byte b = 10;
short 2 bytes -32768 to 32767 / 0 short s = 200;
int 4 bytes -2^31 to 2^31-1 / 0 int x = 5;
long 8 bytes -2^63 to 2^63-1 / 0L long l = 99L;
float 4 bytes ~3.4e38 / 0.0f float f = 3.14f;
double 8 bytes ~1.7e308 / 0.0d double d = 3.14;
char 2 bytes 0 to 65535 (Unicode) / char c = 'A';
'\u0000'
boolean 1 bit true / false / false boolean flag = true;

1.5 Java Keywords (Important ones)

Java has 50+ reserved keywords. Most important for exams:
Category Keywords
Class/Object class, interface, extends, implements, new, this,
super, instanceof
Access Modifiers public, private, protected, (default)
Control Flow if, else, switch, case, default, break, continue, return
Loops for, while, do
Exception try, catch, finally, throw, throws
OOP abstract, final, static, synchronized, volatile, transient
Data void, int, byte, short, long, float, double, char,
boolean
Other import, package, null, true, false

1.6 Java Operators

Operator Type Symbols Example
Arithmetic + - * / % ++ -- a+b, a%b, a++
Relational == != > < >= <= a==b, a>b
Logical && || ! a&&b, !a
Bitwise & | ^ ~ << >> >>> a&b, a<<2
Assignment = += -= *= /= %= a+=5
Ternary ?: x = (a>b) ? a : b
instanceof instanceof obj instanceof String
1.7 Control Statements
if-else
if (x > 0) { [Link]("Positive"); } else { [Link]("Negative");
}

switch
switch(day) { case 1: [Link]("Mon"); break; default:
[Link]("Other"); }

Loops
for(int i=0; i<5; i++) { } // for loop
while(condition) { } // while loop
do { } while(condition); // do-while: runs at least once

1.8 Arrays
int[] arr = new int[5]; // declaration
int[] arr = {1, 2, 3, 4, 5}; // initialization
int[][] matrix = new int[3][3]; // 2D array
[Link] // get array size
★ Exam Tip: Array index starts at 0. Last index = length-1. ArrayIndexOutOfBoundsException if you exceed
bounds.

1.9 Objects and Classes

class Student {
int rollNo; // instance variable
String name;
void display() { // method
[Link](rollNo + " " + name);
}
}
Student s = new Student(); // creating object
[Link] = 1; [Link] = "Ravi"; [Link]();

Constructors
Type Description Example
Default Constructor No parameters; provided by Java Student() { }
if none defined
Parameterized Constructor Takes arguments to initialize Student(int r, String n) { rollNo=r;
values name=n; }
Copy Constructor Creates copy of another object Student(Student s) { [Link] =
(manually written in Java) [Link]; }
★ Remember: Constructor name = class name. No return type. Called when object is created with 'new'.

Finalizer
finalize() method is called by GC before object is destroyed. Used to clean up resources.
protected void finalize() { [Link]("Object destroyed"); }
Visibility Modifiers
Modifier Same Class Same Package Subclass Other Package
private YES NO NO NO
default (none) YES YES NO NO
protected YES YES YES NO
public YES YES YES YES

this and super keywords

[Link] = name; // refers to current object's field
this(); // calls current class constructor
[Link](); // calls parent class method
super(args); // calls parent class constructor (must be first statement)

1.10 Inheritance
Inheritance = acquiring properties of a parent class by a child class using 'extends'.
Type Description Support in Java
Single One child inherits from one parent YES
Multilevel Child inherits from child (chain) YES
Hierarchical Multiple children inherit from one YES
parent
Multiple One child inherits from multiple NO (use interfaces)
parents
Hybrid Combination of above Partially (via interfaces)
class Animal { void eat() { } }
class Dog extends Animal { void bark() { } } // Single inheritance

1.11 Abstract Classes

▸ Declared with 'abstract' keyword
▸ Can have abstract methods (no body) AND concrete methods
▸ Cannot be instantiated directly
▸ Subclass MUST implement all abstract methods
abstract class Shape { abstract double area(); }
class Circle extends Shape { double area() { return 3.14*r*r; } }

1.12 Interfaces
▸ All methods are public abstract by default (Java 7-)
▸ All variables are public static final
▸ A class can implement multiple interfaces (solves multiple inheritance)
▸ From Java 8: can have default and static methods
interface Drawable { void draw(); }
class Circle implements Drawable { public void draw() { } }
1.13 Polymorphism
Type Also Called When Resolved How
Method Overloading Compile-time / Static Compile time Same name, different
polymorphism parameters
Method Overriding Runtime / Dynamic Runtime Same name+params in
polymorphism parent and child

Overloading Example
int add(int a, int b) { return a+b; }
double add(double a, double b) { return a+b; } // different params

Overriding Example
class Animal { void sound() { [Link]("Generic"); } }
class Dog extends Animal { void sound() { [Link]("Bark"); } }
★ Key Rule: Overloading = same class, different signature. Overriding = different class (parent-child), same
signature.

1.14 Packages and Access Control

▸ Package = folder/namespace for organizing related classes
package [Link]; // declare package (first line)
import [Link]; // import specific class
import [Link].*; // import all classes in package

Built-in Package Contains

[Link] String, Math, System, Object (auto-imported)
[Link] Scanner, ArrayList, HashMap, Arrays
[Link] File, InputStream, OutputStream, Reader, Writer
[Link] Connection, Statement, ResultSet
 UNIT II — Java I/O and Files
2.1 I/O Overview
Java I/O is based on STREAMS — sequence of data flowing between source and destination.
Stream Type Base Classes Used For
Byte Stream InputStream / OutputStream Binary data (images, audio, raw
bytes)
Character Stream Reader / Writer Text data (handles
Unicode/encoding)

2.2 Byte Stream Classes

Class Purpose
FileInputStream Read bytes from file
FileOutputStream Write bytes to file
BufferedInputStream Buffered reading for efficiency
BufferedOutputStream Buffered writing for efficiency
DataInputStream Read primitive types (int, float, etc.)
DataOutputStream Write primitive types
ByteArrayInputStream Read from byte array
ObjectInputStream Deserialize objects
ObjectOutputStream Serialize objects
FileInputStream fis = new FileInputStream("[Link]");
int ch; while((ch = [Link]()) != -1) { [Link]((char)ch); }
[Link]();

2.3 Character Stream Classes

Class Purpose
FileReader Read characters from file
FileWriter Write characters to file
BufferedReader Read line by line (readLine())
BufferedWriter Efficient writing with newLine()
PrintWriter print(), println() methods for text
InputStreamReader Converts byte stream to character stream
BufferedReader br = new BufferedReader(new FileReader("[Link]"));
String line; while((line = [Link]()) != null) { [Link](line); }
[Link]();

2.4 Reading and Writing to Console

Reading from Console
Scanner sc = new Scanner([Link]);
int n = [Link](); String s = [Link](); String line = [Link]();
 // OR using BufferedReader:
BufferedReader br = new BufferedReader(new InputStreamReader([Link]));
String input = [Link]();

Writing to Console
[Link]("Hello"); // no newline
[Link]("Hello"); // with newline
[Link]("%d %s", 5, "Hi"); // formatted output

2.5 Reading and Writing Files

Write to File
FileWriter fw = new FileWriter("[Link]");
[Link]("Hello World");
[Link]();

Read from File

FileReader fr = new FileReader("[Link]");
int ch; while((ch = [Link]()) != -1) [Link]((char)ch);
[Link]();
★ Exam Tip: Always close() streams to free resources. Or use try-with-resources: try(FileReader fr = new
FileReader("[Link]")) { }

2.6 Transient and Volatile Modifiers

Modifier Used With Purpose
transient Serialization Skips field during serialization —
field won't be saved
volatile Multithreading Forces thread to read variable
directly from main memory (not
cache)
transient int password; // will not be serialized
volatile boolean flag; // always read from main memory

2.7 String Class

String is immutable — once created, cannot be changed. Every modification creates a new String.
Method Description Example
length() Returns string length "Hello".length() → 5
charAt(i) Character at index i "Hi".charAt(0) → 'H'
substring(s,e) Substring from s to e-1 "Hello".substring(1,3) → "el"
indexOf(ch) First occurrence index "Hello".indexOf('l') → 2
toUpperCase() Convert to uppercase "hi".toUpperCase() → "HI"
toLowerCase() Convert to lowercase "HI".toLowerCase() → "hi"
trim() Remove leading/trailing spaces " hi ".trim() → "hi"
replace(a,b) Replace occurrences "hello".replace('l','r') → "herro"
equals(s) Compare content [Link](s2) → true/false
 Method Description Example
equalsIgnoreCase(s) Compare ignoring case "Hi".equalsIgnoreCase("hi") →
true
contains(s) Check if substring exists "hello".contains("ell") → true
split(regex) Split string into array "a,b,c".split(",") → ["a","b","c"]
concat(s) Append string "Hi".concat(" Bye") → "Hi Bye"
compareTo(s) Lexicographic compare Returns 0 if equal, +ve or -ve
isEmpty() Check if empty Returns true if length == 0

2.8 StringBuffer Class

StringBuffer is mutable — can modify without creating new objects. Thread-safe (synchronized).
StringBuilder is same as StringBuffer but NOT synchronized (faster, not thread-safe).
Method Description
append(x) Add to end: [Link]("World")
insert(i, x) Insert at index: [Link](2, "XY")
delete(s, e) Delete from s to e-1
replace(s, e, str) Replace chars s to e-1 with str
reverse() Reverse the content
length() Current length
capacity() Current capacity (default 16)
charAt(i) Character at index
toString() Convert to String
★ String vs StringBuffer: Use String for fixed text. Use StringBuffer when you need frequent modifications.
Use StringBuilder for single-threaded performance.
 UNIT III — Multithreading and Exceptions
3.1 Thread Concepts
▸ Thread = lightweight process; smallest unit of execution
▸ Java supports multithreading natively through [Link]
▸ Enables concurrent execution of two or more parts of a program

3.2 Thread Life Cycle

State Description How to enter
New Thread object created, not yet new Thread()
started
Runnable Ready to run, waiting for CPU start() called
Running Thread is executing Scheduler selects it
Blocked/Waiting Waiting for resource or notification sleep(), wait(), join()
Terminated (Dead) Thread finished execution run() method ends
★ Diagram: New → Runnable → Running → Blocked/Waiting → Runnable → Dead

3.3 Creating Threads — Two Ways

Way 1: Extending Thread class
class MyThread extends Thread {
public void run() { [Link]("Thread running"); }
}
MyThread t = new MyThread(); [Link]();

Way 2: Implementing Runnable Interface (Preferred)

class MyTask implements Runnable {
public void run() { [Link]("Task running"); }
}
Thread t = new Thread(new MyTask()); [Link]();
★ Why Runnable?: Because Java doesn't support multiple inheritance. Using Runnable allows the class to
extend another class too.

3.4 Thread Methods

Method Description
start() Starts thread execution (calls run() internally)
run() Contains the task logic (override this)
sleep(ms) Pauses thread for specified milliseconds
join() Waits for a thread to finish before continuing
yield() Hints scheduler to give CPU to other threads
isAlive() Returns true if thread is still running
getName() Returns thread name
setName(s) Sets thread name
 Method Description
getPriority() Returns priority (1-10)
setPriority(n) Sets priority (MIN=1, NORM=5, MAX=10)
interrupt() Interrupts a sleeping/waiting thread
[Link]() Returns reference to currently executing thread

3.5 Thread Synchronization

Problem: Multiple threads accessing shared data simultaneously can cause data inconsistency (Race Condition).
Solution: Use synchronized keyword to allow only one thread at a time.

Synchronized Method
synchronized void deposit(int amt) {
balance += amt;
}

Synchronized Block
synchronized(this) {
// critical section
}
★ Remember: synchronized methods/blocks use object's intrinsic lock (monitor). Only one thread can hold
the lock at a time.

3.6 Exception Handling

Exception = runtime error that disrupts normal flow of program.
Keyword Purpose
try Block where exception may occur
catch Handles the exception
finally Always executes (cleanup code)
throw Manually throw an exception
throws Declare exceptions a method may throw

Basic Syntax
try {
int result = 10 / 0; // may throw exception
} catch (ArithmeticException e) {
[Link]("Error: " + [Link]());
} finally {
[Link]("This always runs");
}

3.7 Types of Exceptions

Category Type Examples
Checked (Compile-time) Must be handled or declared IOException,
FileNotFoundException,
 Category Type Examples
SQLException,
ClassNotFoundException
Unchecked (Runtime) Not mandatory to handle NullPointerException,
ArrayIndexOutOfBoundsException,
ArithmeticException,
ClassCastException
Error Serious JVM problems (don't StackOverflowError,
catch) OutOfMemoryError

3.8 Common Exceptions

Exception Cause
NullPointerException Using null object reference
ArrayIndexOutOfBoundsException Accessing invalid array index
ArithmeticException Divide by zero
NumberFormatException Invalid string-to-number conversion
ClassCastException Illegal type cast
StackOverflowError Infinite recursion
FileNotFoundException File does not exist
IOException General I/O error

3.9 Multiple catch and Exception Hierarchy

try {
// risky code
} catch (ArithmeticException e) {
// specific exception first
} catch (Exception e) {
// general exception last
}
★ Rule: Always catch more specific exceptions before general ones (Exception / Throwable must be last).

3.10 throw and throws

// throw: manually throw exception
throw new ArithmeticException("Division error");

// throws: declare that method may throw

void readFile() throws IOException {
// code that may throw IOException
}

3.11 Writing Custom Exception Subclasses

class AgeException extends Exception {
AgeException(String msg) {
 super(msg); // pass message to Exception
}
}

// Usage:
if (age < 18) throw new AgeException("Age must be 18+");
★ Custom Exception: Extend Exception for checked, extend RuntimeException for unchecked custom
exceptions.
 UNIT IV — Database Connectivity (JDBC)
4.1 JDBC Overview
▸ JDBC = Java Database Connectivity
▸ API for connecting Java programs to relational databases
▸ Part of [Link] package
▸ Database-independent API — same code works with MySQL, Oracle, etc. (just change driver)

4.2 JDBC Architecture

Layer Description
Java Application Your Java code using JDBC API
JDBC API [Link] package (Connection, Statement, ResultSet)
JDBC Driver Manager Manages available drivers
JDBC Driver Database-specific driver (translates JDBC calls to DB
calls)
Database Actual DB (MySQL, Oracle, PostgreSQL)

4.3 Types of JDBC Drivers

Type Name Description
Type 1 JDBC-ODBC Bridge Uses ODBC; deprecated; not
recommended
Type 2 Native API Driver Uses DB's native API; partial Java
Type 3 Network Protocol Driver Pure Java; uses middleware
Type 4 Thin Driver (Pure Java) Direct DB connection; most
popular; best performance
★ Exam Tip: Type 4 is the most used in modern Java applications (e.g., MySQL Connector/J).

4.4 JDBC Implementation — Step by Step

Step 1: Load Driver
[Link]("[Link]");

Step 2: Establish Connection

Connection con = [Link](
"jdbc:mysql://localhost:3306/dbname", "username", "password");

Step 3: Create Statement

Statement stmt = [Link]();

Step 4: Execute Query

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

Step 5: Process Results

while([Link]()) {
[Link]([Link]("id") + " " + [Link]("name"));
}
Step 6: Close Connection
[Link](); [Link](); [Link]();

4.5 Connection Class

Method Description
createStatement() Creates a Statement object
prepareStatement(sql) Creates PreparedStatement
prepareCall(sql) Creates CallableStatement
commit() Commits current transaction
rollback() Rollbacks current transaction
setAutoCommit(false) Disables auto-commit
close() Closes connection
isClosed() Checks if connection is closed

4.6 Types of Statement Objects

Type Used When Advantage
Statement Static queries (no parameters) Simple; good for DDL
PreparedStatement Queries with parameters; reusable Faster, prevents SQL injection
CallableStatement Calling stored procedures Executes DB stored procedures

Statement
Statement stmt = [Link]();
ResultSet rs = [Link]("SELECT * FROM emp");
int rows = [Link]("INSERT INTO emp VALUES(1,'John')");

PreparedStatement
PreparedStatement ps = [Link]("SELECT * FROM emp WHERE id=?");
[Link](1, 101); // set parameter
ResultSet rs = [Link]();
★ Security: PreparedStatement prevents SQL Injection attacks by treating input as data, not SQL code.

CallableStatement
CallableStatement cs = [Link]("{call myProcedure(?,?)}");
[Link](1, 100);
[Link]();

4.7 Execute Methods

Method Used For Returns
executeQuery(sql) SELECT statements ResultSet
executeUpdate(sql) INSERT, UPDATE, DELETE, DDL int (rows affected)
execute(sql) Any SQL; used when return type boolean
unknown
4.8 ResultSet
ResultSet stores the result of a SELECT query. Cursor starts BEFORE first row.
Method Description
next() Moves cursor to next row; returns false at end
getInt(col) Get int value from column (name or index)
getString(col) Get String value from column
getDouble(col) Get double value
getDate(col) Get Date value
first() Move to first row (if scrollable)
last() Move to last row
previous() Move to previous row
absolute(n) Move to nth row
isLast() Check if on last row

4.9 Types of ResultSet

Type Constant Description
Forward-only TYPE_FORWARD_ONLY Default; can only move forward
Scroll-insensitive TYPE_SCROLL_INSENSITIVE Scroll any direction; not updated
with DB changes
Scroll-sensitive TYPE_SCROLL_SENSITIVE Scroll any direction; reflects DB
changes
Concurrency Constant Description
Read-only CONCUR_READ_ONLY Cannot update through ResultSet
Updatable CONCUR_UPDATABLE Can update rows via ResultSet
Statement stmt = [Link](
ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

4.10 ResultSetMetaData
Provides information ABOUT the result set (column names, types, count).
ResultSetMetaData rsmd = [Link]();
int cols = [Link]();
[Link](1); // column name
[Link](1); // data type name
[Link](1); // column width

Method Returns
getColumnCount() Number of columns
getColumnName(i) Name of column i
getColumnTypeName(i) Data type of column i
isNullable(i) Whether column allows null
getTableName(i) Table name for column i
4.11 Catching Database Results & Handling Queries
try {
[Link]("[Link]");
Connection con = [Link](url, user, pass);
PreparedStatement ps = [Link]("SELECT * FROM emp WHERE dept=?");
[Link](1, "IT");
ResultSet rs = [Link]();
while([Link]()) {
[Link]([Link](1) + " " + [Link](2));
}
[Link](); [Link](); [Link]();
} catch(ClassNotFoundException e) {
[Link]("Driver not found: " + [Link]());
} catch(SQLException e) {
[Link]("DB Error: " + [Link]());
}

4.12 Transaction Management

[Link](false); // disable auto-commit
try {
[Link]("INSERT ...");
[Link]("UPDATE ...");
[Link](); // save changes
} catch(SQLException e) {
[Link](); // undo changes
}
 ⚡ QUICK REVISION — Important Comparisons
String vs StringBuffer vs StringBuilder
Property String StringBuffer StringBuilder
Mutable? NO YES YES
Thread-safe? YES YES NO
Performance Slow (for modifications) Moderate Fast
Use when Fixed text Multi-threaded Single-threaded
modification modification

Interface vs Abstract Class

Feature Interface Abstract Class
Methods All abstract (default: public Can have abstract + concrete
abstract)
Variables public static final only Any type of variables
Constructor No Yes
Multiple inheritance YES (implement multiple) NO (extend one only)
When to use When unrelated classes share When related classes share code
behavior

Checked vs Unchecked Exceptions

Feature Checked Unchecked
When checked Compile time Runtime
Must handle? YES (catch or throws) NO (optional)
Inherit from Exception (not RuntimeException) RuntimeException
Examples IOException, SQLException NullPointerException,
ArithmeticException

Statement vs PreparedStatement vs CallableStatement

Feature Statement PreparedStatement CallableStatement
SQL type Static SQL Parameterized SQL Stored procedures
(with ?)
Performance Low (re-compiled each High (pre-compiled) High
time)
SQL Injection? Vulnerable Safe Safe
When to use DDL, simple queries Repeated queries with Stored
params procedures/functions

Byte Stream vs Character Stream

Feature Byte Stream Character Stream
Data Raw bytes (0-255) Characters (Unicode)
Feature Byte Stream Character Stream
Base classes InputStream / OutputStream Reader / Writer
Used for Images, audio, binary Text files
Unit byte char (2 bytes)

Overloading vs Overriding
Feature Overloading Overriding
Where Same class Parent-Child classes
Method name Same Same
Parameters Different Same
Return type Can differ Same (or covariant)
Binding Compile-time (static) Runtime (dynamic)
Polymorphism type Compile-time Runtime
static/final? Can overload Cannot override static/final

Thread Ways: extends Thread vs implements Runnable

Feature extends Thread implements Runnable
Inheritance Can't extend other class Free to extend another class
Code reuse Less flexible More flexible (preferred)
Object sharing Not easily shared Same Runnable can be used by
multiple threads
When to use Simple thread tasks When flexibility needed (preferred
way)
 📌📌 Last-Minute Exam Tips
Most Likely Question Areas
▸ Write a Java program demonstrating inheritance with method overriding
▸ Explain JDBC steps with code to connect to database and display results
▸ Explain exception handling with try-catch-finally and custom exception
▸ Difference between String, StringBuffer, StringBuilder with examples
▸ Thread life cycle diagram + creating thread using Runnable interface
▸ Difference between Statement, PreparedStatement, CallableStatement
▸ byte stream vs character stream classes with examples
▸ Explain all OOP concepts with examples

Code Patterns to Remember

★ JDBC Pattern: Load Driver → getConnection() → createStatement() → executeQuery() → [Link]() loop
→ close()
★ Thread Pattern: class implements Runnable → override run() → new Thread(obj) → start()
★ Exception Pattern: try { risky } catch(Specific e) { handle } catch(Exception e) { general } finally { cleanup }
★ Inheritance Pattern: class Child extends Parent → @Override methods → use super() for parent
constructor

Key Definitions to Know

Term 1-line Definition
JVM Virtual machine that executes Java bytecode
Encapsulation Binding data and methods together; hiding data
using access modifiers
Polymorphism One interface, multiple implementations
Abstraction Hiding internal details, showing only functionality
Serialization Converting object to byte stream for
storage/transmission
Synchronization Controlling thread access to shared resources
Garbage Collection Automatic memory management — JVM frees
unused objects
JDBC Java API for connecting to relational databases
ResultSet Object that holds query results, navigated using
next()
Package Namespace/folder for organizing related Java
classes

ALL THE BEST FOR YOUR EXAM! You've got this! 🎯🎯