
OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
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.
More details
Other editions
Additional editions

Persons
Content
- 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
System requirements
File format: PDF
Copy-Protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our eBook Help page.