دانلود کتاب 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