Top
An effective and practical study aid to the new OCP Java SE 17 Developer certification exam
In the OCP Oracle Certified Professional Java SE 17 Developer Study Guide: Exam 1Z0-829, you'll find accessible and essential test prep material for the in-demand and practical OCP Java SE 17 Developer certification. Providing comprehensive coverage of all OCP Java SE 17 exam objectives and competencies, the Study Guide offers you access to all the skills and knowledge you'll need to succeed on the test and in the field as a new or experienced Java developer.
This book provides material on records, sealed classes, text blocks, dates, streams, controlling program flow, using the Java object-oriented approach, handling exceptions, working with arrays and collections, and more. You'll also get:
Perfect for anyone prepping for the brand-new OCP Java SE 17 credential, OCP Oracle Certified Professional Java SE 17 Developer Study Guide: Exam 1Z0-829 is also a can't-miss reference for practicing and aspiring Java developers seeking to learn or reinforce their foundational skills in Java programming and improve their performance on the job.
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 519
Exam Essentials 520
Review Questions 521
Chapter 10 Streams 531
Returning an Optional 532
Creating an Optional 533
Dealing with an Empty Optional 534
Using Streams 536
Understanding the Pipeline Flow 536
Creating Stream Sources 539
Using Common Terminal Operations 541
Using Common Intermediate Operations 549
Putting Together the Pipeline 553
Working with Primitive Streams 557
Creating Primitive Streams 557
Mapping Streams 560
Using Optional with Primitive Streams 562
Summarizing Statistics 564
Working with Advanced Stream Pipeline Concepts 565
Linking Streams to the Underlying Data 565
Chaining Optionals 566
Using a Spliterator 569
Collecting Results 570
Summary 578
Exam Essentials 579
Review Questions 581
Chapter 11 Exceptions and Localization 591
Understanding Exceptions 592
The Role of Exceptions 592
Understanding Exception Types 593
Throwing an Exception 596
Calling Methods That Throw Exceptions 598
Overriding Methods with Exceptions 599
Printing an Exception 600
Recognizing Exception Classes 600
RuntimeException Classes 601
Checked Exception Classes 604
Error Classes 605
Handling Exceptions 605
Using try and catch Statements 606
Chaining catch Blocks 607
Applying a Multi-catch
Block 609
Adding a finally Block 611
Automating Resource Management 615
Introducing Try-with-Resources 615
Basics of Try-with-Resources 616
Applying Effectively Final 620
Understanding Suppressed Exceptions 621
Formatting Values 624
Formatting Numbers 624
Formatting Dates and Times 625
Customizing the Date/Time Format 626
Supporting Internationalization and Localization 629
Picking a Locale 630
Localizing Numbers 632
Localizing Dates 637
Specifying a Locale Category 638
Loading Properties with Resource Bundles 639
Creating a Resource Bundle 640
Picking a Resource Bundle 641
Selecting Resource Bundle Values 643
Formatting Messages 645
Using the Properties Class 645
Summary 646
Exam Essentials 647
Review Questions 648
Chapter 12 Modules 661
Introducing Modules 662
Exploring a Module 663
Benefits of Modules 664
Creating and Running a Modular Program 664
Creating the Files 665
Compiling Our First Module 666
Running Our First Module 668
Packaging Our First Module 669
Updating Our Example for Multiple Modules 669
Updating the Feeding Module 670
Creating a Care Module 670
Creating the Talks Module 672
Creating the Staff Module 674
Diving into the Module Declaration 675
Exporting a Package 676
Requiring a Module Transitively 677
Opening a Package 679
Creating a Service 680
Declaring the Service Provider Interface 681
Creating a Service Locator 682
Invoking from a Consumer 684
Adding a Service Provider 685
Reviewing Directives and Services 686
Discovering Modules 687
Identifying Built-in Modules 688
Getting Details with java 690
Describing with jar 693
Learning about Dependencies with jdeps 693
Using the --jdk-internals Flag 695
Using Module Files with jmod 696
Creating Java Runtimes with jlink 696
Reviewing Command-Line Options 697
Comparing Types of Modules 700
Named Modules 701
Automatic Modules 701
Unnamed Modules 704
Reviewing Module Types 704
Migrating an Application 704
Determining the Order 705
Exploring a Bottom-Up Migration Strategy 706
Exploring a Top-Down
Migration Strategy 707
Splitting a Big Project into Modules 709
Failing to Compile with a Cyclic Dependency 709
Summary 711
Exam Essentials 712
Review Questions 713
Chapter 13 Concurrency 721
Introducing Threads 722
Understanding Thread Concurrency 723
Creating a Thread 724
Distinguishing Thread Types 725
Managing a Thread’s Life Cycle 727
Polling with Sleep 727
Interrupting a Thread 729
Creating Threads with the Concurrency API 730
Introducing the Single-Thread Executor 730
Shutting Down a Thread Executor 731
Submitting Tasks 732
Waiting for Results 733
Scheduling Tasks 737
Increasing Concurrency with Pools 739
Writing Thread-Safe Code 740
Understanding Thread-Safety 740
Accessing Data with volatile 741
Protecting Data with Atomic Classes 742
Improving Access with Synchronized Blocks 744
Synchronizing on Methods 746
Understanding the Lock Framework 747
Orchestrating Tasks with a CyclicBarrier 751
Using Concurrent Collections 754
Understanding Memory Consistency Errors 754
Working with Concurrent Classes 755
Obtaining Synchronized Collections 757
Identifying Threading Problems 758
Understanding Liveness 758
Managing Race Conditions 761
Working with Parallel Streams 761
Creating Parallel Streams 762
Performing a Parallel Decomposition 762
Processing Parallel Reductions 764
Summary 770
Exam Essentials 770
Review Questions 772
Chapter 14 I/O 785
Referencing Files and Directories 786
Conceptualizing the File System 786
Creating a File or Path 789
Operating on File and Path 793
Using Shared Functionality 793
Handling Methods That Declare IOException 797
Providing NIO.2 Optional Parameters 797
Interacting with NIO.2 Paths 799
Creating, Moving, and Deleting Files and Directories 805
Comparing Files with isSameFile() and mismatch() 809
Introducing I/O Streams 811
Understanding I/O Stream Fundamentals 811
Learning I/O Stream Nomenclature 812
Reading and Writing Files 817
Using I/O Streams 817
Enhancing with Files 820
Combining with newBufferedReader() and newBufferedWriter() 822
Reviewing Common Read and Write Methods 823
Serializing Data 824
Applying the Serializable Interface 825
Marking Data transient 827
Ensuring That a Class Is Serializable 827
Storing Data with ObjectOutputStream and ObjectInputStream 828
Understanding the Deserialization Creation Process 830
Interacting with Users 832
Printing Data to the User 832
Reading Input as an I/O Stream 833
Closing System Streams 833
Acquiring Input with Console 834
Working with Advanced APIs 837
Manipulating Input Streams 838
Discovering File Attributes 840
Traversing a Directory Tree 843
Searching a Directory 847
Review of Key APIs 848
Summary 850
Exam Essentials 851
Review Questions 852
Chapter 15 JDBC 863
Introducing Relational Databases and SQL 864
Identifying the Structure of a Relational Database 866
Writing Basic SQL Statements 867
Introducing the Interfaces of JDBC 868
Connecting to a Database 870
Building a JDBC URL 870
Getting a Database Connection 871
Working with a PreparedStatement 873
Obtaining a PreparedStatement 874
Executing a PreparedStatement 875
Working with Parameters 878
Updating Multiple Records 881
Getting Data from a ResultSet 882
Reading a ResultSet 882
Getting Data for a Column 885
Using Bind Variables 887
Calling a CallableStatement 887
Calling a Procedure without Parameters 888
Passing an IN Parameter 889
Returning an OUT Parameter 889
Working with an INOUT Parameter 890
Comparing Callable Statement Parameters 891
Using Additional Options 891
Controlling Data with Transactions 892
Committing and Rolling Back 892
Bookmarking with Savepoints 894
Reviewing Transaction APIs 895
Closing Database Resources 895
Summary 897
Exam Essentials 898
Review Questions 900
Appendix Answers to the Review Questions 909
Chapter 1: Building Blocks 910
Chapter 2: Operators 913
Chapter 3: Making Decisions 916
Chapter 4: Core APIs 921
Chapter 5: Methods 924
Chapter 6: Class Design 927
Chapter 7: Beyond Classes 932
Chapter 8: Lambdas and Functional Interfaces 936
Chapter 9: Collections and Generics 939
Chapter 10: Streams 942
Chapter 11: Exceptions and Localization 945
Chapter 12: Modules 949
Chapter 13: Concurrency 951
Chapter 14: I/O 955
Chapter 15: JDBC 959
Index 963
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.
Need Help? Copyright © 1999-2026
