java Certification OverviewS2C Home « java Certification Overview
This section of the site covers the requirements for the Java Standard Edition 6 Programmer Certified Professional Exam (IZO-851) which when passed gives the Oracle Certified Professional, Java SE 6 Programmer certification.
We will cover the seven topic areas of the exam as described at the Oracle Website and categorized by the certification lessons listed and summarized below:
1: Declarations, Initialization and Scoping
In this lesson we look at all types of class declaration and extension and how to use interfaces and the package and import statements. We examine the declaration, initialization and usage of primitives, arrays, enums, and objects as static, instance, local variables and their respective scopes. After this we cover correct use of overriding and overloading of methods as well as identifying legal return values for methods. we investigate constructors to determine if a default constructor will be created, and if so, determine the behaviour of that constructor. We finish of this lesson by studying class instantiation and how to instantiate nested and non-nested classes.
2: Flow Control
In this lesson we look at the different syntax we can use to affect the flow of logic through our programs. We start by looking at code to implement if
and switch
statements whilst identifying legal argument types for them. We then investigate the different types of loops available in
java and the iterators and their usage within a loop. We will also look at how we can break from a loop, continue from within a loop and label a loop to continue execution from. We continue our study of flow
control by looking at assertions and when, and when not, they should be used. We finish our certification lessons on flow control by looking at exceptions, handling exceptions and how to declare methods and
overriding methods that throw exceptions. We also need to understand what happens to our code when an error or any type of exception occurs in a code fragment and what happens when particular exceptions occur.
3: API Contents
We start this lesson by looking at code that uses the primitive wrapper classes and/or autoboxing and unboxing. We then look at the differences between the String, StringBuilder, and StringBuffer classes. After this
we investigate how we can use classes with the java.io package
to read from files, write to files and use the BufferedReader
, BufferedWriter
, File
, FileReader
,
FileWriter
and PrintWriter
sometimes in unison to create a software solution. We then use classes from the java.text
package to correctly format or parse dates, numbers, and
currency values for a specific locale including usage of the appropriate methods to use the default locale or a specific locale. We finish the section by looking at regular expressions and examine how to format and tokenize our data using java.
4: Concurrency
This lesson is all about concurrency and we start it by looking at thread definition, instantiation and execution using the java.lang.Thread
and java.lang.Runnable
classes. After this we investigate the different
states in which a thread can exist, and identify ways in which a thread can transition from one state to another. We finish the section by examining Java's locking mechanisms at the class and object level and
how we can synchronize methods and blocks of code to protect static or instance variables from concurrent access problems.
5: OO Concepts
We start this lesson by looking at encapsulation, its advantages and how to achieve it within our code. We then look at the design principles of coupling and cohesion and describe the benefits of loose coupling and high cohesion. We then explain polymorphism and how we use it in the Java language before looking at object reference casting and determine when casting will be necessary whilst recognizing compiler vs. runtime errors, related to it. After this we examine the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods. We then look at code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass or overloaded constructors. We finish the lesson by investigating code that implements "is-a" and/or "has-a" relationships.
6: Collections/Generics
We start this lesson by looking at the various types of collections and their corresponding interfaces and which type of collection is suitable for specific types of data. We then look at usage of
the Comparable interface. After this we look at the equals()
method of the Object
class which only ever returns true
when the reference variables refer to the same object which
isn't helpful when we want our collections sorted and stored dependent upon fields in the collection. So in this lesson we look at correct and incorrect overrides of corresponding equals()
and
hashCode()
methods and explain the difference between ==
and the equals()
method. Generics were introduced with java and in this lesson we look at the reasons for doing
this. We then look at usage of type parameters in class/interface declarations, instance variables, method arguments, and return types. We finish the lesson by looking at generic methods as well as methods that
make use of wildcard types. We finish the section by looking at array and list manipulation using the java.util
package, usage of the java.util.Comparator
and java.lang.Comparable
interfaces for sorting collections and the effect of natural ordering of primitive wrapper classes and java.lang.String
on sorting.
7: Fundamentals
We begin this lesson by looking at access modifiers and also investigate the package and import statements. We then look at the javac
command we use to compile our Java programs and
the java
command to run our programs. We finish the lesson with a look at JAR files and how to use them. After this we look at method parameters that are passed into methods as reference variables
and primitive variables and the effects that modification within the methods has on the variable type in question. We then examine the point at which an object becomes eligible for garbage collection, and determine
what is and is not guaranteed by the garbage collection system and how the behaviors of System.gc
and finalization impact this. In our final part of the lesson we look at the various operators that are
available in Java and how to use them.