Java Certification

Junior Associate Certification Topic

What Is Java?

• Describe the features of Java
• Describe the real-world applications of Java

Java Basics

• Describe the Java Development Kit (JDK) and the Java Runtime Environment (JRE)
• Describe the components of object-oriented programming
• Describe the components of a basic Java program
• Compile and execute a Java program

Basic Java Elements

• Identify the conventions to be followed in a Java program
• Use Java reserved words
• Use single-line and multi-line comments in Java programs
• Import other Java packages to make them accessible in your code
• Describe the java.lang package

Working with Java Data Types

• Declare and initialize variables including a  variable using final
• Cast a value from one data type to another including automatic and manual promotion
• Declare and initialize a String variable

Working with Java Operator

• Use basic arithmetic operators to manipulate data including +, -, *, /, and %
• Use the increment and decrement operators
• Use relational operators including ==, !=, >, >=, <, and <=
• Use arithmetic assignment operators
• Use conditional operators including &&, ||, and ?
• Describe the operator precedence and use of parenthesis

Working with the String Class

• Develop code that uses methods from the String class
• Format Strings using escape sequences including %d, %n, and %s

Working with the Random and Math Classes

• Use the Random class
• Use the Math class

Using Decision Statements

• Use the decision making statement  (if-then and if-then-else)
• Use the switch statement
• Compare how == differs between primitives and objects
• Compare two String objects by using the compareTo and equals methods

Using Looping Statements

• Describe looping statements
• Use a for loop including an enhanced for loop
• Use a while loop
• Use a do- while loop
• Compare and contrast the for, while, and do-while loops
• Develop code that uses break and continue statements

Debugging and Exception Handling

• Identify syntax and logic errors
• Use exception handling
• Handle common exceptions thrown
• Use try and catch blocks

Arrays and ArrayLists 

• Use a one-dimensional array
• Create and manipulate an ArrayList
• Traverse the elements of an ArrayList by using iterators and loops including the enhanced for loop
• Compare an array and an ArrayList

 Classes and Constructors

• Create a new class including a main method
• Use the private modifier
• Describe the relationship between an object and its members
• Describe the difference between a class variable, an instance variable, and a local variable
• Develop code that creates an object's default constructor and modifies the object's fields
• Use constructors with and without parameters
• Develop code that overloads constructors

Java Methods

• Describe and create a method
• Create and use accessor and mutator methods
• Create overloaded methods
• Describe a static method and demonstrate its use within a program

OCAJP 8 Certification Topic

Java Basics 

• Define the scope of variables 
• Define the structure of a Java class
• Create executable Java applications with a main method; run a Java program from the command line; produce console output
• Import other Java packages to make them accessible in your code
• Compare and contrast the features and components of Java such as: platform independence, object orientation, encapsulation, etc.

Working With Java Data Types 

• Declare and initialize variables (including casting of primitive data types)
• Differentiate between object reference variables and primitive variables
• Know how to read or write to object fields
• Explain an Object's Lifecycle (creation, "dereference by reassignment" and garbage collection)
• Develop code that uses wrapper classes such as Boolean, Double, and Integer  

Using Operators and Decision Constructs 

• Use Java operators; use parentheses to override operator precedence
• Test equality between Strings and other objects using == and equals ()
• Create if and if/else and ternary constructs 
• Use a switch statement 

Creating and Using Arrays 

• Declare, instantiate, initialize and use a one-dimensional array
• Declare, instantiate, initialize and use multi-dimensional arrays

Using Loop Constructs 

• Create and use while loops
• Create and use for loops including the enhanced for loop
• Create and use do/while loops
• Compare loop constructs
• Use break and continue  

Working with Methods and Encapsulation 

• Create methods with arguments and return values; including overloaded methods
• Apply the static keyword to methods and fields  
• Create and overload constructors; differentiate between default and user defined constructors
• Apply access modifiers
• Apply encapsulation principles to a class
• Determine the effect upon object references and primitive values when they are passed  into methods that change the values

Working with Inheritance 

• Describe inheritance and its benefits
• Develop code that makes use of polymorphism; develop code that overrides methods;  differentiate between the type of a reference and the type of an object
• Determine when casting is necessary
• Use super and this to access objects and constructors
• Use abstract classes and interfaces

Handling Exceptions 

• Differentiate among checked exceptions, unchecked exceptions, and Errors
• Create a try-catch block and determine how exceptions alter normal program flow
• Describe the advantages of Exception handling 
• Create and invoke a method that throws an exception
• Recognize common exception classes (such as NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException)

Working with Selected classes from the Java API 

• Manipulate data using the StringBuilder class and its methods
• Create and manipulate Strings
• Create and manipulate calendar data using classes from java.time.LocalDateTime,  java.time.LocalDate, java.time.LocalTime, java.time.format.DateTimeFormatter, java.time.Period
• Declare and use an ArrayList of a given type 
• Write a simple Lambda expression that consumes a Lambda Predicate expression

OCAJP 7 Certification Topic

Java Basics

• Define the scope of variables
• Define the structure of a Java class
• Create executable Java applications with a main method
• Import other Java packages to make them accessible in your code

Working With Java Data Types

• Declare and initialize variables
• Differentiate between object reference variables and primitive variables
• Read or write to object fields
• Explain an Object's Lifecycle (creation, "dereference" and garbage collection)
• Call methods on objects
• Manipulate data using the StringBuilder class and its methods
• Creating and manipulating Strings

Using Operators and Decision Constructs  

• Use Java operators
• Use parenthesis to override operator precedence
• Test equality between Strings and other objects using == and equals ()
• Create if and if/else constructs
• Use a switch statement

Creating and Using Arrays

• Declare, instantiate, initialize and use a one-dimensional array
• Declare, instantiate, initialize and use multi-dimensional array
• Declare and use an ArrayList

Using Loop Constructs

• Create and use while loops
• Create and use for loops including the enhanced for loop
• Create and use do/while loops
• Compare loop constructs
• Use break and continue  

Working with Methods and Encapsulation

• Create methods with arguments and return values
• Apply the static keyword  to methods and fields  
• Create an overloaded method
• Differentiate between default and user defined constructors
• Create and overload constructors
• Apply access modifiers
• Apply encapsulation principles to a class
• Determine the effect upon object references and primitive values when they are passed  into methods that change the values

Working with Inheritance

• Implement inheritance
• Develop code that demonstrates the use of polymorphism
• Differentiate between the type of a reference and the type of an object
• Determine when casting is necessary
• Use super and this to access objects and constructors
• Use abstract classes and interfaces

Handling Exceptions

• Differentiate among checked exceptions, RuntimeExceptions and Errors
• Create a try-catch block and determine how exceptions alter normal program flow
• Describe what Exceptions are used for in Java
• Invoke a method that throws an exception
• Recognize common exception classes and categories

OCAJP 5/6 Certification Topic

Section 1: Fundamental Object-Oriented Concepts

• Describe, compare, and contrast primitives (integer, floating point, boolean, and character), enumeration types, and objects.
• Describe, compare, and contrast concrete classes, abstract classes, and interfaces, and how inheritance applies to them.
• Describe, compare, and contrast class compositions, and associations (including multiplicity: (one-to-one, one-to-many, and many-to-many), and association navigation.
• Describe information hiding (using private attributes and methods), encapsulation, and exposing object functionality using public methods; and describe the JavaBeans conventions for setter and getter methods.
• Describe polymorphism as it applies to classes and interfaces, and describe and apply the "program to an interface" principle.

Section 2: Java Implementation of Object-Oriented Concepts

• Notes: code examples may use the 'new' operator.
• Develop code that uses primitives, enumeration types, and object references, and recognize literals of these types.
• Develop code that declares concrete classes, abstract classes, and interfaces, code that supports implementation and interface inheritance, code that declares instance attributes and methods, and code that uses the Java access modifiers: private and public.
• Develop code that implements simple class associations, code that implements multiplicity using arrays, and recognize code that implements compositions as opposed to simple associations, and code that correctly implements association navigation.
• Develop code that uses polymorphism for both classes and interfaces, and recognize code that uses the "program to an interface" principle.

Section 3: Algorithm Design and Implementation

• Describe, compare, and contrast these three fundamental types of statements: assignment, conditional, and iteration, and given a description of an algorithm, select the appropriate type of statement to design the algorithm.
• Given an algorithm as pseudo-code, determine the correct scope for a variable used in the algorithm, and develop code to declare variables in any of the following scopes: instance variable, method parameter, and local variable.
• Given an algorithm as pseudo-code, develop method code that implements the algorithm using conditional statements (if and switch), iteration statements (for, for-each, while, and do-while), assignment statements, and break and continue statements to control the flow within switch and iteration statements.
• Given an algorithm with multiple inputs and an output, develop method code that implements the algorithm using method parameters, a return type, and the return statement, and recognize the effects when object references and primitives are passed into methods that modify them.
• Given an algorithm as pseudo-code, develop code that correctly applies the appropriate operators including assignment operators (limited to: =, +=, -=), arithmetic operators (limited to: +, -, *, /, %, ++, --), relational operators (limited to: <, <=, >, >=, ==, !=), logical operators (limited to: !, &&, ||) to produce a desired result. Also, write code that determines the equality of two objects or two primitives.
• Develop code that uses the concatenation operator (+), and the following methods from class String: charAt, indexOf, trim, substring, replace, length, startsWith, and endsWith.

Section 4: Java Development Fundamentals

• Describe the purpose of packages in the Java language, and recognize the proper use of import and package statements.
• Demonstrate the proper use of the "javac" command (including the command-line options: -d and -classpath), and demonstrate the proper use of the "java" command (including the command-line options: -classpath, -D and -version).
• Describe the purpose and types of classes for the following Java packages: java.awt, javax.swing, java.io, java.net, java.util.

Section 5: Java Platforms and Integration Technologies

• Distinguish the basic characteristics of the three Java platforms: J2SE, J2ME, and J2EE, and given a high-level architectural goal, select the appropriate Java platform or platforms.
• Describe at a high level the benefits and basic characteristics of RMI.
• Describe at a high level the benefits and basic characteristics of JDBC, SQL, and RDBMS technologies.
• Describe at a high level the benefits and basic characteristics of JNDI, messaging, and JMS technologies.

Section 6: Client Technologies

• Describe at a high level the basic characteristics, benefits and drawbacks of creating thin-clients using HTML and JavaScript and the related deployment issues and solutions.
• Describe at a high level the basic characteristics, benefits, drawbacks, and deployment issues related to creating clients using J2ME midlets.
• Describe at a high level the basic characteristics, benefits, drawbacks, and deployment issues related to creating fat-clients using Applets.
• Describe at a high level the basic characteristics, benefits, drawbacks, and deployment issues related to creating fat-clients using Swing.

Section 7: Server Technologies

• Describe at a high level the basic characteristics of: EJB, servlets, JSP, JMS, JNDI, SMTP, JAX-RPC, Web Services (including SOAP, UDDI, WSDL, and XML), and JavaMail.
• Describe at a high level the basic characteristics of servlet and JSP support for HTML thin-clients.
• Describe at a high level the use and basic characteristics of EJB session, entity and message-driven beans.
• Describe at a high level the fundamental benefits and drawbacks of using J2EE server-side technologies, and describe and compare the basic characteristics of the web-tier, business-tier, and EIS tier.

OCPJP 8 Certification Topic

Java Class Design

•  Implement encapsulation
• Implement inheritance including visibility modifiers and composition
• Implement polymorphism
• Override hashCode, equals, and toString methods from Object class
• Create and use singleton classes and immutable classes
• Develop code that uses static keyword on initialize blocks, variables, methods, and classes

Advanced Java Class Design

• Develop code that uses abstract classes and methods
• Develop code that uses the final keyword
• Create inner classes including static inner class, local class, nested class, and anonymous inner class
• Use enumerated types including methods, and constructors in an enum type
• Develop code that declares, implements and/or extends interfaces and use the @Override annotation.
• Create and use Lambda expressions

Generics and Collections

• Create and use a generic class
• Create and use ArrayList, TreeSet, TreeMap, and ArrayDeque objects
• Use java.util.Comparator and java.lang.Comparable interfaces
• Collections Streams and Filters
• Iterate using forEach methods of Streams and List
• Describe Stream interface and Stream pipeline
• Filter a collection by using lambda expressions
• Use method references with Streams

Lambda Built-in Functional Interfaces

• Use  the built-in interfaces included in the java.util.function package such as Predicate, Consumer, Function, and Supplier
• Develop code that uses primitive versions of functional interfaces
• Develop code that uses binary versions of functional interfaces
• Develop code that uses the UnaryOperator interface

Java Stream API

• Develop code to extract data from an object using peek() and map() methods including primitive versions of the map() method
• Search for data by using search methods of the Stream classes including findFirst, findAny, anyMatch, allMatch, noneMatch
• Develop code that uses the Optional class
• Develop code that uses Stream data methods and calculation methods
• Sort a collection using Stream API
• Save results to a collection using the collect method and group/partition data using the Collectors class
• Use flatMap() methods in the Stream API

Exceptions and Assertions

• Use try-catch and throw statements
• Use catch, multi-catch, and finally clauses
• Use Autoclose resources with a try-with-resources statement
• Create custom exceptions and Auto-closeable resources
• Test invariants by using assertions

Use Java SE 8 Date/Time API

• Create and manage date-based and time-based events including a combination of date and time into a single object using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration
• Work with dates and times across timezones and manage changes resulting from daylight savings including Format date and times values
• Define and create and manage date-based and time-based events using Instant, Period, Duration, and TemporalUnit

Java I/O Fundamentals

• Read and write data from the console
• Use BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter in the java.io package.

Java File I/O (NIO.2)

• Use Path interface to operate on file and directory paths
• Use Files class to check, read, delete, copy, move, manage metadata of a file or directory
• Use Stream API with NIO.2

Java Concurrency

• Create worker threads using Runnable, Callable and use an ExecutorService to concurrently execute tasks
• Identify potential threading problems among deadlock, starvation, livelock, and race conditions
• Use synchronized keyword and java.util.concurrent.atomic package to control the order of thread execution
• Use java.util.concurrent collections and classes including CyclicBarrier and CopyOnWriteArrayList
• Use parallel Fork/Join Framework
• Use parallel Streams including reduction, decomposition, merging processes, pipelines and performance.

Building Database Applications with JDBC

• Describe the interfaces that make up the core of the JDBC API including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations
• Identify the components required to connect to a database using the DriverManager class including the JDBC URL
• Submit queries and read results from the database including creating statements, returning result sets, iterating through the results, and properly closing result sets, statements, and connections

Localization

• Read and set the locale by using the Locale object
• Create and read a Properties file
• Build a resource bundle for each locale and load a resource bundle in an application

OCPJP 8 (upgrade) Certification Topic

Lambda Expressions

• Describe and develop code that uses Java inner classes, including nested class, static class, local class, and anonymous classes
• Describe and write functional interfaces
• Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing

Using Built-in Lambda Types

• Describe the interfaces of the java.util.function package
• Develop code that uses the Function interface
• Develop code that uses the Consumer interface
• Develop code that uses the Supplier interface
• Develop code that uses the UnaryOperator interface
• Develop code that uses the Predicate interface
• Develop code that uses the primitive and binary variations of the base interfaces of the java.util.function package
• Develop code that uses a method reference, including refactoring a lambda expression to a method reference

Java Collections and Streams with Lambdas

• Develop code that iterates a collection by using the forEach() method and method chaining
• Describe the Stream interface and pipelines
• Filter a collection by using lambda expressions
• Identify the operations, on stream, that are lazy

Collection Operations with Lambda

• Develop code to extract data from an object by using the map() method
• Search for data by using methods such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()
• Describe the unique characteristics of the Optional class
• Perform calculations by using Java Stream methods, such as count(), max(), min(), average(), and sum()
• Sort a collection by using lambda expressions
• Develop code that uses the Stream.collect() method and Collectors class methods, such as averagingDouble(), groupingBy(), joining(), and partitioningBy()

Parallel Streams

• Develop code that uses parallel streams
• Implement decomposition and reduction in streams

Lambda Cookbook

• Develop code that uses Java SE 8 collection improvements, including Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map.computeIfPresent() methods
• Develop code that uses Java SE 8 I/O improvements, including Files.find(), Files.walk(), and lines() methods
• Use flatMap() methods in the Stream API
• Develop code that creates a stream by using the Arrays.stream() and IntStream.range() methods

Method Enhancements

• Add static methods to interfaces
• Define and use a default method of an interface and describe the inheritance rules for the default method

Use Java SE 8 Date/Time API

• Create and manage date- and time-based events, including a combination of date and time in a single object, by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration
• Work with dates and times across time zones and manage changes resulting from daylight savings, including Format date and times values
• Define, create, and manage date- and time-based events using Instant, Period, Duration, and TemporalUnit

OCPJP 8 ( Java SE 6 and all prior versions) Certification Topic

Language Enhancements

• Develop code that uses String objects in the switch statement, binary literals, and numeric literals, including underscores in literals
• Develop code that uses try-with-resources statements, including using classes that implement the AutoCloseable interface
• Develop code that handles multiple Exception types in a single catch block
• Use static and default methods of an interface including inheritance rules for a default method

Concurrency

• Use classes from the java.util.concurrent package including CyclicBarrier and CopyOnWriteArrayList with a focus on the advantages over and differences from the traditional java.util collections 
• Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util.concurrent.locks and java.util.concurrent.atomic packages to support lock-free thread-safe programming on single variables
• Use Executor, ExecutorService, Executors, Callable, and Future to execute tasks using thread pools
• Use the parallel Fork/Join Framework

Localization

• Describe the advantages of localizing an application and developing code that defines, reads, and sets the locale with a Locale object
• Build a resource bundle for a locale and call a resource bundle from an application
• Create and manage date- and time-based events by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration, including a combination of date and time in a single object
• Format dates, numbers, and currency values for localization with the NumberFormat and DateFormat classes, including number and date format patterns
• Work with dates and times across time zones and manage changes resulting from daylight savings

Java File I/O (NIO.2)

• Operate on file and directory paths by using the Paths class
• Check, delete, copy, or move a file or directory by using the Files class 
• Recursively access a directory tree by using the DirectoryStream and FileVisitor interfaces
• Find a file by using the PathMatcher interface, and use Java SE 8 I/O improvements, including Files.find(), Files.walk(), and lines() methods
• Observe the changes in a directory by using the WatchService interface

Lambda

• Define and write functional interfaces and describe the interfaces of the java.util.function package
• Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing
• Develop code that uses the built-in interfaces included in the java.util.function package, such as Function, Consumer, Supplier, UnaryOperator, Predicate, and Optional APIs, including the primitive and binary variations of the interfaces
• Develop code that uses a method reference, including refactoring a lambda expression to a method reference

Java Collections

• Develop code that uses diamond with generic declarations
• Develop code that iterates a collection, filters a collection, and sorts a collection by using lambda expressions
• Search for data by using methods, such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()
• Perform calculations on Java Streams by using count, max, min, average, and sum methods and save results to a collection by using the collect method and Collector class, including the averagingDouble, groupingBy, joining, partitioningBy methods
• Develop code that uses Java SE 8 collection improvements, including the Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map.computeIfPresent() methods
• Develop  code that uses the merge(), flatMap(), and map() methods on Java Streams

Java Streams

• Describe the Stream interface and pipelines; create a stream by using the Arrays.stream() and  IntStream.range() methods; identify the lambda operations that are lazy
• Develop code that uses parallel streams, including decomposition operation and reduction operation in streams

OCPJP 7 Certification Topic

Java Class Design 

• Use access modifiers: private, protected, and public
• Override methods 
• Overload constructors and methods 
• Use the instanceof operator and casting
• Use virtual method invocation
• Override the hashCode, equals, and toString methods from the Object class to improve the functionality of your class. 
• Use package and import statements

Advanced Class Design 

• Identify when and how to apply abstract classes
• Construct abstract Java classes and subclasses
• Use the static and final keywords
• Create top-level and nested classes
• Use enumerated types

Object-Oriented Design Principles 

• Write code that declares, implements and/or extends interfaces
• Choose between interface inheritance and class inheritance
• Apply cohesion, low-coupling, IS-A, and HAS-A principles
• Apply object composition principles (including has-a relationships)
• Design a class using a Singleton design pattern
• Write code to implement the Data Access Object (DAO) pattern
• Design and create objects using a factory pattern

Generics and Collections

• Create a generic class
• Use the diamond for type inference  
• Analyze the interoperability of collections that use raw types and generic types 
• Use wrapper classes, autoboxing and unboxing
• Create and use List, Set and Deque implementations
• Create and use Map implementations
• Use java.util.Comparator and java.lang.Comparable
• Sort and search arrays and lists

String Processing 

• Search, parse and build strings (including Scanner, StringTokenizer, StringBuilder, String and Formatter)
• Search, parse, and replace strings by using regular expressions, using expression patterns for matching limited to: . (dot), * (star), + (plus), ?, \d, \D, \s, \S,  \w, \W, \b. \B, [], ().
• Format strings using the formatting parameters: %b, %c, %d, %f, and %s in format strings.

Exceptions and Assertions 

• Use throw and throws statements 
• Develop code that handles multiple Exception types in a single catch block
• Develop code that uses try-with-resources statements (including using classes that implement the AutoCloseable interface)
• Create custom exceptions
• Test invariants by using assertions

Java I/O Fundamentals 

• Read and write data from the console
• Use streams to read from and write to files by using classes in the java.io package including BufferedReader, BufferedWriter, File, FileReader, FileWriter, DataInputStream, DataOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter

Java File I/O (NIO.2) 

• Operate on file and directory paths with the Path class 
• Check, delete, copy, or move a file or directory with the Files class  
• Read and change file and directory attributes, focusing on the BasicFileAttributes, DosFileAttributes, and PosixFileAttributes interfaces
• Recursively access a directory tree using the DirectoryStream and FileVisitor interfaces
• Find a file with the PathMatcher interface
• Watch a directory for changes with the WatchService interface

Building Database Applications with JDBC 

• Describe the interfaces that make up the core of the JDBC API (including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations)
• Identify the components required to connect to a database using the DriverManager class (including the jdbc URL)
• Submit queries and read results from the database (including creating statements, returning result sets, iterating through the results, and properly closing result sets, statements, and connections)
• Use JDBC transactions (including disabling auto-commit mode, committing and rolling back transactions, and setting and rolling back to savepoints)
• Construct and use RowSet objects using the RowSetProvider class and the RowSetFactory interface
• Create and use PreparedStatement and CallableStatement objects

Threads 

• Create and use the Thread class and the Runnable interface
• Manage and control thread lifecycle
• Synchronize thread access to shared data
• Identify code that may not execute correctly in a multi-threaded environment.

Concurrency 

• Use collections from the java.util.concurrent package with a focus on the advantages over and differences from the traditional java.util collections.
• Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util.concurrent.locks package to support lock-free thread-safe programming on single variables.
• Use Executor, ExecutorService, Executors, Callable, and Future to execute tasks using thread pools.
• Use the parallel Fork/Join Framework

Localization 

• Read and set the locale by using the Locale object
• Build a resource bundle for each locale
• Call a resource bundle from an application
• Format dates, numbers, and currency values for localization with the NumberFormat and DateFormat classes (including number format patterns)
• Describe the advantages of localizing an application
• Define a locale using language and country codes

OCPJP 7 (upgrade) Certification Topic

Language Enhancements

• Develop code that uses String objects in switch statements
• Develop code that uses binary literals and numeric literals with underscores
• Develop code that uses try-with-resources statements (including using classes that implement the AutoCloseable interface)
• Develop code that handles multiple Exception types in a single catch block
• Develop code that uses the diamond with generic declarations

Design Patterns

• Design a class using a Singleton design pattern
• Apply object composition principles (including has-a relationships)
• Write code to implement the Data Access Object (DAO) pattern
• Design and create objects using a factory pattern

Database Applications with JDBC

• Describe the interfaces that make up the core of the JDBC API (including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations)
• Identify the components required to connect to a database using  the DriverManager class (including the jdbc URL)
• Construct and use RowSet objects using the RowSetProvider class and the RowSetFactory interface
• Use JDBC transactions (including disabling auto-commit mode, committing and rolling back transactions, and setting and rolling back to savepoints)
• Submit queries and read results from the database (including creating statements, returning result sets, iterating through the results, and properly closing result sets, statements, and connections)
• Create and use PreparedStatement and CallableStatement objects

Concurrency

• Identify code that may not execute correctly in a multi-threaded environment.
• Use collections from the java.util.concurrent package with a focus on the advantages over and differences from the traditional java.util collections.
• Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util.concurrent.locks package to support lock-free thread-safe programming on single variables.
• Use Executor, ExecutorService, Executors, Callable, and Future to execute tasks using thread pools.
• Use the parallel Fork/Join Framework

Localization

• Describe the advantages of localizing an application
• Define a locale using language and country codes
• Read and set the locale with a Locale object
• Build a resource bundle for a locale
• Call a resource bundle from an application
• Format dates, numbers, and currency values for localization with the NumberFormat and DateFormat classes (including number format patterns)

Java File I/O (NIO.2)

• Operate on file and directory paths with the Path class
• Check, delete, copy, or move a file or directory with the Files class  
• Read and change file and directory attributes, focusing on the BasicFileAttributes, DosFileAttributes, and PosixFileAttributes interfaces
• Recursively access a directory tree using the DirectoryStream and FileVisitor interfaces
• Find a file with the PathMatcher interface
• Watch a directory for changes with the WatchService interface

OCPJP 6 (upgrade) Certification Topic

Section 1: Declarations, Initialization and Scoping

• Develop code that declares classes (including abstract and all forms of nested classes), interfaces, and enums, and includes the appropriate use of package and import statements (including static imports).
• Develop code that declares an interface. Develop code that implements or extends one or more interfaces.
• Develop code that declares an abstract class. Develop code that extends an abstract class.
• Develop code that declares, initializes, and uses primitives, arrays, enums, and objects as static, instance, and local variables. Also, use legal identifiers for variable names.
• Given a code example, determine if a method is correctly overriding or overloading another method, and identify legal return values (including covariant returns), for the method.
• Given a set of classes and superclasses, develop constructors for one or more of the classes. Given a class declaration, determine if a default constructor will be created, and if so, determine the behavior of that constructor. Given a nested or non-nested class listing, write code to instantiate the class.

Section 2: Flow Control

• Develop code that implements an if or switch statement; and identify legal argument types for these statements.
• Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (for-each), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution.
• Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions.
• Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions.
• Recognize the effect of an exception arising at a specified point in a code fragment. Note that the exception may be a runtime exception, a checked exception, or an error.
• Recognize situations that will result in any of the following being thrown: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError or NoClassDefFoundError. Understand which of these are thrown by the virtual machine and recognize situations in which others should be thrown programatically.

Section 3: API Contents

• Develop code that uses the primitive wrapper classes (such as Boolean, Character, Double, Integer, etc.), and/or autoboxing & unboxing. Discuss the differences between the String, StringBuilder, and StringBuffer classes.
• Given a scenario involving navigating file systems, reading from files, writing to files, or interacting with the user, develop the correct solution using the following classes (sometimes in combination), from java.io: BufferedReader, BufferedWriter, File, FileReader, FileWriter, PrintWriter, and Console.
• Use standard J2SE APIs in the java.text package to correctly format or parse dates, numbers, and currency values for a specific locale; and, given a scenario, determine the appropriate methods to use if you want to use the default locale or a specific locale. Describe the purpose and use of the java.util.Locale class.
• Write code that uses standard J2SE APIs in the java.util and java.util.regex packages to format or parse strings or streams. For strings, write code that uses the Pattern and Matcher classes and the String.split method. Recognize and use regular expression patterns for matching (limited to: . (dot), * (star), + (plus), ?, \d, \s, \w, [], ()). The use of *, +, and ? will be limited to greedy quantifiers, and the parenthesis operator will only be used as a grouping mechanism, not for capturing content during matching. For streams, write code using the Formatter and Scanner classes and the PrintWriter.format/printf methods. Recognize and use formatting parameters (limited to: %b, %c, %d, %f, %s) in format strings.

Section 4: Concurrency

• Write code to define, instantiate, and start new threads using both java.lang.Thread and java.lang.Runnable.
• Recognize the states in which a thread can exist, and identify ways in which a thread can transition from one state to another.
• Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.

Section 5: OO Concepts

• Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.
• Given a scenario, develop code that demonstrates the use of polymorphism. Further, determine when casting will be necessary and recognize compiler vs. runtime errors related to object reference casting.
• Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.
• Given a scenario, develop code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass, or overloaded constructors.
• Develop code that implements "is-a" and/or "has-a" relationships.

Section 6: Collections / Generics

• Given a design scenario, determine which collection classes and/or interfaces should be used to properly implement that design, including the use of the Comparable interface.
• Distinguish between correct and incorrect overrides of corresponding hashCode and equals methods, and explain the difference between == and the equals method.
• Write code that uses the generic versions of the Collections API, in particular, the Set, List, and Map interfaces and implementation classes. Recognize the limitations of the non-generic Collections API and how to refactor code to use the generic versions. Write code that uses the NavigableSet and NavigableMap interfaces.
• Develop code that makes proper use of type parameters in class/interface declarations, instance variables, method arguments, and return types; and write generic methods or methods that make use of wildcard types and understand the similarities and differences between these two approaches.
• Use capabilities in the java.util package to write code to manipulate a list by sorting, performing a binary search, or converting the list to an array. Use capabilities in the java.util package to write code to manipulate an array by sorting, performing a binary search, or converting the array to a list. Use the java.util.Comparator and java.lang.Comparable interfaces to affect the sorting of lists and arrays. Furthermore, recognize the effect of the "natural ordering" of primitive wrapper classes and java.lang.String on sorting.

Section 7: Fundamentals

• Given a code example and a scenario, write code that uses the appropriate access modifiers, package declarations, and import statements to interact with (through access or inheritance) the code in the example.
• Given an example of a class and a command-line, determine the expected runtime behavior.
• Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters.
• Given a code example, recognize the point at which an object becomes eligible for garbage collection, determine what is and is not guaranteed by the garbage collection system, and recognize the behaviors of the Object.finalize() method.
• Given the fully-qualified name of a class that is deployed inside and/or outside a JAR file, construct the appropriate directory structure for that class. Given a code example and a classpath, determine whether the classpath will allow the code to compile successfully.
• Write code that correctly applies the appropriate operators including assignment operators (limited to: =, +=, -=), arithmetic operators (limited to: +, -, *, /, %, ++, --), relational operators (limited to: <, <=, >, >=, ==, !=), the instanceof operator, logical operators (limited to: &, |, ^, !, &&, ||), and the conditional operator ( ? : ), to produce a desired result. Write code that determines the equality of two objects or two primitives.

OCPJP 5/6 (upgrade) Certification Topic

Section 1: Declarations, Initialization and Scoping

• Develop code that declares classes (including abstract and all forms of nested classes), interfaces, and enums, and includes the appropriate use of package and import statements (including static imports).
• Develop code that declares, initializes, and uses primitives, arrays, enums, and objects as static, instance, and local variables. Also, use legal identifiers for variable names.
• Develop code that declares both static and non-static methods, and, if appropriate, use method names that adhere to the JavaBeans naming standards. Also develop code that declares and uses a variable-length argument list.
• Given a code example, determine if a method is correctly overriding or overloading another method, and identify legal return values (including covariant returns), for the method.
• Given a set of classes and superclasses, develop constructors for one or more of the classes. Given a class declaration, determine if a default constructor will be created, and if so, determine the behavior of that constructor. Given a nested or non-nested class listing, write code to instantiate the class.

Section 2: Flow Control

• Develop code that implements an if or switch statement; and identify legal argument types for these statements.
• Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (for-each), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution.
• Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions.
• Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions.
• Recognize situations that will result in any of the following being thrown: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError or NoClassDefFoundError. Understand which of these are thrown by the virtual machine and recognize situations in which others should be thrown programatically.

Section 3: API Contents

• Develop code that uses the primitive wrapper classes (such as Boolean, Character, Double, Integer, and so on), and/or autoboxing & unboxing. Discuss the differences between the String, StringBuilder, and StringBuffer classes.
• Given a scenario involving navigating file systems, reading from files, writing to files, or interacting with the user, develop the correct solution using the following classes (sometimes in combination), from java.io: BufferedReader, BufferedWriter, File, FileReader, FileWriter, PrintWriter, and Console.
• Develop code that serializes and/or de-serializes objects using the following APIs from java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and Serializable.
• Use standard J2SE APIs in the java.text package to correctly format or parse dates, numbers, and currency values for a specific locale; and, given a scenario, determine the appropriate methods to use if you want to use the default locale or a specific locale. Describe the purpose and use of the java.util.Locale class.
• Write code that uses standard J2SE APIs in the java.util and java.util.regex packages to format or parse strings or streams. For strings, write code that uses the Pattern and Matcher classes and the String.split method. Recognize and use regular expression patterns for matching (limited to: . (dot), * (star), + (plus), ?, \d, \s, \w, [], ()). The use of *, +, and ? will be limited to greedy quantifiers, and the parenthesis operator will only be used as a grouping mechanism, not for capturing content during matching. For streams, write code using the Formatter and Scanner classes and the PrintWriter.format/printf methods. Recognize and use formatting parameters (limited to: %b, %c, %d, %f, %s) in format strings.

Section 4: Concurrency

• Recognize the states in which a thread can exist, and identify ways in which a thread can transition from one state to another.
• Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.

Section 5: OO Concepts

• Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.
• Given a scenario, develop code that demonstrates the use of polymorphism. Further, determine when casting will be necessary and recognize compiler as compared to runtime errors related to object reference casting.
• Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.
• Develop code that implements "is-a" and/or "has-a" relationships.

Section 6: Collections / Generics

• Given a design scenario, determine which collection classes and/or interfaces should be used to properly implement that design, including the use of the Comparable interface.
• Write code that uses the generic versions of the Collections API, in particular, the Set, List, and Map interfaces and implementation classes. Recognize the limitations of the non-generic Collections API and how to refactor code to use the generic versions. Write code that uses the NavigableSet and NavigableMap interfaces.
• Develop code that makes proper use of type parameters in class/interface declarations, instance variables, method arguments, and return types; and write generic methods or methods that make use of wildcard types and understand the similarities and differences between these two approaches.
• Use capabilities in the java.util package to write code to manipulate a list by sorting, performing a binary search, or converting the list to an array. Use capabilities in the java.util package to write code to manipulate an array by sorting, performing a binary search, or converting the array to a list. Use the java.util.Comparator and java.lang.Comparable interfaces to affect the sorting of lists and arrays. Furthermore, recognize the effect of the "natural ordering" of primitive wrapper classes and java.lang.String on sorting.

Section 7: Fundamentals

• Given an example of a class and a command-line, determine the expected runtime behavior.
• Given the fully-qualified name of a class that is deployed inside and/or outside a JAR file, construct the appropriate directory structure for that class. Given a code example and a classpath, determine whether the classpath will allow the code to compile successfully.

OCEJSF 6 Certification Topic

Section 1: Essentials of JSF2.0

• Identify the features of JSF such as Facelets, BookMarkable View, AJAX support and the benefits they bring in
• Identify the life cycle stages of JSF, flow of request processing, and purpose of FacesContext
• Design XHTML pages using JSF HTML tag library and demonstrate usage of JSF implicit objects
• Develop and associate model components with views using CDI Named beans and identify the advantages of CDI Named beans over Managed Bean
• Manage user and application state using various scopes like flash, conversation, application, request, and session
• Implement internationalization/Localization using resource bundle and Locale class

Section  2: JSF Navigation Model

• Design JSF pages with static and dynamic implicit navigation 
• Configure faces-config.xml to implement navigation rules including conditional and redirection
• Design bookmarkable views

Section 3: Data Conversion and Validation model

• Implement data conversion model using JSF standard converters
• Create, configure, and use custom converters
• Identify the best suited standard validator and implement it in a given JSF application
• Create, configure, and use custom validators
• Describe the usage of bean validation

Section 4: Event Handling

• Use CDI Named bean in a JSF application to handle action and valuechange events 
• Create and implement listeners to handle events
• Develop JSF application that handle life cycle events
• Implement asynchronous events using AJAX

Section 5:  Data table and Composite Components

• Design a DataTable with header and footer to populate and manipulate data from various components like Array, List, ResultSet, DataModel and describe the differences between <f:dataTable> and <ui:repeat/>
• Implement composite components in JSF application and enhance it using AJAX
• Implement templates in a JSF application and describe the differences between <ui:composition/> and <ui:decorate/>

Section 6: Custom Components

• Identify when and how to use custom components and custom renderers.
• Enhance JSF application using HTML5 components

Section 7: Security

• Configure security for JSF application using authorization and authentication techniques

Section 8: Test, Package, and Deploy a web application

• Implement efficient error handling and debugging techniques in a JSF application 
• Configure and deploy a JSF application

OCEJWCD 6 Certification Topic

Introduction to Java Servlets

• Describe web applications, CGI, and the role of Java
• Describe benefits of Java servlet technology
• Create a simple Java Servlet
• Define three-tier architecture
• Define Model-View-Controller (MVC) architecture

Introduction to Java Server Pages

• Describe why Servlets are not the whole solution
• Describe essentials of JSPs
• Understand the fundamentals and reasons for MVC architecture

Implementing an MVC Design

• Code a controller using a servlet
• Code a view using a JSP
• Forward control from a servlet to a JSP
• Understand fundamentals of EL
• Implement a simple MVC system

The servlet's environment

• Understand more details of the HTTP protocol
• Understand fundamentals of HTML forms
• Understand fundamentals of the HttpServlet and related APIs
• Write code that manages client sessions and cookies

Container facilities for servlets and JSPs

• Understand the purpose and structure of deployment descriptors
• Control context root and servlet mapping
• Create and use context and init parameters
• Use annotations to configure servlets

More view facilities

• Understand the four data scopes
• Understand and use EL dot and array access operators with Java Beans, arrays, and collections
• Understand and use EL implicit objects
• Create and use arithmetic expressions in EL
• Identify the need for iteration and selection in the view, and use JSTL tags to address those needs

Developing JSP pages

• Understand the origins, benefits, and weaknesses of JSPs
• Describe JSP technology, the conversion of JSPs to servlets, and the lifecycle of JSPs
• Understand JSP scripting elements, declarations and directives
• Use JSP implicit variables
• Understand and use jsp: tags

Developing JSP pages using custom tags

• Relate the JSTL to common job roles in web application development and understand the use of tags in JSP development
• Recognize correct syntax for tags
• Configure a JSP to use tags from the JSTL
• Write JSP code using several standard tags
• List capabilities of JSTL tags/span>

More Controller facilities

• Understand the servlet lifecycle
• Describe and use more advanced elements of the servlet APIs
• Create filters and use them in web applications

More options for the Model

• Understand the roles of JDBC and JPA
• Understand the many elements that make up the model
• Understand fundamentals of connecting to a database using JDBC or JPA

Asynchronous web applications

• Understand the interactions that are essential to asynchronous web pages
• Understand the role of AJAX-style client side programming
• Implement asynchronous servlets using the facilities of Java EE 6

Web application security

• Understand the role of the container in security
• Describe and implement four authentication models
• Force the use of encryption between a web application and the client browser
• Understand the role of JAAS in pluggable/extensible authentication for web applications

OCEJWSD 6 Certification Topic

Topics

• Create an SOAP web service in a servlet container
• Create a RESTful web service in a servlet container
• Create a SOAP based web service implemented by an EJB component
• Create a RESTful web service implemented by an EJB component
• Configure JavaEE security for a SOAP web service
• Create a web service client for a SOAP based web service
• Create a web service client for a RESTful web service
• Create a SOAP based web service using Java SE platform
• Create handlers for SOAP web services
• Create low-level SOAP web services
• Use MTOM and MIME in a SOAP web service
• Use WS-Addressing with a SOAP web service
• Configure Message Level security for a SOAP web service
• Apply best practices to design and implement web services

OCEJPAD 6 Certification Topic

Overview of the Java Persistence API

• Describe the basics of Object Relational Mapping (ORM)
• Define the key concepts of the Java Persistence API (entity, entity manager, and persistence unit)

Introducing the Auction Application

• Describe the auction application
• Define the domain objects of the auction application
• Describe the implementation model for the auction system

Java Persistence API Entities

• Describe the difference between objects and entities
• Describe the difference between persistent fields and properties
• Identify and use common Java Persistence API annotations, such as @Entity, @Id, @Table, and @Column

Understanding the Entity Manager

• Describe the relationship between an entity manager, a persistence context, and a persistence unit
• Describe the difference between a container-managed entity manager and an application-managed entity manager
• Describe the entity life cycle

Modeling Entity Relationships

• Examine association relationships in the data and object models
• Use relationship properties to define associations
• Implement one-to-one unidirectional associations
• Implement one-to-one bidirectional associations
• Implement many-to-one/one-to-many bidirectional associations
• Implement many-to-many bidirectional associations
• Implement many-to-many unidirectional associations
• Examine fetch and cascade mode settings

Entity Inheritance and Object-Relational Mapping

• Examine entity inheritance
• Examining object/relational inheritance hierarchy mapping strategies
• Inherit from an entity class
• Inherit using a mapped superclass
• Inherit from a non-entity class
• Examine inheritance mapping strategies
• Use an embeddable class

Persisting Enums and Collections

• Persist entities that contain enums with @Enumerated
• Persist entities that contain lists with @ElementCollection
• Persist entities that contain maps with @ElementCollection

Introduction to Querying

• Find an Entity by its primary key
• Understand basic Java Persistence API query language queries
• Understand native SQL queries
• Understand basic Criteria API queries

Using the Java Persistence API Query Language

• Examine the Java Persistence API query language
• Create and use the SELECT statement
• Create and use the UPDATE statement
• Create and use the DELETE statement

Using the Java Persistence API Criteria API

• Contrast queries that use the Criteria API with queries that use the Java Persistence query language
• Describe the metamodel object approach to querying
• Create Criteria API queries

Using the Java Persistence API in a Container

• Use the Java Persistence API from a servlet
• Use the Java Persistence API from a stateless session bean

Implementing Transactions and Locking

• Describe the transaction demarcation management
• Implement container-managed transactions (CMT)
• Interact programmatically with an ongoing CMT transaction
• Implement bean-managed transactions (BMT)
• Apply transactions to the Java Persistence API

Advanced Java Persistence API Concepts

• Specify composite primary keys
• Override mappings with the @AttributeOverride and @AssociationOverride annotations
• Understand entity listeners and callback methods

OCEEJBD 6 Certification Topic

Introduction to Java EE

• Gain an understanding of the Java Platform, Enterprise Edition (Java EE)
• Examine the Java EE application architecture
• Examine Java EE container services
• Examine the EJB component types
• Evaluate the EJB Lite Container
• Compare Java EE application development with traditional enterprise application development

Implementing Session Beans

• Examine session beans
• Identify the three types of session beans
• Choose the correct session bean type given a business constraint
• Create session beans Package and deploy session beans

Accessing Session Beans

• Understand the purpose and role of JNDI in relation to EJB components
• Configure JNDI environment properties
• Use JNDI to look up a resource
• Write code that receives a resource reference through injection
• Create a session bean client
• Create a session facade
• Use dependency injection to locate an EJB

Advanced Session Bean Concepts

• Understand the relationship between the EJB container and an EJB component
• Describe the life cycle for stateless and stateful session beans
• Implement session bean life cycle methods
• Use a session bean to perform asynchronous communication
• Have fine-grained control over packaging and deployment

Singleton Session Bean

• Understand the advantages and disadvantages of using a singleton session bean
• Create a singleton session bean
• Describe the life cycle of a singleton session bean
• Implement singleton session bean life cycle methods
• Describe singleton concurrency access
• Implement a concurrency management strategy

Developing Java EE Applications Using Messaging

• Review JMS technology
• Describe the roles of the participants in the JMS API messaging system
• Create a queue message producer
• Create a synchronous message consumer

Developing Message-Driven Beans

• Understand the short-comings of using session beans as messaging consumers
• Describe the properties and life cycle of message-driven beans
• Create a JMS message-driven bean
• Create life cycle event handlers for a JMS message-driven bean
• Configure a JMS message-driven bean

Using Timer ServicesObjectives

• Describe timer services
• Create a timer notification callback
• Process a timer notification callback Manage timer objects

Implementing Interceptor Classes and Methods

• Describe interceptors and interceptor classes
• Create a business interceptor method in the enterprise bean class
• Create an interceptor class
• Associate multiple business interceptor methods with an enterprise bean
• Include life cycle callback interceptor methods in an interceptor class

Implementing Transactions

• Describe transaction demarcation management
• Implement CMT
• Interact programmatically with an ongoing CMT transaction
• Implement BMT Apply transactions to messaging

Implementing Security

• Understand the Java EE security architecture
• Authenticate the caller Examine Java EE authorization strategies
• Use declarative authorization
• Use programmatic authorization Examine the responsibilities of the deployer

Using EJB Technology Best Practices

• Define best practices and state the benefits of using EJB technology best practices
• Select and apply known patterns to Java EE application design
• Incorporate effective exception handling into your Java EE application design

Package and Deploy EJB applications

Perform EJB Exception Handling

OCMJA 6 (1Z0-807) Certification Exam Topic

Application Design Concepts and Principles

• Identify the effects of an object-oriented approach to system design including the effect of encapsulation, inheritance, and use of interfaces.
• Identify how the Separation of Concerns principle applies to the component model of a Java EE application; including client, the web and business component containers,  and the integration and resource layers.
• Identify the correct interpretation of Separation of Concerns as it applies to the Java EE service layers, including component APIs, run-time containers, the operating system, and hardware resources.
• Identify non-functional and quality-of-service requirements that influence application design, including trade-offs in performance, availability, and serviceability.

Common Architectures

• Identify the appropriate strategy for deploying client applications to desktop and mobile platforms, the principles for designing a user interface and the benefits of applying client-tier patterns.
• Identify best practices for exception handling, logging, and business tier patterns.
• Identify design patterns that address specific challenges in the web tier, including authentication, authorization, and scaling and clustering to meet demand.
• Identify Java EE technologies, including JMS, JCA and Web Services, and design patterns that address specific challenges in enterprise integration.
• Identify the challenges in integrating enterprise resources, the Java EE technologies that address them (including JPA and JDBC), and the communication protocols that support tier-to-tier communication (including RMI, IIOP, and CORBA).

Integration and Messaging

• Identify the APIs available for a Java EE technology-based system to communicating with external resources, including JPA, JDBC, RMI, Web Services, JMS, and JCA. Outline the benefits and drawbacks of each approach.
• Describe the technologies used to integrate business components with Web Services, including XML over HTTP, JSON, SOAP and REST.
• Identify and detail the technologies used to integrate business components with external resources, including JMS and JCA.
• Identify how a Service Oriented Architecture (SOA) facilitates system integration and best practices.

Business Tier Technologies

• Identify the correct EJB technology to apply for a given scenario, including entity classes, session beans, message-driven beans, timers, interceptors, and POJOs.
• Identify benefits and drawbacks of different persistence technologies such as BMP, CMP, and JPA, including ease of development, performance, scalability, extensibility, and security.
• Identify the benefits and drawbacks of implementing Web Services in the EJB component container.
• Select the appropriate use of JPA and JPQL in a given scenario.

Web Tier Technologies

• Identify the benefits and drawbacks of using URL rewriting and cookies to manage HTTP session state.
• Identify appropriate uses for JSP and Servlet technology, and JavaServer Faces in a given Java EE application.
• Identify the benefits of using an EJB container with a web container instead of a web container alone.
• Identify the differences between client pull and server push architectures.
• Identify the benefits and drawbacks of using a browser to access asynchronous, lightweight processes on the server.

Design Patterns

• Demonstrate knowledge of Java EE design patterns including: Service Starter, Singleton, Bean Locator, Resource Binder, Dependency Injection, Payload Extractor, Context Holder, and Thread Tracker.
• Select an appropriate pattern for a given application challenge from the following: Facade, Strategy, Observer, Composite, and Abstract Factory.
• Identify a design pattern, using a description of its features, from the following:  Facade, Strategy, Observer, Composite, and Abstract Factory.
• Identify the use of the law of leaky abstractions or a specific anti-pattern in a given scenario.

Security

• Identify elements of the security model in the Java SE environment for remote clients, including Web Start, applets and the role of the SecurityManager class.
• Select appropriate locations to implement Java EE security technologies or features in a UML component and deployment diagram.
• Classify security threats to an enterprise application select measures an architect can propose to mitigate them.
• Identify techniques associated with declarative and programmatic security, including the use of annotations, deployment descriptors, and JAAS technology.
• Identify the security technologies  that apply to an application’s code, messaging and transport layers

OCMJA 6 (1Z0-865) Certification Exam Topic

Section 1: Application Design Concepts and Principles

• Document a given system architecture by creating UML diagrams for it
• Explain the main advantages of an object-oriented approach to system design. including the effect of encapsulation, inheritance, and use of interfaces on architectural characteristics.
• Describe how the principle of "separation of concerns" has been applied to the main system tiers of a Java Platform, Enterprise Edition (Java EE) application. Tiers include client (both GUI and web), web (web container), business (EJB container), integration, and resource tiers.
• Describe how the principle of "separation of concerns" has been applied to the layers of a Java EE application. Layers include application, virtual platform (component APIs), application infrastructure (containers), enterprise services (operating system and virtualization), compute and storage, and the networking infrastructure layers.

Section 2: Common Architectures

• Explain the advantages and disadvantages of two-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security.
• Explain the advantages and disadvantages of three-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security
• Explain the advantages and disadvantages of multi-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security.
• Explain the benefits and drawbacks of rich clients and browser-based clients as deployed in a typical Java EE application.
• Create a logical and physical model of a system infrastructure architecture.

Section 3: Integration and Messaging

• Explain possible approaches for communicating with an external system from a Java EE technology-based system given an outline description of those systems and describe the benefits and drawbacks of each approach.
• Explain typical uses of web services and XML over HTTP as mechanisms to integrate distinct software components.
• Explain how JCA and JMS are used to integrate distinct software components as part of an overall Java EE application.
• Given a scenario, explain the appropriate messaging strategy to satisfy the requirements

Section 4: Business Tier Technologies

• Explain and contrast uses for entity beans, entity classes, stateful and stateless session beans, and message-driven beans and understand the advantages and disadvantages of each type.
• Explain and contrast the following persistence strategies: container-managed persistence (CMP), BMP, JDO, JPA, and ORM, and using DAOs (Data Access Objects) and direct JDBC technology-based persistence under the following headings: ease of development, performance, scalability, extensibility and security.

Section 5: Web Tier Technologies

• Given a system requirements definition, explain and justify your rationale for choosing a web-centric or EJB-centric implementation to solve the requirements. Web-centric means that you are providing a solution that does not use EJBs. An EJB component-centric solution will require an application server that supports EJB components.

Section 6: Applicability of Java EE Technology 

• Given a specified business problem, design a modular solution that solves the business problem using Java EE technology. 
• Given a specified business problem, identify and prioritize the main technology risk areas that must be addressed by the technical design and architecture. 
• Explain how the Java EE platform enables service-oriented architecture (SOA) -based applications. 
• Identify how the Java SE and Java EE platforms support the internationalization and localization of applications. 
• Explain your rationale for choosing build as compared to buy for a given Java EE component 
• Explain the typical challenges associated with the design and implementation of large scale enterprise software systems and how Java EE technology addresses those challenges. 
• Explain how you would design a Java EE application to repeatedly measure critical non-functional requirements and outline a standard process with specific strategies to refactor that application to improve on the results of the measurements. 

Section 7: Patterns 

• From a list, select the most appropriate pattern for a given scenario. Patterns are limited to those documented in the book - Alur, Crupi and Malks (2003). Core J2EE Patterns: Best Practices and Design Strategies 2nd Edition and named using the names given in that book. 
• From a list, select the most appropriate pattern for a given scenario. Patterns are limited to those documented in the book - Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software and are named using the names given in that book. 
• From a list, select the benefits and drawbacks of a pattern drawn from the book - Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software. 
• From a list, select the benefits and drawbacks of a specified Core J2EE pattern drawn from the book – Alur, Crupi and Malks (2003). Core J2EE Patterns: Best Practices and Design Strategies 2nd Edition. 

Section 8: Security 

• Given an architectural system specification, select the appropriate locations for implementation of specified security features, and select suitable technologies for implementation of those features 
• Identify and classify potential threats to a system and describe how a given architecture will address the threats. 

OCMJA 6 (1Z0-865) Certification Exam Topic

Section 1: Application Design Concepts and Principles

• Document a given system architecture by creating UML diagrams for it
• Explain the main advantages of an object-oriented approach to system design. including the effect of encapsulation, inheritance, and use of interfaces on architectural characteristics.
• Describe how the principle of "separation of concerns" has been applied to the main system tiers of a Java Platform, Enterprise Edition (Java EE) application. Tiers include client (both GUI and web), web (web container), business (EJB container), integration, and resource tiers.
• Describe how the principle of "separation of concerns" has been applied to the layers of a Java EE application. Layers include application, virtual platform (component APIs), application infrastructure (containers), enterprise services (operating system and virtualization), compute and storage, and the networking infrastructure layers.

Section 2: Common Architectures

• Explain the advantages and disadvantages of two-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security.
• Explain the advantages and disadvantages of three-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security
• Explain the advantages and disadvantages of multi-tier architectures when examined under the following topics: scalability, maintainability, reliability, availability, extensibility, performance, manageability, and security.
• Explain the benefits and drawbacks of rich clients and browser-based clients as deployed in a typical Java EE application.
• Create a logical and physical model of a system infrastructure architecture.

Section 3: Integration and Messaging

• Explain possible approaches for communicating with an external system from a Java EE technology-based system given an outline description of those systems and describe the benefits and drawbacks of each approach.
• Explain typical uses of web services and XML over HTTP as mechanisms to integrate distinct software components.
• Explain how JCA and JMS are used to integrate distinct software components as part of an overall Java EE application.
• Given a scenario, explain the appropriate messaging strategy to satisfy the requirements

Section 4: Business Tier Technologies

• Explain and contrast uses for entity beans, entity classes, stateful and stateless session beans, and message-driven beans and understand the advantages and disadvantages of each type.
• Explain and contrast the following persistence strategies: container-managed persistence (CMP), BMP, JDO, JPA, and ORM, and using DAOs (Data Access Objects) and direct JDBC technology-based persistence under the following headings: ease of development, performance, scalability, extensibility and security.

Section 5: Web Tier Technologies

• Given a system requirements definition, explain and justify your rationale for choosing a web-centric or EJB-centric implementation to solve the requirements. Web-centric means that you are providing a solution that does not use EJBs. An EJB component-centric solution will require an application server that supports EJB components.

Section 6: Applicability of Java EE Technology 

• Given a specified business problem, design a modular solution that solves the business problem using Java EE technology. 
• Given a specified business problem, identify and prioritize the main technology risk areas that must be addressed by the technical design and architecture. 
• Explain how the Java EE platform enables service-oriented architecture (SOA) -based applications. 
• Identify how the Java SE and Java EE platforms support the internationalization and localization of applications. 
• Explain your rationale for choosing build as compared to buy for a given Java EE component 
• Explain the typical challenges associated with the design and implementation of large scale enterprise software systems and how Java EE technology addresses those challenges. 
• Explain how you would design a Java EE application to repeatedly measure critical non-functional requirements and outline a standard process with specific strategies to refactor that application to improve on the results of the measurements. 

Section 7: Patterns 

• From a list, select the most appropriate pattern for a given scenario. Patterns are limited to those documented in the book - Alur, Crupi and Malks (2003). Core J2EE Patterns: Best Practices and Design Strategies 2nd Edition and named using the names given in that book. 
• From a list, select the most appropriate pattern for a given scenario. Patterns are limited to those documented in the book - Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software and are named using the names given in that book. 
• From a list, select the benefits and drawbacks of a pattern drawn from the book - Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software. 
• From a list, select the benefits and drawbacks of a specified Core J2EE pattern drawn from the book – Alur, Crupi and Malks (2003). Core J2EE Patterns: Best Practices and Design Strategies 2nd Edition. 

Section 8: Security 

• Given an architectural system specification, select the appropriate locations for implementation of specified security features, and select suitable technologies for implementation of those features 
• Identify and classify potential threats to a system and describe how a given architecture will address the threats.