Introduction
Object-Oriented Programming Concepts
What Is an Object?
What Is a Class?
What Is Inheritance?
What Is an Interface?
What Is a Package?
Language Basics
Variables
Primitive Data Types
Operators
Assignment, Arithmetic, and Unary Operators
Equality, Relational, and Conditional Operators
Bitwise and Bit Shift Operators
Expressions, Statements, and Blocks
Control Flow Statements
The if-then and if-then-else Statements
The switch Statement
The while and do-while Statements
The for Statement
Branching Statements
Classes and Objects
Classes
Declaring Classes
Declaring Member Variables
Defining Methods
Constructors
Passing Information to a Method or a Constructor
Objects
Creating Objects
Using Objects
More on Classes
Returning a Value from a Method
Controlling Access to Members of a Class
Understanding Class Members
Initializing Fields
EXPERT
Numbers and Strings
Numbers
The Numbers Classes
Formatting Numeric Print Output
Characters
Strings
Converting Between Numbers and Strings
Manipulating Characters in a String
Comparing Strings and Portions of Strings
The StringBuilder Class
Autoboxing and Unboxing
Promotion and Caution with Promotion
Methods
Creating and Using Methods
Static Methods and Variables
Passing an Object Reference
Creating Overloaded Methods
Arrays, Loops, and Dates
Iterating Through Data
LocalDateTime
Describing One & Two-Dimensional Arrays
Packages
Creating and Using Packages
Creating a Package
Naming a Package
Using Package Members
Managing Source and Class Files
Annotations
Annotations Basics
Declaring an Annotation Type
Predefined Annotation Types
Type Annotations and Pluggable Type Systems
Repeating Annotations
Encapsulation
Encapsulating Attribute
Getters and Setters methods
Adding Constructors
Inheritance and Polymorphism
Multiple Inheritance of State, Implementation, and Type
Overriding and Hiding Methods
Polymorphism
Hiding Fields
Using the Keyword :this and super
Object as a Superclass
Writing Final Classes and Methods
Abstract classes and Interfaces
Using abstract keywords
Defining an Interface
Implementing an Interface
Using an Interface as a Type
Evolving Interfaces
Default , Static and Private Methods
Nested Classes
Local Classes
Anonymous Classes
Lambda Expressions
When to Use Nested Classes, Local Classes, Anonymous Classes, and LambdaExpressions
Enum Types
Exceptions Handling,Logging and Assertions
What is Handling Exception?
Types of Exceptions
Using Try ,Catch and finally
Try with Resources
Extending Exception and Throwing Exception
Custom Exception
Logging
Debugging Tips
Disabling and Enabling Assertions
Collections and Generics
What is the Collections Framework?
Iterators
Type-Wrapper Classes
What are Generic ?
Collection Interface: LIST,SET and QUEUE Interface
ArrayList and LinkedList
HashSet ,LinkedHastSet, TreeSet
DQUEUE: Array Dqueue and Priority Queue
Map Interface : HashMap,LinkedHaspMap and TreeMap
Comparator and Comparable Interface
Functional Programming
Functional Interfaces and Lambda Expressions
Collections Streams, and Filters
Built-in Functional Interfaces
Creating Consumer Lambda Expression
Creating a Function Lambda Expression
Creating a Supplier Lambda Expression
Creating a BiPredicate Lambda Expression
Modular Programming
Introduction to Modular Programming in Java
Use of Modular Programming
Services in a Modular Application
Migration to a Modular Application
Java I/O Fundamentals and File I/O (NIO.2)
Java I/O Fundamentals : Byte and Character Streams
New File I/O API (NIO.2)
Writing a Simple Console I/O Application
Working with Files
Concurrency
Task Scheduling
Legacy Thread and Runnable
Extending Thread
Implementing Runnable
The java.util.concurrent Package
Recommended Threading Classes
java.util.concurrent.ExecutorService
Shutting Down an ExecutorService
java.util.concurrent.Callable
java.util.concurrent.Future
Threading Concerns
Shared Data
Problems with Shared Data
The synchronized Keyword
synchronized Methods
synchronized Blocks
Object Monitor Locking
Threading Performance
java.util.concurrent Classes and Packages
The java.util.concurrent.atomic Package
java.util.concurrent.CyclicBarrier
Thread-Safe Collections
using Fork-Join Framework
Parallel Streams and Filter
Streams Review
Old Style Collection Processing
New Style Collection Processing
Stream Pipeline
Parallel Stream
Using Parallel Streams: Collection
Using Parallel Streams: From a Stream
Pipelines Fine Print
Embrace Statelessness
Avoid Statefulness
Streams Are Deterministic for Most Part
Some Are Not Deterministic
Reduction
Reduction Fine Print
Filters
User Interface Components with Swing
Swing and the Model-View-Controller Design Pattern
Building Database Applications with JDBC
Using the JDBC API
Using a Vendor's Driver Class
Key JDBC API Components
Writing Queries and Getting Results
Using a ResultSet Object
CRUD Operations Using JDBC API: Retrieve, Create , Update, Delete
SQLException Class
Closing JDBC Objects
try-with-resources Construct
Use Statement and PreparedStatement
Localization
Why Localize?
A Sample Application
Locale ,Properties , Resource Bundle
The printMenu Method
Changing the Locale
Format Date and Currency