OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide – Exam 1Z0–816 and Exam 1Z0–817

Scott Selikoff, OCA/OCP 8 and OCP 11, has been a professional Java Enterprise architect for over 20 years. He is the founder of Selikoff Solutions, LLC, specializing in building custom mobile and server solutions for businesses in the tri-state New York City area. Jeanne Boyarsky, OCA/OCP 8 and OCP 11, is a Java Champion and has worked as a Java developer for a major bank for more than 18 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.

Introduction xxi

Assessment Test xliv

Chapter 1 Java Fundamentals 1

Applying the final Modifier 2

Declaring final Local Variables 3

Adding final to Instance and static Variables 4

Writing final Methods 5

Marking Classes final 5

Working with Enums 6

Creating Simple Enums 6

Using Enums in Switch Statements 8

Adding Constructors, Fields, and Methods 9

Creating Nested Classes 12

Declaring an Inner Class 12

Creating a static Nested Class 15

Writing a Local Class 17

Defining an Anonymous Class 18

Reviewing Nested Classes 21

Understanding Interface Members 22

Relying on a default Interface Method 23

Using static Interface Methods 27

Introducing private Interface Methods 28

Introducing private static Interface Methods 29

Reviewing Interface Members 31

Introducing Functional Programming 32

Defining a Functional Interface 32

Declaring a Functional Interface with Object Methods 34

Implementing Functional Interfaces with Lambdas 36

Writing Lambda Expressions 38

Working with Lambda Variables 40

Summary 43

Exam Essentials 44

Review Questions 46

Chapter 2 Annotations 59

Introducing Annotations 60

Understanding Metadata 60

Purpose of Annotations 61

Creating Custom Annotations 64

Creating an Annotation 64

Specifying a Required Element 65

Providing an Optional Element 66

Selecting an Element Type 67

Applying Element Modifiers 67

Adding a Constant Variable 68

Reviewing Annotation Rules 68

Applying Annotations 69

Using Annotations in Declarations 69

Mixing Required and Optional Elements 71

Creating a value() Element 71

Passing an Array of Values 73

Declaring Annotation-Specific Annotations 74

Limiting Usage with @Target 74

Storing Annotations with @Retention 77

Generating Javadoc with @Documented 77

Inheriting Annotations with @Inherited 79

Supporting Duplicates with @Repeatable 79

Reviewing Annotation-Specific Annotations 81

Using Common Annotations 83

Marking Methods with @Override 83

Declaring Interfaces with @FunctionalInterface 84

Retiring Code with @Deprecated 85

Ignoring Warnings with @SuppressWarnings 86

Protecting Arguments with @SafeVarargs 88

Reviewing Common Annotations 89

Summary 91

Exam Essentials 92

Review Questions 94

Chapter 3 Generics and Collections 105

Using Method References 107

Calling Static Methods 108

Calling Instance Methods on a Particular Object 109

Calling Instance Methods on a Parameter 109

Calling Constructors 110

Reviewing Method References 110

Using Wrapper Classes 111

Using the Diamond Operator 113

Using Lists, Sets, Maps, and Queues 114

Common Collections Methods 115

Using the List Interface 119

Using the Set Interface 124

Using the Queue Interface 126

Using the Map Interface 128

Comparing Collection Types 135

Sorting Data 137

Creating a Comparable Class 137

Comparing Data with a Comparator 141

Comparing Comparable and Comparator 142

Comparing Multiple Fields 143

Sorting and Searching 145

Working with Generics 147

Generic Classes 148

Generic Interfaces 151

Raw Types 152

Generic Methods 153

Bounding Generic Types 154

Putting It All Together 159

Summary 161

Exam Essentials 163

Review Questions 164

Chapter 4 Functional Programming 175

Working with Built-in Functional Interfaces 176

Implementing Supplier 178

Implementing Consumer and BiConsumer 179

Implementing Predicate and BiPredicate 180

Implementing Function and BiFunction 181

Implementing UnaryOperator and BinaryOperator 183

Checking Functional Interfaces 184

Convenience Methods on Functional Interfaces 185

Returning an Optional 187

Creating an Optional 188

Dealing with an Empty Optional 189

Using Streams 191

Understanding the Pipeline Flow 191

Creating Stream Sources 194

Using Common Terminal Operations 197

Using Common Intermediate Operations 204

Putting Together the Pipeline 209

Working with Primitive Streams 213

Creating Primitive Streams 214

Mapping Streams 217

Using Optional l with Primitive Streams 219

Summarizing Statistics 220

Learning the Functional Interfaces for Primitives 221

Working with Advanced Stream Pipeline Concepts 224

Linking Streams to the Underlying Data 224

Chaining Optionals 224

Collecting Results 227

Summary 234

Exam Essentials 236

Review Questions 238

Chapter 5 Exceptions, Assertions, and Localization 247

Reviewing Exceptions 248

Handling Exceptions 248

Distinguishing between throw and throws 250

Examining Exception Categories 250

Inheriting Exception Classes 252

Creating Custom Exceptions 253

Declaring Exception Classes 253

Adding Custom Constructors 253

Printing Stack Traces 255

Automating Resource Management 256

Constructing Try-With-Resources Statements 256

Learning the New Effectively Final Feature 259

Understanding Suppressed Exceptions 261

Declaring Assertions 264

Validating Data with the assert Statement 264

Enabling Assertions 266

Disabling Assertions 267

Applying Assertions 267

Writing Assertions Correctly 268

Working with Dates and Times 268

Creating Dates and Times 269

Formatting Dates and Times 271

Supporting Internationalization and Localization 276

Picking a Locale 276

Localizing Numbers 279

Localizing Dates 283

Specifying a Locale Category 284

Loading Properties with Resource Bundles 285

Creating a Resource Bundle 286

Picking a Resource Bundle 288

Selecting Resource Bundle Values 289

Formatting Messages 291

Using the Properties Class 292

Summary 293

Exam Essentials 294

Review Questions 295

Chapter 6 Modular Applications 309

Reviewing Module Directives 310

Comparing Types of Modules 311

Named Modules 311

Automatic Modules 312

Unnamed Modules 315

Comparing Module Types 315

Analyzing JDK Dependencies 316

Identifying Built-in Modules 316

Using jdeps 318

Migrating an Application 321

Determining the Order 321

Exploring a Bottom-Up Migration Strategy 322

Exploring a Top-Down Migration Strategy 324

Splitting a Big Project into Modules 325

Failing to Compile with a Cyclic Dependency 326

Creating a Service 328

Declaring the Service Provider Interface 329

Creating a Service Locator 330

Invoking from a Consumer 332

Adding a Service Provider 333

Merging Service Locator and Consumer 334

Reviewing Services 337

Summary 337

Exam Essentials 338

Review Questions 339

Chapter 7 Concurrency 345

Introducing Threads 347

Distinguishing Thread Types 348

Understanding Thread Concurrency 348

Defining a Task with Runnable 349

Creating a Thread 351

Polling with Sleep 353

Creating Threads with the Concurrency API 355

Introducing the Single-Thread Executor 355

Shutting Down a Thread Executor 356

Submitting Tasks 357

Waiting for Results 358

Submitting Task Collections 362

Scheduling Tasks 363

Increasing Concurrency with Pools 366

Writing Thread-Safe Code 367

Understanding Thread-Safety 367

Protecting Data with Atomic Classes 369

Improving Access with Synchronized Blocks 371

Synchronizing on Methods 373

Understanding the Lock Framework 375

Orchestrating Tasks with a CyclicBarrier 379

Using Concurrent Collections 382

Understanding Memory Consistency Errors 383

Working with Concurrent Classes 383

Obtaining Synchronized Collections 388

Identifying Threading Problems 389

Understanding Liveness 390

Managing Race Conditions 393

Working with Parallel Streams 394

Creating Parallel Streams 395

Performing a Parallel Decomposition 396

Processing Parallel Reductions 398

Avoiding Stateful Operations 403

Summary 404

Exam Essentials 405

Review Questions 406

Chapter 8 I/O 419

Understanding Files and Directories 420

Conceptualizing the File System 420

Storing Data as Bytes 422

Introducing the File Class 422

Introducing I/O Streams 426

Understanding I/O Stream Fundamentals 426

Learning I/O Stream Nomenclature 427

Common I/O Stream Operations 433

Reading and Writing Data 433

Closing the Stream 435

Manipulating Input Streams 436

Flushing Output Streams 438

Reviewing Common I/O Stream Methods 439

Working with I/O Stream Classes 440

Reading and Writing Binary Data 440

Buffering Binary Data 441

Reading and Writing Character Data 443

Buffering Character Data 444

Serializing Data 445

Printing Data 452

Review of Stream Classes 457

Interacting with Users 458

Printing Data to the User 459

Reading Input as a Stream 460

Closing System Streams 460

Acquiring Input with Console 461

Summary 464

Exam Essentials 464

Review Questions 466

Chapter 9 NIO.2 475

Introducing NIO.2 476

Introducing Path 477

Creating Paths 478

Understanding Common NIO.2 Features 483

Interacting with Paths 486

Viewing the Path with toString(), getNameCount(), and getName() 486

Creating a New Path with subpath() 487

Accessing Path Elements with getFileName(), getParent(), and getRoot() 488

Checking Path Type with isAbsolute() and toAbsolutePath() 490

Joining Paths with resolve() 491

Deriving a Path with relativize() 491

Cleaning Up a Path with normalize() 493

Retrieving the File System Path with toRealPath() 493

Reviewing Path Methods 494

Operating on Files and Directories 495

Checking for Existence with exists() 495

Testing Uniqueness with isSameFile() 496

Making Directories with createDirectory() and createDirectories() 497

Copying Files with copy() 498

Moving or Renaming Paths with move() 500

Deleting a File with delete() and deleteIfExists() 500

Reading and Writing Data with newBufferedReader() and newBufferedWriter() 501

Reading a File with readAllLines() 502

Reviewing Files Methods 502

Managing File Attributes 503

Discovering File Attributes 503

Improving Attribute Access 506

Applying Functional Programming 508

Listing Directory Contents 508

Traversing a Directory Tree 510

Searching a Directory with find() 514

Reading a File with lines() 515

Comparing Legacy java.io.File and NIO.2 Methods 517

Summary 518

Exam Essentials 518

Review Questions 520

Chapter 10 JDBC 529

Introducing Relational Databases and SQL 530

Identifying the Structure of a Relational Database 532

Writing Basic SQL Statements 533

Introducing the Interfaces of JDBC 535

Connecting to a Database 537

Building a JDBC URL 537

Getting a Database Connection 539

Working with a PreparedStatement 542

Obtaining a PreparedStatement 543

Executing a PreparedStatement 543

Working with Parameters 546

Updating Multiple Times 549

Getting Data from a ResultSet 551

Reading a ResultSet 551

Getting Data for a Column 555

Using Bind Variables 556

Calling a CallableStatement 557

Calling a Procedure without Parameters 558

Passing an IN Parameter 559

Returning an OUT Parameter 559

Working with an INOUT Parameter 560

Comparing Callable Statement Parameters 560

Closing Database Resources 561

Summary 564

Exam Essentials 564

Review Questions 566

Chapter 11 Security 575

Designing a Secure Object 576

Limiting Accessibility 576

Restricting Extensibility 577

Creating Immutable Objects 578

Cloning Objects 581

Introducing Injection and Input Validation 583

Preventing Injection with a PreparedStatement 583

Invalidating Invalid Input with Validation 586

Working with Confidential Information 588

Guarding Sensitive Data from Output 589

Protecting Data in Memory 589

Limiting File Access 590

Serializing and Deserializing Objects 591

Specifying Which Fields to Serialize 591

Customizing the Serialization Process 592

Pre/Post-Serialization Processing 593

Reviewing Serialization Methods 596

Constructing Sensitive Objects 597

Making Methods final 598

Making Classes final 598

Making the Constructor private 599

Preventing Denial of Service Attacks 600

Leaking Resources 600

Reading Very Large Resources 600

Including Potentially Large Resources 601

Overflowing Numbers 601

Wasting Data Structures 602

Summary 603

Exam Essentials 604

Review Questions 605

Appendices 611

Appendix A The Upgrade Exam 611

Working with Local Variable Type Inference 612

Type Inference of var 613

Examples with var 614

Review of var Rules 617

Introducing Modules 617

Exploring a Module 618

Benefits of Modules 619

Creating and Running a Modular Program 621

Creating the Files 622

Compiling Our First Module 623

Running Our First Module 625

Packaging Our First Module 627

Updating Our Example for Multiple Modules 628

Updating the Feeding Module 628

Creating a Care Module 629

Creating the Talks Module 631

Creating the Staff Module 634

Diving into the module-info File 635

exports 635

requires transitive 636

provides, uses, and opens 639

Discovering Modules 639

The java Command 639

The jar Command 643

The jdeps Command 643

The jmod Command 645

Reviewing Command-Line Options 645

Summary 648

Exam Essentials 649

Review Questions 650

Appendix B Answers to Review Questions 657

Chapter 1: Java Fundamentals 658

Chapter 2: Annotations 662

Chapter 3: Generics and Collections 665

Chapter 4: Functional Programming 669

Chapter 5: Exceptions, Assertions, and Localization 672

Chapter 6: Modular Applications 676

Chapter 7: Concurrency 678

Chapter 8: I/O 682

Chapter 9: NIO.2 685

Chapter 10: JDBC 689

Chapter 11: Security 691

Appendix A: The Upgrade Exam 693

Index 697