Programmer Level II Exam
Trail: Bonus
Lesson: Preparation for Java Programmer Language Certification

Programmer Level II Exam

This page maps sections in the Java Tutorials to topics covered in the Java SE 7 Programmer II exam. This exam is associated with the "Oracle Certified Professional, Java SE 7 Programmer" certificate. The topics covered in this exam are:

  1. Java Class Design
  2. Advanced Class Design
  3. Object-Oriented Design Principles
  4. Generics and Collections
  5. String Processing
  6. Exceptions and Assertions
  7. Java I/O Fundamentals
  8. Java File I/O (NIO.2)
  9. Building Database Applications with JDBC
  10. Threads
  11. Concurrency
  12. Localization

Section 1: Java Class Design

Item 1: Use access modifiers: private, protected, public.

Item 2: Override methods.

Item 3: Overload constructors and other methods appropriately.

Item 4: Use the instanceof operator and casting.

Item 5: Use virtual method invocation.

Item 6: Override methods from the Object class to improve the functionality of your class.

Item 7: Use package and import statements.

Section 2: Advanced Class Design

Item 1: Identify when and how to apply abstract classes.

Item 2: Construct abstract Java classes and subclasses.

Item 3: Use the static and final keywords.

Item 4: Create top-level and nested classes.

Item 5: Use enumerated types.

Section 3: Object-Oriented Design Principles

The Java Tutorials do not cover Design Patterns topics. The following references cover design patterns using the Java programming language:

Item 1: Write code that declares, implements and/or extends interfaces.

Item 2: Choose between interface inheritance and class inheritance.

Item 3: Develop code that implements "is-a" and/or "has-a" relationships.

Item 4: Apply object composition principles.

Item 5: Design a class using the Singleton design pattern.

Item 6: Write code to implement the DAO pattern.

Item 7: Design and create objects using a factory, and use factories from the API.

Section 4: Generics and Collections

The Generics (Updated) lesson, the Collections trail and, in particular, the specified pages.

Item 1: Create a generic class.

Item 2: Use the diamond syntax to create a collection.

Item 3: Analyze the interoperability of collections that use raw types and generic types.

Item 4: Use wrapper classes and autoboxing.

Item 5: Create and use a List, a Set, and a Deque.

Item 6: Create and use a Map.

Item 7: Use java.util.Comparator and java.lang.Comparable.

Item 8: Sort and search arrays and lists.

Section 5: String Processing

Item 1: Search, parse and build strings.

Item 2: Search, parse, and replace strings by using regular expressions.

Item 3: Use string formatting.

Section 6: Exceptions and Assertions

Item 1: Use throw and throws statements.

Item 2: Use the try statement with multi-catch, and finally clauses.

Item 3: Autoclose resources with a try-with-resources statement.

Item 4: Create custom exceptions.

Item 5: Test invariants by using assertions.

Section 7: Java I/O Fundamentals

Item 1: Read and write data from the console.

The I/O Streams lesson and, in particular, the following pages:

Item 2: Use streams to read and write files.

The File I/O (Featuring NIO.2) lesson, and in particular, the following pages:

Section 8: Java File I/O (NIO.2)

Item 1: Use the Path class to operate on file and directory paths.

Item 2: Use the Files class to check, delete, copy, or move a file or directory.

Item 3: Read and change file and directory attributes.

Item 4: Recursively access a directory tree.

Item 5: Find a file by using the PathMatcher class.

Item 6: Watch a directory for changes by using WatchService.

Section 9: Building Database Applicatons with JDBC

Item 1: Define the layout of the JDBC API.

Item 2: Connect to a database by using a JDBC driver.

Item 3: Update and query a database..

Item 4: Customize the transaction behavior of JDBC and commit transactions.

Item 5: Use the JDBC 4.1 RowSetProvider, RowSetFactory and RowSet interfaces.

Section 10: Threads

Item 1: Create and use the Thread class and the Runtime interface.

Item 2: Manage and control thread lifecycle.

Item 3: Synchronize thread access to shared data.

Item 4: Identify potential threading problems.

Section 11: Concurrency

Item 1: Use java.util.concurrent collections.

Item 2: Apply atomic variables and looks.

Item 3: Use Executors and ThreadPools.

Item 4: Use the parallel Fork/Join Framework.

Section 12: Localization

Item 1: Read and set the locale by using the Locale object..

Item 2: Build a resource bundle for each locale.

Item 3: Load a resource bundle in an application.

Item 4: Format text for localization by using NumberFormat and DateFormat.

Previous page: Programmer Level I Exam
Next page: Java SE 7 Upgrade Exam