Introduction

This book is for those looking to complete the Java SE 21 Developer Professional exam (1Z0-830) and obtain the Java 21 Developer Certified Professional title. This exam is commonly referred to as the OCP (Oracle Certified Professional) 21 exam. This book is also for those looking to gain a deeper understanding and appreciation of Java. Not only do we want you to pass your exams, but we want to help you to improve yourself and become a better professional software developer.

The book provides detailed preparation for the following Oracle certification exam:

• 1Z0-830 Exam: Java SE 21 Developer Professional The Developer Professional exam covers a wide variety of core topics in Java 21 including classes, interfaces, streams, collections, concurrency, and modules.

In this introduction, we start by covering important information about the various exams. We then move on to information about how this book is structured. Finally, we conclude with an assessment test so you can see how much studying lies ahead of you.

Understanding the Exam

At the end of the day, the exam is a list of questions. The more you know about the structure of the exam, the better you are likely to do. For example, knowing how many questions the exam contains allows you to better manage your progress and time remaining. In this section, we discuss the details of the exam, along with some history of previous certification exams.

Choosing Which Exam to Take

Java is now about 30 years old, celebrating being "born" in 1995. As with anything that age, there is a good amount of history and variation between different versions of Java. Over the years, the certification exams have changed to cover different topics. The number of exams and names of certifications have also changed.

Oracle has simplified things over time. Becoming an Oracle Certified Professional now requires passing only one exam, not two, and there are no Java 21 upgrade exams. Regardless of the previous certifications you hold, everyone takes the same Java 21 exam to become an Oracle Certified Professional.

There's another less popular exam called the Java Foundations exam. Our advice is to only take the Java Foundations exam if your employer has specifically asked you to as it is not meant for professionals who work with Java every day. Our book page explains how to use this book to study for the Java Foundations exam:

www.selikoff.net/ocp21

Differences Between the Java 21 Exam and Previous Java Exams

If you're certified with an older version of Java, you might expect the Java 21 exam to be a lot like the exams you took in the past. While there are some similarities, the exam also contains some major differences that you should be aware of.

• Questions are generally longer, have more code to read, and contain a lot more answer options (up to 10).
• Questions often span multiple, independent objectives.
• You're more likely to run out of time on this exam.
• There is no longer an exam software feature to right-click and cross out options you've eliminated.

In our experience, we found this to be a more challenging exam than some of the Java exams of the past, so it's important to allot an appropriate amount of time to study for the exam.

Taking an Online Exam

In the past, the exam was offered both at a physical testing center and online via a remote proctor. Oracle now only offers the exam online, which means you'll need to take it remotely.

You'll need a quiet environment, free from interruption for the length of the exam. Prior to taking the exam, you'll also need to install software that monitors your session and ensures the integrity of the exam is not violated. For this reason, we don't recommend taking the exam with a work computer, where installing software may be restricted.

We have posted our experiences taking the exam remotely to give you want an idea of what is involved.

www.selikoff.net/ocp21

Reviewing the Format of the Exam

At the time this book is being published, the exam details are as follows:

• Time limit: 120 minutes
• Number of questions: 50
• Passing score: 68% (34 questions)

Oracle has a tendency to fiddle with the length of the exam and the passing score once it comes out. Oracle also likes to "tweak" the exam objectives over time. It wouldn't be a surprise for Oracle to make minor changes to the exam objectives, the number of questions, or the passing score after this book goes to print.

If there are any changes to the exam after this book is published, we will post them on the book page of our blog: www.selikoff.net/ocp21

Considering the Exam Objectives

Oracle provides a list of objectives to guide you on what to study for the exam. Each objective defines a list of subobjectives providing additional details about the objective. Unfortunately, the objectives don't encompass the full amount of material needed to pass the exam.

So how do you know what to study? By reading this study guide, of course! We've spent years studying the certification exams in all of their forms and have carefully cultivated topics, material, and practice questions that we are confident can lead to successfully passing the exam. For the last 10 years, we've worked directly with Oracle helping to create and refine the objectives and material for the Java 8, Java 11, Java 17, and Java 21 exams. You can even thank us for successfully lobbying to remove JDBC from the Java 21 exam. That's one whole chapter less to study!

As a starting point, you should review the list of objectives presented in this introduction and mark down the ones that are unfamiliar to you. This list, along with the Assessment Test at the end of this introduction, will give you a rough idea of how much you are going to need to study for the exam.

Scope of Objectives

In previous certification exams, the list of exam objectives tended to include specific topics, classes, and APIs that you needed to know for the exam. For example, take a look at an objective for the OCP 8 exam (1Z0-809):

• Use BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter in the java.io package.

Now compare it with the equivalent objective for the OCP 21 exam (1Z0-830):

• Read and write console and file data using I/O streams.

Notice the difference? The older version is more detailed and describes specific classes you need to understand. The newer version is a lot more vague. It also gives the exam writers a lot more freedom to insert a new feature without having to update the list of objectives.

Non-Objective Objectives

Oracle has a habit of adding additional assumptions and requirements outside the scope of exam objectives. For the 1Z0-830, that includes the following two lists of items.

Exam Assumptions

• Missing package and import statements: If sample code does not include package or import statements and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package or that import statements exist to support them.
• No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file.
  • Each class is contained in a separate file, and all files are in one directory.
• Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
• Code fragments: A code fragment is a small section of source code presented without its context. Assume that all necessary supporting code exists and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
• Descriptive comments: Take descriptive comments, such as "setters and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

Exam Expectations

• Understand the basics of Java Logging API.
• Use Annotations such as @Override, @FunctionalInterface, @Deprecated, @SuppressWarnings, and @SafeVarargs.
• Use generics, including wildcards.

Many of these topics fall under the same theme. You can assume external things like imports, file structure, and line breaks are not being tested, unless the exam question is specifically asking about them. Some items include cursory use of things like the Logging API and annotations. Don't worry, we cover what you need to know for the exam in this book!

Choosing the...