What is Java? | Zero To Mastery Academy

Autoplay
Autocomplete

Previous Lesson Complete and Continue

Java Programming Bootcamp: Zero to Mastery

Introduction

Java Programming Bootcamp: Zero to Mastery (2:11)
Exercise: Meet Your Classmates and Instructor
Understanding Your Video Player (notes, video speed, subtitles + more)
Course Code & Resources
Set Your Learning Streak Goal

Welcome to Java (the language)!

What is Java? (4:16)
When Do We Need Java? Backend vs. Frontend (3:11)
Time To Get Your Hands Dirty - Your First Java Program (4:50)
Quiz
Mac Users: Development Environment Setup
Windows Users: Development Environment Setup
Linux Users: Development Environment Setup
Other Users: Development Environment Setup

Java Application Structure

Creating Classes (6:40)
Using Classes to Create Objects (3:31)
Structuring the Application with Packages (5:31)
Adding Class Members to Classes (7:06)
Understanding the Application Structure (1:48)
Quiz
Let's Have Some Fun (+ Free Resources)

Exercises: Packages and Classes

A Note on Exercises
Exercise: Basic Bank Account
Solution: Basic Bank Account
Exercise: Product Inventory
Solution: Product Inventory
Exercise: University Application
Solution: University Application
Exercise: Football Tournament
Solution: Football Tournament

Working with Variables and Arrays

Understanding Variables (2:30)
Working with Variables in Java (2:34)
Working with Primitives (5:53)
Sizes of Primitives (2:43)
Performing Operations with Operators (1:30)
Arithmetic Operators (4:30)
Assignment Operators (2:07)
Unary Operators (4:21)
Relational Operators (2:12)
Storing Text Variables in Strings (7:15)
Understanding Casting (2:43)
Casting in Java (5:08)
Storing Multiple Values in One Variable (3:22)
Working with Arrays (2:04)
Quiz
Unlimited Updates

Exercises: Primitives, Arrays and Casting

Exercise: Assign and Print Integer Values
Solution: Assign and Print Integer Values
Exercise: Add Two Floating-Point Numbers
Solution: Add Two Floating-Point Numbers
Exercise: Concatenate Two Strings
Solution: Concatenate Two Strings
Exercise: Initialize and Print an Integer Array
Solution: Initialize and Print an Integer Array
Exercise: Multiply Two Integer Variables
Solution: Multiply Two Integer Variables
Exercise: Find the Length of a String
Solution: Find the Length of a String
Exercise: Initialize and Print a String Array
Solution: Initialize and Print a String Array
Exercise: Divide Two Double Variables
Solution: Divide Two Double Variables
Exercise: Cast a Double to an Int
Solution: Case a Double to an Int

Primitives vs. Objects

Primitives vs. Objects (3:51)
Objects Containing Primitives (1:09)
Objects Containing Objects (2:23)
Understanding the Stack and Heap (4:47)
The Meaning of Pass by Value (4:58)
Quiz
Implement a New Life System

Exercises: Objects

Exercise: Create a Simple Object with Primitives
Solution: Create a Simple Object with Primitives
Exercise: Create an Object Containing Other Objects
Solution: Create an Object Containing Other Objects
Exercise: Predict the Output of the Code
Solution: Predict the Output of the Code
Exercise: Pass Primitive Data Type to a Method
Solution: Pass Primitive Data Type to a Method
Exercise: Pass Object to a Method
Solution: Pass Object to a Method

Control Flow

If Statement (3:16)
Demo: If Statement (6:27)
Switch Statement (3:51)
Demo: Switch Statement (6:46)
While Loop (2:53)
Demo: While Loop (3:59)
Do While Loop (2:10)
Demo: Do While Loop (2:12)
For Loop (3:09)
Demo: For Loop (4:12)
Foreach Loop (1:58)
Demo: Foreach Loop (1:49)
Controlling Loops with Break and Continue (5:48)
Quiz
Course Check-In

Exercises: Control Flow Statements

Exercise: Determine Entrance Ticket Price Using If Statement
Solution: Determine Entrance Ticket Price Using If Statement
Exercise: Comment on a Student's Grade Using Switch Statement
Solution: Comment on a Student's Grade Using Switch Statement
Exercise: Print All Values in an Array Using a For Loop
Solution: Print All Values in an Array Using a For Loop
Exercise: Print the First N Even Numbers Using a While Loop
Solution: Print the First N Even Numbers Using a While Loop
Exercise: Print a Sequence of Numbers Using a Do-While Loop
Solution: Print a Sequence of Numbers Using a Do-While Loop
Exercise: Calculate the Sum of an Array Using a For-Each Loop
Solution: Calculate the Sum of an Array Using a For-Each Loop
Exercise: Determine the Highest and Lowest Grades Using Control Flow Statements
Solution: Determine the Highest and Lowest Grades Using Control Flow Statements
Exercise: Find the Average of Odd Numbers in an Array Using Control Flow Statements
Solution: Find the Average of Odd Numbers in an Array Using Control Flow Statements

Writing & Using Methods in Java

The Syntax of a Basic Method (2:36)
Adding Input Parameters to Methods (2:43)
Adding the Return Type and the Return Statement (2:19)
Invoking Different Methods (3:40)
Quiz
Exercise: Imposter Syndrome (2:55)

Exercises: Methods

Exercise: Basic Method
Solution: Basic Method
Exercise: Method with Input Parameters
Solution: Method with Input Parameters
Exercise: Method with Return Type and Return Statement
Solution: Method with Return Type and Return Statement
Exercise: Invoking Methods from Another Class
Solution: Invoking Methods from Another Class
Exercise: Create a Method to Perform Several Calculations and Invoke It from Another Class
Solution: Create a Method to Perform Several Calculations and Invoke It from Another Class

Access Modifiers and Static

Understanding Access Modifiers (2:06)
Public Access Modifier (1:42)
Demo: Public (2:14)
Private Access Modifier (3:06)
Demo: Private (2:17)
Default Access (No Modifier) (2:17)
Demo: Default (1:25)
Protected Access Modifier (1:54)
Demo: Protected (1:51)
Static Modifier (4:36)
Demo: Static (3:14)
Quiz

Exercises: Access Modifiers and Static

Exercise: Access Modifiers - Public, Protected, Default, Private
Solution: Access Modifiers - Public, Protected, Default, Private
Exercise: Static Modifier
Solution: Static Modifier
Exercise: Fix the Problem
Solution: Fix the Problem

Working with Text Variables (String and StringBuilder)

String Class (1:05)
Methods on the String Class (5:41)
Understanding String Immutability (6:19)
Comparing Strings (5:04)
Working with StringBuilder (4:41)
Quiz

Exercises: String and StringBuilder

Exercise: String Class
Solution: String Class
Exercise: Methods on the String Class
Solution: Methods on the String Class
Exercise: Immutability of Strings
Solution: Immutability of Strings
Exercise: Comparing Strings
Solution: Comparing Strings
Exercise: StringBuilder - Create, Compare, Concatenate, and Reverse Strings
Solution: StringBuilder - Create, Compare, Concatenate, and Reverse Strings

Working with Dates & Times

LocalDate (5:06)
LocalTime (3:13)
LocalDateTime (4:31)
ZonedDateTime (5:34)
Duration and Period (5:01)
Calculating with Dates and Times (4:13)
Formatting and Parsing Dates (10:01)
Quiz

Exercises: Dates and Times

Exercise: LocalDate
Solution: LocalDate
Exercise: LocalTime
Solution: LocalTime
Exercise: LocalDateTime
Solution: LocalDateTime
Exercise: ZonedDateTime, Duration, and Period
Solution: ZonedDateTime, Duration, and Period
Exercise: Formatting and Parsing Dates
Solution: Formatting and Parsing Dates

Object Oriented Programming (OOP)

Introduction to OOP (3:36)
OOP Pillar 1: Inheritance (5:47)
OOP Pillar 2: Encapsulation (4:22)
OOP Pillar 3: Abstraction (1:53)
OOP Pillar 4: Polymorphism (7:16)
Overriding, Overloading and Hiding (6:55)
Quiz

Exercises: Object Oriented Programming

Exercise: Apply Inheritance and the Three Pillars of OOP with Getters and Setters
Solution: Apply Inheritance and the Three Pillars of OOP with Getters and Setters

Constructors

Constructors Explained (2:40)
Default Constructor (2:18)
Custom Constructor (3:06)
Using super() and this() (5:35)
Constructors and Inheritance (5:34)
Quiz

Exercises: Working with Constructors

Exercise: Default Constructor
Solution: Default Constructor
Exercise: Custom Constructor
Solution: Custom Constructor
Exercise: super() and this()
Solution: super() and this()
Exercise: Constructors and Inheritance
Solution: Constructors and Inheritance

Enums

What Are Enums? (1:45)
Creating and Using Basic Enums (3:22)
Enums with Members (3:52)
How Enums Work Beneath the Surface (4:34)
Quiz

Exercises: Working with Enums

Exercise: Basic Enums
Solution: Basic Enums
Exercise: Enums with Fields
Solution: Enums with Fields
Exercise: Game Statuses Enum
Solution: Game Statuses Enum

Interfaces and Abstract Classes

Understanding Interfaces (4:19)
Creating Interfaces (3:06)
Implementing Interfaces (3:18)
Interfaces with Default Methods (3:14)
Interfaces with Static and Private Methods (2:50)
Implementing Interfaces with Conflicting Method Signatures (2:45)
Abstract Classes and Abstract Methods (6:07)
Final Keyword (2:38)
Quiz

Exercises: Working with Interfaces

Exercise: Creating Interfaces
Solution: Creating Interfaces
Exercise: Implementing Interfaces
Solution: Implementing Interfaces
Exercise: Default Methods in Interfaces
Solution: Default Methods in Interfaces
Exercise: Implementing Interfaces with Conflicting Methods
Solution: Implementing Interfaces with Conflicting Methods

Generics and Collections

Understanding Generics (4:50)
Using Classes with Generics (3:37)
Collection Framework: List (6:16)
Collection Framework: Set (3:12)
Collection Framework: Queue (5:17)
Collection Framework: Map (6:53)
Quiz
Comparable and Comparator

Exercises: Working with Generics and Collections

Exercise: Generics - Parameterized Class
Solution: Generics - Parameterized Class
Exercise: Using Classes with Generics
Solution: Using Classes with Generics
Exercise: Collection Framework - List
Solution: Collection Framework - List
Exercise: Collection Framework - Set
Solution: Collection Framework - Set
Exercise: Collection Framework - Queue
Solution: Collection Framework - Queue
Exercise: Collection Framework - Map
Solution: Collection Framework - Map
Exercise: Create a Class Bag with a Type Parameter and Collection
Solution: Create a Class Bag with a Type Parameter and Collection

Exceptions

Understanding Exceptions (1:41)
Throwing Exceptions (4:08)
Checked and Unchecked Exceptions (4:46)
Handling Exceptions: Throws (4:30)
Handling Exceptions: Try/Catch (3:12)
Handling Exceptions: Try with Resources (5:27)
Creating Custom Exceptions (6:29)
Quiz

Exercises: Working with Exceptions

Exercise: Throwing Exceptions
Solution: Throwing Exceptions
Exercise: Handling Exceptions - Try/Catch
Solution: Handling Exceptions - Try/Catch
Exercise: Checked vs Unchecked Exceptions
Solution: Checked vs Unchecked Exceptions
Exercise: Custom Checked Exception, Method, and Handling
Solution: Custom Checked Exception, Method, and Handling

Reading and Writing Files

Reading and Writing Files (2:10)
Reading Files with FileReader (4:50)
Writing to Files with FileWriter (4:05)
Quiz

Exercises: Reading and Writing Files

Exercise: Reading from a File
Solution: Reading from a File
Exercise: Writing to a File
Solution: Writing to a File
Exercise: Read from a File and Copy to a New File
Solution: Read from a File and Copy to a New File

Lambda Expressions and Functional Interfaces

Functional Interfaces (3:10)
Getting Started with Lambda Expressions (1:53)
Understanding Lambda Expressions (2:45)
Writing Lambda Expression (9:05)
Lambda Expressions as Arguments (8:29)
Scope and Lambda Expressions (4:30)
Built-in Functional Interfaces (8:38)
Quiz

Exercises: Lambda Expressions and Functional Interfaces

Exercise: Functional Interface
Solution: Functional Interface
Exercise: Lambda Expression
Solution: Lambda Expression
Exercise: Lambda Expression for Comparison
Solution: Lambda Expression for Comparison
Exercise: Another Functional Interface
Solution: Another Functional Interface
Exercise: Implementing the StringFormatter Interface
Solution: Implementing the StringFormatter Interface

Functional Programming

Understanding Streams (2:45)
Shorthand Lambda Expression: Method Reference (8:53)
Stream API: Source Operations (4:53)
Stream API: Terminal Operations (10:39)
Stream API: Intermediate Operations (4:19)
Using the Stream API: Practical Examples (3:18)
Quiz

Exercises: Functional Programming

Exercise: Method Reference
Solution: Method Reference
Exercise: Stream API - Filtering and Mapping
Solution: Stream API - Filtering and Mapping
Exercise: Stream API - Terminal Operations
Solution: Stream API - Terminal Operations
Exercise: Stream API - Intermediate Operations
Solution: Stream API - Intermediate Operations
Exercise: Rewrite a For Loop using forEach
Solution: Rewrite a For Loop using forEach
Exercise: Sum of Squares using Reduce
Solution: Sum of Squares using Reduce
Exercise: Find Maximum Value using Stream API
Solution: Find Maximum Value using Stream API

The Java Memory

Different Parts of the Memory: Heap, Stack, Metaspace (6:26)
The Automatic Garbage Collection Process (3:18)
Understanding StackOverflowError and OutOfMemoryError (2:21)
Quiz

Concurrency and Multithreading

Understanding Concurrency and Multithreading (3:54)
Working with Threads (7:21)
Atomic Classes (4:10)
Synchronized (4:36)
Lock Interface (5:13)
Concurrent Collections (4:54)
ExecutorService and Thread Pools (5:34)
Common Problems in Multithreading (9:33)

Exercises: Concurrency and Multithreading

Exercise: Basic Thread Creation
Solution: Basic Thread Creation
Exercise: Runnable Interface
Solution: Runnable Interface
Exercise: Synchronized Method
Solution: Synchronized Method
Exercise: Using ExecutorService
Solution: Using ExecutorService

Projects - Build, Build, Build!

Using Scanner for Interactive Console Apps (4:15)
Create a Wordle Game
Solution: Wordle
Create a Hangman Game
Solution: Hangman
Create a Tic Tac Toe Game
Solution: Tic Tac Toe
Create a Trivia Game
Solution: Trivia

Where To Go From Here?

Thank You (1:17)
Review This Course!
Become An Alumni
Learning Guideline
ZTM Events Every Month
LinkedIn Endorsements

What is Java?