OCP Oracle Certified Professional Java SE 17 developer study guide : exam 1z0-829 / Scott Selikoff, Jeanne Boyarsky.

Format:

Book

Author/Creator:

Selikoff, Scott, author.

Boyarsky, Jeanne, author.

Language:

English

Subjects (All):

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

Java (Computer program language).

Electronic data processing personnel--Certification.

Electronic data processing personnel.

Physical Description:

1 online resource (1059 pages)

Place of Publication:

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

Summary:

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: Intuitively organized information that aligns with the competencies tested on the exam and those required by real-world Java developers Opportunities to practice and develop skills that remain in high demand in the IT industry Access to the Sybex online learning center, with chapter review questions, full-length practice exams, hundreds of electronic flashcards, and a glossary of key terms 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.

Contents:

Cover

Title Page

Copyright Page

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

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

Compiling with JAR Files

Creating a JAR File

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

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

Applying switch Statements

The switch Statement

The switch Expression

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 Multidimensional Arrays

Calculating with Math APIs

Finding the Minimum and Maximum

Rounding Numbers

Determining the Ceiling and Floor

Calculating Exponents

Generating Random Numbers

Working with Dates and Times.

Day vs. Date

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

Using Enums in switch Statements

Adding Constructors, Fields, and Methods

Sealing Classes

Declaring a Sealed Class

Compiling Sealed Classes

Specifying the Subclass Modifier

Omitting the permits Clause

Sealing Interfaces

Reviewing Sealed Class Rules

Encapsulating Data with Records

Understanding Encapsulation

Applying Records

Understanding Record Immutability

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

Using the Diamond Operator

Adding Data

Removing Data

Counting Elements

Clearing the Collection

Check Contents

Removing with Conditions

Iterating

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

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

Calling Basic Methods

Iterating through a Map

Getting Values Safely

Replacing Values

Putting if Absent

Merging Data

Comparing Collection Types

Sorting Data

Creating a Comparable Class

Comparing Data with a Comparator

Comparing Comparable and Comparator

Comparing Multiple Fields

Sorting and Searching.

Sorting a List.

Notes:

Description based on print version record.

Includes index.

ISBN:

1-119-86460-7

OCLC:

1306203716