This certification is for programmers experienced using the Java programming language. Achieving this certification provides clear evidence that a programmer understands the basic syntax and structure of the Java programming language and can create Java technology applications that run on server and desktop systems using J2SE 5.0. This course covers training for certification exam 1Z0-851, same as Version SE 6.

To achieve this certification, candidates must successfully complete one exam. It is not necessary to be a Certified Java Associate prior to taking this exam.
Formerly Sun Certified Java Programmer (SCJP) Exam CX-310-055 before Oracle's acquisition of SUN. The new exam is Oracle's 1Z0-853
Java  OCP (Formerly SCJP Exam ) Certification Course Includes

 Full Multi-media interactive Online Tutorials e
 Hands-on Labs - a perfectly simulated, real-world environment to test skills without risk. 
 Practice Exams - Simulated certification exams designed to validate exam readiness.
 Printable Transcripts of all lessons for easy review
 Online Instructor  Mentoring 24 7
Mentoring provides personal access to our talented group of expert instructors in a unique collaborative environment. Students can correspond  with the Instructor Team 24x7.

Training Tutorials for Exam 1Z0-853, covers the following information:
Getting Started

• Use of objects, classes, inheritance, and polymorphism in Java.
• Code involved in declaring a main method and identify the command lines used to compile and run an application.
• Create, compile, and execute a Java application.
• Appropriate lexical element to use for a given scenario.
• Code involved in declaring primitive variables and defining literal values.
• Code used to declare and initialize Java string literals and arrays.
• Declare and initialize Java data types, strings, and arrays in a given scenario

Operators and Flow Control in Java

• Build expressions and determine the value of an expression variable for a given code sample.
• Evaluate an expression, and evaluate a compound expression using operator precedence.
• Identify valid primitive type conversions and casting operations.
• Create expressions and compare integers in a specific application.
• Write if and switch statements for a given scenario.
• Specify the code to use while and do-while loop constructs to perform iteration, and identify the functions of the break and continue keywords.
• Standard and enhanced for loop constructs to perform iteration over arrays and multi-dimensional arrays.
• Selection statements and loop constructs for a given scenario.

Creating Classes in Java

• Encapsulation affects a class, pass messages between objects.
• Declare a specific class and a constructor for a class.
• Method and implement a variable argument list in a method for a given scenario, and declare a variable in a class based on that variable's scope.
• Write an appropriate class and method declaration, and pass variable arguments to a method.
• Create an object, call an object's method, and assign the result of the method to an existing variable for a given scenario.
• Iterate over, and switch on type safe enums 
• Enumeration and object, iterate over the enumeration's values, and call one of the object's methods.
• Create a package in a given scenario, and import classes, static methods, and variables into a source file.
• Appropriate level of access to apply to classes, variables, methods, and constructors for a given scenario.
• Create and import a specific Java package, import static methods and variables into a source file, and identify the access levels of the class members in that package.

Working with Classes

• Inheritance and polymorphism are implemented
• Code required to create a subclass for a given scenario.
• Inheritance class structure for a given scenario, and extend a superclass.
• Specify the code required to create abstract classes and methods for a given scenario, and recognize the code required to create a class that implements an interface.
• Declare, access, and initialize Java instance and class members in a given scenario.
• Final modifier to declare variables, methods, and classes for a given scenario.
• Declare and initialize variables, and declare and call methods in an enterprise scenario.
• Garbage collection is implemented, and the function of the finalize method.
• Instantiate inner classes for a given scenario.

Generics and Annotations

• advantages and disadvantages of using generics in code, and outline how generics are used to make raw code type safe
• Generic, type safe version of a given piece of legacy code.
• Code involved in building a generic class for a given scenario.
• Required code to declare a generic subclass, test generic object types, and cast a generic object.
• Convert a given application's legacy code into a generic type safe equivalent.
• Retention policies and built-in annotations with their corresponding features and functionality.
• Code to annotate an overriding method, a deprecated method, and to suppress compiler warnings.
• Declare custom and meta-annotations.
• Inspect and represent a custom annotation, write an annotation processor, and run the processor against a set of annotations.
• Create and implement a custom annotation for a given scenario.

Reference Types and Threading

• Valid reference type conversions between classes, interfaces, and arrays.
• Casting operations between classes, interfaces, and arrays for a given scenario.
• Methods of the Object class and Comparable interface to clone and compare Java objects for a given scenario.
• Clone, compare, and cast Java reference types.
• Thread class and Runnable interface to create a multi-threaded application for a given scenario.
• Code involved in changing a thread's state and priority.
• Synchronize thread access to code in a multi-threaded application for a given scenario.
• Create a multi-threaded program in a given scenario.

Exception Handling and Assertions

• Code required to use try, catch, and finally blocks to handle exceptions for a given scenario.
• Appropriate method of the Throwable class to use in a given piece of code, and associate runtime and checked exceptions with the events that throw them.
• Handle exceptions in calling methods, create and throw exceptions explicitly, and use exception chaining to set the cause of a thrown exception.
• Create an exception subclass for a given code sample, and implement exception handlers on a thread basis.
• Create, throw, catch, and handle exceptions for a given scenario.
• Code used to create a Java assertion statement for a given scenario, and specify the commands and flags used to create and compile assertions.
• Create, enable, and compile assertions 

Utilities

• Methods of the Math class to determine the value of a variable in a given piece of code, and associate the new methods of the Math class with their corresponding functions.
• Utility methods of the wrapper classes to compare wrapper objects, transform values into strings, and extract values from wrapper objects.
• New methods of the Integer and Long wrapper classes to manipulate bits for a given scenario, and specify the code required to perform automatic conversions between primitive and wrapper types
• Code required to test the equality of strings, carry out pattern matching in regular expressions, and modify strings and string buffers for a given scenario.
• String class to manipulate strings and define regular expressions.
• Code required to modify system resources for a given scenario.
• Code used to access, modify, and launch system properties, and create operating system processes for a given scenario.
• Access and edit system environmental variables, launch system processes, and retrieve system timing information.
• Manipulate and traverse the elements of a collection for a given scenario.
• Collection class to modify, sort, and search a collection in a given scenario.
• Iterators to traverse the elements of a list in a given code sample, and sort and modify the list elements using the Collections class.
• Collection classes, interfaces, and method implementation to meet the requirements of a given scenario.

I/O

• Classes of the.io package to access files, and read and write data for a given scenario
• Java.nio package to modify buffers, retrieve a channel, and transfer data between channels
• Write code to read and copy files
• Scanner to retrieve input from a specific source
• Printf method and the Formatter class to format output for a given scenario
• Format specific output, and use the Scanner class to retrieve input

Basic GUI Development in Java

• Components of the Swing architecture with their corresponding functionality, and identify the guidelines associated with using Swing's components
• Create and use the containers required for a Swing application in a given scenario
• Set up and display Swing container objects in a specific Swing application and launch that application.
• Create labels, text, buttons, and menus for a given application
• Implement an event handler for a specific event in a given scenario
• Using Swing's layout manager classes to display and arrange components in an application
• Guidelines associated with painting in Swing and AWT.
• Handling events for Swing components and displaying these components in a GUI application.

Java Applets

• Create and initialize an applet for a given scenario.
• Embed an applet in a web page using the APPLET tag, customize an applet in a web page using the PARAM tag, and con
• ert applet tags using the HTML converter tool.
• Create and deploy an applet.
• Associate the features of the applet security model with the functions they provide and identify the restrictions that it imposes on applets.
• Play sound files and display images, documents, and status information in a given applet.
• Support applet persistence, locate applets for communication, and access JApplet panes for a given scenario.
• Locate applets for communication, add an audio clip to an applet, and display status information in an applet.