OCP Oracle Certified Professional Java SE 21 Developer Study Guide / Jeanne Boyarsky and Scott Selikoff.

Format:

Book

Author/Creator:

Boyarsky, Jeanne, author.

Selikoff, Scott, author.

Series:

Sybex Study Guide Series

Language:

English

Subjects (All):

Database management--Examinations--Study guides.

Database management.

Java (Computer program language)--Examinations--Study guides.

Java (Computer program language).

Oracle (Computer file)--Examinations--Study guides.

Oracle (Computer file).

Physical Description:

1 online resource (1043 pages)

Edition:

First edition.

Place of Publication:

Hoboken, New Jersey : John Wiley & Sons, Inc., [2025]

Summary:

Unlock your Java potential and master the OCP Java SE 21 Developer exam with confidence Dive into the OCP Oracle Certified Professional Java SE 21 Developer Study Guide: Exam 1Z0-830 for a comprehensive journey through the Java SE 21 Developer certification exam. Crafted by a team of seasoned Java professionals, this guide not only prepares you for the 1Z0-830 exam but also equips you with essential skills for both new and existing Java development roles. Enhance your knowledge, refine your skills, and discover new techniques with this expertly written roadmap. Explore the depths of Java development, from writing methods that utilize pattern matching to building applications with virtual threads. This guide covers all you need to ace the certification and excel in your Java development career. Additionally, it provides exclusive access to Sybex's online learning environment and test bank, featuring a wealth of practice questions, electronic flashcards, and a glossary to ensure you're fully prepared for exam day. You'll also: Gain a solid understanding of Java SE 21 features and how to apply them effectively in your development projects Boost your preparation with hundreds of practice questions and valuable online resources from the Sybex online learning environment Quickly reference key concepts thanks to a searchable glossary, making it an indispensable tool for both junior and senior Java developers Whether you're gearing up for the OCP Java SE 21 Developer exam or seeking to solidify your Java expertise, this study guide is an essential resource. It not only serves as a comprehensive preparatory material for the certification but also as a go-to reference for your daily programming needs. Embrace this opportunity to reduce test anxiety, enhance your Java skills, and step confidently into your role as a Java developer. Make this book your coding companion today and set the stage for a thriving career in Java development.

Contents:

Cover

Title Page

Copyright Page

Acknowledgments

About the Authors

About the Technical Editor

Contents at a Glance

Contents

Introduction

Understanding the Exam

Reading This Book

Studying for the Exam

Applying Test-Taking Strategies

Taking the Exam

Objective Map

How to Contact the Publisher

Assessment Test

Chapter 1 Building Blocks

Learning About the Environment

Major Components of Java

Downloading a JDK

Understanding the Class Structure

Fields and Methods

Comments

Classes and Source Files

Writing a main() Method

Creating a main() Method

Passing Parameters to a Java Program

Understanding Package Declarations and Imports

Packages

Wildcards

Redundant Imports

Naming Conflicts

Creating a New Package

Compiling and Running Code with Packages

Compiling to Another Directory

Ordering Elements in a Class

Creating Objects

Calling Constructors

Reading and Writing Member Fields

Executing Instance Initializer Blocks

Following the Order of Initialization

Understanding Data Types

Using Primitive Types

Using Reference Types

Distinguishing Between Primitives and Reference Types

Creating Wrapper Classes

Defining Text Blocks

Declaring Variables

Identifying Identifiers

Declaring Multiple Variables

Initializing Variables

Creating Local Variables

Passing Constructor and Method Parameters

Defining Instance and Class Variables

Inferring the Type with var

Managing Variable Scope

Limiting Scope

Tracing Scope

Applying Scope to Classes

Reviewing Scope

Destroying Objects

Understanding Garbage Collection

Tracing Eligibility

Summary

Exam Essentials

Review Questions

Chapter 2 Operators

Understanding Java Operators

Types of Operators

Operator Precedence.

Applying Unary Operators

Complement and Negation Operators

Increment and Decrement Operators

Working with Binary Arithmetic Operators

Arithmetic Operators

Numeric Promotion

Assigning Values

Assignment Operator

Casting Values

Compound Assignment Operators

Return Value of Assignment Operators

Comparing Values

Equality Operators

Relational Operators

Logical Operators

Bitwise Operators

Conditional Operators

Making Decisions with the Ternary Operator

Chapter 3 Making Decisions

Creating Decision-Making Statements

Statements and Blocks

The if Statement

The else Statement

Shortening Code with Pattern Matching

Building switch Statements and Expressions

Introducing switch

Structuring switch Statements and Expressions

Working with switch Statements

Working with switch Expressions

Using Pattern Matching with switch

Writing while Loops

The while Statement

The do/while Statement

Infinite Loops

Constructing for Loops

The for Loop

The for-each Loop

Controlling Flow with Branching

Nested Loops

Adding Optional Labels

The break Statement

The continue Statement

The return Statement

Unreachable Code

Reviewing Branching

Chapter 4 Core APIs

Creating and Manipulating Strings

Concatenating

Important String Methods

Method Chaining

Using the StringBuilder Class

Mutability and Chaining

Creating a StringBuilder

Important StringBuilder Methods

Understanding Equality

Comparing equals() and ==

The String Pool

Understanding Arrays

Creating an Array of Primitives

Creating an Array with Reference Variables

Using an Array

Sorting

Searching

Comparing

Using Methods with Varargs.

Working with Arrays of Arrays

Calculating with Math APIs

Finding the Minimum and Maximum

Rounding Numbers

Determining the Ceiling and Floor

Calculating Exponents

Generating Random Numbers

Using BigInteger and BigDecimal

Working with Dates and Times

Creating Dates and Times

Manipulating Dates and Times

Working with Periods

Working with Durations

Period vs. Duration

Working with Instants

Accounting for Daylight Saving Time

Chapter 5 Methods

Designing Methods

Access Modifiers

Optional Specifiers

Return Type

Method Name

Parameter List

Method Signature

Exception List

Method Body

Declaring Local and Instance Variables

Local Variable Modifiers

Effectively Final Variables

Instance Variable Modifiers

Working with Varargs

Creating Methods with Varargs

Calling Methods with Varargs

Accessing Elements of a Vararg

Using Varargs with Other Method Parameters

Applying Access Modifiers

Private Access

Package Access

Protected Access

Public Access

Reviewing Access Modifiers

Accessing Static Data

Designing Static Methods and Variables

Accessing a Static Variable or Method

Class vs. Instance Membership

Static Variable Modifiers

Static Initializers

Static Imports

Passing Data among Methods

Passing Objects

Returning Objects

Autoboxing and Unboxing Variables

Overloading Methods

Reference Types

Primitives

Autoboxing

Arrays

Varargs

Putting It All Together

Chapter 6 Class Design

Understanding Inheritance

Declaring a Subclass

Class Modifiers

Single vs. Multiple Inheritance

Inheriting Object

Creating Classes

Extending a Class

Applying Class Access Modifiers.

Accessing the this Reference

Calling the super Reference

Declaring Constructors

Creating a Constructor

The Default Constructor

Calling Overloaded Constructors with this()

Calling Parent Constructors with super()

Initializing Objects

Initializing Classes

Initializing final Fields

Initializing Instances

Inheriting Members

Overriding a Method

Redeclaring private Methods

Hiding Static Methods

Hiding Variables

Writing final Methods

Creating Abstract Classes

Introducing Abstract Classes

Declaring Abstract Methods

Creating a Concrete Class

Creating Constructors in Abstract Classes

Spotting Invalid Declarations

Creating Immutable Objects

Declaring an Immutable Class

Performing a Defensive Copy

Chapter 7 Beyond Classes

Implementing Interfaces

Declaring and Using an Interface

Extending an Interface

Inheriting an Interface

Inserting Implicit Modifiers

Declaring Concrete Interface Methods

Working with Enums

Creating Simple Enums

Working with Complex Enums

Sealing Classes

Declaring a Sealed Class

Compiling Sealed Classes

Specifying the Subclass Modifier

Omitting the permits Clause

Sealing Interfaces

Applying Pattern Matching to a Sealed Class

Reviewing Sealed Class Rules

Encapsulating Data with Records

Understanding Encapsulation

Applying Records

Understanding Record Immutability

Using Pattern Matching with Records

Customizing Records

Creating Nested Classes

Declaring an Inner Class

Creating a static Nested Class

Writing a Local Class

Defining an Anonymous Class

Reviewing Nested Classes

Understanding Polymorphism

Object vs. Reference

Casting Objects

The instanceof Operator

Polymorphism and Method Overriding.

Overriding vs. Hiding Members

Chapter 8 Lambdas and Functional Interfaces

Writing Simple Lambdas

Looking at a Lambda Example

Learning Lambda Syntax

Coding Functional Interfaces

Defining a Functional Interface

Adding Object Methods

Using Method References

Calling static Methods

Calling Instance Methods on a Particular Object

Calling Instance Methods on a Parameter

Reviewing Method References

Working with Built-in Functional Interfaces

Implementing Supplier

Implementing Consumer and BiConsumer

Implementing Predicate and BiPredicate

Implementing Function and BiFunction

Implementing UnaryOperator and BinaryOperator

Checking Functional Interfaces

Using Convenience Methods on Functional Interfaces

Learning the Functional Interfaces for Primitives

Working with Variables in Lambdas

Listing Parameters

Using Local Variables Inside a Lambda Body

Referencing Variables from the Lambda Body

Chapter 9 Collections and Generics

Using Common Collection APIs

Understanding Generic Types

Shortening Generics Code

Adding Data

Removing Data

Counting Elements

Clearing the Collection

Checking Contents

Removing with Conditions

Iterating on a Collection

Determining Equality

Using the List Interface

Comparing List Implementations

Creating a List with a Factory

Creating a List with a Constructor

Working with List Methods

Searching a List

Converting from List to an Array

Using the Set Interface

Comparing Set Implementations

Working with Set Methods

Using the Queue and Deque Interfaces

Comparing Deque Implementations

Working with Queue and Deque Methods

Using the Map Interface

Comparing Map Implementations.

Working with Map Methods.

Notes:

Description based on publisher supplied metadata and other sources.

Description based on print version record.

Includes bibliographical references and index.

ISBN:

9781394286621

1394286627

9781394286638

1394286635

OCLC:

1470910603