Understanding the Java Class Structure
Fields and Methods
Comments
Classes vs. Files
Writing a main() Method
Understanding Package Declarations and Imports
Wildcards
Redundant Imports
Naming Conflicts
Creating a New Package
Creating Objects
Constructors
Reading and Writing Object Fields
Instance Initializer Blocks
Order of Initialization
Distinguishing Between Object References and Primitives
Primitive Types
Reference Types
Key Differences
Declaring and Initializing Variables
Declaring Multiple Variables
Identifiers
Understanding Default Initialization of Variables
Local Variables
Instance and Class Variables
Understanding Variable Scope
Ordering Elements in a Class
Destroying Objects
Garbage Collection
Understanding Java Operators
Working with Binary Arithmetic Operators
Arithmetic Operators
Numeric Promotion
Working with Unary Operators
Logical Complement and Negation Operators
Increment and Decrement Operators
Using Additional Binary Operators
Assignment Operators
Compound Assignment Operators
Relational Operators
Logical Operators
Equality Operators
Understanding Java Statements
The if-then Statement
The if-then-else Statement
The switch Statement
The while Statement
The do-while Statement
The for Statement
Understanding Advanced Flow Control
Nested Loops
Adding Optional Labels
The break Statement
The continue Statement
Creating and Manipulating Strings
Concatenation
Immutability
The String Pool
Important String Methods
Method Chaining
Using the StringBuilder Class
Mutability and Chaining
Creating a StringBuilder
Important StringBuilder Methods
StringBuilder vs. StringBuffer
Understanding Equality
Understanding Java Arrays
Creating an Array of Primitives
Creating an Array with Reference Variables
Using an Array
Sorting
Searching
Varargs
Multidimensional Arrays
Understanding an ArrayList
Creating an ArrayList
Using an ArrayList
Wrapper Classes
Autoboxing
Converting Between array and List
Sorting
Working with Dates and Times
Creating Dates and Times
Manipulating Dates and Times
Working with Periods
Formatting Dates and Times
Parsing Dates and Times
Return Type
Method Name
Parameter List
Optional Exception List
Method Body
Working with Varargs
Applying Access Modifiers
Private Access
Default (Package Private) Access
Protected Access
Public Access
Designing Static Methods and Fields
Calling a Static Variable or Method
Static vs. Instance
Static Variables
Static Initialization
Static Imports
Passing Data Among Methods
Overloading Methods
Creating Constructors
Default Constructor
Overloading Constructors
Final Fields
Order of Initialization
Encapsulating Data
Creating Immutable Classes
Writing Simple Lambdas
Lambda Example
Lambda Syntax
Predicates
Introducing Class Inheritance
Extending a Class
Applying Class Access Modifiers
Creating Java Objects
Defining Constructors
Calling Inherited Class Members
Inheriting Methods
Inheriting Variables
Creating Abstract Classes
Defining an Abstract Class
Creating a Concrete Class
Extending an Abstract Class
Implementing Interfaces
Defining an Interface
Inheriting an Interface
Interface Variables
Default Interface Methods
Static Interface Methods
Understanding Polymorphism
Object vs. Reference
Casting Objects
Virtual Methods
Polymorphic Parameters
Polymorphism and Method Overriding
Understanding Exceptions
The Role of Exceptions
Understanding Exception Types
Throwing an Exception
Using a try Statement
Adding a finally Block
Catching Various Types of Exceptions
Throwing a Second Exception
Recognizing Common Exception Types
Runtime Exceptions
Checked Exceptions
Errors
Calling Methods That Throw Exceptions
