Session 1: A First LookA Simple Java ClassJava’s “Hello World” ProgramThe Java Shell (REPL)LABS:Hello World: A Simple Application
A Simple Java Class
Java’s “Hello World” Program
The Java Shell (REPL)LABS:Hello World: A Simple Application
LABS:
Hello World: A Simple Application
Session 2: Java BasicsLanguage and Platform FeaturesThe Java Release CycleProgram Life CycleThe Java SE Development Kit (JDK)LABS:Working with the Development Environment
Language and Platform Features
The Java Release Cycle
Program Life Cycle
The Java SE Development Kit (JDK)LABS:Working with the Development Environment
LABS:
Working with the Development Environment
Session 3: Class and Object BasicsThe Object Model and Object-Oriented ProgrammingClasses, References, and InstantiationAdding Data to a Class DefinitionAdding Methods (Behavior)LABS:Exploring Types and Object InstancesWriting and Using a Class Definition with Fields and Methods
The Object Model and Object-Oriented Programming
Classes, References, and Instantiation
Adding Data to a Class Definition
Adding Methods (Behavior)LABS:Exploring Types and Object InstancesWriting and Using a Class Definition with Fields and Methods
LABS:
Exploring Types and Object Instances
Writing and Using a Class Definition with Fields and Methods
Session 4: More on Classes and ObjectsAccessing data, the "this" variableEncapsulation and Access Control, public and private AccessConstructors and InitializationStatic Members of a ClassType Inference (Java 10+)Scopes, Blocks, References to ObjectsType-safe EnumsLABS:Encapsulation / Access ProtectionWriting and Using Constructors(Optional) Static MembersUsing enumsUsing the Debugger
Accessing data, the "this" variable
Encapsulation and Access Control, public and private Access
Constructors and Initialization
Static Members of a Class
Type Inference (Java 10+)
Scopes, Blocks, References to Objects
Type-safe EnumsLABS:Encapsulation / Access ProtectionWriting and Using Constructors(Optional) Static MembersUsing enumsUsing the Debugger
LABS:
Encapsulation / Access Protection
Writing and Using Constructors
(Optional) Static Members
Using enums
Using the Debugger
Session 5: Flow of ControlBranching: if, if-else, switchIteration: while, do-while, for, break, continueLABS:Flow of Control / Data Validation
Branching: if, if-else, switch
Iteration: while, do-while, for, break, continueLABS:Flow of Control / Data Validation
LABS:
Flow of Control / Data Validation
Session 6: Strings, Arrays, and Dates/TimesString, StringBuffer, StringBuilderArrays, Primitive Arrays, Arrays of Reference TypesvarargsLocalDate/LocalTime (Java 8+)LABS:Using Strings and Arrays
String, StringBuffer, StringBuilder
Arrays, Primitive Arrays, Arrays of Reference Types
varargs
LocalDate/LocalTime (Java 8+)LABS:Using Strings and Arrays
LABS:
Using Strings and Arrays
Session 7: Packages and ModulesPackage Overview - Using Packages to Organize Codeimport statementsCreating Packages, package Statement, Required Directory StructureJava 9 Module OverviewDefining Modules, Requires, and ExportsModule Path and Classpath - Differences and CoexistenceLABS:Using Packages and Modules
Package Overview - Using Packages to Organize Code
import statements
Creating Packages, package Statement, Required Directory Structure
Java 9 Module Overview
Defining Modules, Requires, and Exports
Module Path and Classpath - Differences and CoexistenceLABS:Using Packages and Modules
LABS:
Using Packages and Modules
Session 8: Composition and InheritanceUsing Composition to Deal With ComplexityComposition/HAS-A, DelegationUsing Inheritance and Polymorphism to share commonalityIS-A, extends, Inheriting Features, Overriding Methods, Using PolymorphismClass ObjectAbstract ClassesLABS:(Optional) Working with CompositionUsing Inheritance to Specialize Classes
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Class Object
Abstract ClassesLABS:(Optional) Working with CompositionUsing Inheritance to Specialize Classes
LABS:
(Optional) Working with Composition
Using Inheritance to Specialize Classes
Session 9: InterfacesUsing Interfaces to Define TypesInterfaces and Abstract ClassesDefault Methods and static Methods (Java 8)LABS:Using Interfaces to Remove Implementation Dependencies
Using Interfaces to Define Types
Interfaces and Abstract Classes
Default Methods and static Methods (Java 8)LABS:Using Interfaces to Remove Implementation Dependencies
LABS:
Using Interfaces to Remove Implementation Dependencies
Session 10: ExceptionsExceptions and the Exception HierarchyTry and catchHandling ExceptionsProgram Flow with ExceptionsFinallyLABS:Throwing and Handling Exceptions
Exceptions and the Exception Hierarchy
Try and catch
Handling Exceptions
Program Flow with Exceptions
FinallyLABS:Throwing and Handling Exceptions
LABS:
Throwing and Handling Exceptions
Session 11: Java Collections and GenericsThe Collections Framework and its APICollections and Java GenericsCollection, Set, List, Map, IteratorAutoboxingCollections of Object (non-generic)Using ArrayList, HashSet, and HashMap for each LoopProcessing Items With an IteratorMore About GenericsLABS:Using Lists and GenericsUsing Sets
The Collections Framework and its API
Collections and Java Generics
Collection, Set, List, Map, Iterator
Autoboxing
Collections of Object (non-generic)
Using ArrayList, HashSet, and HashMap for each Loop
Processing Items With an Iterator
More About GenericsLABS:Using Lists and GenericsUsing Sets
LABS:
Using Lists and Generics
Using Sets
Session 12: Database Access with JDBC and JPAli>JDBC OverviewJDBC Architecture and APIUsing DriverManager, Connection, Statement and ResultSetJPA OverviewJPA Architecture and Programming ViewEntity Classes and AnnotationsMapping an Entity ClassEntityManagerFactory and EntityManagerWorking with JPA (Find by primayry key and inserts)LABS:Mapping an Entity ClassWorking with JPA
li>JDBC Overview
JDBC Architecture and API
Using DriverManager, Connection, Statement and ResultSet
JPA Overview
JPA Architecture and Programming View
Entity Classes and Annotations
Mapping an Entity Class
EntityManagerFactory and EntityManager
Working with JPA (Find by primayry key and inserts)LABS:Mapping an Entity ClassWorking with JPA
LABS:
Mapping an Entity Class
Working with JPA
Session 13: Additional Java FeaturesAnnotationsLambda Expressions and Method References (Java 8+)Additional Features
Annotations
Lambda Expressions and Method References (Java 8+)
Additional Features
Session 14: I/O Streams (As Time Allows)Readers and WritersFilter StreamsByte StreamsFormatted OutputThe File ClassNew I/O (NIO) APIsLABS:Formatting Output
Readers and Writers
Filter Streams
Byte Streams
Formatted Output
The File Class
New I/O (NIO) APIsLABS:Formatting Output
LABS:
Formatting Output

Learner Outcomes
Understand Java’s importance, uses, strengths and weaknesses
Understand the release cycle and Long Term Support (LTS) releases
Understand Java language basics
Write, compile, and run Java programs
Use the Java shell (JShell - Java 9+) for interactive programming
Understand the Object Model and Object Oriented Programming
Understand and use classes, inheritance, polymorphism
Create well designed classes and use them in your Java programs
Use composition and delegation to create objects from other objects
Understand & use packages to organize code
Understand and use Java 9 modules
Understand interfaces, their importance, and their uses
Use interfaces to implement abstraction
Learn good Java coding style
Create well structured Java programs
Compile and execute programs with the JDK development tools and with an Integrated Development Environment (IDE) of your choice
Use the core Java libraries (java.lang, java.util)
Understand & use exceptions for error handling
Understand the basics of using JDBC and JPA, and use them to access databases from Java
Use the Java Collections Framework including new API introduced in Java 9-11
Use other new features such as type inference
Be aware of, and use the new features of Java 9-11, as well as important advanced features of earlier Java versions
Understand and use basic I/O streams (As Time Allows)