OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide

Name: OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide | Exam 1Z0-816 and Exam 1Z0-817
Brand: Wiley-Scrivener
Price: 32.99 EUR
Availability: OnlineOnly

Exam 1Z0-816 and Exam 1Z0-817

Scott Selikoff Jeanne Boyarsky(Autor*in)

Wiley-Scrivener (Verlag)

1. Auflage

Erschienen am 23. Juni 2020

768 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-1-119-61763-1 (ISBN)

32,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

This OCP Oracle Certified Professional Java SE 11 Programmer I Study Guide: Exam 1Z0-815 and the Programmer II Study Guide: Exam 1Z0-816 were published before Oracle announced major changes to its OCP certification program and the release of the new Developer 1Z0-819 exam.

No matter the changes, rest assured both of the Programmer I and II Study Guides cover everything you need to prepare for and take Exam 1Z0-819. If you've purchased one of the Programmer Study Guides, purchase the other one and you'll be all set.

NOTE: The OCP Java SE 11 Programmer I Exam 1Z0-815 and Programmer II Exam 1Z0-816 have been retired (as of October 1, 2020), and Oracle has released a new Developer Exam 1Z0-819 to replace the previous exams. The Upgrade Exam 1Z0-817 remains the same.

The completely-updated preparation guide for the new OCP Oracle Certified Professional Java SE 11 Programmer II exam--covers Exam 1Z0-816

Java, a platform-independent, object-oriented programming language, is used primarily in mobile and desktop application development. It is a popular language for client-side cloud applications and the principal language used to develop Android applications. Oracle has recently updated its Java Programmer certification tracks for Oracle Certified Professional.

OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide ensures that you are fully prepared for this difficult certification exam. Covering 100% of exam objectives, this in-depth study guide provides comprehensive coverage of the functional-programming knowledge necessary to succeed. Every exam topic is thoroughly and completely covered including exceptions and assertions, class design, generics and collections, threads, concurrency, IO and NIO, and more. Access to Sybex's superior online interactive learning environment and test bank--including self-assessment tests, chapter tests, bonus practice exam questions, electronic flashcards, and a searchable glossary of important terms--provides everything you need to be fully prepared on exam day. This must-have guide:

* Covers all exam objectives such as inheriting abstract classes and interfaces, advanced strings and localization, JDBC, and Object-Oriented design principles and patterns

* Explains complex material and reinforces your comprehension and retention of important topics

* Helps you master more advanced areas of functional programming

* Demonstrates practical methods for building Java solutions

OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide will prove invaluable for anyone seeking achievement of this challenging exam, as well as junior- to senior-level programmers who uses Java as their primary programming language.

Weitere Details

Weitere Ausgaben

Personen

Inhalt

Cover
Title Page
Copyright Page
Dedication
Acknowledgments
About the Authors
Contents at a Glance
Contents
Introduction
Understanding the Exam
Reading This Book
Preparing for the Exam
Taking the Exam
Objective Map
Taking the Assessment Test
Chapter 1: Java Fundamentals
Applying the final Modifier
Declaring final Local Variables
Adding final to Instance and static Variables
Writing final Methods
Marking Classes final
Working with Enums
Creating Simple Enums
Using Enums in Switch Statements
Adding Constructors, Fields, and Methods
Creating Nested Classes
Declaring an Inner Class
Creating a static Nested Class
Writing a Local Class
Defining an Anonymous Class
Reviewing Nested Classes
Understanding Interface Members
Relying on a default Interface Method
Using static Interface Methods
Introducing private Interface Methods
Introducing private static Interface Methods
Reviewing Interface Members
Introducing Functional Programming
Defining a Functional Interface
Declaring a Functional Interface with Object Methods
Implementing Functional Interfaces with Lambdas
Writing Lambda Expressions
Working with Lambda Variables
Summary
Exam Essentials
Review Questions
Chapter 2: Annotations
Introducing Annotations
Understanding Metadata
Purpose of Annotations
Creating Custom Annotations
Creating an Annotation
Specifying a Required Element
Providing an Optional Element
Selecting an Element Type
Applying Element Modifiers
Adding a Constant Variable
Reviewing Annotation Rules
Applying Annotations
Using Annotations in Declarations
Mixing Required and Optional Elements
Creating a value() Element
Passing an Array of Values
Declaring Annotation-Specific Annotations
Limiting Usage with @Target
Storing Annotations with @Retention
Generating Javadoc with @Documented
Inheriting Annotations with @Inherited
Supporting Duplicates with @Repeatable
Reviewing Annotation-Specific Annotations
Using Common Annotations
Marking Methods with @Override
Declaring Interfaces with @FunctionalInterface
Retiring Code with @Deprecated
Ignoring Warnings with @SuppressWarnings
Protecting Arguments with @SafeVarargs
Reviewing Common Annotations
Summary
Exam Essentials
Review Questions
Chapter 3: Generics and Collections
Using Method References
Calling Static Methods
Calling Instance Methods on a Particular Object
Calling Instance Methods on a Parameter
Calling Constructors
Reviewing Method References
Using Wrapper Classes
Using the Diamond Operator
Using Lists, Sets, Maps, and Queues
Common Collections Methods
Using the List Interface
Using the Set Interface
Using the Queue Interface
Using the Map Interface
Comparing Collection Types
Sorting Data
Creating a Comparable Class
Comparing Data with a Comparator
Comparing Comparable and Comparator
Comparing Multiple Fields
Sorting and Searching
Working with Generics
Generic Classes
Generic Interfaces
Raw Types
Generic Methods
Bounding Generic Types
Putting It All Together
Summary
Exam Essentials
Review Questions
Chapter 4: Functional Programming
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
Convenience Methods on Functional Interfaces
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
Learning the Functional Interfaces for Primitives
Working with Advanced Stream Pipeline Concepts
Linking Streams to the Underlying Data
Chaining Optionals
Collecting Results
Summary
Exam Essentials
Review Questions
Chapter 5: Exceptions, Assertions, and Localization
Reviewing Exceptions
Handling Exceptions
Distinguishing between throw and throws
Examining Exception Categories
Inheriting Exception Classes
Creating Custom Exceptions
Declaring Exception Classes
Adding Custom Constructors
Printing Stack Traces
Automating Resource Management
Constructing Try-With-Resources Statements
Learning the New Effectively Final Feature
Understanding Suppressed Exceptions
Declaring Assertions
Validating Data with the assert Statement
Enabling Assertions
Disabling Assertions
Applying Assertions
Writing Assertions Correctly
Working with Dates and Times
Creating Dates and Times
Formatting Dates and Times
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 6: Modular Applications
Reviewing Module Directives
Comparing Types of Modules
Named Modules
Automatic Modules
Unnamed Modules
Comparing Module Types
Analyzing JDK Dependencies
Identifying Built-in Modules
Using jdeps
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
Creating a Service
Declaring the Service Provider Interface
Creating a Service Locator
Invoking from a Consumer
Adding a Service Provider
Merging Service Locator and Consumer
Reviewing Services
Summary
Exam Essentials
Review Questions
Chapter 7: Concurrency
Introducing Threads
Distinguishing Thread Types
Understanding Thread Concurrency
Defining a Task with Runnable
Creating a Thread
Polling with Sleep
Creating Threads with the Concurrency API
Introducing the Single-Thread Executor
Shutting Down a Thread Executor
Submitting Tasks
Waiting for Results
Submitting Task Collections
Scheduling Tasks
Increasing Concurrency with Pools
Writing Thread-Safe Code
Understanding Thread-Safety
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
Avoiding Stateful Operations
Summary
Exam Essentials
Review Questions
Chapter 8: I/O
Understanding Files and Directories
Conceptualizing the File System
Storing Data as Bytes
Introducing the File Class
Introducing I/O Streams
Understanding I/O Stream Fundamentals
Learning I/O Stream Nomenclature
Common I/O Stream Operations
Reading and Writing Data
Closing the Stream
Manipulating Input Streams
Flushing Output Streams
Reviewing Common I/O Stream Methods
Working with I/O Stream Classes
Reading and Writing Binary Data
Buffering Binary Data
Reading and Writing Character Data
Buffering Character Data
Serializing Data
Printing Data
Review of Stream Classes
Interacting with Users
Printing Data to the User
Reading Input as a Stream
Closing System Streams
Acquiring Input with Console
Summary
Exam Essentials
Review Questions
Chapter 9: NIO.2
Introducing NIO.2
What About NIO?
Introducing
Creating Paths
Understanding Common NIO.2 Features
Interacting with Paths
Viewing the Path with toString(), getNameCount(), and getName()
Creating a New Path with subpath()
Accessing Path Elements with getFileName(), getParent(), and getRoot()
Checking Path Type with isAbsolute() and toAbsolutePath()
Joining Paths with resolve()
Deriving a Path with relativize()
Cleaning Up a Path with normalize()
Retrieving the File System Path with toRealPath()
Reviewing Path Methods
Operating on Files and Directories
Checking for Existence with exists()
Testing Uniqueness with isSameFile()
Making Directories with createDirectory() and createDirectories()
Copying Files with copy()
Moving or Renaming Paths with move()
Deleting a File with delete() and
Reading and Writing Data with newBufferedReader() and
Reading a File with readAllLines()
Reviewing Files Methods
Managing File Attributes
Discovering File Attributes
Improving Attribute Access
Applying Functional Programming
Listing Directory Contents
Traversing a Directory Tree
Searching a Directory with
Reading a File with lines()
Comparing Legacy java.io.File and NIO.2 Methods
Summary
Exam Essentials
Review Questions
Chapter 10: 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
Obtaining a PreparedStatement
Executing a PreparedStatement
Working with Parameters
Updating Multiple Times
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
Closing Database Resources
Summary
Exam Essentials
Review Questions
Chapter 11: Security
Designing a Secure Object
Limiting Accessibility
Restricting Extensibility
Creating Immutable Objects
Cloning Objects
Introducing Injection and Input Validation
Preventing Injection with a PreparedStatement
Invalidating Invalid Input with Validation
Working with Confidential Information
Guarding Sensitive Data from Output
Protecting Data in Memory
Limiting File Access
Serializing and Deserializing Objects
Specifying Which Fields to Serialize
Customizing the Serialization Process
Pre/Post-Serialization Processing
Reviewing Serialization Methods
Constructing Sensitive Objects
Making Methods final
Making Classes final
Making the Constructor private
Preventing Denial of Service Attacks
Leaking Resources
Reading Very Large Resources
Including Potentially Large Resources
Overflowing Numbers
Wasting Data Structures
Summary
Exam Essentials
Review Questions
Appendix A: The Upgrade Exam
Working with Local Variable Type Inference
Type Inference of var
Examples with var
Review of var Rules
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-info File
exports
requires transitive
provides, uses, and opens
Discovering Modules
The java Command
The jar Command
The jdeps Command
The jmod Command
Reviewing Command-Line Options
Summary
Exam Essentials
Review Questions
Appendix B: Answers to Review Questions
Chapter 1: Java Fundamentals
Chapter 2: Annotations
Chapter 3: Generics and Collections
Chapter 4: Functional Programming
Chapter 5: Exceptions, Assertions, and Localization
Chapter 6: Modular Applications
Chapter 7: Concurrency
Chapter 8: I/O
Chapter 9: NIO.2
Chapter 10: JDBC
Chapter 11: Security
Appendix A: The Upgrade Exam
Index
Online Test Bank
EULA

Systemvoraussetzungen

Als PDF speichern Als Link merken