Video description

Table of Contents

Part I

Java Fundamentals: Introduction to Part I

Before You Begin: Setting Up Your Development Environment

Overview

Software Used

Installing the JDK (Required)

Installing Eclipse (Optional)

Installing IntelliJ IDEA

Downloading the Code Examples and Contacting Me for Help

Dive Into NetBeans: Using NetBeans to Compile Exiting Programs and Create New Ones (Optional)

Overview

Getting NetBeans, opening the IDE and configuring tabs and line numbers

Creating a project and adding existing code to the project

Creating a new program

Dive Into Eclipse: Using Eclipse to Compile Exiting Programs and Create New Ones (Optional)

Overview

Getting Eclipse, opening the IDE and configuring tabs and line numbers

Creating a project and adding existing code to the project

Creating a new program

Dive Into IntelliJ IDEA: Using NetBeans to Compile Exiting Programs and Create New Ones (Optional)

Overview

Getting IntelliJ, opening the IDE and configuring tabs and line numbers

Creating a project and adding existing code to the project

Creating a new program

Lesson 1: Test Driving a Java Program at the Command Line

Introduction

Test-Driving the command line

Lesson 2: Introduction to Java Applications

Introduction

Text-printing program

Printing a line of text with multiple statements

Printing multiple lines of text with a single statement

Displaying multiple lines with method System.out.printf

Addition program and an Introduction to using the online Java documentation

Compare integers using if statements, relational operators and equality operators

Lesson 3: Introduction to Classes, Objects, Methods and Strings

Introduction

Account class that contains a name instance variable and methods to set and get its value

Creating and manipulating an Account object

Conceptual view of an Account object

Primitive Types vs. Reference Types

Account class with a constructor that initializes the name instance variable

Using the Account constructor to initialize the name instance variable when each Account object is created

Account class with a double instance variable balance and a constructor and deposit method that perform validation

Inputting and outputting floating-point numbers with Account objects

Lesson 4: Control Statements, Part 1

Introduction

Student Class: Nested if…else Statements

Calculating a class average using the while statement and counter-controller repetition

Calculating a class average using the while statement and sentinel-controller repetition

Arithmetic assignment operators

Prefix increment and postfix increment operators

Lesson 5: Control Statements, Part 2

Introduction

Compound-interest calculations with for

do…while repetition statement

LetterGrades class that uses the switch statement to count letter grades

Demonstrating Strings in switch—Class that represents an auto insurance policy

break statement exiting a for statement

continue statement terminating an iteration of a for statement

Logical operators

Lesson 6: Methods—A Deeper Look

Introduction

static Methods, static Fields and Class Math

Programmer-declared method maximum with three double parameters

Argument Promotion and Casting

Java API Packages

Shifted and scaled random integers

Roll a six-sided die 6,000,000 times

Craps class simulates the dice game craps

Scope class demonstrates field and local-variable scopes

Overloaded method declarations

Lesson 7:Arrays

Introduction

Initializing the elements of an array to default values of zero

Initializing the elements of an array with an array initializer

Calculating the values to be placed into the elements of an array

Computing the sum of the elements of an array

Bar chart printing program

Die-rolling program using arrays instead of switch

Poll analysis program

Card shuffling and dealing

Using the enhanced for statement to total integers in an array

Passing arrays and individual array elements to methods

GradeBook class using an array to store test grades

Initializing two-dimensional arrays

GradeBook class using a two-dimensional array to store grades

Using variable-length argument lists

Initializing an array using command-line arguments

Arrays class methods and System.arraycopy

Generic ArrayListT collection demonstration

Part II

Java Fundamentals I, II, III, and IV LiveLessons: Introduction to Part II

Lesson 8: Classes and Objects—A Deeper Look

Introduction

Time1 class declaration maintains the time in 24-hour format

Private members of class Time1 are not accessible

“this” used implicitly and explicitly to refer to members of an object

Time2 class with overloaded constructors

Composition demonstration with classes Date and Employee

Declaring an enum type with a constructor and explicit instance fields and accessors for these fields

Garbage Collection

Declaring and using static variables and methods to maintain a count of the number of Employee objects in memory

static import of Math class methods

Package access members of a class are accessible by other classes in the same package

Compound-interest calculations with BigDecimal

Lesson 9: Object-Oriented Programming—Inheritance

Introduction

Inheritance hierarchy UML class diagrams

Creating and using a CommissionEmployee class

Creating and Using a BasePlusCommissionEmployee Class

Creating a CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy

CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy Using protected Instance Variables

CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy Using private Instance Variables

Class Object

Lesson 10: Object-Oriented Programming—Polymorphism

Introduction

Demonstrating Polymorphic Behavior—Assigning superclass and subclass references to superclass and subclass variables

Abstract Classes and Methods

Case Study: Payroll System Using Polymorphism

Abstract Superclass Employee

Concrete Subclass SalariedEmployee

Concrete Subclass HourlyEmployee

Concrete Subclass CommissionEmployee

Indirect Concrete Subclass BasePlusCommissionEmployee

Polymorphic Processing, Operator instanceof and Downcasting

final Methods and Classes

Creating and Using Interfaces (Java SE 7 and earlier)

Developing a Payable Hierarchy

Class Invoice

Modifying Class Employee to Implement Interface Payable

Modifying Class SalariedEmployee for Use in the Payable Hierarchy

Using Interface Payable to Process Invoices and Employees Polymorphically

Java SE 8 Interface Enhancements overview

Lesson 11: Exception Handling—A Deeper Look

Introduction

Integer division without exception handling

Handling ArithmeticExceptions and InputMismatchExceptions

Throwable hierarchy; Introduction to checked and unchecked exceptions

try…catch…finally exception-handling mechanism

Stack unwinding and obtaining data from an exception object

Chained exceptions

Declaring new exception types

Checking with assert that a value is within range

try-with-Resources: Automatic Resource Deallocation

Lesson 12: GUI Components: Part 1

Introduction

Using Java’s Nimbus Look-and-Feel

Simple GUI-Based Input/Output with JOptionPane

Common superclasses of the lightweight Swing components

Displaying Text and Images in a Window

Text Fields and an Introduction to Event Handling with the ActionListener interface Nested Classes

Common GUI Event Types and Listener Interfaces

How Event Handling Works

JButton

Buttons That Maintain State: JCheckBox and the ItemListener interface

Buttons That Maintain State: JRadioButton and the ItemListener interface

JComboBox and the ItemListener interface; Using an Anonymous Inner Class for Event Handling

JList and the ListSelectionListener interface

Multiple-Selection Lists

Mouse Event Handling with the MousListener and MouseMotionListener interfaces

Adapter Classes in Event Handling: Mouse Event Handling with the MouseAdapter class

Custom JPanels

Key Event Handling

FlowLayout

BorderLayout

GridLayout

Using Panels to Manage More Complex Layouts

JTextArea and JScrollPane

Lesson 13: Graphics and Java 2D

Introduction

Color control: Drawing rectangles and strings in various colors

Choosing colors with JColorChooser

Displaying strings in different fonts and colors

FontMetrics and Graphics methods useful for obtaining font metrics

Drawing lines, rectangles and ovals

Drawing arcs with Graphics methods drawArc and fillArc

Drawing polygons with Graphics methods drawPolygon and fillPolygon

Demonstrating Java 2D shapes

Java 2D general paths and rotating/translating Java 2D shapes

Lesson 14: Strings, Characters and Regular Expressions

Introduction

String class constructors

String methods length, charAt and getChars

Comparing Strings: String methods equals, equalsIgnoreCase, compareTo and regionMatches

Comparing Strings: String methods startsWith and endsWith

String-searching methods indexOf and lastIndexOf

Extracting substrings from Strings: String class substring methods

String method concat

String methods replace, toLowerCase, toUpperCase, trim and toCharArray

String valueOf methods

StringBuilder constructors

StringBuilder length, setLength, capacity and ensureCapacity methods

StringBuilder methods charAt, setCharAt, getChars and reverse

StringBuilder append methods

StringBuilder methods insert, delete and deleteCharAt

Character static methods for testing characters and converting case

Character class static conversion methods

Character class instance methods

StringTokenizer object used to tokenize strings

Validating user input with regular expressions

String methods replaceFirst, replaceAll and split

Classes Pattern and Matcher

Lesson 15: Files, Streams and Object Serialization

Introduction

Obtaining file and directory information

Writing data to a sequential text file with class Formatter

Reading from a sequential text file using a Scanner

Credit-inquiry program

Creating a Sequential-Access File Using Object Serialization

Reading and Deserializing Data from a Sequential-Access File

Opening Files with JFileChooser

Part III

Java Fundamentals I, II, III, and IV LiveLessons: Introduction to Part III

Lesson 16: Generic Collections

Introduction

Manipulating lists with List, ArrayList, Collection and Iterator

Manipulating lists with List, LinkedList and ListIterator

Viewing arrays as Lists and converting Lists to arrays

Collections method sort

Collections method sort with a Comparator object

Collections method sort with a custom Comparator object

Card shuffling and dealing with Collections method shuffle

Collections methods reverse, fill, copy, max and min

Collections method binarySearch

Collections methods addAll, frequency and disjoint

HashSet used to remove duplicate values from an array of strings

Using SortedSets and TreeSets

Using a Map to count the number of occurrences of each word in a String

Lesson 17: Java SE 8 Lambdas and Streams

Introduction

Functional Programming

Functional Interfaces

Lambda Expressions

Streams

IntStream Operations: Creating an IntStream and Displaying Its Values with the forEach Terminal Operation

IntStream Operations: Terminal Operations count, min, max, sum and average

IntStream Operations: Terminal Operation reduce

IntStream Intermediate Operations: Filtering and Sorting IntStream Values

IntStream Intermediate Operation: Mapping

IntStream Operations: Creating Streams of ints with IntStream Methods range and rangeClosed

StreamInteger Manipulations

StreamString Manipulations

StreamEmployee Manipulations: Creating and Displaying a ListEmployee

StreamEmployee Manipulations: Filtering Employees with Salaries in a Specified Range

StreamEmployee Manipulations: Sorting Employees By Multiple Fields

StreamEmployee Manipulations: Mapping Employees to Unique Last Name Strings

StreamEmployee Manipulations: Grouping Employees By Department

StreamEmployee Manipulations: Counting the Number of Employees in Each Department

StreamEmployee Manipulations: Summing and Averaging Employee Salaries

Creating a StreamString from a File

Generating Streams of Random Values: Rolling a die 6,000,000 times

Lambda Event Handlers

Additional Notes on Java SE 8 Interfaces

Lesson 18: Generic Classes and Methods

Introduction

Overloaded method that perform the exact same task for different types

Generic Methods: Implementation and Compile-Time Translation

Additional Compile-Time Translation Issues: Methods That Use a Type Parameter as the Return Type

Generic Classes: Implementing a Generic Stack Class

Creating Generic Methods to Test Class StackT

Wildcards in Methods That Accept Type Parameters: Totaling the the numbers in an ArrayListNumber

Wildcards in Methods That Accept Type Parameters: Implementing Method sum with a Wildcard Type Argument in Its Parameter

Lesson 19: GUI Components, Part 2

Introduction

JSlider

Using menus with JFrames

JPopupMenu

Pluggable look-and-feel

Multiple-document interfaces with JDesktopPane and JinternalFrame

JTabbedPane

BoxLayout layout manager

GridBagLayout Layout Manager

GridBagLayout Layout Manager: Using GridBagConstraints RELATIVE and REMAINDER

Lesson 20: Concurrency and Multi-core Progamming

Introduction

Concurrent programming overview

Thread States and Life Cycle

Creating and Executing Threads with the Executor Framework

Thread Synchronization Overview

Unsynchronized Mutable Data Sharing (Not thread safe)

Synchronized Mutable Data Sharing—Making Operations Atomic

Producer/Consumer Relationship without Synchronization (Not thread safe)

Producer/Consumer Relationship: ArrayBlockingQueue

(Advanced) Producer/Consumer Relationship with synchronized, wait, notify and notifyAll

(Advanced) Producer/Consumer Relationship: Bounded Buffers

(Advanced) Producer/Consumer Relationship: The Lock and Condition Interfaces

Performing Computations in a Worker Thread: Fibonacci Numbers

Processing Intermediate Results: Sieve of Eratosthenes

sort/parallelSort Timings with the Java SE 8 Date/Time API

Java SE 8: Sequential vs. Parallel Streams

Executing Aysnchronous Tasks with CompletableFuture—Fibonacci calculations performed synchronously and asynchronously

Lesson 21: Accessing Databases with JDBC

Introduction

Overview of relational database concepts

Overview of the books database

Basic SELECT Query

WHERE Clause

ORDER BY Clause

Merging Data from Multiple Tables: INNER JOIN

INSERT Statement

UPDATE Statement

DELETE Statement

Java DB Overview

Connecting to and Querying a Database

Querying the books Database: Test-Driving the Example

Querying the books Database: Implementing the TableModel interface to populate a JTable from a ResultSet

Querying the books Database: DisplayQueryResults class

RowSet Interface and JdbcRowSet class

PreparedStatements: Address book example

Lesson 22: Java FX, Part 1

Introduction

Tools Used in This Lesson: FXML, JavaFX Scene Builder and the NetBeans IDE

JavaFX App Window Structure

Welcome App—Displaying Text and an Image

Creating the App’s Project

NetBeans Projects Window—Viewing the Project Contents and Adding an Image to the Project

Opening JavaFX Scene Builder from NetBeans and Preparing to Build the Welcome App

Changing to a VBox Layout Container and Configuring the Layout

Adding and Configuring a Label

Adding and Configuring an ImageView and Running the App

Welcome.java—Creating the GUI from the FXML file

Tip Calculator App Test Drive—Introduction to Event Handling

Tip Calculator Technologies Overview

Building the Tip Calculator App’s GUI: fx:id values for the app’s controls

Building the Tip Calculator App’s GUI: Creating the project

Building the Tip Calculator App’s GUI, Step 1: Changing the Root Layout from an AnchorPane to a GridPane

Building the Tip Calculator App’s GUI, Step 3: Adding the Controls to the GridPane

Building the Tip Calculator App’s GUI, Step 4: Right-Aligning GridPane Column 0’s Contents

Building the Tip Calculator App’s GUI, Step 5: Sizing the GridPane Columns to Fit Their Contents

Building the Tip Calculator App’s GUI, Step 7: Sizing the Button and Previewing the GUI

Building the Tip Calculator App’s GUI, Step 8: Configuring the GridPane’s Padding and Horizontal Gap Between Its Columns

Building the Tip Calculator App’s GUI, Step 9: Making the tipTextField and totalTextField Uneditable and Not Focusable

Building the Tip Calculator App’s GUI, Step 10: Setting the Slider’s Properties and Previewing the Final Layout

TipCalculator Subclass of Application

TipCalculatorController Class: import Statements

TipCalculatorController Class: static Variables and Instance Variables

TipCalculatorController Class: calculateButtonPressed Event Handler

TipCalculatorController Class: initalize Method

Part IV

Java Fundamentals: Introduction to Part IV

Lesson 23: Java FX GUI: Part 2

Lesson Introduction

NetBeans and JavaFX Scene Builder Downloads

Laying Out Nodes in a Scene Graph

Painter App: Technologies Overview

Painter App: Creating the Project and Building the GUI

Painter App: Painter Subclass of Application

Painter App: PainterController Class

Color Chooser App: Technologies Overview

Color Chooser App: GUI Overview

Color Chooser App: ColorChooser and ColorChooserController classes

Cover Viewer App: Technologies Overview

Cover Viewer App: Adding the Images and the Book class; GUI Overview

Cover Viewer App: CoverViewer and CoverViewerController classes

Cover Viewer App: Customizing ListView Cells Technologies Overview

Cover Viewer App: Copying the Project

Cover Viewer App: ImageTextCell Custom Cell Factory Class

Cover Viewer App: CoverViewerController Class

Lesson 24: Java FX Graphics and Multimedia

Lesson Introduction

FontCSS App: Using External Stylesheets to Style Labels and a VBox

Programmatically Loading CSS

BasicShapes App: Defining Two-Dimensional Shapes with FXML

BasicShapes App: CSS That Styles the Two-Dimensional Shapes

PolyShapes App: GUI and CSS for a Polyline, Polygon and Path

PolyShapes App: PolyshapesController Class

DrawStars App: Applying Transforms to Nodes

VideoPlayer App: Playing Video with Classes Media, MediaPlayer and MediaViewer

TransitionAnimations App: Predefined Animations for Modifying Specific Properties

TimelineAnimation App: Custom Transitions Specified with KeyFrames

Lesson 25: Java Persistence API (JPA)

Lesson Introduction

JPA Overview—Generated Entity Classes

JPA Overview—Relationships Between Tables in the Entity Classes

JPA Overview—javax.persistence Package

Querying a Database with JPA—Creating the Java DB Database

Querying a Database with JPA—Populate the books Database with Sample Data

Querying a Database with JPA—Creating the Java Project

Querying a Database with JPA—Adding the JPA and Java DB Libraries

Querying a Database with JPA—Creating the Persistence Unit for the books Database

Querying a Database with JPA—Querying the Authors Table

Querying a Database with JPA—JPA Features of Autogenerated Class Authors

Named Queries; Accessing Data from Multiple Tables—Using a Named Query to Get the List of Authors, then Display the Authors with Their ISBNs

Named Queries; Accessing Data from Multiple Tables—Using a Named Query to Get the List of Titles, then Display Each with Its Authors

Address Book: Using JPA and Transactions to Modify a Database—Transaction Processing

Address Book: Using JPA and Transactions to Modify a Database—Creating the AddressBook Database and Its Persistence Unit

Address Book: Using JPA and Transactions to Modify a Database—Addresses Entity Class

Address Book: Using JPA and Transactions to Modify a Database—AddressBook Class

Address Book: Using JPA and Transactions to Modify a Database—Other JPA Operations

Lesson 26: JavaServer Faces (JSF) Web Apps: Part 1

Lesson Introduction

JavaServer Faces Setup/Software

Web Basics

Multitier Application Architecture

Your First JSF Web App

The Default index.xhtml Document: Introducing Facelets and JSF Expression Language

JavaBeans, Properties and the WebTimeBeanClass

Additional Notes on the WebTime Example

Model-View-Controller (MVC) Architecture in JSF Apps

Common JSF View Components

Validation Using JSF Standard Validators

Session Tracking with

Lesson 27: JavaServer Faces (JSF) Web Apps: Part 2

Lesson Introduction

AddressBook: Accessing Databases in Web Apps

AddressBook: Setting Up the Database

AddressBook: Class AddressBean

AddressBook: index.xhtml Facelets Page

AddressBook: addEntry.xhtml Facelets Page

Ajax Introduction

Validation App: Adding Ajax Functionality

Lesson 28: Web Services

Lesson Introduction

Web Service Basics

Simple Object Access Protocol (SOAP) Introduction

Representational State Transfer (REST) Introduction

JavaScript Object Notation (JSON) Introduction

Publishing and Consuming SOAP-Based Web Services

Publishing and Consuming SOAP-Based Web Services: Creating a Web Application and Adding a Web Service

Publishing and Consuming SOAP-Based Web Services: Defining the WelcomeSOAP Web Service in NetBeans

Publishing and Consuming SOAP-Based Web Services: Publishing the WelcomeSOAP Web Service from NetBeans

Publishing and Consuming SOAP-Based Web Services: Testing the WelcomeSOAP Web Service with GlassFish’s Tester Web Page

Publishing and Consuming SOAP-Based Web Services: Describing the WelcomeSOAP Web Service with Web Service Description Language (WSDL)

Publishing and Consuming SOAP-Based Web Services: Creating a Client to Consume the WelcomeSOAP Web Service

Publishing and Consuming SOAP-Based Web Services: Consuming the WelcomeSOAP Web Service

Publishing and Consuming REST-Based XML Web Services

Publishing and Consuming REST-Based XML Web Services: Creating a REST-Based XML Web Service

Publishing and Consuming REST-Based XML Web Services: Consuming a REST-Based XML Web Service

Publishing and Consuming REST-Based JSON Web Services: Creating a REST-Based JSON Web Service

Publishing and Consuming REST-Based JSON Web Services: Consuming a REST-Based JSON Web Service

SOAP-Based Web Service with Session Tracking Support

SOAP-Based Web Service That Accesses a Database

REST-Based XML Equation Generator Web Service

REST-Based JSON Equation Generator Web Service

Lesson: Introduction to JShell

Lesson intro

How to use this lesson

Before You Begin: Installing and Configuring JDK 9 on Windows

Before You Begin: Installing and Configuring JDK 9 on macOS

Before You Begin: Installing and Configuring JDK 9 on Linux

JShell Overview

SECTION 1: Videos in this section can be viewed after Lesson 2

Starting a JShell session

Executing statements

Declaring variables explicitly; compilation errors; recalling and reexecuting snippets

Listing and executing prior snippets

Evaluating expressions and declaring variables implicitly

Using implicitly declared variables

Viewing a variable’s value

Resetting a JShell session

Writing multiline statements

Editing code snippets

Exiting JShell

SECTION 2: Videos in this section can be viewed after Lesson 3

Creating a class in JShell and viewing the declared types

Explicitly declaring reference-type variables

Creating objects and implicitly declaring reference-type variables

Manipulating objects

Creating a meaningful variable name for an expression

Saving and opening code-snippet files

SECTION 3: Videos in this section can be viewed after Lesson 3

Auto-completing identifiers

Auto-completing JShell commands

SECTION 4: Videos in this section can be viewed after Lesson 6

Exploring a class’s members and viewing documentation

Listing class Math’s static members

Viewing a method’s parameters

Viewing a method’s documentation

Viewing a public field’s documentation

Viewing a class’s documentation

Viewing method overloads

Exploring members of a specific object

SECTION 5: Videos in this section can be viewed after Lesson 6

Declaring and using a method

Forward referencing an undeclared method—Declaring method displayCubes

Declaring a previously undeclared method

Testing method cube and replacing its declaration

Testing updated method cube and method displayCubes

SECTION 6: Videos in this section can be viewed after Lesson 7

Exception handling in JShell

SECTION 7: The videos in this lesson may be covered in sequence any time after Lesson 8

Importing classes and adding packages to the CLASSPATH

Using an external editor

Summary of JShell Commands

Getting help in JShell

/reload command

Feedback modes

How JShell reinterprets Java for interactive use

SECTION 8: Exercises for Section 2

Exercses 1 and 2: Printing a string does not display quotes

Exercses 3 and 4: Comments are not executable

Exercise 5: Multiline comments continue until a closing */ is reached

Exercise 6: Code indentation does not affect how the code executes

Exercise 7: Declaring valid and invalid identifiers

Exercise 8: Unmatched braces in string literals are allowed

Exercise 9: Viewing compilation errors for common programming errors

Exercise 10: Using multiple print statements to display text on one line; Saving/opening snippet files

Exercise 11: Using multiple println statements to display text on separate lines

Exercise 12: Resetting a JShell session

Exercises 13-15: \n, \t and illegal escape sequences

Exercises 16-18: \, \“ and \r escape sequences

Exercise 19: Demonstrating various compilation errors and exceptions with System.out.printf

Exercises 20-21: The /imports command and declaring an import statement inside a class

Exercise 22: Proving that Java is case sensitive

Exercise 23: Proving variables were initialized properly

Exercise 24: Adding 1 to the largest int value and subtracting 1 from the smallest int value

Exercise 25: Using _ in numeric literals

Exercise 26: Spaces are not required around binary operators

Exercise 27: Demonstrating that parentheses are not required around an argument to printf statement

Exercises 28-29: Assigning to a variable is destructive and printing a variable is non-destructive

Exercise 30: Multiplication requires an operator in Java

Exercises 31-32: Integer division and division by zero

Exercises 33-34: Operator precedence and associativity

Exercises 35-37: Testing the relation and equality operators

Exercise 38: Accidentally following an if statement’s condition with a semicolon

Exercise 39: Demonstrating concatenated assignments

Exercise 40: Forcing order of evaluation with parentheses

Lesson: Introduction to Modularity—Java 9’s Platform Module System (JPMS)

Lesson Introduction

Before You Begin

SECTION 1: Introduction

Introduction

Introduction—What is a Module?

Introduction—History

Introduction—JPMS Goals

Introduction—Lab 01: Listing the JDK’s Modules

Introduction—JEPs and JSRs of Java Modularity

SECTION 2: Module Declarations

Module Declarations—Section Overview

Module Declarations

Module Declarations—requires

Module Declarations—requires transitive and Implied Readability

Module Declarations—exports and exports…to

Module Declarations—uses

Module Declarations—provides…with

Module Declarations—open, opens, opens…to

Module Declarations—Restricted Keywords

SECTION 3: Modularized Welcome App

Modularized Welcome App—Section Overview

Modularized Welcome App—App Structure

Modularized Welcome App—Lab 02: Listing the java.base Module’s Contents

Modularized Welcome App—Class Welcome

Modularized Welcome App—Lab 03: module-info.java

Modularized Welcome App—Lab 04: Module-Dependency Graph

Modularized Welcome App—Lab 05: Compiling a Module

Modularized Welcome App—Lab 06/07: Listing the com.deitel.welcome Module’s Description

Modularized Welcome App—Lab 08: Running an app from a Module’s Exploded Folders

Modularized Welcome App—Lab 09: Packaging a Module in a Modular JAR File

Modularized Welcome App—Lab 10: Running the App from a Modular JAR File

Modularized Welcome App—Aside: Classpath vs. Module Path

SECTION 4: Creating and Using a Custom Module

Creating and Using a Custom Module—Section Overview

Creating and Using a Custom Module—Lab 11: Exporting a Package for Use in Other Modules

Creating and Using a Custom Module—Lab 11: Using a Class from a Package in Another Module

Creating and Using a Custom Module—Lab 12: Module Dependency Graphs

Creating and Using a Custom Module—Lab 13/14/15: Compiling and Running the Example

Creating and Using a Custom Module—Lab 16/17: Packaging the App Into Modular JAR Files

Creating and Using a Custom Module—Lab 18: Strong Encapsulation and the Accessibility of Types

SECTION 5: Module-Dependency Graphs: A Deeper Look

Module-Dependency Graphs: A Deeper Look—Section Overview

Module-Dependency Graphs: A Deeper Look—Lab 19: java.sql

Module-Dependency Graphs: A Deeper Look—Lab 20: java.se

Module-Dependency Graphs: A Deeper Look—Browsing the JDK Module Graph

Module-Dependency Graphs: A Deeper Look—Lab21/22: Error from a Module Graph with a Cycle

SECTION 6: Using Pre-Java-9 Non-Modularized Code in Java 9

Using Pre-Java-9 Non-Modularized Code in Java 9—Section Overview

Using Pre-Java-9 Non-Modularized Code in Java 9—Unnamed Module

Using Pre-Java-9 Non-Modularized Code in Java 9—Automatic Modules

Using Pre-Java-9 Non-Modularized Code in Java 9—Labs 23/24/25/26: jdeps Java Dependency Analysis Tool

SECTION 7: Resources in Modules; Using an Automatic Module

Resources in Modules; Using an Automatic Module—Section Overview

Resources in Modules; Using an Automatic Module

Resources in Modules; Using an Automatic Module—Automatic Module controlsfx

Resources in Modules; Using an Automatic Module—Requiring Multiple Modules

Resources in Modules; Using an Automatic Module—Module-Dependency Graph

Resources in Modules; Using an Automatic Module—Compiling the Module

Resources in Modules; Using an Automatic Module—Running the Modularized App

Resources in Modules; Using an Automatic Module—Showing the Exceptions that Occur if package com.deitel.videoplayer is Not Opened to the Correct JavaFX Modules

SECTION 8: Creating Custom Runtimes with jlink

Creating Custom Runtimes with jlink—Section Overview

Creating Custom Runtimes with jlink—Listing the JRE’s Modules

Creating Custom Runtimes with jlink—Custom Runtime Containing Only java.base

Creating Custom Runtimes with jlink—Creating a Custom Runtim for the Welcome App, Listing Its Modules and Running the App from the Custom Runtime

Creating Custom Runtimes with jlink—Using the Module Resolver on a Custom Runtime

SECTION 9: Services and ServiceLoader

Services and ServiceLoader—Section Overview

Services and ServiceLoader

Services and ServiceLoader—Service-Provider Interface

Services and ServiceLoader—Loading and Consuming Service Providers

Services and ServiceLoader—uses Module Directive and Service Consumers

Services and ServiceLoader—Running the App with No Service Providers

Services and ServiceLoader—Implementing a Service Provider

Services and ServiceLoader—provides…with Module Directive and Declaring a Service Provider

Services and ServiceLoader—Running the App with One Service Provider

Services and ServiceLoader—Implementing a Second Service Provider

Services and ServiceLoader—Running the App with Both Service Providers

Myths of JPMS

Additional Resources