1z0804

Examples for the 1Z0-804 exam

• Section 0: Basics
• Section 1: Class design
• Item 1: Use access modifiers: private, protected, public.
• 1.1.1. (1) Controlling Access to Members of a Class
• Item 2: Override methods.
• 1.2.1. (2) Overriding and Hiding Methods
• 1.2.2. (3) Defining Methods
• 1.2.3. (4) Using the Keyword super
• Item 3: Overload constructors and other methods appropriately.
• 1.3.1. (5) Defining Methods
• Item 4: Use the instanceof operator and casting.
• 1.4.1. (6) Inheritance
• Item 5: Use virtual method invocation.
• 1.5.1. (7) Polymorphism
• Item 6: Override methods from the Object class to improve the functionality of your class.
• 1.6.1. (8) Overriding and Hiding Methods
• Item 7: Use package and import statements.
• 1.7.1. (9) Creating and Using Packages
• 1.7.2. (10) Using Package Members
• Section 2: Advanced class design
• Item 1: Identify when and how to apply abstract classes.
• 2.1.1. (11) Abstract Methods and Classes
• Item 2: Construct abstract Java classes and subclasses.
• 2.2.1. (12) Abstract Methods and Classes
• Item 3: Use the static and final keywords.
• 2.3.1. (13) Variables
• 2.3.2. (14) Understanding Class Members
• Item 4: Create top-level and nested classes.
• 2.4.1. (15) Declaring Classes
• 2.4.2. (16) Nested Classes
• Item 5: Use enumerated types.
• 2.5.1. (17) Enum Types
• Section 3: Object-oriented design principles
• Item 1: Write code that declares, implements and/or extends interfaces.
• 3.1.1. (18) Defining an Interface
• 3.1.2. (19) Interfaces
• 3.1.3. (20) Implementing an Interface
• Item 2: Choose between interface inheritance and class inheritance.
• (21) Subject
• Item 3: Develop code that implements "is-a" and/or "has-a" relationships.
• (22) Subject
• Item 4: Apply object composition principles.
• (23) Subject
• Item 5: Design a class using the Singleton design pattern.
• (24) Subject
• Item 6: Write code to implement the DAO pattern.
• (25) Subject
• Item 7: Design and create objects using a factory, and use factories from the API.
• (26) Subject
• Section 4: Generics and collections
• Item 1: Create a generic class.
• 4.1.1. (27) Generic Types
• Item 2: Use the diamond syntax to create a collection.
• 4.2.1. (28) The Diamond
• Item 3: Analyze the interoperability of collections that use raw types and generic types.
• 4.3.1. (29) Raw Types
• 4.3.2. (30) Type Inference
• Item 4: Use wrapper classes and autoboxing.
• 4.4.1. (31) The Numbers Classes
• 4.4.2. (32) Autoboxing and Unboxing
• Item 5: Create and use a List, a Set, and a Deque.
• 4.5.1. (33) The List Interface
• 4.5.2. (34) List Implementations
• 4.5.3. (35) The Set Interface
• 4.5.4. (36) List Implementations
• 4.5.5. (37) The Queue Interface
• 4.5.6. (38) Queue Implementations
• Item 6: Create and use a Map.
• 4.6.1. (39) The Map Interface
• 4.6.2. (40) Map Implementations
• Item 7: Use java.util.Comparator and java.lang.Comparable.
• 4.7.1. (41) Object Ordering
• 4.7.2. (42) The SortedMap Interface
• 4.7.3. (43) The SortedSet Interface
• Item 8: Sort and search arrays and lists.
• 4.8.1. (44) Algorithms
• 4.8.2. (45) The List Interface
• 4.8.3. (46) Object Ordering
• 4.8.4. (47) The SortedSet Interface
• 4.8.5. (48) The SortedMap Interface
• Section 5: String processing
• Item 1: Search, parse and build strings.
• 5.1.1. (49) Strings
• 5.1.2. (50) Converting Between Numbers and Strings
• 5.1.3. (51) Comparing Strings and Portions of Strings
• 5.1.4. (52) Manipulating Characters in a String
• Item 2: Search, parse, and replace strings by using regular expressions.
• 5.2.1. (53) Methods of the Pattern Class
• 5.2.2. (54) Methods of the Matcher Class
• Item 3: Use string formatting.
• 5.3.1. (55) Strings
• 5.3.2. (56) Formatting Numeric Print Output
• Section 6: Exceptions and assertions
• Item 1: Use throw and throws statements.
• 6.1.1. (57) Specifying the Exceptions Thrown by a Method
• 6.1.2. (58) How to Throw Exceptions
• Item 2: Use the try statement with multi-catch, and finally clauses.
• 6.2.1. (59) Catching and Handling Exceptions
• 6.2.2. (60) The try Block
• 6.2.3. (61) The catch Blocks
• 6.2.4. (62) The finally Block
• 6.2.5. (63) Putting It All Together
• Item 3: Autoclose resources with a try-with-resources statement.
• 6.3.1. (64) The try-with-resources Statement
• Item 4: Create custom exceptions.
• 6.4.1. (65) Creating Exception Classes
• Item 5: Test invariants by using assertions.
• 6.5.1. (66) Questions and Exercises: Classes (assertion example)
• Section 7: Java I/O fundamentals
• Item 1: Read and write data from the console.
• 7.1.1. (67) Byte Streams
• 7.1.2. (68) I/O from the Command Line
• Item 2: Use streams to read and write files.
• 6.2.1. (69) Reading, Writing, and Creating Files
• 6.2.2. (70) Creating and Reading Directories
• 6.2.3. (71) Random Access Files
• Section 8: Java File I/O (NIO.2)
• Item 1: Use the Path class to operate on file and directory paths.
• 8.1.1. (72) What Is a Path? (And Other File System Facts)
• 8.1.2. (73) Path Operations
• Item 2: Use the Files class to check, delete, copy, or move a file or directory.
• 8.2.1. (74) File Operations
• 8.2.2. (75) Checking a File or Directory
• 8.2.3. (76) Deleting a File or Directory
• 8.2.4. (77) Copying a File or Directory
• 8.2.5. (78) Moving a File or Directory
• Item 3: Read and change file and directory attributes.
• 8.3.1. (79) Managing Metadata (File and File Store Attributes)
• Item 4: Recursively access a directory tree.
• 8.4.1. (80) Walking the File Tree
• Item 5: Find a file by using the PathMatcher class.
• 8.5.1. (81) Finding Files
• 8.5.2. (82) What is a Glob?
• Item 6: Watch a directory for changes by using WatchService.
• 8.6.1. (83) Watching a Directory for Changes
• Section 9: Building Database Applications with JDBC
• Item 1: Define the layout of the JDBC API.
• 9.1.1. (84) JDBC Basics: Getting Started
• Item 2: Connect to a database by using a JDBC driver.
• 9.2.1. (85) Establishing a Connection
• 9.2.2. (86) Connecting with DataSource Objects
• Item 3: Update and query a database.
• 9.3.1. (87) Processing SQL Statements with JDBC
• Item 4: Customize the transaction behavior of JDBC and commit transactions.
• 9.4.1. (88) Using Transactions
• Item 5: Use the JDBC 4.1 RowSetProvider, RowSetFactory and RowSet interfaces.
• 9.5.1. (89) Using RowSet Objects
• 9.5.2. (90) Using JdbcRowSet Objects
• Section 10: Threads
• Item 1: Create and use the Thread class and the Runtime interface.
• 10.1.1. (91) Defining and Starting a Thread
• Item 2: Manage and control thread lifecycle.
• 10.2.1. (92) Pausing Execution with Sleep
• 10.2.2. (93) Interrupts
• 10.2.3. (94) Joins
• Item 3: Synchronize thread access to shared data.
• 10.3.1. (95) Synchronization
• 10.3.2. (96) Thread Interference
• 10.3.3. (97) Synchronized Methods
• 10.3.4. (98) Intrinsic Locks and Synchronization
• Item 4: Identify potential threading problems.
• 10.4.1. (99) Memory Consistency Errors
• 10.4.2. (100) Deadlock
• Section 11: Concurrency
• Item 1: Use java.util.concurrent collections.
• 11.1.1. (101) Concurrent Collections
• Item 2: Apply atomic variables and looks.
• 11.2.1. (102) Atomic Variables
• Item 3: Use Executors and ThreadPools.
• 11.3.1. (103) Executors
• 11.3.2. (104) Executor Interfaces
• 11.3.3. (105) Thread Pools
• Item 4: Use the parallel Fork/Join Framework.
• 11.4.1. (106) Fork/Join
• Section 12: Localization
• Item 1: Read and set the locale by using the Locale object.
• 12.1.1. (107) Setting the Locale
• 12.1.2. (108) Creating a Locale
• Item 2: Build a resource bundle for each locale.
• 12.2.1. (109) About the ResourceBundle Class
• 12.2.2. (110) Backing a ResourceBundle with Properties Files
• Item 3: Load a resource bundle in an application.
• 12.3.1. (111) Customizing Resource Bundle Loading
• Item 4: Format text for localization by using NumberFormat and DateFormat.
• 12.4.1. (112) Numbers and Currencies
• 12.4.2. (113) Dates and Times