Syllabus for JCP

[Shah Chunky]

Can someone tell me from where can i get the syllabus (NOT Objectives) of JCP ?

What i want is the topics that r covered in JCP ?
The reason i m asking for syllabus is that, i m refferring 2 books
1) Java Certification - Simon Roberts.
2) Java - Complete Reference - Patrick Naughton.

The problem is that there r no of classess & methods from Complete reference
which r not covered in simon roberts.

For E.x. :- In Java.lang Package , there r no of classess like :- Runtime,
ClassLoader...
Other classess like :- Date, Calendar, Loacale .....

So what i wanted to know is that do i have to refer to these Extra Classess
or should i completely
Ignore it ?

So what i want is Complete Syllabus & not the Objectives.
Thanks

[Sri Enga]

This si dirctly a cut and paste from Sun's site http://suned.sun.com/USA/certification/progobj.html#Java2

Section 1 Declarations and Access Control
Write code that declares, constructs, and initializes arrays of any base type using any of the permitted forms both for
declaration and for initialization.
Declare classes, inner classes, methods, instance variables, static variables, and automatic (method local) variables
making appropriate use of all permitted modifiers (such as public, final,static, abstract, and so forth). State the significance
of each of these modifiers both singly and in combination, and state the effect of package relationships on declared items
qualified by these modifiers.
For a given class, determine if a default constructor will be created, and if so, state the prototype of that constructor.
State the legal return types for any method given the declarations of all related methods in this or parent classes.
Section 2 FLOW CONTROL AND EXCEPTION HANDLING
Write code using if and switch statements and identify legal argument types for these statements.
Write code using all forms of loops including labeled and unlabeled use of break and continue, and state the values taken
by loop control variables during and after loop execution.
Write code that makes proper use of exceptions and exception handling clauses (try, catch, finally) and declares methods
and overriding methods that throw exceptions.
Section 3 Garbage Collection
State the behavior that is guaranteed by the garbage collection system, and write code that explicitly makes objects
eligible for collection.
Section 4 Language Fundamentals
Identify correctly constructed source files, package declarations, import statements, class declarations (of all forms
including inner classes), interface declarations and implementations (for java.lang.Runnable or other interface described in
the test), method declarations (including the main method that is used to start execution of a class), variable declarations
and identifiers.
State the correspondence between index values in the argument array passed to a main method and command line
arguments. Identify all Java Programming Language keywords and correctly constructed identifiers.
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 data types and declare literal values for String and all primitive types using all permitted
formats, bases, and representations.
Section 5 Operators and assignments
Determine the result of applying any operator, including assignment operators, instanceof, and casts to operands of any
type, class, scope, or accessibility, or any combination of these.
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.
In an expression involving the operators &, |, &&, | |, and variables of known values state which operands are evaluated
and the value of the expression.
Determine the effect upon objects and primitive values of passing variables into methods and performing assignments or
other modifying operations in that method.
Section 6 Overloading, Overriding, Runtime Type, and Object Orientation
State the benefits of encapsulation in object oriented design and write code that implements tightly encapsulated classes
and the relationships "is a" and "has a".
Write code to invoke overridden or overloaded methods and parental or overloaded constructors; and describe the effect
of invoking these methods.
Write code to construct instances of any concrete class including normal top level classes, inner classes, static inner
classes, and anonymous inner classes.
Section 7 Threads
Write code to define, instantiate, and start new threads using both java.lang.Thread and java.lang.Runnable.
Recognize conditions that might prevent a thread from executing.
Write code using synchronized, wait, notify, or notifyAll, to protect against concurrent access problems and to
communicate between threads. Define the interaction between threads and between threads and object locks when
executing synchronized, wait, notify, or notifyAll.
Section 8 The java.awt PACKAGE
Write code using component, container, and LayoutManager classes of the java.awt package to present a GUI with
specified appearance and resize behavior, and distinguish the responsibilities of layout managers from those of containers.
Write code to implement listener classes and methods, and in listener methods, extract information from the event to
determine the affected component, mouse position, nature, and time of the event. State the event classname for any
specified event listener interface in the java.awt.event package.
Section 9 The java.lang PACKAGE
Write code using the following methods of the java.lang.Math class: abs, ceil, floor, max, min, random, round, sin, cos,
tan, sqrt.
Describe the significance of the immutability of String objects.
Section 10 The java.util PACKAGE
Make appropriate selection of collection classes/interfaces to suit specified behavior requirements.
Section 11 The java.io PACKAGE
Write code that uses objects of the file class to navigate a file system.
Write code that uses objects of the classes InputStreamReader and OutputStreamWriter to translate between Unicode
and either platform default or ISO 8859-1 character encoding and Distinguish between conditions under which platform
default encoding conversion should be used and conditions under which a specific conversion should be used.
Select valid constructor arguments for FilterInputStream and FilterOutputStream subclasses from a list of classes in the
java.io.package.
Write appropriate code to read, write and update files using FileInputStream, FileOutputStream, and RandomAccessFile
objects.
Describe the permanent effects on the file system of constructing and using FileInputStream, FileOutputStream, and
RandomAccessFile objects.
Return to the top

SUN CERTIFIED PROGRAMMER FOR THE JAVA PLATFORM, JDK
1.1
Note: The certification exam for the jdk 1.1 will be retired January 31, 2001. If you plan to pursue this certification you will
need to register by this date. As of February 1, 2001, Sun will only offer certification exams for the Java 2 Platform.
LANGUAGE FUNDAMENTALS.
Use standard "javadoc" format documentation to identify and use variables and methods in classes. Employ such
documentation to identify variables and methods that are inherited from a superclass.
Distinguish legal and illegal orderings of package declarations, import statements, public class declarations, and
non-public class declarations.
State the correct declaration for a main() method.
Select specific elements from the command line arguments of the main() method by using the correct array subscript
value.
Identify Java� keywords from a list of keywords and non-keywords.
Determine the value of a member variable of any type when no explicit assignment has been made to it.
Determine the value of an element of an array of any base type, when the array has been constructed but no explicit
assignment has been made to the element.
Recognize source code that fails to ensure definite initialization before use of method automatic variables and modify that
code to correct the error.
State the range of primitive data types byte, short, int, long and char.
Distinguish between legal and illegal identifiers.
Construct literal numeric values using decimal, octal and hexadecimal formats.
Construct literal String values using quoted format.
Construct a literal value of char type using Java's unicode escape format for a specified character code.

OPERATORS AND ASSIGNMENTS.
Determine the result, in terms of a bit pattern, of applying the '>>', '>>>' and '<<' operators to an int value
specified as a bit pattern.
Determine the result of the + operator applied to a combination of variables or constants of any type.
Determine the result of applying the '==' comparison operator to any two objects of any type.
Determine the result of applying the equals() method to any combination of objects of the classes
java.lang.String, java.lang.Boolean, and java.lang.Object.
In an expression involving the operators &, |, && and | |, state which operands are evaluated and dermine the resulting
value of the expression.
Determine if an assignment is permitted between any two variables of possibly different types.
Determine the effect of assignment and modification operations upon variables of any type.
Determine the effect upon objects and primitive variables of passing variables into methods and performing assignments
and other modifying operations in that method.

DECLARATIONS AND ACCESS CONTROL.
Declare variables of type "array of X" for any type X. Identify the legal positions for the "[ ]" part of an array declaration.
Construct arrays of any type.
Write code to intialize an array using loop iteration.
Write code to initialize an array using the combined declaration and initialization format.
Define clases, including member variables and member methods.
Declare classes using the modifiers public, abstract or final.
Declare vairables using the modifiers private, protected, public, static, final, native or abstract.
State the prototype of the default constructor. List the circumstances which govern creation of a default constructor.
State the consequences, in terms of the results of an assignment to a variable, of the qualifiers static or final being
applied to that variable.
State the effects on scope and accessibility of an instance variable or method of these factors:
The calling method is static
The calling method is non-static
The calling method is in the same class as the target
The calling method is in a subclass of the class containing the target
The calling method is in a class which is in the same package as the class containing the target
No special relationship exists between the class of the caller and the class of the target
The target declaration is qualified by any of private, protected, public, static, final, or
abstract.
FLOW CONTROL AND EXCEPTION HANDLING.
Write nested conditional code using the if, else and switch constructs.
Identying the legal expression types for the argument of if() and switch().
Write nested loops to iterate blocks with specific values in loop counter variables.
Demonstrate the use of both the labeled and unlabeled versions of the break and continue keywords to modify
normal loop behavior.
Demonstrate the flow of control that occurs in try, catch(), and finally constructions under conditions of normal
execution, caught exception and uncaught exception.
Write code that correctly uses the throws clause in a method declaration where that method contains code that might
throw exceptions.
State what exceptions may be legitimately thrown from an overriding method in a subclass, based on the declaration of
the overidden supperclass method.
Write code to create and throw a specified exception.

OVERLOADING, OVERRIDING, RUNTIME TYPE, AND OBJECT ORIENTATION.
Write classes that implement object oriented relationships specified using the clauses 'is a' and 'has a'.
Determine at run time if an object is an instance of a specified class or some subclass of that class using the
instanceof operator.
Distinguish between overloaded and overridden methods.
State the legal return types for an overloading method given the original method declaration.
State legal return types for an overriding method given the original method declaration.
Describe the effect of invoking overridden method in base and derived classes.
Write code for any overriden method that invokes the parental method, using super.
Write constructor bodies using this() and super() to access overloaded or parent-class constructors.
Define a non-static inner class either in a class or method scope.
Define, in method scope, an anonymous inner clas that implements a specified interface.
Write code in a non-static method of the outer class to construct an instance of the inner class.
Write code to construct an instance on an inner class where either no this object exists, or the current this object is
not an instance of the outer class.
State which variables and methods in enclosing scopes are accessible from methods of the inner class.

GARBAGE COLLECTION.
Distinguish between guaranteed and non-guaranteed behavior of the garbage collection and finalization mechanisms.
Identify the earliest point in a method at which the object referred to by a local variable is definitely eligibile to be garbage
collected, in the absence of compiler optimization.

THREADS.
Write code to create a new thread of execution, using both the Runnable interface and the Thread class.
State the requirements for a concrete class that is declared to implement the java.lang.Runnable interface.
Name the method that provides the starting point for execution of a thread.
Write code to start the execution of a thread.
State and recognize conditions that might prevent a thread from executing.
Write code to use the synchronized keyword to require a thread of execution to obtain an object lock prior to
proceeding.
Define the behavior of a thread which invokes the wait() method of an object and the effect of that method on the
object lock flag.
Define the behavior of a thread which invokes the notify() or notifyAll() methods of an object and the effect of
the method on the object lock flag.
Define the interaction between threads executing the wait(), notify(), or notifyAll() methods, and the object
lock flag.

THE java.lang PACKAGE.
Write code to demonstrate the use of methods of the java.lang.Math class in an expression: abs(), ceil(),
floor(), max(), min(), random(), round(), sin(), cos(), tan(), sqrt().
Write code to demonstrate the use of the following methods of the java.lang.String class: length(),
toUpperCase(), toLowerCase(), equals(), equalsIgnoreCase(), charAT(), concat(),
indexOf(), lastIndexOf(), substring(), toString(), trim().
State all operators that are legal in String expressions.
Recognize the implications of the immutability rule of the String class.

THE java.awt PACKAGE - COMPONENTS AND FACILITIES.
Write code to demonstrate the use of the following methods of the java.awt.Component class:
setVisible(boolean), setEnabled(boolean), getSize(), setForeground() and
setBackground().
Construct a java.awt.TextArea or java.awt.List that prefers to display a specified number of columns.
Construct a java.awt.TextArea or java.awt.TextField that prefers to display a specified number of columns.
State the significance of a "column" where one of the text components is using a proportional (variable) pitch font or a fized
pitch font.
Identify the following as methods of the Graphics class: drawString(), drawLine(), drawRect(),
drawImage(), drawPolygon(), drawArc(), fillRect(), fillPolygon(), fillArc().
Write code to obtain a suitable Graphics object from an Image.
Distinguish between situations that require the use of an Image object from those that require the use of a Graphics
object.

THE java.awt PACKAGE - LAYOUT.
Demonstrate the use of the methods add(Component) and add(String, Component) of the
java.awt.Container class and recognize which classes in the java.awt and java.awt packages are valid
arguments to these methods.
Distinguish between AWT classes which are directly responsible for determining component layout and those which are
responsible for implementing that layout.
Write code to change the layout scheme associated with an AWT container.
User BorderLayout, FlowLayout, and GridLayout to achieve required dynamic resizing behavior of a
component.

THE java.awt PACKAGE - EVENT HANDLING.
Write a non-abstract class that implements a specified Listener interface, given the interface definition.
Select methods from the classes in the java.awt.event package that identify the affected component, mouse
position, nature, and time of the event.
Demonstrate correct uses of the Listener methods in the Component, TextArea, and TextField classes.
For any listener in the java.awt.event package, state the argument type and return type of a specified listener
method, given the name of the interface that declares the method and the name of the method itself.

THE java.awt PACKAGE - PAINTING.
Identify the sequence of Component methods involved in redrawing areas of an AWT GUI under exposure and
programmed redraw conditions.
Distinguish betwen methods invoked by the user thread and those normally invoked by an AWT thread.
Write code to implement the paint() method of a java.awt.Component.

THE java.io PACKAGE.
Write code that uses objects of the file class to navigate a file system.
Write code that uses objects of the classes InputStreamReader and OutputStreamWriter to translate between Unicode
and either platform default or ISO 8859-1 character encodings.
Distinguish between conditions under which platform default encoding conversion should be used and conditions under
which a specific conversion should be used.
Select valid constructor arguments for FilterInputStream and FilterOutputStream subclasses from a list of classes in the
java.io.package.
Write appropriate code to read, write and update files using FileInputStream, FileOutputStream, and RandomAccessFile
objects.
Describe the permanent effects on the file system of constructing and using FileInputStream, FileOutputStream, and
RandomAccessFile objects.
Return to the top

Return to main Java page
To contact a Sun Educational Services Representative:
Address: UBRM12-175, 500 Eldorado Blvd., Broomfield, CO 80021
Phone: [phone] or fax [phone].
Certification: Java Technology | Solaris System Administration | Resellers |
Certification News | FAQs
Copyright 1994-2001 Sun Microsystems, Inc., 901 San Antonio Road, Palo Alto, CA 94303

[Shah Chunky]

Hello...
I needed Syllabus & not Objectives...
I m confused about what classess & packages should i study & which of them should i ignore
For E.g. Should i study Date, Calender, Class Loader, Class & so on...
Thanks

[David Brafford]

The objectives in the post above are the 1.1 objectives - not
the Java 2 objectives ( they are different ).
To answer your question, study the classes and packages
mentioned in the objectives. The exam is very focused on the
objectives. It is a language focused exam, not an exam to
test you on all of the api's for J2SE.
So rather than specific classes with specific constructor
signatures, you will be tested on understanding what a
constructor is, how it can be overloaded, what is the calling
sequence in an inheritance hierarchy, ...
Some specific classes you will see are related to
Garbage Collection ( System.gc() ), java.lang.String,
java.lang.Boolean, java.lang.Object, java.lang.Thread,
java.lang.Math, the layout manager classes, the java.io
classes ( File, Streams, Readers, ... ) and the
java.util Collection Classes.
The focus is not on specific classes ( with the exception of
io, Collection, LayoutManager, and some java.lang classes ) -
the focus is on how the language works, how to read /
interpret Java code, and understanding the language
constructs. Follow the objectives.
---------------------------
JCertify 4.0
The best investment in your career you will make all year http://www.enterprisedeveloper.com/jcertify

[Mapraputa Is]

Shah, I suspect there is no such thing as SCJP syllabus in the world, unfortunately At least, I have never seen any valid document, stating �This class will be on exam and that class will be not�, except Sun objectives, of course. However, there is such thing, as previous taker experience You can read �Programmer Certification results� forum, where folk report what kind of questions did they have (not discussing the questions themselves, of course). For IO section you can read our FAQ.
For collection, here is my old post:
Collections (the java.util package). You should know the following classes and interfaces:
Interfaces
Collection
List
Set
Map
SortedSet
SortedMap
Classes
HashSet
TreeSet
ArrayList
LinkedList
Vector
Stack
HashMap
TreeMap
Hashtable
You should know main purpose of each interface : which can be used to maintain unique elements, or non-unique elements, or map keys and values... which allow null elements, provide sorted access, unordered access, positional indexing , synchronized access. Also you should know which interface each class implements.
Java.lang Package:
Never heart that Runtime, ClassLoader, Date, Calendar, or Locale were asked on the exam.
I remember a question on Math class on my exam, though.