Java Fundamentals

0%Certificate0/442

Join the Community

History of Java

Features of Java

JDK, JRE, and JVM

Setting Up Environment

First Java Program

Variables & Data Types

Exercise: Variables & Data Types

Primitive Types

Exercise: Primitive Types

Reference Types

Exercise: Reference Types

Exercise: Type Casting

Exercise: Operators

Exercise: Input & Output

Exercise: Comments

Naming Conventions

Exercise: Naming Conventions

If-Else Statements

Exercise: If-Else Statements

Switch Statement

Exercise: Switch Statement

Exercise: For Loop

Exercise: While Loop

Exercise: Do-While Loop

Enhanced For Loop

Exercise: Enhanced For Loop

Break & Continue

Exercise: Break & Continue

Labeled Statements

Exercise: Labeled Statements

Exercise: Arrays Basics

Array Operations

Exercise: Array Operations

Multidimensional Arrays

Exercise: Multidimensional Arrays

Exercise: Arrays Class

Exercise: Copying Arrays

Exercise: String Basics

Exercise: String Methods

String Immutability

Exercise: String Immutability

Exercise: StringBuilder

Exercise: StringBuffer

String Formatting

Exercise: String Formatting

String Comparison

Exercise: String Comparison

Regular Expressions

Exercise: Regular Expressions

Exercise: Methods Basics

Method Parameters

Exercise: Method Parameters

Exercise: Return Types

Method Overloading

Exercise: Method Overloading

Variable Arguments (Varargs)

Exercise: Variable Arguments (Varargs)

Exercise: Recursion

Exercise: Pass by Value

Classes & Objects

Exercise: Classes & Objects

Exercise: Constructors

Exercise: this Keyword

Access Modifiers

Exercise: Access Modifiers

Getters & Setters

Exercise: Getters & Setters

Exercise: static Keyword

Exercise: final Keyword

Initializer Blocks

Exercise: Initializer Blocks

Exercise: Inner Classes

Anonymous Classes

Exercise: Anonymous Classes

Exercise: Record Classes

Exercise: Sealed Classes

Inheritance Basics

Exercise: Inheritance Basics

extends Keyword

Exercise: extends Keyword

Exercise: super Keyword

Method Overriding

Exercise: Method Overriding

Constructor Chaining

Exercise: Constructor Chaining

Exercise: Object Class

instanceof Operator

Exercise: instanceof Operator

Polymorphism Basics

Exercise: Polymorphism Basics

Compile-Time Polymorphism

Exercise: Compile-Time Polymorphism

Runtime Polymorphism

Exercise: Runtime Polymorphism

Dynamic Method Dispatch

Exercise: Dynamic Method Dispatch

Covariant Return Types

Exercise: Covariant Return Types

Abstract Classes

Exercise: Abstract Classes

Abstract Methods

Exercise: Abstract Methods

Exercise: Interfaces

Default Methods

Exercise: Default Methods

Static Interface Methods

Exercise: Static Interface Methods

Private Interface Methods

Exercise: Private Interface Methods

Functional Interfaces

Exercise: Functional Interfaces

Marker Interfaces

Exercise: Marker Interfaces

Encapsulation Basics

Exercise: Encapsulation Basics

Exercise: Data Hiding

Immutable Classes

Exercise: Immutable Classes

Exercise: Packages

import Statement

Exercise: import Statement

Exercise: Static Import

Java Modules (JPMS)

Exercise: Java Modules (JPMS)

module-info.java

Exercise: module-info.java

Exception Basics

Exercise: Exception Basics

try-catch Block

Exercise: try-catch Block

Multiple Catch Blocks

Exercise: Multiple Catch Blocks

Exercise: finally Block

Exercise: throw Keyword

Exercise: throws Keyword

Checked vs Unchecked Exceptions

Exercise: Checked vs Unchecked Exceptions

Custom Exceptions

Exercise: Custom Exceptions

try-with-resources

Exercise: try-with-resources

Exception Chaining

Exercise: Exception Chaining

Collections Overview

Exercise: Collections Overview

Collection Interface

Exercise: Collection Interface

Exercise: List Interface

Exercise: ArrayList

Exercise: LinkedList

Exercise: Vector

Exercise: Stack

Exercise: Set Interface

Exercise: HashSet

Exercise: LinkedHashSet

Exercise: TreeSet

Queue Interface

Exercise: Queue Interface

Exercise: PriorityQueue

Deque Interface

Exercise: Deque Interface

Exercise: ArrayDeque

Exercise: Map Interface

Exercise: HashMap

Exercise: LinkedHashMap

Exercise: TreeMap

Exercise: Hashtable

Concurrent Collections

Exercise: Concurrent Collections

Collections Utility Class

Exercise: Collections Utility Class

Comparable & Comparator

Exercise: Comparable & Comparator

Iterator & ListIterator

Exercise: Iterator & ListIterator

Generics Basics

Exercise: Generics Basics

Generic Classes

Exercise: Generic Classes

Generic Methods

Exercise: Generic Methods

Bounded Type Parameters

Exercise: Bounded Type Parameters

Exercise: Wildcards

Exercise: Type Erasure

Generic Restrictions

Exercise: Generic Restrictions

Lambda Expressions

Exercise: Lambda Expressions

Method References

Exercise: Method References

Exercise: Streams Basics

Stream Operations

Exercise: Stream Operations

Intermediate Operations

Exercise: Intermediate Operations

Terminal Operations

Exercise: Terminal Operations

Exercise: Collectors

Parallel Streams

Exercise: Parallel Streams

Exercise: Optional Class

Exercise: File Class

FileInputStream & FileOutputStream

Exercise: FileInputStream & FileOutputStream

FileReader & FileWriter

Exercise: FileReader & FileWriter

BufferedReader & BufferedWriter

Exercise: BufferedReader & BufferedWriter

Exercise: PrintWriter

Exercise: Scanner Class

Exercise: Serialization

Deserialization

Exercise: Deserialization

Exercise: NIO Package

Exercise: Paths & Files

Exercise: File Channels

Exercise: Threads Basics

Creating Threads

Exercise: Creating Threads

Thread Lifecycle

Exercise: Thread Lifecycle

Exercise: Thread Methods

Thread Priority

Exercise: Thread Priority

Synchronization

Exercise: Synchronization

Synchronized Blocks

Exercise: Synchronized Blocks

volatile Keyword

Exercise: volatile Keyword

Exercise: Deadlock

Thread Communication

Exercise: Thread Communication

Exercise: Thread Pools

Executor Framework

Exercise: Executor Framework

Callable & Future

Exercise: Callable & Future

CompletableFuture

Exercise: CompletableFuture

Locks & Conditions

Exercise: Locks & Conditions

Exercise: ReentrantLock

Exercise: ReadWriteLock

Exercise: Semaphore

Exercise: CountDownLatch

Exercise: CyclicBarrier

Fork/Join Framework

Exercise: Fork/Join Framework

Exercise: Atomic Classes

Virtual Threads (Project Loom)

Exercise: Virtual Threads (Project Loom)

Memory Model Basics

Exercise: Memory Model Basics

Exercise: Heap & Stack

Garbage Collection

Exercise: Garbage Collection

Exercise: GC Algorithms

Exercise: Memory Leaks

Weak, Soft & Phantom References

Exercise: Weak, Soft & Phantom References

Annotations Basics

Exercise: Annotations Basics

Built-in Annotations

Exercise: Built-in Annotations

Custom Annotations

Exercise: Custom Annotations

Retention Policy

Exercise: Retention Policy

Annotation Processing

Exercise: Annotation Processing

Reflection Basics

Exercise: Reflection Basics

Exercise: Class Object

Inspecting Classes

Exercise: Inspecting Classes

Accessing Fields & Methods

Exercise: Accessing Fields & Methods

Creating Instances Dynamically

Exercise: Creating Instances Dynamically

Reflection Use Cases

Exercise: Reflection Use Cases

Networking Basics

Exercise: Networking Basics

Exercise: InetAddress

Exercise: URL Class

Exercise: URLConnection

Exercise: Sockets

Exercise: Server Sockets

Datagram Sockets (UDP)

Exercise: Datagram Sockets (UDP)

Exercise: HTTP Client

Exercise: JDBC Basics

Exercise: JDBC Drivers

Connecting to Database

Exercise: Connecting to Database

Statement Interface

Exercise: Statement Interface

PreparedStatement

Exercise: PreparedStatement

CallableStatement

Exercise: CallableStatement

Exercise: ResultSet

Exercise: Transactions

Connection Pooling

Exercise: Connection Pooling

Date & Time Overview

Exercise: Date & Time Overview

Exercise: LocalDate

Exercise: LocalTime

Exercise: LocalDateTime

Exercise: ZonedDateTime

Exercise: Instant

Duration & Period

Exercise: Duration & Period

DateTimeFormatter

Exercise: DateTimeFormatter

var Keyword (Java 10)

Exercise: var Keyword (Java 10)

Text Blocks (Java 15)

Exercise: Text Blocks (Java 15)

Switch Expressions (Java 14)

Exercise: Switch Expressions (Java 14)

Pattern Matching for instanceof (Java 16)

Exercise: Pattern Matching for instanceof (Java 16)

Pattern Matching for switch (Java 21)

Exercise: Pattern Matching for switch (Java 21)

Records (Java 16)

Exercise: Records (Java 16)

Sealed Classes & Interfaces (Java 17)

Exercise: Sealed Classes & Interfaces (Java 17)

Unnamed Patterns (Java 22)

Exercise: Unnamed Patterns (Java 22)

Sequenced Collections (Java 21)

Exercise: Sequenced Collections (Java 21)

String Templates (Java 21)

Exercise: String Templates (Java 21)

Coding Standards

Effective Java Tips

Clean Code Principles

Common Pitfalls

Performance Optimization

Debugging Techniques

Java Fundamentals

Welcome

Course Roadmap
Course Setup
Join the Community

Introduction to Java

What is Java?
History of Java
Features of Java
JDK, JRE, and JVM
Setting Up Environment
First Java Program
How Java Works

Basic Syntax

Variables & Data Types
Exercise: Variables & Data Types
Primitive Types
Exercise: Primitive Types
Reference Types
Exercise: Reference Types
Type Casting
Exercise: Type Casting
Operators
Exercise: Operators
Input & Output
Exercise: Input & Output
Comments
Exercise: Comments
Naming Conventions
Exercise: Naming Conventions

Control Flow

If-Else Statements
Exercise: If-Else Statements
Switch Statement
Exercise: Switch Statement
For Loop
Exercise: For Loop
While Loop
Exercise: While Loop
Do-While Loop
Exercise: Do-While Loop
Enhanced For Loop
Exercise: Enhanced For Loop
Break & Continue
Exercise: Break & Continue
Labeled Statements
Exercise: Labeled Statements

Arrays

Arrays Basics
Exercise: Arrays Basics
Array Operations
Exercise: Array Operations
Multidimensional Arrays
Exercise: Multidimensional Arrays
Arrays Class
Exercise: Arrays Class
Copying Arrays
Exercise: Copying Arrays

Strings

String Basics
Exercise: String Basics
String Methods
Exercise: String Methods
String Immutability
Exercise: String Immutability
StringBuilder
Exercise: StringBuilder
StringBuffer
Exercise: StringBuffer
String Formatting
Exercise: String Formatting
String Comparison
Exercise: String Comparison
Regular Expressions
Exercise: Regular Expressions

Methods

Methods Basics
Exercise: Methods Basics
Method Parameters
Exercise: Method Parameters
Return Types
Exercise: Return Types
Method Overloading
Exercise: Method Overloading
Variable Arguments (Varargs)
Exercise: Variable Arguments (Varargs)
Recursion
Exercise: Recursion
Pass by Value
Exercise: Pass by Value

Object-Oriented Programming

Classes & Objects
Exercise: Classes & Objects
Constructors
Exercise: Constructors
this Keyword
Exercise: this Keyword
Access Modifiers
Exercise: Access Modifiers
Getters & Setters
Exercise: Getters & Setters
static Keyword
Exercise: static Keyword
final Keyword
Exercise: final Keyword
Initializer Blocks
Exercise: Initializer Blocks
Inner Classes
Exercise: Inner Classes
Anonymous Classes
Exercise: Anonymous Classes
Record Classes
Exercise: Record Classes
Sealed Classes
Exercise: Sealed Classes

Inheritance

Inheritance Basics
Exercise: Inheritance Basics
extends Keyword
Exercise: extends Keyword
super Keyword
Exercise: super Keyword
Method Overriding
Exercise: Method Overriding
Constructor Chaining
Exercise: Constructor Chaining
Object Class
Exercise: Object Class
instanceof Operator
Exercise: instanceof Operator

Polymorphism

Polymorphism Basics
Exercise: Polymorphism Basics
Compile-Time Polymorphism
Exercise: Compile-Time Polymorphism
Runtime Polymorphism
Exercise: Runtime Polymorphism
Dynamic Method Dispatch
Exercise: Dynamic Method Dispatch
Covariant Return Types
Exercise: Covariant Return Types

Abstraction

Abstract Classes
Exercise: Abstract Classes
Abstract Methods
Exercise: Abstract Methods
Interfaces
Exercise: Interfaces
Default Methods
Exercise: Default Methods
Static Interface Methods
Exercise: Static Interface Methods
Private Interface Methods
Exercise: Private Interface Methods
Functional Interfaces
Exercise: Functional Interfaces
Marker Interfaces
Exercise: Marker Interfaces

Encapsulation

Encapsulation Basics
Exercise: Encapsulation Basics
Data Hiding
Exercise: Data Hiding
Immutable Classes
Exercise: Immutable Classes

Packages & Modules

Packages
Exercise: Packages
import Statement
Exercise: import Statement
Static Import
Exercise: Static Import
Java Modules (JPMS)
Exercise: Java Modules (JPMS)
module-info.java
Exercise: module-info.java

Exception Handling

Exception Basics
Exercise: Exception Basics
try-catch Block
Exercise: try-catch Block
Multiple Catch Blocks
Exercise: Multiple Catch Blocks
finally Block
Exercise: finally Block
throw Keyword
Exercise: throw Keyword
throws Keyword
Exercise: throws Keyword
Checked vs Unchecked Exceptions
Exercise: Checked vs Unchecked Exceptions
Custom Exceptions
Exercise: Custom Exceptions
try-with-resources
Exercise: try-with-resources
Exception Chaining
Exercise: Exception Chaining

Collections Framework

Generics

Generics Basics
Exercise: Generics Basics
Generic Classes
Exercise: Generic Classes
Generic Methods
Exercise: Generic Methods
Bounded Type Parameters
Exercise: Bounded Type Parameters
Wildcards
Exercise: Wildcards
Type Erasure
Exercise: Type Erasure
Generic Restrictions
Exercise: Generic Restrictions

Lambda & Streams

Lambda Expressions
Exercise: Lambda Expressions
Method References
Exercise: Method References
Streams Basics
Exercise: Streams Basics
Stream Operations
Exercise: Stream Operations
Intermediate Operations
Exercise: Intermediate Operations
Terminal Operations
Exercise: Terminal Operations
Collectors
Exercise: Collectors
Parallel Streams
Exercise: Parallel Streams
Optional Class
Exercise: Optional Class

File I/O

File Class
Exercise: File Class
FileInputStream & FileOutputStream
Exercise: FileInputStream & FileOutputStream
FileReader & FileWriter
Exercise: FileReader & FileWriter
BufferedReader & BufferedWriter
Exercise: BufferedReader & BufferedWriter
PrintWriter
Exercise: PrintWriter
Scanner Class
Exercise: Scanner Class
Serialization
Exercise: Serialization
Deserialization
Exercise: Deserialization
NIO Package
Exercise: NIO Package
Paths & Files
Exercise: Paths & Files
File Channels
Exercise: File Channels

Multithreading

Java Memory Model

Memory Model Basics
Exercise: Memory Model Basics
Heap & Stack
Exercise: Heap & Stack
Garbage Collection
Exercise: Garbage Collection
GC Algorithms
Exercise: GC Algorithms
Memory Leaks
Exercise: Memory Leaks
Weak, Soft & Phantom References
Exercise: Weak, Soft & Phantom References

Annotations

Annotations Basics
Exercise: Annotations Basics
Built-in Annotations
Exercise: Built-in Annotations
Custom Annotations
Exercise: Custom Annotations
Retention Policy
Exercise: Retention Policy
Annotation Processing
Exercise: Annotation Processing

Reflection

Reflection Basics
Exercise: Reflection Basics
Class Object
Exercise: Class Object
Inspecting Classes
Exercise: Inspecting Classes
Accessing Fields & Methods
Exercise: Accessing Fields & Methods
Creating Instances Dynamically
Exercise: Creating Instances Dynamically
Reflection Use Cases
Exercise: Reflection Use Cases

Networking

Networking Basics
Exercise: Networking Basics
InetAddress
Exercise: InetAddress
URL Class
Exercise: URL Class
URLConnection
Exercise: URLConnection
Sockets
Exercise: Sockets
Server Sockets
Exercise: Server Sockets
Datagram Sockets (UDP)
Exercise: Datagram Sockets (UDP)
HTTP Client
Exercise: HTTP Client

JDBC

JDBC Basics
Exercise: JDBC Basics
JDBC Drivers
Exercise: JDBC Drivers
Connecting to Database
Exercise: Connecting to Database
Statement Interface
Exercise: Statement Interface
PreparedStatement
Exercise: PreparedStatement
CallableStatement
Exercise: CallableStatement
ResultSet
Exercise: ResultSet
Transactions
Exercise: Transactions
Connection Pooling
Exercise: Connection Pooling

Date & Time API

Date & Time Overview
Exercise: Date & Time Overview
LocalDate
Exercise: LocalDate
LocalTime
Exercise: LocalTime
LocalDateTime
Exercise: LocalDateTime
ZonedDateTime
Exercise: ZonedDateTime
Instant
Exercise: Instant
Duration & Period
Exercise: Duration & Period
DateTimeFormatter
Exercise: DateTimeFormatter

Modern Java Features

var Keyword (Java 10)
Exercise: var Keyword (Java 10)
Text Blocks (Java 15)
Exercise: Text Blocks (Java 15)
Switch Expressions (Java 14)
Exercise: Switch Expressions (Java 14)
Pattern Matching for instanceof (Java 16)
Exercise: Pattern Matching for instanceof (Java 16)
Pattern Matching for switch (Java 21)
Exercise: Pattern Matching for switch (Java 21)
Records (Java 16)
Exercise: Records (Java 16)
Sealed Classes & Interfaces (Java 17)
Exercise: Sealed Classes & Interfaces (Java 17)
Unnamed Patterns (Java 22)
Exercise: Unnamed Patterns (Java 22)
Sequenced Collections (Java 21)
Exercise: Sequenced Collections (Java 21)
String Templates (Java 21)
Exercise: String Templates (Java 21)

Best Practices

Coding Standards
Effective Java Tips
Clean Code Principles
Common Pitfalls
Performance Optimization
Testing Basics
JUnit Testing
Debugging Techniques

Exercise: Pattern Matching for switch (Java 21)

Medium Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Pattern Matching for...Records (Java 16)