Java All-in-One For Dummies

Title Page
Copyright Page
Table of Contents
Introduction
	About This Book
	Foolish Assumptions
	Icons Used in This Book
	Beyond the Book
	Where to Go from Here
Book 1 Java Basics
	Chapter 1 Welcome to Java
		What Is Java, and Why Is It So Great?
			Platform independence
			Object orientation
			The Java API
			The Internet
		Java versus Other Languages
		Important Features of the Java Language
			Type checking
			Exception handling
		On the Downside: Java’s Weaknesses
		Java Version Insanity
		What’s in a Name?
	Chapter 2 Installing and Using Java Tools
		Downloading and Installing the Java Development Kit
			Downloading the JDK
			Installing the JDK
			Perusing the JDK folders
			Setting the path
		Using Java’s Command-Line Tools
			Compiling a program
			Compiling more than one file
			Using Java compiler options
			Running a Java program
			Using the javap command
		Using Java Documentation
	Chapter 3 Working with TextPad
		Downloading and Installing TextPad
		Editing Source Files
		Compiling a Program
		Running a Java Program
Book 2 Programming Basics
	Chapter 1 Java Programming Basics
		Looking at the Infamous Hello, World! Program
		Dealing with Keywords
		Working with Statements
			Types of statements
			White space
		Working with Blocks
		Creating Identifiers
		Crafting Comments
			End-of-line comments
			Traditional comments
			JavaDoc comments
		Introducing Object-Oriented Programming
			Understanding classes and objects
			Understanding static methods
			Creating an object from a class
			Viewing a program that uses an object
			So what’s the difference?
		Importing Java API Classes
	Chapter 2 Working with Variables and Data Types
		Declaring Variables
			Declaring two or more variables in one statement
			Declaring class variables
			Declaring instance variables
			Declaring local variables
		Initializing Variables
			Initializing variables with assignment statements
			Initializing variables with initializers
		Using Final Variables (Constants)
		Working with Primitive Data Types
			Integer types
			Floating-point types
			The char type
			The Boolean type
			Using wrapper classes
			Using reference types
			Using inferred variable types
		Working with Strings
			Declaring and initializing strings
			Combining strings
			Converting primitives to strings
			Converting strings to primitives
		Converting and Casting Numeric Data
			Automatic conversions
			Type casting
		Thinking Inside the Box
		Understanding Scope
		Shadowing Variables
		Printing Data with System.out
			Using standard input and output streams
			Using System.out and System.err
		Getting Input with the Scanner Class
			Importing the Scanner class
			Declaring and creating a Scanner object
			Getting input
		Getting Input with the JOptionPane Class
		Using enum to Create Your Own Data Types
	Chapter 3 Working with Numbers and Expressions
		Working with Arithmetic Operators
		Dividing Integers
		Combining Operators
		Using the Unary Plus and Minus Operators
		Using Increment and Decrement Operators
		Using the Assignment Operator
		Using Compound Assignment Operators
		Using the Math Class
			Using constants of the Math class
			Working with mathematical functions
			Creating random numbers
			Rounding functions
		Formatting Numbers
		Recognizing Weird Things about Java Math
			Integer overflow
			Floating-point weirdness
			Division by zero
	Chapter 4 Making Choices
		Using Simple Boolean Expressions
		Using if Statements
			Simple if statements
			if-else statements
			Nested if statements
			else-if statements
		Using Mr. Spock’s Favorite Operators (Logical Ones, of Course)
			Using the ! operator
			Using the & and && operators
			Using the | and || operators
			Using the ^ operator
			Combining logical operators
		Using the Conditional Operator
		Comparing Strings
	Chapter 5 Going Around in Circles (Or, Using Loops)
		Using Your Basic while Loop
			The while statement
			A counting loop
		Breaking Out of a Loop
		Looping Forever
			Letting the user decide when to quit
			Letting the user decide in another way
		Using the continue Statement
		Running do-while Loops
		Validating Input from the User
		Using the Famous for Loop
			Understanding the formal format of the for loop
			Scoping out the counter variable
			Counting even numbers
			Counting backward
			Using for loops without bodies
			Ganging up your expressions
			Omitting expressions
			Breaking and continuing your for loops
		Nesting Your Loops
			A simple nested for loop
			A guessing game
	Chapter 6 Pulling a Switcheroo
		Battling else-if Monstrosities
			Viewing an example else-if program
			Creating a better version of the example program
		Using the switch Statement
			Viewing a boring switch example, complete with flowchart
			Putting if statements inside switch statements
		Creating Character Cases
		Intentionally Leaving Out a Break Statement
		Switching with Strings
		Enhanced Switch Features with Java 13
	Chapter 7 Adding Some Methods to Your Madness
		The Joy of Methods
		The Basics of Making Methods
			An example
			Another example
		Methods That Return Values
			Declaring the method’s return type
			Using the return statement to return the value
			Using a method that returns a type
			You gotta have a proper return statement
			Trying another version of the guessing-game program
		Methods That Take Parameters
			Declaring parameters
			Scoping out parameters
			Understanding pass-by-value
			Trying yet another version of the guessing-game program
	Chapter 8 Handling Exceptions
		Understanding Exceptions
			Witnessing an exception
			Finding the culprit
		Catching Exceptions
			A simple example
			Another example
		Handling Exceptions with a Preemptive Strike
		Catching All Exceptions at Once
		Displaying the Exception Message
		Using a finally Block
		Handling Checked Exceptions
			Viewing the catch-or-throw compiler error
			Catching FileNotFoundException
			Throwing the FileNotFoundException
			Throwing an exception from main
			Swallowing exceptions
		Throwing Your Own Exceptions
Book 3 Object-Oriented Programming
	Chapter 1 Understanding Object-Oriented Programming
		What Is Object-Oriented Programming?
		Understanding Objects
			Objects have identity
			Objects have type
			Objects have state
			Objects have behavior
		Understanding the Life Cycle of an Object
		Working with Related Classes
			Inheritance
			Interfaces
		Designing a Program with Objects
		Diagramming Classes with UML
			Drawing classes
			Drawing arrows
	Chapter 2 Making Your Own Classes
		Declaring a Class
			Picking class names
			Knowing what goes in the class body
			Seeing where classes go
		Working with Members
			Understanding fields
			Understanding instance methods
			Understanding visibility
		Using Getters and Setters
		Overloading Methods
		Creating Constructors
			Creating basic constructors
			Creating default constructors
			Calling other constructors
		Finding More Uses for the this Keyword
		Using Initializers
		Using Records
	Chapter 3 Working with Statics
		Understanding Static Fields and Methods
		Working with Static Fields
		Using Static Methods
		Counting Instances
		Preventing Instances
		Using Static Initializers
	Chapter 4 Using Subclasses and Inheritance
		Introducing Inheritance
			Motorcycles, trains, and automobiles
			Game play
			A businesslike example
			Inheritance hierarchies
		Creating Subclasses
		Overriding Methods
		Protecting Your Members
		Using this and super in Your Subclasses
		Understanding Inheritance and Constructors
		Using final
			Final methods
			Final classes
		Casting Up and Down
		Determining an Object’s Type
		Poly What?
		Creating Custom Exceptions
			Tracing the Throwable hierarchy
			Creating an exception class
			Throwing a custom exception
	Chapter 5 Using Abstract Classes and Interfaces
		Using Abstract Classes
		Using Interfaces
			Creating a basic interface
			Implementing an interface
			Using an interface as a type
		More Things You Can Do with Interfaces
			Adding fields to an interface
			Extending interfaces
			Using interfaces for callbacks
		Using Additional Interface Method Types
	Chapter 6 Using the Object and Class Classes
		The Mother of All Classes: Object
			Every object is an Object
			Object as a type
			Methods of the Object class
			Primitives aren’t objects
		The toString Method
			Using toString
			Overriding toString
		The equals Method
			Using equals
			Overriding the equals method
		The clone Method
			Implementing the clone method
			Using clone to create a shallow copy
			Creating deep copies
		The Class Class
	Chapter 7 Using Inner Classes, Anonymous Classes, and Lambda Expressions
		Declaring Inner Classes
			Understanding inner classes
			Viewing an example
		Using Static Inner Classes
		Using Anonymous Inner Classes
			Creating an anonymous class
			Creating a program with an anonymous class
		Using Lambda Expressions
	Chapter 8 Working with Packages and the Java Module System
		Working with Packages
			Importing classes and packages
			Creating your own packages
			An example
		Putting Your Classes in a JAR File
			jar command-line options
			Archiving a package
			Adding a jar to your classpath
			Running a program directly from an archive
		Using Javadoc to Document Your Classes
			Adding Javadoc comments
			Using the javadoc command
			Viewing Javadoc pages
		Using the Java Module System
			Understanding modules
			The module-info.java file
			Setting up folders for a module
			Compiling a module
			Creating a modular JAR file
			Running a modular JAR file
Book 4 Strings, Arrays, and Collections
	Chapter 1 Working with Strings
		Reviewing Strings
		Using the String Class
			Finding the length of a string
			Making simple string modifications
			Extracting characters from a string
			Extracting substrings from a string
			Splitting a string
			Replacing parts of a string
		Using the StringBuilder and StringBuffer Classes
			Creating a StringBuilder object
			Using StringBuilder methods
			Viewing a StringBuilder example
		Using the CharSequence Interface
	Chapter 2 Using Arrays
		Understanding Arrays
		Creating Arrays
		Initializing an Array
		Using for Loops with Arrays
		Solving Homework Problems with Arrays
		Using the Enhanced for Loop
		Using Arrays with Methods
		Using Varargs
		Using Two-Dimensional Arrays
			Creating a two-dimensional array
			Accessing two-dimensional array elements
			Initializing a two-dimensional array
			Using jagged arrays
			Going beyond two dimensions
		Working with a Fun but Complicated Example: A Chessboard
		Using the Arrays Class
			Filling an array
			Copying an array
			Sorting an array
			Searching an array
			Comparing arrays
			Converting arrays to strings
	Chapter 3 Using the ArrayList Class
		Understanding the ArrayList Class
		Creating an ArrayList Object
		Adding Elements
		Accessing Elements
		Printing an ArrayList
		Using an Iterator
		Updating Elements
		Deleting Elements
	Chapter 4 Using the LinkedList Class
		Understanding the LinkedList Class
		Creating a LinkedList
		Adding Items to a LinkedList
		Retrieving Items from a LinkedList
		Updating LinkedList Items
		Removing LinkedList Items
	Chapter 5 Creating Generic Collection Classes
		Why Generics?
		Creating a Generic Class
		A Generic Stack Class
		Using Wildcard-Type Parameters
		A Generic Queue Class
	Chapter 6 Using Bulk Data Operations with Collections
		Looking At a Basic Bulk Data Operation
		Looking Closer at the Stream Interface
		Using Parallel Streams
Book 5 Programming Techniques
	Chapter 1 Programming Threads
		Understanding Threads
		Creating a Thread
			Understanding the Thread class
			Extending the Thread class
			Creating and starting a thread
		Implementing the Runnable Interface
			Using the Runnable interface
			Creating a class that implements Runnable
			Using the CountDownApp class
		Creating Threads That Work Together
		Using an Executor
		Synchronizing Methods
		Creating a Lock
		Coping with Threadus Interruptus
			Finding out whether you’ve been interrupted
			Aborting the countdown
	Chapter 2 Using Regular Expressions
		Creating a Program for Experimenting with Regular Expressions
		Performing Basic Character Matching
			Matching single characters
			Using predefined character classes
			Using custom character classes
			Using ranges
			Using negation
			Matching multiple characters
			Using escapes
			Using parentheses to group characters
			Using the pipe symbol
		Using Regular Expressions in Java Programs
			Understanding the String problem
			Using regular expressions with the String class
			Using the Pattern and Matcher classes
	Chapter 3 Using Recursion
		Calculating the Classic Factorial Example
			The nonrecursive solution
			The recursive solution
		Displaying Directories
		Writing Your Own Sorting Routine
			Understanding how Quicksort works
			Using the sort method
			Using the partition method
			Putting it all together
	Chapter 4 Working with Dates and Times
		Pondering How Time is Represented
		Picking the Right Date and Time Class for Your Application
		Using the now Method to Create a Date-Time Object
		Using the parse Method to Create a Date-Time Object
		Using the of Method to Create a Date-Time Object
			Using the Month enumeration
			Using the ZoneId class
			Using the ZoneOffset class
		Looking Closer at the LocalDate Class
		Extracting Information About a Date
		Comparing Dates
		Calculating with Dates
		Formatting Dates
		Looking at a Fun Birthday Calculator
	Chapter 5 IoT Programming with Raspberry Pi
		Introducing the Raspberry Pi
		Setting Up a Raspberry Pi
		Installing Java on a Raspberry Pi
		Installing the Pi4J Library
		Configuring the Geany Integrated Development Environment for Java Development
		Examining GPIO Ports
		Connecting an LED to a GPIO Port
		Building a Raspberry Pi LED Circuit
			Parts
			Steps
		Examining the Pi4J Library
		Importing GPIO Types
		Instantiating a GpioController
		Provisioning GPIO Pins
		Controlling the Pin State
		The Morse Code Program
		The Cylon Eyes Program
			Assembling the Cylon Eyes circuit
			Running the Cylon Eyes program
		Working with Input Pins
			Understanding active-high and active-low inputs
			Provisioning a digital input
			Reading the state of a digital input pin
			Building a circuit with a digital input pin
		Running the Button Switcher Program
		Finding a Better Way to Handle Input Events
			Crafting a state change event listener
			Adding an event handler to a pin
			Using automatic debounce
			Working with the EventSwitcher program
Book 6 JavaFX
	Chapter 1 Hello, JavaFX!
		Perusing the Possibilities of JavaFX
		Getting Ready to Run JavaFX
		Looking at a Simple JavaFX Program
		Importing JavaFX Packages
		Extending the Application Class
		Launching the Application
		Overriding the start Method
		Creating a Button
		Handling an Action Event
		Creating a Layout Pane
		Making a Scene
		Setting the Stage
		Examining the Click Counter Program
	Chapter 2 Handling Events
		Examining Events
		Handling Events
		Implementing the EventHandler Interface
		Handling Events with Inner Classes
		Handling Events with Anonymous Inner Classes
		Using Lambda Expressions to Handle Events
	Chapter 3 Setting the Stage and Scene Layout
		Examining the Stage Class
		Examining the Scene Class
		Switching Scenes
		Creating an Alert Box
		Exit, Stage Right
			Creating a Close button
			Handling the CloseRequest event
			Putting it all together
	Chapter 4 Using Layout Panes to Arrange Your Scenes
		Working with Layout Panes
			Introducing five JavaFX layout panes
			Creating layout panes
			Combining layout panes
		Using the HBox Layout
		Spacing Things Out
		Adding Space with Margins
		Adding Space by Growing Nodes
		Using the VBox Layout
		Aligning Nodes in a Layout Pane
		Using the Flow Layout
		Using the Border Layout
		Using the GridPane Layout
			Sketching out a plan
			Creating a grid pane
			Working with grid pane constraints
			Examining a grid pane example
	Chapter 5 Getting Input from the User
		Using Text Fields
		Validating Numeric Data
		Using Check Boxes
		Using Radio Buttons
	Chapter 6 Choosing from a List
		Using Choice Boxes
			Creating a choice box
			Setting a default value
			Getting the selected item
		Working with Observable Lists
		Listening for Selection Changes
		Using Combo Boxes
			Creating combo boxes
			Getting the selected item
			Handling combo box events
		Using List Views
			Creating a list view
			Getting the selected items
		Using Tree Views
			Building a tree
			Creating a TreeView control
			Getting the selected node
			Looking at a complete program that uses a tree view
Book 7 Web Programming
	Chapter 1 Creating Servlets
		Understanding Servlets
		Using Tomcat
			Installing Tomcat
			Testing Tomcat
		Creating a Simple Servlet
			Creating the folder structure for a servlet
			Creating the web.xml file
			Importing the servlet packages
			Extending the HttpServlet class
			Printing to a web page
			Responding with HTML
		Running a Servlet
		Improving the HelloWorld Servlet
		Getting Input from the User
			Working with forms
			Using the InputServlet servlet
		Using Classes in a Servlet
	Chapter 2 Using JavaServer Pages
		Understanding JavaServer Pages
		Using UEL Expressions
			Unified Expression Language
			JSP Standard Tag Library
		Looking at Core Tags
			Using c:out
			Working with variables
			Getting conditional
			Creating loops
		Formatting Numbers
		Considering the Controller Servlet
			Setting request attributes
			Redirecting to the JSP page
		The ListMovies Application Meets JSP
	Chapter 3 Using JavaBeans
		Getting to Know JavaBeans
		Looking Over a Sample Bean
		Using Beans with JSP Pages
			Creating bean instances
			Getting property values
			Setting property values
			Viewing a JSP page that uses a bean
		Scoping Your Beans
			A shopping cart application
			The shopping cart page
			The BookCart JavaBean
	Chapter 4 Using HttpClient
		Understanding HTTP
			Diving into HTTP
			Looking at a simple HTTP exchange
		Getting Started with Java’s HTTP Client Library
			HttpClient
			HttpRequest
			HttpResponse
			Using the send method
		Putting It All Together
		The HTTP Tester Program
Index
EULA