Produktbild: Boyarsky, J: OCP Oracle Certified Professional Java SE 11 De

Boyarsky, J: OCP Oracle Certified Professional Java SE 11 De Exam 1Z0-815, Exam 1Z0-816, and Exam 1Z0-817

Name: Boyarsky, J: OCP Oracle Certified Professional Java SE 11 De
Price: 114.0 CHF
Availability: LimitedAvailability
ISBN: 978-1-119-61913-0

- Taschenbuch ausgewählt
- eBook
Sprache:Englisch

Fr. 114.00

inkl. gesetzl. MwSt., Versandkostenfrei

Lieferung nach Hause

Versandfertig innert 6 - 9 Werktagen

Filialabholung – Versandkostenfrei

Beschreibung

Produktdetails

Einband

Taschenbuch

Erscheinungsdatum

21.09.2020

Verlag

John Wiley & Sons

Seitenzahl

1296

Maße (L/B/H)

23.6/18.7/6 cm

Gewicht

1752 g

Auflage

1. Auflage

Sprache

Englisch

ISBN

978-1-119-61913-0

Kundinnen und Kunden meinen

0 Bewertungen

Verfassen Sie die erste Bewertung zu diesem Artikel

Helfen Sie anderen Kund*innen durch Ihre Meinung

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