As promised here are the testing objectives. Good luck, this is a great exam!
Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0
Section 1: Declarations, Initialization and Scoping
1.1Develop 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).
1.2Develop 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.
1.3Develop code that declares, initializes, and uses primitives, arrays, enums, and objects as static, instance, and local variables. Also, use legal identifiers for variable names.
1.4Develop 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.
1.5Given 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.
1.6Given 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
2.1Develop code that implements an if or switch statement; and identify legal argument types for these statements.
2.2Develop 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.
2.3Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions.
2.4Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions.
2.5Recognize 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.
3.1Develop 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.
3.4Use 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.
3.5Write 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.
4.2Recognize the states in which a thread can exist, and identify ways in which a thread can transition from one state to another.
4.3Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.
4.4Given a scenario, write code that makes appropriate use of wait, notify, or notifyAll.
Section 5: OO Concepts
5.1Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.
5.2Given 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.
5.3Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.
5.4Given a scenario, develop code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass, overridden, or overloaded constructors.
5.5Develop code that implements "is-a" and/or "has-a" relationships.
Section 6: Collections / Generics
6.1Given 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.
6.2Distinguish between correct and incorrect overrides of corresponding hashCode and equals methods, and explain the difference between == and the equals method.
6.3Write 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.
6.4Develop 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.
6.5Use 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
7.1Given 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.
7.2Given an example of a class and a command-line, determine the expected runtime behavior.
7.3Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters.
7.4Given a code example, recognize the point at which an object becomes eligible for garbage collection, and determine what is and is not guaranteed by the garbage collection system. Recognize the behaviors of System.gc and finalization.
7.5Given 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.
7.6Write 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.
Are you a developer who is experienced in the basic syntax and structure of the Java programming language and in creating applications using the Java 2 Platform, Standard Edition (J2SE), especially the new J2SE Development Kit 5.0 and the J2SE Runtime Environment 5.0? If so, we invite you to help set Java technology industry standards and have your skills certified at the same time by taking the beta version of the revised Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 exam.
Beta Dates: Janaury 13 � February 13, 2005 Registration Start Date: January 3, 2005
From January 13 through February 13, 2005, a beta version of the new Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 exam will be available at all worldwide Prometric authorized testing centers at a reduced cost of $49 (US). Exam registration begins on Janaury 3, 2005.
Candidates may only schedule and take the exam once during the beta test period.
Beta Cost: $49 US Exam Number: 311-055 Passing the exam provides you with full Sun certification status, and you will receive a "certification kit".
Candidates will have four to five (4-5) hours to complete 138 questions. The time allotted should give you time to respond to all questions and provide your valuable comments while taking the exam.
Beta exam is offered at all Worldwide Prometric Centers! ---------------------------------------------- Beta Exam Sign-up Registration
Unlike other SUN Microsystems certification exams, this exam does NOT require a voucher.
To register for the SUN Microsystems "Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0" Beta exam, you may register online at www.2test.com, and follow the prompts.
Originally posted by Mike Saloni: If I read those objectives correctly I guess no more hexadecimal, octal stuff. No more shift operators like << and >>. File system API is back, serialization is added along with new features of tiger.
Tomas, you might find that some of those objectives are inherent in the current objectives. Now the last one I can definitely say is not on the exam, that is memorization of methods, which this exam does not test on. Now knowing that those methods exist and what you would use them for, might be on the test.
One of the main goals of this new exam is to create a test that is "performance based" rather than "knowledge based" (Sun's terms). Generally what this means is that a "knowledge based" question tends towards memorization of details, and a "performance based" question tends towards more real world activities like actually writing code. We are constrained in the types of questions we can create because the test has to be available world-wide, and therefore run on at all of the testing centers in the world
So a knowledge based question might be something like:
"How many arguments does the doubleValue method take?"
A performance based question might present you with a chunk of code, maybe 10-20 lines of code, and ask you how to make the doubleValue method work correctly in the code.
We have to make judgement calls all the time about what's trivia and what's not. Sometimes it's easy, we decided that you really have to know that "start" and "run" methods are keys to concurrency (I hope I didn't give anything away!)
Sometimes it's harder, for instance objective 3.1 talks about using primitvive wrapper classes... unlike the old objective it doesn't list the exact methods you need to understand, but I'd say you better be comfortable doing basic conversions!
So there are places where the new objectives are quite explicit, like which I/O classes will be tested, and there are places where the objectives are a bit vague... where the objectives are vague, we're not being tricky, the default approach you should take is: "What do I need to know to handle the common situations associated with this objective?"
In general I'd say that the new exam is a LOT less trivia oriented or tricky than the old exam. It's not perfectly free from trivia, and there is probably still a bit of tricky code, but IMHO it's much more real-world oriented than the last exam.
Spot false dilemmas now, ask me how!
(If you're not on the edge, you're taking up too much room.)
Joined: Jan 30, 2000
we decided that you really have to know that "start" and "run" methods are keys to concurrency (I hope I didn't give anything away!)
Thanks a lot, Bert. Now Kathy and I have to rewrite all our questions. Hmmm, maybe java.util.concurrent will be on the exam...
Originally posted by Pradeep Bhat: Did I miss Anything else?
Probably best NOT to take the approach of looking for specific changes in the objectives. Instead, look at each objective from a fresh perspective. For example, think about objective 6.1. There's now a Queue interface in java.util...and it might (!!) be covered on the exam.
Co-Author of <a href="http://www.oreilly.com/catalog/jswing2" target="_blank" rel="nofollow">Java Swing</a><br />Co-Creator of <a href="http://www.sun.com/training/catalog/courses/CX-310-055.xml" target="_blank" rel="nofollow">SCJP 5.0</a> and <a href="http://www.sun.com/training/certification/java/associate_beta.xml" target="_blank" rel="nofollow">SCJA</a> exams