Atjaunināt sīkdatņu piekrišanu

E-grāmata: OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide: Exam 1Z0-815, Exam 1Z0-816, and Exam 1Z0-817

4.57/5 (14 ratings by Goodreads)
(CodeRanch), (Selikoff Solutions, LLC)
  • Formāts: EPUB+DRM
  • Izdošanas datums: 17-Jul-2020
  • Izdevniecība: Sybex Inc.,U.S.
  • Valoda: eng
  • ISBN-13: 9781119619147
Citas grāmatas par šo tēmu:
  • Formāts - EPUB+DRM
  • Cena: 63,87 €*
  • * ši ir gala cena, t.i., netiek piemērotas nekādas papildus atlaides
  • Ielikt grozā
  • Pievienot vēlmju sarakstam
  • Šī e-grāmata paredzēta tikai personīgai lietošanai. E-grāmatas nav iespējams atgriezt un nauda par iegādātajām e-grāmatām netiek atmaksāta.
OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide: Exam 1Z0-815, Exam 1Z0-816, and Exam 1Z0-817Palielināt
  • Formāts: EPUB+DRM
  • Izdošanas datums: 17-Jul-2020
  • Izdevniecība: Sybex Inc.,U.S.
  • Valoda: eng
  • ISBN-13: 9781119619147
Citas grāmatas par šo tēmu:

DRM restrictions

  • Kopēšana (kopēt/ievietot):

    nav atļauts

  • Drukāšana:

    nav atļauts

  • Lietošana:

    Digitālo tiesību pārvaldība (Digital Rights Management (DRM))
    Izdevējs ir piegādājis šo grāmatu šifrētā veidā, kas nozīmē, ka jums ir jāinstalē bezmaksas programmatūra, lai to atbloķētu un lasītu. Lai lasītu šo e-grāmatu, jums ir jāizveido Adobe ID. Vairāk informācijas šeit. E-grāmatu var lasīt un lejupielādēt līdz 6 ierīcēm (vienam lietotājam ar vienu un to pašu Adobe ID).

    Nepieciešamā programmatūra
    Lai lasītu šo e-grāmatu mobilajā ierīcē (tālrunī vai planšetdatorā), jums būs jāinstalē šī bezmaksas lietotne: PocketBook Reader (iOS / Android)

    Lai lejupielādētu un lasītu šo e-grāmatu datorā vai Mac datorā, jums ir nepieciešamid Adobe Digital Editions (šī ir bezmaksas lietotne, kas īpaši izstrādāta e-grāmatām. Tā nav tas pats, kas Adobe Reader, kas, iespējams, jau ir jūsu datorā.)

    Jūs nevarat lasīt šo e-grāmatu, izmantojot Amazon Kindle.

This OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide was 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 this Study Guide covers everything you need to prepare for and take the exam.

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.

This is the most comprehensive prep guide available for the OCP Oracle Certified Professional Java SE 11 Developer certificationit covers Exam 1Z0-819 and the Upgrade Exam 1Z0-817 (as well as the retired Programmer I Exam 1Z0-815 and Programmer II Exam 1Z0-816)!

Java is widely-used for backend cloud applications, Software as a Service applications (SAAS), and is the principal language used to develop Android applications. This object-oriented programming language is designed to run on all platforms that support Java without the need for recompilation. Oracle Java Programmer certification is highly valued by employers throughout the technology industry.

The OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide in an indispensable resource for anyone preparing for the certification exam. This fully up-to-date guide covers 100% of exam objectives for Exam 1Z0-819 and Upgrade Exam 1Z0-817 (in addition to the previous Exam 1Z0-815 and Exam 1Z0-816). In-depth chapters present clear, comprehensive coverage of the functional-programming knowledge necessary to succeed. Each chapter clarifies complex material while reinforcing your understanding of vital exam topics. Also included is access to Sybex's superior online interactive learning environment and test bank that includes self-assessment tests, chapter tests, bonus practice exam questions, electronic flashcards, and a searchable glossary of important terms. The ultimate study aid for the challenging OCP exams, this popular guide:





Helps you master the changes in depth, difficultly, and new module topics of the latest OCP exams Covers all exam objectives such as Java arrays, primitive data types, string APIs, objects and classes, operators and decision constructs, and applying encapsulation Allows developers to catch up on all of the newest Java material like lambda expressions, streams, concurrency, annotations, generics, and modules Provides practical methods for building Java applications, handling exceptions, programming through interfaces, secure coding in Java SE, and more Enables you to gain the information, understanding, and practice you need to pass the OCP exams

The OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide is a must-have book for certification candidates needing to pass these challenging exams, as well as junior- to senior-level developers who use Java as their primary programming language.
Introduction xxix
Assessment Tests lix
Part I Exam 1Z0-815, OCP Java SE 11 Programmer I
1(492)
Chapter 1 Welcome To Java
3(34)
Learning About the Java Environment
4(2)
Major Components of Java
4(1)
Downloading a JDK
5(1)
Identifying Benefits of Java
6(1)
Understanding the Java Class Structure
7(3)
Fields and Methods
7(1)
Comments
8(2)
Classes vs. Files
10(1)
Writing a main() Method
10(5)
Creating a main() Method
11(1)
Passing Parameters to a Java Program
12(2)
Running a Program in One Line
14(1)
Understanding Package Declarations and Imports
15(11)
Wildcards
17(1)
Redundant Imports
17(1)
Naming Conflicts
18(2)
Creating a New Package
20(1)
Compiling and Running Code with Packages
21(1)
Using an Alternate Directory
22(2)
Compiling with JAR Files
24(1)
Creating a JAR File
25(1)
Running a Program in One Line with Packages
26(1)
Ordering Elements in a Class
26(2)
Code Formatting on the Exam
28(1)
Summary
29(1)
Exam Essentials
29(2)
Review Questions
31(6)
Chapter 2 Java Building Blocks
37(44)
Creating Objects
38(4)
Calling Constructors
38(1)
Reading and Writing Member Fields
39(1)
Executing Instance Initializer Blocks
40(1)
Following Order of Initialization
41(1)
Understanding Data Types
42(6)
Using Primitive Types
42(4)
Using Reference Types
46(1)
Distinguishing between Primitives and Reference Types
47(1)
Declaring Variables
48(4)
Identifying Identifiers
48(3)
Declaring Multiple Variables
51(1)
Initializing Variables
52(9)
Creating Local Variables
53(1)
Passing Constructor and Method Parameters
54(1)
Defining Instance and Class Variables
55(1)
Introducing var
55(6)
Managing Variable Scope
61(3)
Limiting Scope
61(1)
Nesting Scope
62(1)
Tracing Scope
62(1)
Applying Scope to Classes
63(1)
Reviewing Scope
64(1)
Destroying Objects
64(5)
Understanding Garbage Collection
65(1)
Tracing Eligibility
66(3)
Summary
69(1)
Exam Essentials
69(2)
Review Questions
71(10)
Chapter 3 Operators
81(34)
Understanding Java Operators
82(2)
Types of Operators
82(1)
Operator Precedence
83(1)
Applying Unary Operators
84(3)
Logical Complement and Negation Operators
85(1)
Increment and Decrement Operators
86(1)
Working with Binary Arithmetic Operators
87(5)
Arithmetic Operators
88(2)
Numeric Promotion
90(2)
Assigning Values
92(5)
Assignment Operator
92(1)
Casting Values
92(3)
Compound Assignment Operators
95(1)
Assignment Operator Return Value
96(1)
Comparing Values
97(7)
Equality Operators
97(2)
Relational Operators
99(2)
Logical Operators
101(1)
Short-Circuit Operators
102(2)
Making Decisions with the Ternary Operator
104(1)
Summary
105(1)
Exam Essentials
106(1)
Review Questions
107(8)
Chapter 4 Making Decisions
115(48)
Creating Decision-Making Statements
116(12)
Statements and Blocks
116(1)
The if Statement
117(1)
The else Statement
118(3)
The switch Statement
121(7)
Writing while Loops
128(4)
The while Statement
128(1)
The do/while Statement
129(1)
Comparing while and do/while Loops
130(1)
Infinite Loops
131(1)
Constructing for Loops
132(11)
The for Loop
133(5)
The for-each Loop
138(5)
Controlling Flow with Branching
143(8)
Nested Loops
143(1)
Adding Optional Labels
144(1)
The break Statement
145(2)
The continue Statement
147(2)
The return Statement
149(1)
Unreachable Code
150(1)
Reviewing Branching
150(1)
Summary
151(1)
Exam Essentials
152(1)
Review Questions
153(10)
Chapter 5 Core Java Apis
163(60)
Creating and Manipulating Strings
164(10)
Concatenation
165(1)
Immutability
166(1)
Important String Methods
167(6)
Method Chaining
173(1)
Using the StringBuilder Class
174(5)
Mutability and Chaining
175(1)
Creating a StringBuilder
176(1)
Important StringBuilder Methods
176(3)
Understanding Equality
179(3)
Comparing equais() and ==
179(2)
The String Pool
181(1)
Understanding Java Arrays
182(13)
Creating an Array of Primitives
183(2)
Creating an Array with Reference Variables
185(2)
Using an Array
187(1)
Sorting
188(1)
Searching
189(1)
Comparing
190(2)
Varargs
192(1)
Multidimensional Arrays
192(3)
Understanding an ArrayList
195(11)
Creating an ArrayList
195(2)
Using an ArrayList
197(4)
Wrapper Classes
201(2)
Autoboxing and Unboxing
203(1)
Converting Between array and List
203(2)
Using Varargs to Create a List
205(1)
Sorting
206(1)
Creating Sets and Maps
206(2)
Introducing Sets
206(1)
Introducing Maps
207(1)
Calculating with Math APIs
208(2)
min() and max()
208(1)
Round()
209(1)
pow()
209(1)
Random()
210(1)
Summary
210(1)
Exam Essentials
211(1)
Review Questions
212(11)
Chapter 6 Lembdas And Functional Interfaces
223(26)
Writing Simple Lambdas
224(5)
Lambda Example
224(3)
Lambda Syntax
227(2)
Introducing Functional Interfaces
229(4)
Predicate
230(1)
Consumer
230(1)
Supplier
231(1)
Comparator
232(1)
Working with Variables in Lambdas
233(3)
Parameter List
233(1)
Local Variables inside the Lambda Body
233(1)
Variables Referenced from the Lambda Body
234(2)
Calling APIs with Lambdas
236(2)
removeIf()
236(1)
sort()
237(1)
forEach()
237(1)
Summary
238(1)
Exam Essentials
239(1)
Review Questions
240(9)
Chapter 7 Methods And Encapsulation
249(48)
Designing Methods
250(6)
Access Modifiers
251(1)
Optional Specifiers
252(1)
Return Type
253(1)
Method Name
254(1)
Parameter List
255(1)
Optional Exception List
255(1)
Method Body
256(1)
Working with Varargs
256(2)
Applying Access Modifiers
258(8)
Private Access
258(1)
Default (Package-Private) Access
259(2)
Protected Access
261(4)
Public Access
265(1)
Applying the static Keyword
266(8)
Designing static Methods and Fields
266(1)
Accessing a static Variable or Method
267(1)
Static vs. Instance
268(2)
Static Variables
270(1)
Static Initialization
271(1)
Static Imports
272(2)
Passing Data among Methods
274(3)
Overloading Methods
277(6)
Varargs
279(1)
Auroboxing
279(1)
Reference Types
279(2)
Primitives
281(1)
Generics
281(1)
Arrays
282(1)
Putting It All Together
282(1)
Encapsulating Data
283(2)
Summary
285(1)
Exam Essentials
286(1)
Review Questions
287(10)
Chapter 8 Class Design
297(68)
Understanding Inheritance
298(3)
Single vs. Multiple Inheritance
299(1)
Inheriting Object
300(1)
Creating Classes
301(6)
Extending a Class
301(2)
Applying Class Access Modifiers
303(1)
Accessing the this Reference
304(1)
Calling the super Reference
305(2)
Declaring Constructors
307(18)
Creating a Constructor
307(1)
Default Constructor
308(2)
Calling Overloaded Constructors with this()
310(2)
Calling Parent Constructors with super()
312(4)
Constructors and final Fields
316(2)
Order of Initialization
318(6)
Reviewing Constructor Rules
324(1)
Inheriting Members
325(14)
Calling Inherited Members
325(1)
Inheriting Methods
326(12)
Hiding Variables
338(1)
Understanding Polymorphism
339(9)
Object vs. Reference
341(1)
Casting Objects
342(1)
The instance of Operator
343(1)
Polymorphism and Method Overriding
344(2)
Overriding vs. Hiding Members
346(2)
Summary
348(1)
Exam Essentials
349(2)
Review Questions
351(14)
Chapter 9 Advanced Class Design
365(38)
Creating Abstract Classes
366(9)
Introducing Abstract Classes
366(2)
Defining Abstract Methods
368(4)
Creating a Concrete Class
372(2)
Reviewing Abstract Class Rules
374(1)
Implementing Interfaces
375(15)
Defining an Interface
375(4)
Inserting Implicit Modifiers
379(3)
Inheriting an Interface
382(4)
Polymorphism and Interfaces
386(2)
Reviewing Interface Rules
388(2)
Introducing Inner Classes
390(2)
Defining a Member Inner Class
390(1)
Using a Member Inner Class
391(1)
Summary
392(1)
Exam Essentials
393(1)
Review Questions
394(9)
Chapter 10 Exceptions
403(50)
Understanding Exceptions
404(7)
The Role of Exceptions
404(2)
Understanding Exception Types
406(3)
Throwing an Exception
409(2)
Recognizing Exception Classes
411(5)
RuntimeException Classes
411(3)
Checked Exception Classes
414(1)
Error Classes
415(1)
Handling Exceptions
416(18)
Using try and catch Statements
416(2)
Chaining catch Blocks
418(2)
Applying a Multi-catch Block
420(3)
Adding a finally Block
423(3)
Finally Closing Resources
426(6)
Throwing Additional Exceptions
432(2)
Calling Methods That Throw Exceptions
434(5)
Declaring and Overriding Methods with Exceptions
436(1)
Printing an Exception
437(2)
Summary
439(1)
Exam Essentials
440(2)
Review Questions
442(11)
Chapter 11 Modules
453(40)
Introducing Modules
454(4)
Exploring a Module
455(1)
Benefits of Modules
456(2)
Creating and Running a Modular Program
458(7)
Creating the Files
459(1)
Compiling Our First Module
460(2)
Running Our First Module
462(1)
Packaging Our First Module
463(2)
Updating Our Example for Multiple Modules
465(7)
Updating the Feeding Module
465(1)
Creating a Care Module
466(2)
Creating the Talks Module
468(3)
Creating the Staff Module
471(1)
Diving into the module-info File
472(5)
exports
472(2)
Requires transitive
474(2)
provides, uses, and opens
476(1)
Discovering Modules
477(6)
The Java Command
477(3)
The jar Command
480(1)
The jdeps Command
480(2)
The jmod Command
482(1)
Reviewing Command-Line Options
483(2)
Summary
485(1)
Exam Essentials
486(1)
Review Questions
487(6)
Part II Exam 1Z0-816, OCP Java SE 11 Programmer II Exam 1Z0-817, Upgrade OCP Java SE 11
493(612)
Chapter 12 Java Fundamentals
495(58)
Applying the final Modifier
496(4)
Declaring final Local Variables
496(1)
Adding final to Instance and static Variables
497(1)
Writing final Methods
498(1)
Marking Classes final
499(1)
Working with Enums
500(6)
Creating Simple Enums
500(2)
Using Enums in Switch Statements
502(1)
Adding Constructors, Fields, and Methods
503(3)
Creating Nested Classes
506(10)
Declaring an Inner Class
506(3)
Creating a static Nested Class
509(2)
Writing a Local Class
511(1)
Defining an Anonymous Class
512(3)
Reviewing Nested Classes
515(1)
Understanding Interface Members
516(10)
Relying on a default Interface Method
517(4)
Using static Interface Methods
521(1)
Introducing private Interface Methods
522(1)
Introducing private static Interface Methods
523(2)
Reviewing Interface Members
525(1)
Introducing Functional Programming
526(11)
Defining a Functional Interface
526(2)
Declaring a Functional Interface with Object Methods
528(2)
Implementing Functional Interfaces with Lambdas
530(2)
Writing Lambda Expressions
532(2)
Working with Lambda Variables
534(3)
Summary
537(1)
Exam Essentials
538(2)
Review Questions
540(13)
Chapter 13 Annotations
553(46)
Introducing Annotations
554(4)
Understanding Metadata
554(1)
Purpose of Annotations
555(3)
Creating Custom Annotations
558(5)
Creating an Annotation
558(1)
Specifying a Required Element
559(1)
Providing an Optional Element
560(1)
Selecting an Element Type
561(1)
Applying Element Modifiers
561(1)
Adding a Constant Variable
562(1)
Reviewing Annotation Rules
562(1)
Applying Annotations
563(5)
Using Annotations in Declarations
563(2)
Mixing Required and Optional Elements
565(1)
Creating a value() Element
565(2)
Passing an Array of Values
567(1)
Declaring Annotation-Specific Annotations
568(9)
Limiting Usage with @Target
568(3)
Storing Annotations with @Retention
571(1)
Generating javadoc with @Documented
572(1)
Inheriting Annotations with @Inherited
573(1)
Supporting Duplicates with @Repeatable
573(2)
Reviewing An notation-Specific Annotations
575(2)
Using Common Annotations
577(8)
Marking Methods with @Override
577(1)
Declaring Interfaces with @FunctionalInterface
578(1)
Retiring Code with @Deprecated
579(1)
Ignoring Warnings with @SuppressWarnings
580(2)
Protecting Arguments with @SafeVarargs
582(1)
Reviewing Common Annotations
583(2)
Summary
585(1)
Exam Essentials
586(2)
Review Questions
588(11)
Chapter 14 Generics And Collections
599(70)
Using Method References
601(4)
Calling Static Methods
602(1)
Calling Instance Methods on a Particular Object
603(1)
Calling Instance Methods on a Parameter
603(1)
Calling Constructors
604(1)
Reviewing Method References
604(1)
Using Wrapper Classes
605(2)
Using the Diamond Operator
607(1)
Using Lists, Sets, Maps, and Queues
608(23)
Common Collections Methods
609(4)
Using the List Interface
613(5)
Using the Set Interface
618(2)
Using the Queue Interface
620(2)
Using the Map Interface
622(7)
Comparing Collection Types
629(2)
Sorting Data
631(10)
Creating a Comparable Class
631(4)
Comparing Data with a Comparator
635(1)
Comparing Comparable and Comparator
636(1)
Comparing Multiple Fields
637(2)
Sorting and Searching
639(2)
Working with Generics
641(14)
Generic Classes
642(3)
Generic Interfaces
645(1)
Raw Types
646(1)
Generic Methods
647(1)
Bounding Generic Types
648(5)
Putting It All Together
653(2)
Summary
655(2)
Exam Essentials
657(1)
Review Questions
658(11)
Chapter 15 Functional Programming
669(72)
Working with Built-in Functional Interfaces
670(11)
Implementing Supplier
672(1)
Implementing Consumer and BiConsumer
673(1)
Implementing Predicate and BiPredicate
674(1)
Implementing Function and BiFunction
675(2)
Implementing UnaryOperator and BinaryOperator
677(1)
Checking Functional Interfaces
678(1)
Convenience Methods on Functional Interfaces
679(2)
Returning an Optional
681(4)
Creating an Optional
682(1)
Dealing with an Empty Optional
683(2)
Using Streams
685(22)
Understanding the Pipeline Flow
685(3)
Creating Stream Sources
688(3)
Using Common Terminal Operations
691(7)
Using Common Intermediate Operations
698(5)
Putting Together the Pipeline
703(4)
Working with Primitive Streams
707(11)
Creating Primitive Streams
708(3)
Mapping Streams
711(2)
Using Optional with Primitive Streams
713(1)
Summarizing Statistics
714(1)
Learning the Functional Interfaces for Primitives
715(3)
Working with Advanced Stream Pipeline Concepts
718(10)
Linking Streams to the Underlying Data
718(1)
Chaining Optionals
718(3)
Collecting Results
721(7)
Summary
728(2)
Exam Essentials
730(2)
Review Questions
732(9)
Chapter 16 Exceptions, Assertions, And Localization
741(62)
Reviewing Exceptions
742(5)
Handling Exceptions
742(2)
Distinguishing between throw and throws
744(1)
Examining Exception Categories
744(2)
Inheriting Exception Classes
746(1)
Creating Custom Exceptions
747(3)
Declaring Exception Classes
747(1)
Adding Custom Constructors
747(2)
Printing Stack Traces
749(1)
Automating Resource Management
750(8)
Constructing Try-With-Resources Statements
750(3)
Learning the New Effectively Final Feature
753(2)
Understanding Suppressed Exceptions
755(3)
Declaring Assertions
758(4)
Validating Data with the assert Statement
758(2)
Enabling Assertions
760(1)
Disabling Assertions
761(1)
Applying Assertions
761(1)
Writing Assertions Correctly
762(1)
Working with Dates and Times
762(8)
Creating Dates and Times
763(2)
Formatting Dates and Times
765(5)
Supporting Internationalization and Localization
770(9)
Picking a Locale
770(3)
Localizing Numbers
773(4)
Localizing Dates
777(1)
Specifying a Locale Category
778(1)
Loading Properties with Resource Bundles
779(8)
Creating a Resource Bundle
780(2)
Picking a Resource Bundle
782(1)
Selecting Resource Bundle Values
783(2)
Formatting Messages
785(1)
Using the Properties Class
786(1)
Summary
787(1)
Exam Essentials
788(1)
Review Questions
789(14)
Chapter 17 Modular Applications
803(36)
Reviewing Module Directives
804(1)
Comparing Types of Modules
805(5)
Named Modules
805(1)
Automatic Modules
806(3)
Unnamed Modules
809(1)
Comparing Module Types
809(1)
Analyzing JDK Dependencies
810(5)
Identifying Built-in Modules
810(2)
Using jdeps
812(3)
Migrating an Application
815(7)
Determining the Order
815(1)
Exploring a Bottom-Up Migration Strategy
816(2)
Exploring a Top-Down Migration Strategy
818(1)
Splitting a Big Project into Modules
819(1)
Failing to Compile with a Cyclic Dependency
820(2)
Creating a Service
822(9)
Declaring the Service Provider Interface
823(1)
Creating a Service Locator
824(2)
Invoking from a Consumer
826(1)
Adding a Service Provider
827(1)
Merging Service Locator and Consumer
828(3)
Reviewing Services
831(1)
Summary
831(1)
Exam Essentials
832(1)
Review Questions
833(6)
Chapter 18 Concurrency
839(74)
Introducing Threads
841(8)
Distinguishing Thread Types
842(1)
Understanding Thread Concurrency
842(1)
Defining a Task with Runnable
843(2)
Creating a Thread
845(2)
Polling with Sleep
847(2)
Creating Threads with the Concurrency API
849(12)
Introducing the Single-Thread Executor
849(1)
Shutting Down a Thread Executor
850(1)
Submitting Tasks
851(1)
Waiting for Results
852(4)
Submitting Task Collections
856(1)
Scheduling Tasks
857(3)
Increasing Concurrency with Pools
860(1)
Writing Thread-Safe Code
861(15)
Understanding Thread-Safety
861(2)
Protecting Data with Atomic Classes
863(2)
Improving Access with Synchronized Blocks
865(2)
Synchronizing on Methods
867(2)
Understanding the Lock Framework
869(4)
Orchestrating Tasks with a CyclicBarrier
873(3)
Using Concurrent Collections
876(7)
Understanding Memory Consistency Errors
877(1)
Working with Concurrent Classes
877(5)
Obtaining Synchronized Collections
882(1)
Identifying Threading Problems
883(5)
Understanding Liveness
884(3)
Managing Race Conditions
887(1)
Working with Parallel Streams
888(10)
Creating Parallel Streams
889(1)
Performing a Parallel Decomposition
890(2)
Processing Parallel Reductions
892(5)
Avoiding Stateful Operations
897(1)
Summary
898(1)
Exam Essentials
899(1)
Review Questions
900(13)
Chapter 19 I/O
913(56)
Understanding Files and Directories
914(6)
Conceptualizing the File System
914(2)
Storing Data as Bytes
916(1)
Introducing the File Class
916(4)
Introducing I/O Streams
920(7)
Understanding I/O Stream Fundamentals
920(1)
Learning I/O Stream Nomenclature
921(6)
Common I/O Stream Operations
927(7)
Reading and Writing Data
927(2)
Closing the Stream
929(1)
Manipulating Input Streams
930(2)
Flushing Output Streams
932(1)
Reviewing Common I/O Stream Methods
933(1)
Working with I/O Stream Classes
934(18)
Reading and Writing Binary Data
934(1)
Buffering Binary Data
935(2)
Reading and Writing Character Data
937(1)
Buffering Character Data
938(1)
Serializing Data
939(7)
Printing Data
946(5)
Review of Stream Classes
951(1)
Interacting with Users
952(6)
Printing Data to the User
953(1)
Reading Input as a Stream
954(1)
Closing System Streams
954(1)
Acquiring Input with Console
955(3)
Summary
958(1)
Exam Essentials
958(2)
Review Questions
960(9)
Chapter 20 Nio.2
969(54)
Introducing NiO.2
970(10)
Introducing Path
971(1)
Creating Paths
972(5)
Understanding Common Nio.2 Features
977(3)
Interacting with Paths
980(9)
Viewing the Path with toString(), getNameCount(), and getHame()
980(1)
Creating a New Path with subpath()
981(1)
Accessing Path Elements with getFileName(), getParent(), and getRoot()
982(2)
Checking Path Type with isAbsolute() and toAbsolutePath()
984(1)
Joining Paths with resolve()
985(1)
Deriving a Path with relativized
985(2)
Cleaning Up a Path with normalized
987(1)
Retrieving the File System Path with toRealPath()
987(1)
Reviewing Path Methods
988(1)
Operating on Files and Directories
989(8)
Checking for Existence with exists()
989(1)
Testing Uniqueness with isSameFile()
990(1)
Making Directories with createDirectory() and createDirectories()
991(1)
Copying Files with copy()
992(2)
Moving or Renaming Paths with move()
994(1)
Deleting a File with delete() and deleteIfExists()
994(1)
Reading and Writing Data with newBufferedReader() and newBufferedWriter()
995(1)
Reading a File with readAllLines()
996(1)
Reviewing Files Methods
996(1)
Managing File Attributes
997(5)
Discovering File Attributes
997(3)
Improving Attribute Access
1000(2)
Applying Functional Programming
1002(9)
Listing Directory Contents
1002(2)
Traversing a Directory Tree
1004(4)
Searching a Directory with find()
1008(1)
Reading a File with Unes()
1009(2)
Comparing Legacy java.io.File and Nio.2 Methods
1011(1)
Summary
1012(1)
Exam Essentials
1012(2)
Review Questions
1014(9)
Chapter 21 Jdbc
1023(46)
Introducing Relational Databases and SQL
1024(5)
Identifying the Structure of a Relational Database
1026(1)
Writing Basic SQL Statements
1027(2)
Introducing the Interfaces of JDBC
1029(2)
Connecting to a Database
1031(5)
Building a JDBC URL
1031(2)
Getting a Database Connection
1033(3)
Working with a PreparedStatement
1036(9)
Obtaining a PreparedStatement
1037(1)
Executing a PreparedStatement
1037(3)
Working with Parameters
1040(3)
Updating Multiple Times
1043(2)
Getting Data from a ResultSet
1045(6)
Reading a ResultSet
1045(4)
Getting Data for a Column
1049(1)
Using Bind Variables
1050(1)
Calling a CallableStatement
1051(4)
Calling a Procedure without Parameters
1052(1)
Passing an IN Parameter
1053(1)
Returning an OUT Parameter
1053(1)
Working with an INOUT Parameter
1054(1)
Comparing Callable Statement Parameters
1054(1)
Closing Database Resources
1055(3)
Summary
1058(1)
Exam Essentials
1058(2)
Review Questions
1060(9)
Chapter 22 Security
1069(36)
Designing a Secure Object
1070(7)
Limiting Accessibility
1070(1)
Restricting Extensibility
1071(1)
Creating Immutable Objects
1072(3)
Cloning Objects
1075(2)
Introducing Injection and Input Validation
1077(5)
Preventing Injection with a PreparedStatement
1077(3)
Invalidating Invalid Input with Validation
1080(2)
Working with Confidential Information
1082(3)
Guarding Sensitive Data from Output
1083(1)
Protecting Data in Memory
1083(1)
Limiting File Access
1084(1)
Serializing and Deserializing Objects
1085(6)
Specifying Which Fields to Serialize
1085(1)
Customizing the Serialization Process
1086(1)
Pre/Post-Serialization Processing
1087(3)
Reviewing Serialization Methods
1090(1)
Constructing Sensitive Objects
1091(3)
Making Methods final
1092(1)
Making Classes final
1092(1)
Making the Constructor private
1093(1)
Preventing Denial of Service Attacks
1094(3)
Leaking Resources
1094(1)
Reading Very Large Resources
1094(1)
Including Potentially Large Resources
1095(1)
Overflowing Numbers
1095(1)
Wasting Data Structures
1096(1)
Summary
1097(1)
Exam Essentials
1098(1)
Review Questions
1099(6)
Appendix Answers to Review Questions
1105(72)
Chapter 1 Welcome to Java
1106(2)
Chapter 2 Java Building Blocks
1108(4)
Chapter 3 Operators
1112(3)
Chapter 4 Making Decisions
1115(4)
Chapter 5 Core Java APIs
1119(4)
Chapter 6 Lambdas and Functional Interfaces
1123(2)
Chapter 7 Methods and Encapsulation
1125(2)
Chapter 8 Class Design
1127(5)
Chapter 9 Advanced Class Design
1132(4)
Chapter 10 Exceptions
1136(4)
Chapter 11 Modules
1140(2)
Chapter 12 Java Fundamentals
1142(4)
Chapter 13 Annotations
1146(3)
Chapter 14 Generics and Collections
1149(4)
Chapter 15 Functional Programming
1153(3)
Chapter 16 Exceptions, Assertions, and Localization
1156(4)
Chapter 17 Modular Applications
1160(2)
Chapter 18 Concurrency
1162(4)
Chapter 19 I/O
1166(3)
Chapter 20 NiO.2
1169(4)
Chapter 21 JDBC
1173(2)
Chapter 22 Security
1175(2)
Index 1177
Jeanne Boyarsky, OCA/OCP 8 and OCP 11, is a Java Champion and has worked as a Java developer for a major bank for more than 18 years. She is a senior moderator at CodeRanch, and trains and mentors students of all levels, including the programming division of a FIRST robotics team.

Scott Selikoff, OCA/OCP 8 and OCP 11, has been a professional Java Enterprise architect for over 20 years. He is the founder of Selikoff Solutions, LLC, specializing in building custom mobile and server solutions for businesses in the tri-state New York City area.
Biežāk uzdotie jautājumi par e-grāmatām Biežāk uzdotie jautājumi par e-grāmatām
Permanent link: https://www.kriso.lv/db/97811196191476e.html