Programmer 5.0 Beta "Testing Objectives"

Hi Everyone,

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.

2.6Recognize 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

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.2Given a scenario involving navigating file systems, reading from files, or writing to files, develop the correct solution using the following classes (sometimes in combination), from java.io: BufferedReader,BufferedWriter, File, FileReader, FileWriter and PrintWriter.

3.3Develop code that serializes and/or de-serializes objects using the following APIs from java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and Serializable.

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.

Section 4: Concurrency

4.1Write code to define, instantiate, and start new threads using both java.lang.Thread and java.lang.Runnable.

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.

-------------------------------------------------------
posted December 15, 2004 02:01 PM Programmer 5.0 Beta Certification Exam

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.

Or, you may register by phone, by calling your regional Prometric registration office, listed at www.prometric.com/ContactUs/TestTakers.

Asia/Australia 61-2-96405830
Europe 31-320-239-800
Japan 81-0120-107737
Latin America* Contact your local Prometric testing center, listed at www.2test.com
USA/Canada 1-800-795-3926

Sun Employees ONLY: Please send an email to register4beta@central.sun.com with your full name, employee number, and Sun email.

Note: It is strongly recommended that beta test takers have 6-12 months Programmer experience.

Thank you.

PS If you have any problems registering, please send an email to sunbeta@thomson.com

4.3Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.

Does this include java 5 Lock class?

No, the exam doesn't use anything from java.util.concurrent or its subpackages.

Hi Jim,

Just wanted to whether the below listed features are the only ones from java 5 for the exam

1.Static imports
2.Enums and switch statement for enum
4. Enhanced for loop
5. (Auto) boxing
6. Vargs
7. co-variant return types
8. Generics

Did I miss Anything else?
:roll: Thanks

Originally posted by Pradeep Bhat:

Did I miss Anything else?

* Section 3.1 *
StringBuilder

* Section 3.5 *
Formatter
Scanner
java.io.PrintWriter.format/printf methods

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.

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.

You are correct, no more bit manipulation.

Mark

No shift!

Or something like that...

Originally posted by Jim Yingst:
No shift!

Or something like that...

That is good. I used the shift operators a lot when I was doing C programming.

This might seem obvious, but can we assume that any SCJP 1.4 objectives not mentioned above are no longer required - e.g. the following are not on the exam...

Identify all Java programming language keywords.

State the effect of using a variable or array element of any kind when no explicit assignment has been made to it.

State the range of all primitive formats, data types and declare literal values for String and all primitive types using all permitted formats bases and representations.

Determine the result of applying the boolean equals (Object) method to objects of any combination of the classes java.lang.String, java.lang.Boolean and java.lang.Object.

Write code using the following methods of the wrapper classes (e.g., Integer, Double, etc.):

* doubleValue
* floatValue
* intValue
* longValue
* parseXxx
* getXxx
* toString
* toHexString

[ December 22, 2004: Message edited by: Tomas Conway ]

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.

Mark

Let's expand on Mark's answer a little bit:

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.

HTH,

Bert

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.

Originally posted by Jim Yingst:
Thanks a lot, Bert. Now Kathy and I have to rewrite all our questions. Hmmm, maybe java.util.concurrent will be on the exam...

Executor.execute(Runnable r) here we come.

Mark

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

This is about the question format. Besides multiple choice questions with number of correct answers to choose indicated, are there any "drag-and-drop" and "fill-in-short-answer" questions?

Will there be a lot of questions with these two options given "Compilation fails" and "An exception is thrown"?

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.

Could you please show us a few full sample questions of how a performance based questions are being presented on the exam?

[ December 22, 2004: Message edited by: Joyce Lee ]

lots o' drag 'n drop... no fill in the blanks

expect some mocks after the new year...

Thanks Bert.

lots o' drag 'n drop

I dont really like this type of questions because we cannot review them.

How many % they contribute in the 138 question set?

Nick

Originally posted by Nicholas Cheung:

I dont really like this type of questions because we cannot review them.

How many % they contribute in the 138 question set?

Nick

I'd probably say close to 30-40% Drag and Drop. that's probably a high guess.

A good way to be able to review is to write down what you chose before closing the drop-down screen.

Mark

Mark,

A good way to be able to review is to write down what you chose before closing the drop-down screen.

But if there are 30-40%, which is equals to around 55 (out of 138) or 66 (out of 166) questions!!! I wonder whether I will have enough time to check for them one by one.

Nick

Originally posted by Nicholas Cheung:
Mark,

But if there are 30-40%, which is equals to around 55 (out of 138) or 66 (out of 166) questions!!! I wonder whether I will have enough time to check for them one by one.

Nick

Exactly, so then you just have to get them right the first time.

Just Kidding. Like I said I think 30% might be a little more than actual. I think you will feel confident with certain ones and not mark them, so you won't have to check them all.

Mark

note to candidates: check out the thread "Tiger objectives - take 2" for updated objectives!