OCP Oracle Certified Professional Java SE 17 Developer Study Guide - Exam 1Z0-829.

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
Summary
Exam Essentials
Review Questions
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
Summary
Exam Essentials
Review Questions
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
Summary
Exam Essentials
Review Questions
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
Summary
Exam Essentials
Review Questions
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
Summary
Exam Essentials
Review Questions
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
Declaring Constructors
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
Summary
Exam Essentials
Review Questions
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
Calling Constructors
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
Summary
Exam Essentials
Review Questions
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
Working with Generics
Creating Generic Classes
Understanding Type Erasure
Implementing Generic Interfaces
Writing Generic Methods
Creating a Generic Record
Bounding Generic Types
Putting It All Together
Summary
Exam Essentials
Review Questions
Chapter 10 Streams
Returning an Optional
Creating an Optional
Dealing with an Empty Optional
Using Streams
Understanding the Pipeline Flow
Creating Stream Sources
Using Common Terminal Operations
Using Common Intermediate Operations
Putting Together the Pipeline
Working with Primitive Streams
Creating Primitive Streams
Mapping Streams
Using Optional with Primitive Streams
Summarizing Statistics
Working with Advanced Stream Pipeline Concepts
Linking Streams to the Underlying Data
Chaining Optionals
Using a Spliterator
Collecting Results
Summary
Exam Essentials
Review Questions
Chapter 11 Exceptions and Localization
Understanding Exceptions
The Role of Exceptions
Understanding Exception Types
Throwing an Exception
Calling Methods That Throw Exceptions
Overriding Methods with Exceptions
Printing an Exception
Recognizing Exception Classes
RuntimeException Classes
Checked Exception Classes
Error Classes
Handling Exceptions
Using try and catch Statements
Chaining catch Blocks
Applying a Multi-catch Block
Adding a finally Block
Automating Resource Management
Introducing Try-with-Resources
Basics of Try-with-Resources
Applying Effectively Final
Understanding Suppressed Exceptions
Formatting Values
Formatting Numbers
Formatting Dates and Times
Customizing the Date/Time Format
Supporting Internationalization and Localization
Picking a Locale
Localizing Numbers
Localizing Dates
Specifying a Locale Category
Loading Properties with Resource Bundles
Creating a Resource Bundle
Picking a Resource Bundle
Selecting Resource Bundle Values
Formatting Messages
Using the Properties Class
Summary
Exam Essentials
Review Questions
Chapter 12 Modules
Introducing Modules
Exploring a Module
Benefits of Modules
Creating and Running a Modular Program
Creating the Files
Compiling Our First Module
Running Our First Module
Packaging Our First Module
Updating Our Example for Multiple Modules
Updating the Feeding Module
Creating a Care Module
Creating the Talks Module
Creating the Staff Module
Diving into the Module Declaration
Exporting a Package
Requiring a Module Transitively
Opening a Package
Creating a Service
Declaring the Service Provider Interface
Creating a Service Locator
Invoking from a Consumer
Adding a Service Provider
Reviewing Directives and Services
Discovering Modules
Identifying Built-in Modules
Getting Details with java
Describing with jar
Learning about Dependencies with jdeps
Using the --jdk-internals Flag
Using Module Files with jmod
Creating Java Runtimes with jlink
Reviewing Command-Line Options
Comparing Types of Modules
Named Modules
Automatic Modules
Unnamed Modules
Reviewing Module Types
Migrating an Application
Determining the Order
Exploring a Bottom-Up Migration Strategy
Exploring a Top-Down Migration Strategy
Splitting a Big Project into Modules
Failing to Compile with a Cyclic Dependency
Summary
Exam Essentials
Review Questions
Chapter 13 Concurrency
Introducing Threads
Understanding Thread Concurrency
Creating a Thread
Distinguishing Thread Types
Managing a Thread’s Life Cycle
Polling with Sleep
Interrupting a Thread
Creating Threads with the Concurrency API
Introducing the Single-Thread Executor
Shutting Down a Thread Executor
Submitting Tasks
Waiting for Results
Scheduling Tasks
Increasing Concurrency with Pools
Writing Thread-Safe Code
Understanding Thread-Safety
Accessing Data with volatile
Protecting Data with Atomic Classes
Improving Access with synchronized Blocks
Synchronizing on Methods
Understanding the Lock Framework
Orchestrating Tasks with a CyclicBarrier
Using Concurrent Collections
Understanding Memory Consistency Errors
Working with Concurrent Classes
Obtaining Synchronized Collections
Identifying Threading Problems
Understanding Liveness
Managing Race Conditions
Working with Parallel Streams
Creating Parallel Streams
Performing a Parallel Decomposition
Processing Parallel Reductions
Summary
Exam Essentials
Review Questions
Chapter 14 I/O
Referencing Files and Directories
Conceptualizing the File System
Creating a File or Path
Operating on File and Path
Using Shared Functionality
Handling Methods That Declare IOException
Providing NIO.2 Optional Parameters
Interacting with NIO.2 Paths
Creating, Moving, and Deleting Files and Directories
Comparing Files with isSameFile() and mismatch()
Introducing I/O Streams
Understanding I/O Stream Fundamentals
Learning I/O Stream Nomenclature
Reading and Writing Files
Using I/O Streams
Enhancing with Files
Combining with newBufferedReader() and newBufferedWriter()
Reviewing Common Read and Write Methods
Serializing Data
Applying the Serializable Interface
Marking Data transient
Ensuring That a Class Is Serializable
Storing Data with ObjectOutputStream and ObjectInputStream
Understanding the Deserialization Creation Process
Interacting with Users
Printing Data to the User
Reading Input as an I/O Stream
Closing System Streams
Acquiring Input with Console
Working with Advanced APIs
Manipulating Input Streams
Discovering File Attributes
Traversing a Directory Tree
Searching a Directory
Review of Key APIs
Summary
Exam Essentials
Review Questions
Chapter 15 JDBC
Introducing Relational Databases and SQL
Identifying the Structure of a Relational Database
Writing Basic SQL Statements
Introducing the Interfaces of JDBC
Connecting to a Database
Building a JDBC URL
Getting a Database Connection
Working with a PreparedStatement
Little Bobby Tables
Obtaining a PreparedStatement
Executing a PreparedStatement
Working with Parameters
Updating Multiple Records
Getting Data from a ResultSet
Reading a ResultSet
Getting Data for a Column
Using Bind Variables
Calling a CallableStatement
Calling a Procedure without Parameters
Passing an IN Parameter
Returning an OUT Parameter
Working with an INOUT Parameter
Comparing Callable Statement Parameters
Using Additional Options
Controlling Data with Transactions
Committing and Rolling Back
Bookmarking with Savepoints
Reviewing Transaction APIs
Closing Database Resources
Summary
Exam Essentials
Review Questions
Appendix Answers to the Review Questions
Chapter 1: Building Blocks
Chapter 2: Operators
Chapter 3: Making Decisions
Chapter 4: Core APIs
Chapter 5: Methods
Chapter 6: Class Design
Chapter 7: Beyond Classes
Chapter 8: Lambdas and Functional Interfaces
Chapter 9: Collections and Generics
Chapter 10: Streams
Chapter 11: Exceptions and Localization
Chapter 12: Modules
Chapter 13: Concurrency
Chapter 14: I/O
Chapter 15: JDBC
Index
EULA