Doug Lowe began writing computer books before Java was invented. He's covered dinosaurs such as COBOL, FORTRAN, and IBM mainframe computers, as well as web programming, Microsoft PowerPoint, and networking. Doug has written more than 30 For Dummies computer guides.

Introduction 1

About This Book 2

Foolish Assumptions 2

Icons Used in This Book 3

Beyond the Book 4

Where to Go from Here 4

Book 1: Java Basics 5

Chapter 1: Welcome to Java 7

What Is Java, and Why Is It So Great? 8

Platform independence 8

Object orientation 9

The Java API 10

The Internet 10

Java versus Other Languages 11

Important Features of the Java Language 12

Type checking 13

Exception handling 14

On the Downside: Java’s Weaknesses 15

Java Version Insanity 16

What’s in a Name? 18

Chapter 2: Installing and Using Java Tools 19

Downloading and Installing the Java Development Kit 20

Downloading the JDK 20

Installing the JDK 21

Perusing the JDK folders 21

Setting the path 22

Using Java’s Command-Line Tools 24

Compiling a program 24

Compiling more than one file 25

Using Java compiler options 26

Running a Java program 28

Using the javap command 28

Using Java Documentation 30

Chapter 3: Working with TextPad 33

Downloading and Installing TextPad 33

Editing Source Files 35

Compiling a Program 37

Running a Java Program 38

Book 2: Programming Basics 41

Chapter 1: Java Programming Basics 43

Looking at the Infamous Hello, World! Program 44

Dealing with Keywords 47

Working with Statements 49

Types of statements 49

White space 50

Working with Blocks 52

Creating Identifiers 53

Crafting Comments 54

End-of-line comments 54

Traditional comments 54

JavaDoc comments 55

Introducing Object-Oriented Programming 56

Understanding classes and objects 56

Understanding static methods 56

Creating an object from a class 57

Viewing a program that uses an object 58

So what’s the difference? 60

Importing Java API Classes 61

Chapter 2: Working with Variables and Data Types 63

Declaring Variables 64

Declaring two or more variables in one statement 65

Declaring class variables 65

Declaring instance variables 66

Declaring local variables 67

Initializing Variables 68

Initializing variables with assignment statements 69

Initializing variables with initializers 70

Using Final Variables (Constants) 70

Working with Primitive Data Types 71

Integer types 72

Floating-point types 74

The char type 76

The Boolean type 77

Using wrapper classes 78

Using reference types 78

Using inferred variable types 80

Working with Strings 81

Declaring and initializing strings 82

Combining strings 82

Converting primitives to strings 83

Converting strings to primitives 84

Converting and Casting Numeric Data 85

Automatic conversions 85

Type casting 86

Thinking Inside the Box 87

Understanding Scope 87

Shadowing Variables 89

Printing Data with System out 90

Using standard input and output streams 91

Using System out and System err 92

Getting Input with the Scanner Class 93

Importing the Scanner class 94

Declaring and creating a Scanner object 94

Getting input 94

Getting Input with the JOptionPane Class 96

Using enum to Create Your Own Data Types 98

Chapter 3: Working with Numbers and Expressions 99

Working with Arithmetic Operators 99

Dividing Integers 102

Combining Operators 104

Using the Unary Plus and Minus Operators 105

Using Increment and Decrement Operators 106

Using the Assignment Operator 108

Using Compound Assignment Operators 110

Using the Math Class 111

Using constants of the Math class 112

Working with mathematical functions 113

Creating random numbers 116

Rounding functions 119

Formatting Numbers 121

Recognizing Weird Things about Java Math 123

Integer overflow 123

Floating-point weirdness 124

Division by zero 125

Chapter 4: Making Choices 129

Using Simple Boolean Expressions 130

Using if Statements 132

Simple if statements 132

if-else statements 135

Nested if statements 136

else-if statements 140

Using Mr Spock’s Favorite Operators (Logical Ones, of Course) 142

Using the ! operator 142

Using the & and && operators 144

Using the | and || operators 145

Using the ^ operator 146

Combining logical operators 147

Using the Conditional Operator 148

Comparing Strings 149

Chapter 5: Going Around in Circles (Or, Using Loops) 151

Using Your Basic while Loop 152

The while statement 152

A counting loop 152

Breaking Out of a Loop 154

Looping Forever 154

Letting the user decide when to quit 156

Letting the user decide in another way 157

Using the continue Statement 158

Running do-while Loops 159

Validating Input from the User 161

Using the Famous for Loop 164

Understanding the formal format of the for loop 164

Scoping out the counter variable 166

Counting even numbers 167

Counting backward 168

Using for loops without bodies 169

Ganging up your expressions 170

Omitting expressions 172

Breaking and continuing your for loops 172

Nesting Your Loops 173

A simple nested for loop 174

A guessing game 174

Chapter 6: Pulling a Switcheroo 179

Battling else-if Monstrosities 179

Viewing an example else-if program 180

Creating a better version of the example program 181

Using the switch Statement 183

Viewing a boring switch example, complete with flowchart 184

Putting if statements inside switch statements 186

Creating Character Cases 187

Intentionally Leaving Out a Break Statement 188

Switching with Strings 192

Enhanced Switch Features with Java 13 193

Chapter 7: Adding Some Methods to Your Madness 197

The Joy of Methods 198

The Basics of Making Methods 198

An example 200

Another example 201

Methods That Return Values 203

Declaring the method’s return type 203

Using the return statement to return the value 204

Using a method that returns a type 205

You gotta have a proper return statement 205

Trying another version of the guessing-game program 207

Methods That Take Parameters 210

Declaring parameters 211

Scoping out parameters 212

Understanding pass-by-value 213

Trying yet another version of the guessing-game program 214

Chapter 8: Handling Exceptions 217

Understanding Exceptions 218

Witnessing an exception 219

Finding the culprit 220

Catching Exceptions 221

A simple example 222

Another example 222

Handling Exceptions with a Preemptive Strike 224

Catching All Exceptions at Once 226

Displaying the Exception Message 227

Using a finally Block 228

Handling Checked Exceptions 231

Viewing the catch-or-throw compiler error 232

Catching FileNotFoundException 232

Throwing the FileNotFoundException 233

Throwing an exception from main 234

Swallowing exceptions 234

Throwing Your Own Exceptions 236

Book 3: Object-Oriented Programming 239

Chapter 1: Understanding Object-Oriented Programming 241

What Is Object-Oriented Programming? 242

Understanding Objects 243

Objects have identity 243

Objects have type 244

Objects have state 245

Objects have behavior 246

Understanding the Life Cycle of an Object 247

Working with Related Classes 248

Inheritance 248

Interfaces 249

Designing a Program with Objects 250

Diagramming Classes with UML 251

Drawing classes 252

Drawing arrows 253

Chapter 2: Making Your Own Classes 255

Declaring a Class 256

Picking class names 256

Knowing what goes in the class body 257

Seeing where classes go 258

Working with Members 259

Understanding fields 259

Understanding instance methods 260

Understanding visibility 261

Using Getters and Setters 261

Overloading Methods 264

Creating Constructors 266

Creating basic constructors 266

Creating default constructors 267

Calling other constructors 268

Finding More Uses for the this Keyword 270

Using Initializers 271

Using Records 273

Chapter 3: Working with Statics 275

Understanding Static Fields and Methods 275

Working with Static Fields 276

Using Static Methods 277

Counting Instances 278

Preventing Instances 281

Using Static Initializers 282

Chapter 4: Using Subclasses and Inheritance 285

Introducing Inheritance 285

Motorcycles, trains, and automobiles 287

Game play 287

A businesslike example 288

Inheritance hierarchies 288

Creating Subclasses 289

Overriding Methods 291

Protecting Your Members 292

Using this and super in Your Subclasses 293

Understanding Inheritance and Constructors 294

Using final 295

Final methods 296

Final classes 296

Casting Up and Down 297

Determining an Object’s Type 299

Poly What? 300

Creating Custom Exceptions 302

Tracing the Throwable hierarchy 302

Creating an exception class 304

Throwing a custom exception 305

Chapter 5: Using Abstract Classes and Interfaces 307

Using Abstract Classes 307

Using Interfaces 310

Creating a basic interface 311

Implementing an interface 312

Using an interface as a type 313

More Things You Can Do with Interfaces 314

Adding fields to an interface 314

Extending interfaces 315

Using interfaces for callbacks 316

Using Additional Interface Method Types 320

Chapter 6: Using the Object and Class Classes 323

The Mother of All Classes: Object 323

Every object is an Object 324

Object as a type 324

Methods of the Object class 325

Primitives aren’t objects 326

The toString Method 327

Using toString 327

Overriding toString 328

The equals Method 330

Using equals 331

Overriding the equals method 332

The clone Method 336

Implementing the clone method 336

Using clone to create a shallow copy 339

Creating deep copies 341

The Class Class 346

Chapter 7: Using Inner Classes, Anonymous Classes, and Lambda Expressions 349

Declaring Inner Classes 350

Understanding inner classes 350

Viewing an example 351

Using Static Inner Classes 354

Using Anonymous Inner Classes 355

Creating an anonymous class 356

Creating a program with an anonymous class 357

Using Lambda Expressions 359

Chapter 8: Working with Packages and the Java Module System 361

Working with Packages 362

Importing classes and packages 362

Creating your own packages 363

An example 365

Putting Your Classes in a JAR File 366

jar command-line options 366

Archiving a package 367

Adding a jar to your classpath 368

Running a program directly from an archive 369

Using Javadoc to Document Your Classes 370

Adding Javadoc comments 371

Using the javadoc command 373

Viewing Javadoc pages 374

Using the Java Module System 375

Understanding modules 376

The module-info java file 377

Setting up folders for a module 378

Compiling a module 379

Creating a modular JAR file 379

Running a modular JAR file 380

Book 4: Strings, Arrays, and Collections 381

Chapter 1: Working with Strings 383

Reviewing Strings 384

Using the String Class 386

Finding the length of a string 388

Making simple string modifications 389

Extracting characters from a string 389

Extracting substrings from a string 390

Splitting a string 392

Replacing parts of a string 394

Using the StringBuilder and StringBuffer Classes 395

Creating a StringBuilder object 396

Using StringBuilder methods 396

Viewing a StringBuilder example 398

Using the CharSequence Interface 399

Chapter 2: Using Arrays 401

Understanding Arrays 401

Creating Arrays 402

Initializing an Array 404

Using for Loops with Arrays 404

Solving Homework Problems with Arrays 405

Using the Enhanced for Loop 408

Using Arrays with Methods 409

Using Varargs 410

Using Two-Dimensional Arrays 411

Creating a two-dimensional array 412

Accessing two-dimensional array elements 413

Initializing a two-dimensional array 414

Using jagged arrays 415

Going beyond two dimensions 416

Working with a Fun but Complicated Example: A Chessboard 417

Using the Arrays Class 425

Filling an array 426

Copying an array 427

Sorting an array 428

Searching an array 429

Comparing arrays 429

Converting arrays to strings 430

Chapter 3: Using the ArrayList Class 431

Understanding the ArrayList Class 432

Creating an ArrayList Object 435

Adding Elements 436

Accessing Elements 437

Printing an ArrayList 438

Using an Iterator 438

Updating Elements 440

Deleting Elements 442

Chapter 4: Using the LinkedList Class 445

Understanding the LinkedList Class 446

Creating a LinkedList 450

Adding Items to a LinkedList 450

Retrieving Items from a LinkedList 452

Updating LinkedList Items 454

Removing LinkedList Items 455

Chapter 5: Creating Generic Collection Classes 457

Why Generics? 458

Creating a Generic Class 459

A Generic Stack Class 461

Using Wildcard-Type Parameters 464

A Generic Queue Class 466

Chapter 6: Using Bulk Data Operations with Collections 471

Looking At a Basic Bulk Data Operation 473

Looking Closer at the Stream Interface 475

Using Parallel Streams 478

Book 5: Programming Techniques 481

Chapter 1: Programming Threads 483

Understanding Threads 484

Creating a Thread 485

Understanding the Thread class 485

Extending the Thread class 486

Creating and starting a thread 488

Implementing the Runnable Interface 488

Using the Runnable interface 489

Creating a class that implements Runnable 489

Using the CountDownApp class 491

Creating Threads That Work Together 493

Using an Executor 497

Synchronizing Methods 499

Creating a Lock 503

Coping with Threadus Interruptus 505

Finding out whether you’ve been interrupted 505

Aborting the countdown 506

Chapter 2: Using Regular Expressions 511

Creating a Program for Experimenting with Regular Expressions 512

Performing Basic Character Matching 515

Matching single characters 515

Using predefined character classes 515

Using custom character classes 518

Using ranges 519

Using negation 520

Matching multiple characters 520

Using escapes 521

Using parentheses to group characters 522

Using the pipe symbol 523

Using Regular Expressions in Java Programs 524

Understanding the String problem 524

Using regular expressions with the String class 525

Using the Pattern and Matcher classes 526

Chapter 3: Using Recursion 529

Calculating the Classic Factorial Example 529

The nonrecursive solution 530

The recursive solution 530

Displaying Directories 532

Writing Your Own Sorting Routine 536

Understanding how Quicksort works 536

Using the sort method 537

Using the partition method 538

Putting it all together 540

Chapter 4: Working with Dates and Times 545

Pondering How Time is Represented 546

Picking the Right Date and Time Class for Your Application 547

Using the now Method to Create a Date-Time Object 548

Using the parse Method to Create a Date-Time Object 550

Using the of Method to Create a Date-Time Object 551

Using the Month enumeration 552

Using the ZoneId class 553

Using the ZoneOffset class 554

Looking Closer at the LocalDate Class 554

Extracting Information About a Date 556

Comparing Dates 557

Calculating with Dates 558

Formatting Dates 560

Looking at a Fun Birthday Calculator 562

Chapter 5: IoT Programming with Raspberry Pi 567

Introducing the Raspberry Pi 568

Setting Up a Raspberry Pi 570

Installing Java on a Raspberry Pi 571

Installing the Pi4J Library 572

Configuring the Geany Integrated Development Environment for Java Development 572

Examining GPIO Ports 574

Connecting an LED to a GPIO Port 576

Building a Raspberry Pi LED Circuit 581

Parts 581

Steps 582

Examining the Pi4J Library 582

Importing GPIO Types 583

Instantiating a GpioController 584

Provisioning GPIO Pins 584

Controlling the Pin State 587

The Morse Code Program 589

The Cylon Eyes Program 593

Assembling the Cylon Eyes circuit 593

Running the Cylon Eyes program 596

Working with Input Pins 598

Understanding active-high and active-low inputs 599

Provisioning a digital input 600

Reading the state of a digital input pin 601

Building a circuit with a digital input pin 602

Running the Button Switcher Program 604

Finding a Better Way to Handle Input Events 606

Crafting a state change event listener 607

Adding an event handler to a pin 608

Using automatic debounce 609

Working with the EventSwitcher program 610

Book 6: JavaFX 613

Chapter 1: Hello, JavaFX! 615

Perusing the Possibilities of JavaFX 616

Getting Ready to Run JavaFX 618

Looking at a Simple JavaFX Program 620

Importing JavaFX Packages 622

Extending the Application Class 623

Launching the Application 624

Overriding the start Method 625

Creating a Button 626

Handling an Action Event 627

Creating a Layout Pane 629

Making a Scene 630

Setting the Stage 631

Examining the Click Counter Program 632

Chapter 2: Handling Events 637

Examining Events 638

Handling Events 639

Implementing the EventHandler Interface 641

Handling Events with Inner Classes 644

Handling Events with Anonymous Inner Classes 647

Using Lambda Expressions to Handle Events 649

Chapter 3: Setting the Stage and Scene Layout 655

Examining the Stage Class 656

Examining the Scene Class 659

Switching Scenes 661

Creating an Alert Box 666

Exit, Stage Right 670

Creating a Close button 671

Handling the CloseRequest event 672

Putting it all together 674

Chapter 4: Using Layout Panes to Arrange Your Scenes 677

Working with Layout Panes 678

Introducing five JavaFX layout panes 678

Creating layout panes 679

Combining layout panes 680

Using the HBox Layout 680

Spacing Things Out 682

Adding Space with Margins 684

Adding Space by Growing Nodes 685

Using the VBox Layout 687

Aligning Nodes in a Layout Pane 689

Using the Flow Layout 690

Using the Border Layout 694

Using the GridPane Layout 697

Sketching out a plan 697

Creating a grid pane 698

Working with grid pane constraints 701

Examining a grid pane example 703

Chapter 5: Getting Input from the User 709

Using Text Fields 710

Validating Numeric Data 717

Using Check Boxes 719

Using Radio Buttons 721

Chapter 6: Choosing from a List 725

Using Choice Boxes 725

Creating a choice box 727

Setting a default value 728

Getting the selected item 729

Working with Observable Lists 729

Listening for Selection Changes 732

Using Combo Boxes 734

Creating combo boxes 735

Getting the selected item 736

Handling combo box events 737

Using List Views 738

Creating a list view 739

Getting the selected items 740

Using Tree Views 740

Building a tree 742

Creating a TreeView control 745

Getting the selected node 746

Looking at a complete program that uses a tree view 748

Book 7: Web Programming 751

Chapter 1: Creating Servlets 753

Understanding Servlets 753

Using Tomcat 755

Installing Tomcat 755

Testing Tomcat 756

Creating a Simple Servlet 757

Creating the folder structure for a servlet 758

Creating the web xml file 758

Importing the servlet packages 760

Extending the HttpServlet class 760

Printing to a web page 761

Responding with HTML 762

Running a Servlet 764

Improving the HelloWorld Servlet 765

Getting Input from the User 767

Working with forms 767

Using the InputServlet servlet 768

Using Classes in a Servlet 769

Chapter 2: Using JavaServer Pages 775

Understanding JavaServer Pages 776

Using UEL Expressions 778

Unified Expression Language 778

JSP Standard Tag Library 780

Looking at Core Tags 782

Using c:out 783

Working with variables 783

Getting conditional 784

Creating loops 785

Formatting Numbers 786

Considering the Controller Servlet 788

Setting request attributes 788

Redirecting to the JSP page 789

The ListMovies Application Meets JSP 790

Chapter 3: Using JavaBeans 797

Getting to Know JavaBeans 797

Looking Over a Sample Bean 799

Using Beans with JSP Pages 801

Creating bean instances 802

Getting property values 803

Setting property values 803

Viewing a JSP page that uses a bean 804

Scoping Your Beans 806

A shopping cart application 807

The shopping cart page 808

The BookCart JavaBean 810

Chapter 4: Using HttpClient 815

Understanding HTTP 815

Diving into HTTP 817

Looking at a simple HTTP exchange 822

Getting Started with Java’s HTTP Client Library 822

HttpClient 823

HttpRequest 824

HttpResponse 827

Using the send method 828

Putting It All Together 829

The HTTP Tester Program 831

Index 835

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.