ABOUT THE AUTHORS

Scott Selikoff has been a professional Java Enterprise architect for over 20 years. He currently works as a Staff Software Engineer at Google, specializing in Architecture and Cloud Services. He is a Leader of the Garden State Java User Group, helping to facilitate discussions and exchange of ideas within the community.

Jeanne Boyarsky is a Java Champion and has worked as a Java developer for a major bank for more than 20 years. She is a senior moderator at CodeRanch, and trains and mentors students of all levels, including the programming department of a FIRST robotics team.

Introduction xxiii

Assessment Test xlv
Chapter 1 Building Blocks 1

Learning about the Environment 2

Major Components of Java 2

Downloading a JDK 3

Understanding the Class Structure 4

Fields and Methods 4

Comments 5

Classes and Source Files 7

Writing a main() Method 8

Creating a main() Method 8

Passing Parameters to a Java Program 9

Understanding Package Declarations and Imports 11

Packages 12

Wildcards 13

Redundant Imports 13

Naming Conflicts 15

Creating a New Package 16

Compiling and Running Code with Packages 16

Compiling to Another Directory 18

Compiling with JAR Files 20

Creating a JAR File 20

Ordering Elements in a Class 21

Creating Objects 23

Calling Constructors 23

Reading and Writing Member Fields 24

Executing Instance Initializer Blocks 24

Following the Order of Initialization 25

Understanding Data Types 26

Using Primitive Types 27

Using Reference Types 29

Distinguishing between Primitives and Reference Types 30

Creating Wrapper Classes 31

Defining Text Blocks 32

Declaring Variables 34

Identifying Identifiers 35

Declaring Multiple Variables 36

Initializing Variables 38

Creating Local Variables 38

Passing Constructor and Method Parameters 40

Defining Instance and Class Variables 41

Inferring the Type with var 41

Managing Variable Scope 45

Limiting Scope 45

Tracing Scope 46

Applying Scope to Classes 47

Reviewing Scope 48

Destroying Objects 48

Understanding Garbage Collection 48

Tracing Eligibility 49

Summary 51

Exam Essentials 52

Review Questions 54

Chapter 2 Operators 65

Understanding Java Operators 66

Types of Operators 66

Operator Precedence 67

Applying Unary Operators 69

Complement and Negation Operators 70

Increment and Decrement Operators 71

Working with Binary Arithmetic Operators 72

Arithmetic Operators 72

Numeric Promotion 75

Assigning Values 77

Assignment Operator 77

Casting Values 77

Compound Assignment Operators 81

Return Value of Assignment Operators 82

Comparing Values 83

Equality Operators 83

Relational Operators 84

Logical Operators 87

Conditional Operators 88

Making Decisions with the Ternary Operator 90

Summary 92

Exam Essentials 92

Review Questions 94

Chapter 3 Making Decisions 101

Creating Decision- Making Statements 102

Statements and Blocks 102

The if Statement 103

The else Statement 104

Shortening Code with Pattern Matching 106

Applying switch Statements 110

The switch Statement 110

The switch Expression 115

Writing while Loops 121

The while Statement 121

The do/while Statement 123

Infinite Loops 123

Constructing for Loops 124

The for Loop 124

The for- each Loop 129

Controlling Flow with Branching 131

Nested Loops 131

Adding Optional Labels 132

The break Statement 133

The continue Statement 135

The return Statement 137

Unreachable Code 138

Reviewing Branching 139

Summary 139

Exam Essentials 140

Review Questions 142

Chapter 4 Core APIs 155

Creating and Manipulating Strings 156

Concatenating 157

Important String Methods 158

Method Chaining 169

Using the StringBuilder Class 170

Mutability and Chaining 171

Creating a StringBuilder 172

Important StringBuilder Methods 172

Understanding Equality 175

Comparing equals() and == 175

The String Pool 176

Understanding Arrays 178

Creating an Array of Primitives 179

Creating an Array with Reference Variables 180

Using an Array 182

Sorting 183

Searching 184

Comparing 185

Using Methods with Varargs 187

Working with Multidimensional Arrays 188

Calculating with Math APIs 190

Finding the Minimum and Maximum 190

Rounding Numbers 191

Determining the Ceiling and Floor 191

Calculating Exponents 192

Generating Random Numbers 192

Working with Dates and Times 192

Creating Dates and Times 193

Manipulating Dates and Times 197

Working with Periods 199

Working with Durations 202
Period vs. Duration 204

Working with Instants 205

Accounting for Daylight Saving Time 206

Summary 208

Exam Essentials 209

Review Questions 210

Chapter 5 Methods 219

Designing Methods 220

Access Modifiers 221

Optional Specifiers 222

Return Type 224

Method Name 226

Parameter List 226

Method Signature 227

Exception List 227

Method Body 228

Declaring Local and Instance Variables 228

Local Variable Modifiers 229

Effectively Final Variables 230

Instance Variable Modifiers 231

Working with Varargs 232

Creating Methods with Varargs 232

Calling Methods with Varargs 233

Accessing Elements of a Vararg 234

Using Varargs with Other Method Parameters 234

Applying Access Modifiers 235

Private Access 235

Package Access 236

Protected Access 237

Public Access 242

Reviewing Access Modifiers 242

Accessing static Data 243

Designing static Methods and Variables 243

Accessing a static Variable or Method 244

Class vs. Instance Membership 245
Static Variable Modifiers 248
Static Initializers 250
Static Imports 251

Passing Data among Methods 253

Passing Objects 253

Returning Objects 255

Autoboxing and Unboxing Variables 256

Overloading Methods 258

Reference Types 259

Primitives 260

Autoboxing 261

Arrays 261

Varargs 261

Putting It All Together 262

Summary 263

Exam Essentials 264

Review Questions 265

Chapter 6 Class Design 275

Understanding Inheritance 276

Declaring a Subclass 276

Class Modifiers 278

Single vs. Multiple Inheritance 279

Inheriting Object 279

Creating Classes 281

Extending a Class 281

Applying Class Access Modifiers 282

Accessing the this Reference 283

Calling the super Reference 284

Declaring Constructors 286

Creating a Constructor 286

The Default Constructor 287

Calling Overloaded Constructors with this() 289

Calling Parent Constructors with super() 292

Initializing Objects 297

Initializing Classes 297

Initializing final Fields 298

Initializing Instances 300

Inheriting Members 304

Overriding a Method 305

Redeclaring private Methods 311

Hiding Static Methods 311

Hiding Variables 313

Writing final Methods 314

Creating Abstract Classes 315

Introducing Abstract Classes 315

Declaring Abstract Methods 317

Creating a Concrete Class 318

Creating Constructors in Abstract Classes 320

Spotting Invalid Declarations 321

Creating Immutable Objects 323

Declaring an Immutable Class 323

Performing a Defensive Copy 325

Summary 326

Exam Essentials 327

Review Questions 330

Chapter 7 Beyond Classes 345

Implementing Interfaces 346

Declaring and Using an Interface 346

Extending an Interface 348

Inheriting an Interface 349

Inserting Implicit Modifiers 351

Declaring Concrete Interface Methods 353

Working with Enums 361

Creating Simple Enums 361

Using Enums in switch Statements 363

Adding Constructors, Fields, and Methods 364

Sealing Classes 367

Declaring a Sealed Class 367

Compiling Sealed Classes 368

Specifying the Subclass Modifier 369

Omitting the permits Clause 370

Sealing Interfaces 372

Reviewing Sealed Class Rules 372

Encapsulating Data with Records 373

Understanding Encapsulation 374

Applying Records 375

Understanding Record Immutability 377

Declaring Constructors 378

Customizing Records 381

Creating Nested Classes 382

Declaring an Inner Class 382

Creating a static Nested Class 386

Writing a Local Class 387

Defining an Anonymous Class 389

Reviewing Nested Classes 391

Understanding Polymorphism 392

Object vs. Reference 393

Casting Objects 395

The instanceof Operator 397

Polymorphism and Method Overriding 397

Overriding vs. Hiding Members 399

Summary 401

Exam Essentials 402

Review Questions 404

Chapter 8 Lambdas and Functional Interfaces 419

Writing Simple Lambdas 420

Looking at a Lambda Example 420

Learning Lambda Syntax 422

Coding Functional Interfaces 426

Defining a Functional Interface 426

Adding Object Methods 427

Using Method References 429

Calling static Methods 430

Calling Instance Methods on a Particular Object 430

Calling Instance Methods on a Parameter 432

Calling Constructors 433

Reviewing Method References 433

Working with Built- in Functional Interfaces 434

Implementing Supplier 435

Implementing Consumer and BiConsumer 436

Implementing Predicate and BiPredicate 438

Implementing Function and BiFunction 439

Implementing UnaryOperator and BinaryOperator 440

Checking Functional Interfaces 441

Using Convenience Methods on Functional Interfaces 442

Learning the Functional Interfaces for Primitives 443

Working with Variables in Lambdas 445

Listing Parameters 446

Using Local Variables inside a Lambda Body 448

Referencing Variables from the Lambda Body 449

Summary 450

Exam Essentials 451

Review Questions 452

Chapter 9 Collections and Generics 463

Using Common Collection APIs 464

Using the Diamond Operator 465

Adding Data 466

Removing Data 466

Counting Elements 467

Clearing the Collection 467

Check Contents 468

Removing with Conditions 468

Iterating 469

Determining Equality 470

Using the List Interface 471

Comparing List Implementations 472

Creating a List with a Factory 472

Creating a List with a Constructor 473

Working with List Methods 474

Converting from List to an Array 476

Using the Set Interface 477

Comparing Set Implementations 477

Working with Set Methods 478

Using the Queue and Deque Interfaces 479

Comparing Deque Implementations 480

Working with Queue and Deque Methods 480

Using the Map Interface 483

Comparing Map Implementations 484

Working with Map Methods 484

Calling Basic Methods 486

Iterating through a Map 487

Getting Values Safely 487

Replacing Values 488

Putting if Absent 488

Merging Data 488

Comparing Collection Types 490

Sorting Data 492

Creating a Comparable Class 492

Comparing Data with a Comparator 496

Comparing Comparable and Comparator 497

Comparing Multiple Fields 498

Sorting and Searching 500

Sorting a List 503

Working with Generics 503

Creating Generic Classes 504

Understanding Type Erasure 506

Implementing Generic Interfaces 509

Writing Generic Methods 510

Creating a Generic Record 512

Bounding Generic Types 512

Putting It All Together 517

Summary...