Java for Software Engineers: Core OOP, Data Structures, and I/O
Master core Java concepts: OOP, data structures, and I/O, to build robust software applications.
...
Share
Introduction to Java and Setting Up Your Environment
Unit 1: Welcome to Java!
Welcome to Java!
What is Java?
Java's History
Java's Key Features
Java Versions
Unit 2: Setting Up Your Java Environment
JDK vs. JRE vs. JVM
Installing the JDK
Choosing an IDE
Installing IntelliJ IDEA
Installing Eclipse
Unit 3: Your First Java Program
Hello, World!
Running Your Program
Anatomy of a Program
Using an IDE
Next Steps
Java Fundamentals: Data Types, Variables, and Operators
Unit 1: Java Data Types
What are Data Types?
Integer Data Types
Floating-Point Types
Characters and Booleans
Type Conversion
Unit 2: Variables in Java
Declaring Variables
Initializing Variables
Variable Scope
Constants in Java
Unit 3: Operators in Java
Arithmetic Operators
Assignment Operators
Relational Operators
Logical Operators
Operator Precedence
Putting it All Together
Control Flow: Conditional Statements and Loops
Unit 1: Conditional Statements: Making Decisions
Intro to Conditional Logic
The 'if' Statement
'else' for Alternatives
'else if' for More Paths
Nesting Conditionals
Unit 2: Looping Constructs: Repeating Actions
Intro to Loops
The 'for' Loop
The 'while' Loop
The 'do-while' Loop
Loop Control: Break
Loop Control: Continue
Unit 3: Applying Control Flow: Problem Solving
Simple Number Guessing
Calculating Factorial
Prime Number Checker
Introduction to Object-Oriented Programming (OOP)
Unit 1: Understanding OOP Fundamentals
What is OOP?
Classes and Objects
Attributes Explained
Methods: Object Behavior
Your First Class in Java
Unit 2: Creating and Using Objects
Instantiating Objects
Accessing Attributes
Calling Methods
Object Interactions
Object Lifecycle
Unit 3: Diving Deeper into OOP Principles
Encapsulation Intro
Inheritance: Code Reuse
Polymorphism Explained
Real-World OOP Examples
OOP: Best Practices
Encapsulation and Data Hiding
Unit 1: Understanding Encapsulation
What is Encapsulation?
Access Modifiers Intro
Public Access Modifier
Private Access Modifier
Protected Access Modifier
Unit 2: Data Hiding and Getters/Setters
Data Hiding Explained
Why Use Data Hiding?
Getters and Setters Intro
Creating Getters
Creating Setters
Unit 3: Advanced Encapsulation Techniques
Validation in Setters
Immutable Objects
Defensive Copying
Encapsulation Best Practices
Encapsulation Recap
Inheritance and Code Reusability
Unit 1: Understanding Inheritance Basics
What is Inheritance?
Extends Keyword
Simple Inheritance Example
Superclass vs. Subclass
Single Inheritance
Unit 2: Method Overriding and the Super Keyword
Method Overriding Intro
Overriding in Action
The 'super' Keyword
Super() Example
Overriding vs. Hiding
Unit 3: Designing Class Hierarchies
Class Hierarchy Design
Promoting Reusability
Reducing Redundancy
Real-World Examples
Best Practices
Polymorphism and Interfaces
Unit 1: Method Overriding
Intro to Overriding
Rules of Overriding
Override in Action
super Keyword
Overriding Gotchas
Unit 2: Method Overloading
Intro to Overloading
Overload by Parameter
Overload Return Type?
Overloading in Action
Unit 3: Interfaces
What are Interfaces?
Interface Syntax
Interface Constants
Multiple Interfaces
Interface Inheritance
Interfaces in Action
Abstract Classes and Methods
Unit 1: Understanding Abstraction
What is Abstraction?
Abstract Classes Intro
Abstract Methods Intro
Abstract Class vs Interface
Why Use Abstract Classes?
Unit 2: Implementing Abstract Classes
Declaring Abstract Class
Declaring Abstract Method
Extending Abstract Class
Implementing Abstract Method
Abstract Class Example
Unit 3: Advanced Concepts
Abstract Class Constructor
Abstract & Concrete Methods
Abstract Class Design
Real World Abstract
Abstract Class Pitfalls
Data Structures: Arrays and Linked Lists
Unit 1: Arrays in Java
Arrays: The Basics
Declaring Arrays
Initializing Arrays
Accessing Elements
Iterating Through Arrays
Unit 2: Linked Lists: The Basics
Linked Lists: Intro
Singly Linked Lists
Doubly Linked Lists
Creating a Node Class
LinkedList Class
Unit 3: Linked List Operations
Add to Head
Add to Tail
Remove from Head
Remove from Tail
Searching a List
Unit 4: Arrays vs. Linked Lists
Arrays vs. LinkedLists
Data Structures: Stacks and Queues
Unit 1: Introduction to Stacks
What is a Stack?
Stack Operations
Array-Based Stacks
Linked List Stacks
Stack Time Complexity
Unit 2: Introduction to Queues
What is a Queue?
Queue Operations
Array-Based Queues
Circular Queues
Linked List Queues
Unit 3: Applications of Stacks and Queues
Stack Use Case: Reversal
Stack Use Case: Expression Eval
Queue Use Case: Task Sched
Queue Use Case: BFS
Stacks vs. Queues
Data Structures: Hash Maps
Unit 1: Introduction to Hash Maps
What are Hash Maps?
Hash Table Basics
Hashing Explained
Simple Hash Function
Hash Map Performance
Unit 2: Collision Resolution Techniques
What are Collisions?
Chaining: The Basics
Chaining Implementation
Open Addressing Intro
Linear Probing
Unit 3: Advanced Collision Resolution and Usage
Quadratic Probing
Double Hashing
HashMap API
HashMap Use Case
Custom HashMap
File I/O: Reading and Writing Text Files
Unit 1: Introduction to Java File I/O
File I/O: An Overview
Java I/O Streams
Working with the File Class
File Paths: Absolute vs. Relative
Your First File Read
Unit 2: Reading Text Files in Detail
FileReader vs. BufferedReader
Reading Files Line by Line
Reading Character by Character
Closing Streams Properly
Handling Exceptions
Unit 3: Writing to Text Files
FileWriter vs. BufferedWriter
Writing Text to a File
Appending to a File
More Exception Handling
Simple Text Editor
File I/O: Handling Different File Formats (CSV, JSON)
Unit 1: CSV File Handling in Java
CSV Basics
Reading CSV with Scanner
Intro to Apache Commons CSV
Reading CSV with Commons
Writing CSV with Commons
Unit 2: JSON File Handling in Java
JSON Basics
Intro to Jackson Library
Reading JSON with Jackson
Mapping JSON to Objects
Writing JSON with Jackson
Unit 3: Converting Between File Formats
CSV to JSON: Overview
CSV to JSON: Implementation
JSON to CSV: Overview
JSON to CSV: Implementation
Error Handling
Exception Handling and Debugging
Unit 1: Introduction to Exception Handling
What are Exceptions?
Checked vs Unchecked
The Try-Catch Block
Catching Exceptions
Finally Block
Unit 2: Advanced Exception Handling
Try-with-resources
Throwing Exceptions
Exception Propagation
Custom Exceptions
Best Practices
Unit 3: Debugging Techniques
Debugging Tools
Setting Breakpoints
Stepping Through Code
Inspecting Variables
Debugging Strategies