OCP Oracle Certified Professional Java SE 11 Programmer I Study Guide

Jeanne Boyarsky, OCA/OCP 8 and OCP 11, has worked as a Java developer for a major bank for more than 17 years. She is a senior moderator at CodeRanch, and trains and mentors students of all levels, including the programming division of a FIRST robotics team. Scott Selikoff, OCA/OCP 8 and OCP 11, has been a professional Java Enterprise developer for over 20 years. He currently operates Selikoff Solutions, LLC, which provides software consulting services to businesses in the tri-state New York City area.

Introduction xxi

The Assessment Test xliii

Chapter 1 Welcome to Java 1

Learning About the Java Environment 2

Major Components of Java 2

Downloading a JDK 3

Identifying Benefits of Java 4

Understanding the Java Class Structure 5

Fields and Methods 5

Comments 6

Classes vs. Files 8

Writing a main() Method 8

Creating a main() Method 9

Passing Parameters to a Java Program 10

Running a Program in One Line 12

Understanding Package Declarations and Imports 13

Wildcards 15

Redundant Imports 15

Naming Conflicts 16

Creating a New Package 18

Compiling and Running Code with Packages 19

Using an Alternate Directory 20

Compiling with JAR Files 22

Creating a JAR File 23

Running a Program in One Line with Packages 24

Ordering Elements in a Class 24

Code Formatting on the Exam 26

Summary 27

Exam Essentials 27

Review Questions 29

Chapter 2 Java Building Blocks 35

Creating Objects 36

Calling Constructors 36

Reading and Writing Member Fields 37

Executing Instance Initializer Blocks 38

Following Order of Initialization 39

Understanding Data Types 40

Using Primitive Types 40

Using Reference Types 44

Distinguishing between Primitives and Reference Types 45

Declaring Variables 46

Identifying Identifiers 46

Declaring Multiple Variables 49

Initializing Variables 50

Creating Local Variables 51

Passing Constructor and Method Parameters 52

Defining Instance and Class Variables 53

Introducing var 53

Managing Variable Scope 59

Limiting Scope 59

Nesting Scope 60

Tracing Scope 60

Applying Scope to Classes 61

Reviewing Scope 62

Destroying Objects 62

Understanding Garbage Collection 63

Tracing Eligibility 64

Summary 67

Exam Essentials 67

Review Questions 69

Chapter 3 Operators 79

Understanding Java Operators 80

Types of Operators 80

Operator Precedence 81

Applying Unary Operators 82

Logical Complement and Negation Operators 83

Increment and Decrement Operators 84

Working with Binary Arithmetic Operators 85

Arithmetic Operators 86

Numeric Promotion 88

Assigning Values 90

Assignment Operator 90

Casting Values 90

Compound Assignment Operators 93

Assignment Operator Return Value 94

Comparing Values 95

Equality Operators 95

Relational Operators 97

Logical Operators 99

Short-Circuit Operators 100

Making Decisions with the Ternary Operator 102

Summary 103

Exam Essentials 104

Review Questions 105

Chapter 4 Making Decisions 113

Creating Decision-Making Statements 114

Statements and Blocks 114

The if Statement 115

The else Statement 116

The switch Statement 119

Writing while Loops 126

The while Statement 126

The do/while Statement 127

Comparing while and do/while Loops 128

Infinite Loops 129

Constructing for Loops 130

The for Loop 131

The for-each Loop 136

Controlling Flow with Branching 141

Nested Loops 141

Adding Optional Labels 142

The break Statement 143

The continue Statement 145

The return Statement 147

Unreachable Code 148

Reviewing Branching 148

Summary 149

Exam Essentials 150

Review Questions 151

Chapter 5 Core Java APIs 161

Creating and Manipulating Strings 162

Concatenation 163

Immutability 164

Important String Methods 165

Method Chaining 171

Using the StringBuilder Class 172

Mutability and Chaining 173

Creating a StringBuilder 174

Important StringBuilder Methods 174

Understanding Equality 177

Comparing equals() and == 177

The String Pool 179

Understanding Java Arrays 180

Creating an Array of Primitives 181

Creating an Array with Reference Variables 183

Using an Array 185

Sorting 186

Searching 187

Comparing 188

Varargs 190

Multidimensional Arrays 190

Understanding an ArrayList 193

Creating an ArrayList 193

Using an ArrayList 195

Wrapper Classes 199

Autoboxing and Unboxing 201

Converting Between array and List 201

Using Varargs to Create a List 203

Sorting 204

Creating Sets and Maps 204

Introducing Sets 204

Introducing Maps 205

Calculating with Math APIs 206

min() and max() 206

round() 207

pow() 207

random() 208

Summary 208

Exam Essentials 209

Review Questions 210

Chapter 6 Lambdas and Functional Interfaces 221

Writing Simple Lambdas 222

Lambda Example 222

Lambda Syntax 225

Introducing Functional Interfaces 227

Predicate 228

Consumer 228

Supplier 229

Comparator 230

Working with Variables in Lambdas 231

Parameter List 231

Local Variables inside the Lambda Body 231

Variables Referenced from the Lambda Body 232

Calling APIs with Lambdas 234

removeIf() 234

sort() 235

forEach() 235

Summary 236

Exam Essentials 237

Review Questions 238

Chapter 7 Methods and Encapsulation 247

Designing Methods 248

Access Modifiers 249

Optional Specifiers 250

Return Type 251

Method Name 252

Parameter List 253

Optional Exception List 253

Method Body 254

Working with Varargs 254

Applying Access Modifiers 256

Private Access 256

Default (Package-Private) Access 257

Protected Access 259

Public Access 263

Applying the static Keyword 264

Designing static Methods and Fields 264

Accessing a static Variable or Method 265

Static vs. Instance 266

static Variables 268

Static Initialization 269

Static Imports 270

Passing Data among Methods 272

Overloading Methods 275

Varargs 277

Autoboxing 277

Reference Types 277

Primitives 279

Generics 279

Arrays 280

Putting It All Together 280

Encapsulating Data 281

Summary 283

Exam Essentials 284

Review Questions 285

Chapter 8 Class Design 295

Understanding Inheritance 296

Single vs. Multiple Inheritance 297

Inheriting Object 298

Creating Classes 299

Extending a Class 299

Applying Class Access Modifiers 301

Accessing the this Reference 302

Calling the super Reference 303

Declaring Constructors 305

Creating a Constructor 305

Default Constructor 306

Calling Overloaded Constructors with this() 308

Calling Parent Constructors with super() 310

Constructors and final Fields 314

Order of Initialization 316

Reviewing Constructor Rules 322

Inheriting Members 323

Calling Inherited Members 323

Inheriting Methods 324

Hiding Variables 336

Understanding Polymorphism 337

Object vs. Reference 339

Casting Objects 340

The instanceof Operator 341

Polymorphism and Method Overriding 342

Overriding vs. Hiding Members 344

Summary 346

Exam Essentials 347

Review Questions 349

Chapter 9 Advanced Class Design 363

Creating Abstract Classes 364

Introducing Abstract Classes 364

Defining Abstract Methods 366

Creating a Concrete Class 370

Reviewing Abstract Class Rules 372

Implementing Interfaces 373

Defining an Interface 373

Inserting Implicit Modifiers 377

Inheriting an Interface 380

Polymorphism and Interfaces 384

Reviewing Interface Rules 386

Introducing Inner Classes 388

Defining a Member Inner Class 388

Using a Member Inner Class 389

Summary 390

Exam Essentials 391

Review Questions 392

Chapter 10 Exceptions 401

Understanding Exceptions 402

The Role of Exceptions 402

Understanding Exception Types 404

Throwing an Exception 407

Recognizing Exception Classes 409

RuntimeException Classes 409

Checked Exception Classes 412

Error Classes 413

Handling Exceptions 414

Using try and catch Statements 414

Chaining catch Blocks 416

Applying a Multi-catch Block 418

Adding a finally Block 421

Finally Closing Resources 424

Throwing Additional Exceptions 430

Calling Methods That Throw Exceptions 432

Declaring and Overriding Methods with Exceptions 434

Printing an Exception 435

Summary 437

Exam Essentials 438

Review Questions 440

Chapter 11 Modules 451

Introducing Modules 452

Exploring a Module 453

Benefits of Modules 454

Creating and Running a Modular Program 456

Creating the Files 457

Compiling Our First Module 458

Running Our First Module 460

Packaging Our First Module 461

Updating Our Example for Multiple Modules 463

Updating the Feeding Module 463

Creating a Care Module 464

Creating the Talks Module 466

Creating the Staff Module 469

Diving into the module-info File 470

exports 470

requires transitive 472

provides, uses, and opens 474

Discovering Modules 475

The java Command 475

The jar Command 478

The jdeps Command 478

The jmod Command 480

Reviewing Command-Line Options 481

Summary 483

Exam Essentials 484

Review Questions 485

Appendix Answers to Review Questions 491

Chapter 1: Welcome to Java 492

Chapter 2: Java Building Blocks 494

Chapter 3: Operators 498

Chapter 4: Making Decisions 501

Chapter 5: Core Java APIs 505

Chapter 6: Lambdas and Functional Interfaces 509

Chapter 7: Methods and Encapsulation 511

Chapter 8: Class Design 513

Chapter 9: Advanced Class Design 518

Chapter 10: Exceptions 522

Chapter 11: Modules 526

Index 529