The Java Workshop: A New, Interactive Approach to Learning Java

✍ Scribed by David Cuartielles, Andreas Göransson, and Eric Foster-Johnson

• Publisher: Packt
• Year: 2019
• Tongue: English
• Category: Library

✦ Synopsis

You already know you want to learn Java, and a smarter way to learn Java 12 is to learn
by doing. The Java Workshop focuses on building up your practical skills so that you can
develop high-performance Java applications that work flawlessly within the JVM across
web, mobile and desktop. You'll learn from real examples that lead to real results.
Throughout The Java Workshop, you'll take an engaging step-by-step approach to
understanding Java. You won't have to sit through any unnecessary theory. If you're
short on time you can jump into a single exercise each day or spend an entire weekend
learning about Reactive programming and Unit testing. It's your choice. Learning on
your terms, you'll build up and reinforce key skills in a way that feels rewarding.
Every physical print copy of The Java Workshop unlocks access to the interactive
edition. With videos detailing all exercises and activities, you'll always have a guided
solution. You can also benchmark yourself against assessments, track progress, and
receive free content updates. You'll even earn a secure credential that you can share
and verify online upon completion. It's a premium learning experience that's included
with your printed copy. To redeem, follow the instructions located at the start of your
Java book.
Fast-paced and direct, The Java Workshop is the ideal companion for Java beginners.
You'll build and iterate on your code like a software developer, learning along the
way. This process means that you'll find that your new skills stick, embedded as best
practice. A solid foundation for the years ahead.

✦ Table of Contents

Preface
Chapter 1: Getting Started
Introduction
Writing, Compiling, and Executing Your Hello World Program
Exercise 1: Creating Your Hello World Program in Java
Basic Syntax and Naming Conventions
Printing Out Different Data Types
Variables and Variable Types
Exercise 2: Printing Different Types of Data
Primitive versus Reference Data Types
Null
Chars and Strings
Exercise 3: Declaring Strings
Doing Some Math
Exercise 4: Solving a Simple Trigonometry Problem
Comments Help You to Share Code
CLI versus GUI
Exercise 5: Running the Code from the CLI
Activity 1: Obtaining the Minimum of Two Numbers
Summary
Chapter 2: Learning the Basics
Introduction
Controlling the Flow of Your Programs
Exercise 1: Creating a Basic if Statement
Comparison Operators
Exercise 2: Using Java Comparison Operators
Nested if Statements
Exercise 3: Implementing a Nested if Statement
Branching Two Ways with if and else
Exercise 4: Using if and else Statements
Using Complex Conditionals
Exercise 5: Using Logical Operators to Create Complex Conditionals
Using Arithmetic Operators in an if Condition
The Ternary Operator
Exercise 6: Using the Ternary Operator
Equality Can Be Tricky
Exercise 7: Comparing Decimal Values
Comparing Strings
Using switch Statements
Exercise 8: Using switch
Exercise 9: Allowing Cases to Fall Through
Using Java 12 Enhanced switch Statements
Exercise 10: Using Java 12 switch Statements
Looping and Performing Repetitive Tasks
Looping with the for Loop
Exercise 11: Using a Classic for Loop
Exercise 12: Using an Enhanced for Loop
Jumping Out of Loops with Break and Continue
Exercise 13: Using break and continue
Using the while Loop
Exercise 14: Using a while Loop
Using the do-while Loop
Handling Command-Line Arguments
Exercise 15: Testing Command-Line Arguments
Converting Command-Line Arguments
Exercise 16: Converting String to Integers and Doubles
Diving Deeper into Variables — Immutability
Comparing Final and Immutable
Using Static Values
Using Local Variable Type Inference
Activity 1: Taking Input and Comparing Ranges
Summary
Chapter 3: Object-Oriented Programming
Introduction
The Anatomy of a Class
Working with Objects in Java
Checking the Precedence of a Class with instanceof
Exercise 1: Creating the WordTool Class
Activity 1: Adding the Frequency-of-Symbol Calculation to WordTool
Inheritance in Java
Overriding and Hiding Methods
Avoiding Overriding: Final Classes and Methods
Overloading Methods and Constructors
Recursion
Annotations
Interfaces
Inner Classes
Documenting with JavaDoc
Activity 2: Adding Documentation to WordTool
Summary
Chapter 4: Collections, Lists and Java's Built-In APIs
Introduction
Arrays
Activity 1: Searching for Multiple Occurrences in an Array
Sets
Lists
Exercise 1: Creating the AnalyzeInput Application
Maps
Iterating through Collections
Exercise 2: Bringing Analytics into the AnalyzeInput Application
Sorting Collections
Exercise 3: Sort the Results from the AnalyzeInput Application
Properties
Activity 2: Iterating through Large Lists
Summary
Chapter 5: Exceptions
Introduction
A Simple Exception Example
NullPointerException – Have No Fear
Catching Exceptions
Exercise 1: Logging Exceptions
Throws and Throw
Exercise 2: Breaking the Law (and Fixing It)
The finally Block
Activity 1: Designing an Exception Class Logging Data
Best Practices for Handling Exceptions
Where Do Exceptions Come from?
Summary
Chapter 6: Libraries, Packages, and Modules
Introduction
Organizing Code into Packages
Importing Classes
Exercise 1: Importing Classes
Fully Qualified Class Names
Importing All Classes in a Package
Dealing with Duplicated Names
Static Imports
Creating a Package
Naming Your Package
Directories and Packages
Exercise 2: Creating a Package for a Fitness Tracking App
Building JAR Files
Exercise 3: Building a JAR File
Defining the Manifest
Exercise 4: Building an Executable JAR File
Build Tools
Maven
Exercise 5: Creating a Maven Project
Exercise 6: Adding Java Sources to the Maven Project
Exercise 7: Building the Maven Project
Exercise 8: Creating an Executable JAR with Maven
Using Gradle
Exercise 9: Creating a Gradle Project
Exercise 10: Building an Executable JAR with Gradle
Using Third-Party Libraries
Finding the Libraries
Adding a Project Dependency
Exercise 11: Adding a Third-Party Library Dependency
Using the Apache Commons Lang Library
Exercise 12: Using the Apache Commons Lang Library
Using Modules
Creating Modules
Exercise 13: Creating a Project for a Module
Exercise 14: Creating a Second Module Using the First One
Activity 1: Tracking Summer High Temperatures
Summary
Chapter 7: Databases and JDBC
Introduction
Relational Databases
Relational Database Management Systems
Installing a Database
Exercise 1: Running the H2 Database
Introducing SQL
Exercise 2: Creating the customer Table
Inserting Data into a Table
Exercise 3: Inserting Data
Retrieving Data
Relating Tables
Exercise 4: Creating the email Table
Selecting Data from Multiple Tables
Modifying Existing Rows
Exercise 5: Modifying email Data
Deleting Data
JDBC—Accessing Databases from Java
Connecting to Databases
Querying Data with JDBC
Exercise 6: Querying Data with JDBC
Sanitizing User Input
Using Prepared Statements
Transactions and Rollback
Exercise 7: Using Prepared Statements with Transactions
Simplifying JDBC Programming
Using Object-Relational Mapping Software
Database Connection Pooling
Non-Relational, or NoSQL, Databases
Activity 1: Track Your Progress
Summary
Chapter 8: Sockets, Files, and Streams
Introduction
Listing Files and Directories
Separating Directories from Files
Exercise 1: Listing the Contents of Subdirectories
Creating and Writing to a File
Activity 1: Writing the Directory Structure to a File
Reading an Existing File
Reading a Properties File
Exercise 2: Creating a Properties File from the CLI
What are Streams?
The Different Streams of the Java Language
What are Sockets?
Creating a SocketServer
Writing Data on and Reading Data from a Socket
Activity 2: Improving the EchoServer and EchoClient Programs
Blocking and Non-Blocking Calls
Summary
Chapter 9: Working with HTTP
Introduction
Exploring HTTP
HTTP Request Methods
Representational State Transfer
Request Headers
Using HttpUrlConnection
Exercise 1: Creating a HEAD Request
Reading the Response Data with a GET Request
Exercise 2: Creating a GET Request
Dealing with Slow Connections
Requesting Parameters
Handling Redirects
Creating HTTP POST Requests
Exercise 3: Sending JSON Data with POST Requests
Parsing HTML Data
Exercise 4: Using jsoup to Extract Data from HTML
Delving into the java.net.http Module
Exercise 5: Getting HTML Contents Using the java.net.http Module
Activity 1: Using the jsoup Library to Download Files from the Web
Summary
Chapter 10: Encryption
Introduction
Plaintext
Ciphertext
Ciphers
Keys
Symmetric Key Encryption
Exercise 1: Encrypting the String
Using Advanced Encryption Standard
Block Ciphers
Initialization Vectors
Stream Ciphers
Asymmetric Key Encryption
Exercise 2: Encrypting the String Using the RSA Asymmetric
Key Encryption
Encrypting Files
Exercise 3: Encrypting a File
Summary
Chapter 11: Processes
Introduction
Launching a Process
Sending Input to a Child Process
Capturing the Output of a Child Process
Storing the Output of a Child Process in a File
Activity 1: Making a Parent Process to Launch a Child Process
Summary
Chapter 12: Regular Expressions
Introduction
Decrypting Regular Expressions
Character Classes
Character Sets
Quantifiers
Anchors
Capturing Groups
Escaped Characters
Flags
Exercise 1: Implementing Regular Expressions
Activity 1: Regular Expressions to Check If the Entrance
is Entered in the Desired Format
Regular Expressions in Java
Exercise 2: Extracting the Domain Using Pattern Matching
Exercise 3: Extracting Links Using Pattern Matching
Summary
Chapter 13: Functional Programming with Lambda Expressions
Introduction
Background
Functional Programming
Side Effects
Deterministic Functions
Pure Functions
Exercise 1: Writing Pure Functions
Immutability of State
Exercise 2: Creating an Immutable Class
Activity 1: Modifying Immutable Lists
Immutable Collections
Exercise 3: Overriding the String Method
Functional Interfaces
Lambda Expressions
Exercise 4: Listing Spare Tires
Summary
Chapter 14: Recursion
Introduction
Delving into Recursion
Exercise 1: Using Recursion to Overflow the Stack
Trying Tail Recursion
Exercise 2: Using Recursion to Calculate Factorials
Processing an XML Document
Exercise 3: Creating an XML File
Introducing the DOM XML API
Exercise 4: Traversing an XML Document
Activity 1: Calculating the Fibonacci Sequence
Summary
Chapter 15: Processing Data with Streams
Introduction
Creating Streams
Parallel Streams
Encounter Order
Closing Streams
Terminal Operations
Intermediate Operations
Exercise 1: Using the Stream API
Activity 1: Applying Discount on the Items
Using Collectors
I/O Streams
Exercise 2: Converting CSV to a List
Activity 2: Searching for Specifics
Summary
Chapter 16: Predicates and Other Functional Interfaces
Introduction
Predicate Interface
Exercise 1: Defining a predicate
Activity 1: Toggling the Sensor States
Consumer Interface
Exercise 2: Producing Side Effects
Function
Exercise 3: Extracting Data
Activity 2: Using a Recursive Function
Activity 3: Using a Lambda Function
Summary
Chapter 17: Reactive Programming with Java Flow
Introduction
Publisher
SubmissionPublisher
Subscriber
Subscription
Exercise 1: A Simple Application with a Single Publisher
and a Single Subscriber
Processor
Exercise 2: Using a Processor to Convert a Stream
of Strings to Numbers
Activity 1: Let NumberProcessor Format Values as Integers
Summary
Chapter 18: Unit Testing
Introduction
Getting Started with Unit Tests
Introducing JUnit
Writing Unit Tests with JUnit
Exercise 1: Writing a First Unit Test
Exercise 2: Writing a Successful Test
Deciding What to Test
Writing Parameterized Tests
Exercise 3: Writing a Parameterized Test
When Tests Won't Work—Disabling Tests
Test Setup
Exercise 4: Using Test Setup and Cleanup Methods
Mocking
Testing with Mocks Using Mockito
Exercise 5: Using Mocks when Testing
Activity 1: Counting the Words in the String
Summary
Appendix
Index