Bert,
You made this statement, "This (SCJA) exam overlaps VERY LITTLE with the new OCA exam. Study materials for the old SCJA / OCAJ, WILL NOT prepare you for the new OCA exam."
Below is a quick-look of the overlapping objectives between the Sun Certified Java Associate (CX-310-019) and the Java SE 7 Programmer I (IZO-803) exams, showing that SCJA material will surely assist in studying for *many* of the objectives:
=========================================================================
SCJA: 1.2 Describe, compare, and contrast concrete classes, abstract classes, and interfaces, and how inheritance applies to them.
OCAJP7: 7.1 Implement inheritance
=========================================================================
SCJA: 1.4 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.
OCAJP7: 6.7 Apply encapsulation principles to a class
OCAJP7: 2.3 Read or write to object fields
=========================================================================
SCJA: 1.5 Describe
polymorphism as it applies to classes and interfaces, and describe and apply the "program to an interface" principle.
OCAJP7: 7.2 Develop code that demonstrates the use of polymorphism
=========================================================================
SCJA: 3.1 Develop code that uses primitives, enumeration types, and object references, and recognize literals of these types.
OCAJP7: 2.2 Differentiate between object reference variables and primitive variables
OCAJP7: 7.3 Differentiate between the type of a reference and the type of an object
OCAJP7: 6.8 Determine the effect upon object references and primitive values when they are passed into methods that change the values
=========================================================================
SCJA: 3.2 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.
OCAJP7: 7.6 Use abstract classes and interfaces
OCAJP7: 6.6 Apply access modifiers
=========================================================================
SCJA: 3.3 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.
OCAJP7: 4.1 Declare, instantiate, initialize and use a one-dimensional array
OCAJP7: 4.2 Declare, instantiate, initialize and use multi-dimensional array
=========================================================================
SCJA: 3.4 Develop code that uses polymorphism for both classes and interfaces, and recognize code that uses the "program to an interface" principle.
OCAJP7: 7.2 Develop code that demonstrates the use of polymorphism
=========================================================================
SCJA: 4.1 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.
OCAJP7: 5.1 Create and use while loops
OCAJP7: 5.2 Create and use for loops including the enhanced for loop
OCAJP7: 5.3 Create and use do/while loops
OCAJP7: 5.4 Compare loop constructs
OCAJP7: 5.5 Use break and continue
=========================================================================
SCJA: 4.2 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.
OCAJP7: 1.1 Define the scope of variables
OCAJP7: 2.1 Declare and initialize variables
OCAJP7: 6.1 Create methods with arguments and return values
=========================================================================
SCJA: 4.3 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.
OCAJP7: 3.5 Use a switch statement
OCAJP7: 3.4 Create if and if/else constructs
=========================================================================
SCJA: 4.4 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.
OCAJP7: 2.5 Call methods on objects
=========================================================================
SCJA: 4.5 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.
OCAJP7: 3.1 Use Java operators
=========================================================================
SCJA: 4.6 Develop code that uses the concatenation operator (+), and the following methods from class
String: charAt, indexOf, trim, substring, replace, length, startsWith, and endsWith.
OCAJP7: 2.7 Create and manipulate strings
=========================================================================
SCJA: 5.1 Describe the purpose of packages in the Java language, and recognize the proper use of import and package statements.
OCAJP7: 1.4 Import other Java packages to make them accessible in your code
=========================================================================
The OCAJP7 (Oracle Certified Associate, Java SE 7 Programmer (OCAJP7) certification) does have extended coverage, especially in the case of constructors and exception handling.
Here are some of the new requirements in the OCAJP7 that the SCJA fell short on:
2.4 Explain an object's lifecycle
2.6 Manipulate data using the StringBuilder class and its methods
3.3
Test equality between strings and other objects using == and equals ()
3.2 Use parentheses to override operator precedence
4.3 Declare and use an ArrayList
6.2 Apply the static keyword to methods and fields
6.3 Create an overloaded method
6.4 Differentiate between default and user-defined constructors
6.5 Create and overload constructors
7.4 Determine when casting is necessary
7.5 Use super and this to access objects and constructors
8.1 Differentiate among checked exceptions, RuntimeExceptions and Errors
8.2 Create a try-catch block and determine how exceptions alter normal program flow
8.3 Describe what exceptions are used for in Java
8.4 Invoke a method that throws an exception
8.5 Recognize common exception classes and categories
I hope this information assists our fellow certification candidates.
Sincerely,
Robert Liguori
1
