OCP Oracle Certified Professional Java SE 17 developer study guide : exam 1z0-829

OCP Oracle Certified Professional Java SE 17 developer study guide exam 1z0-829

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 c...

Descripción completa

Detalles Bibliográficos
Otros Autores: Selikoff, Scott, author (author), Boyarsky, Jeanne, author
Formato: Libro electrónico
Idioma:Inglés
Publicado: Hoboken, New Jersey : John Wiley & Sons, Inc [2022]
Materias:
Java (Computer program language) > Examinations > Study guides.
Electronic data processing personnel > Certification.
Ver en Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009659942506719
Tabla de Contenidos:
  • 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.

Ejemplares similares