1 Vergelijking Sun certificering voor Java en het

Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) Vergelijking Sun certificering voor Java en het CPP Gecertificeerd Javaprogrammeur van de Open Universiteit Nederland Inleiding Op het gebied van scholing van de taal Java zijn er vele aanbieders op de markt. De certificering van het resultaat van die scholing is van groot belang. In de praktijk speelt de certificering van Sun op het gebied van Java een dominante rol. Omdat ook de Open Universiteit Nederland (OU) scholing en certificering op het gebied van Java verzorgt, onder andere in de vorm van het CPP Gecertificeerd Javaprogrammeur, achtte de OU het zinvol een vergelijking te trekken tussen de CPP‐opleiding en de certificering door Sun. De paragraaf Afbakening beschrijft welke Sun‐examens vergeleken gaan worden met de exameneisen van het CPP‐Java van de OU. De paragraaf Generieke verschillen in de vorm van de examinering beschrijft de verschillen in de vorm van de examinering bij Sun en de vorm van toetsing bij het CPP‐Java. Deze vergelijking is in 2003 voor het eerst uitgevoerd. Sindsdien is er veel veranderd, reden om de vergelijking nu in 2009 nog eens te herhalen. Dit document is gebaseerd op de stand van zaken op 1‐11‐
2009. In de loop van 2010 zal de cursus Distributed Computing als onderdeel van het CPP‐Java vervangen worden door de cursus Web Applicaties: the server side. Hierdoor zal op wat details deze vergelijking wat moeten worden aangepast Afbakening Sun kent een aantal examens die met elkaar samenhangen zoals figuur 1 toont. FIGUUR 1 De verschillende examens van SUN In de vergelijking betrekken we de volgende SUN‐examens: • Sun Certified Java Associate (SCJA) • Sun Certified Java Programmer (SCJP) • Sun Certified Java Developer (SCJD) De inhoud van het CPP‐Java is gebaseerd op (delen van) de volgende cursussen van de Open Universiteit Nederland: W07A0A Inleiding Objectgeoriënteerd analyseren en ontwerpen met UML (Inl. OO) 1
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) T25151 Objectgeoriënteerd programmeren in Java 1 (OPiJ1) T42241 Objectgeoriënteerd programmeren in Java 2 (OPiJ2) T21321 Distributed Computing (DC) W07A0E Inleiding datastructuren en algoritmen (Inl. D&A) T50211 Programmeerpracticum De onderdelen van Java die in het CPP‐Java behandeld en getoetst worden, komen grofweg overeen met de onderdelen van Java die in de drie genoemde examens van Sun getoetst worden. De onderdelen van de Sun‐examens en die van het CPP‐Java zijn gebaseerd op Java 1.6 . Figuur 2 laat zien dat het CPP‐Java en de examens SCJA, SCJP en SCJD elkaar voor een groot deel overlappen, hetgeen in het overige deel van deze vergelijking aangetoond zal worden. Sommige onderdelen van SCJA, SCJP en SCJD worden niet volledig gedekt door het CPP‐Java, anderzijds komen in het CPP‐Java onderdelen uit SCWCD aan de orde. Open Universiteit
Sun
Programmeer
practicum
Inleiding
datastructuren en
algoritmes
Distributed computing
Objectgeorienteerd
programmeren in
Java 2
Objectgeorienteerd
programmeren in
Java 1
Inleiding OO
FIGUUR 2 De verschillende examens van SUN Generieke verschillen in vorm en inhoud van de examinering Alvorens in te gaan op een vergelijking van onderdelen die in beide examenprogrammaʹs voorkomen, staan we eerst even stil bij de manier van toetsen. Sun Certified Java Associate (SCJA) wordt geëxamineerd in de vorm van een meerkeuzetoets van 51 vragen die in 115 minuten beantwoord moeten worden. De toets is een geslotenboek‐toets, dat wil zeggen dat de student tijdens de toets geen hulpbronnen mag raadplegen. Het SCJP‐examen bestaat uit 60 meerkeuze vragen die in 180 minuten beantwoord moeten worden, ook in geslotenboek‐vorm. De toetsing van de onderdelen van het CPP‐Java geschiedt in de regel door middel van programmeeropdrachten en een schriftelijke toets van 60‐120 minuten. Deze toets is een openboek toets. 2
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) Sun Certified Developer for Java 2 Platform wordt geëxamineerd in twee delen. In deel 1 maakt de student een programmeeropdracht. In deel 2 schrijft de student in een zitting van 120 minuten een essay over de opdracht. Het onderdeel programmeerpracticum van het CPP‐Java komt hier voor een redelijk deel mee overeen. De grote verschillen betreffen dus SCJA en SCJP. Na het bestuderen van een aantal voorbeeldexamens van Sun kunnen de volgende generieke verschillen vastgesteld worden tussen de Sun‐examens SCJA en SCJP en de toetsing van het Java‐CPP (hier verder OU te noemen): • Bij SUN moet de student beschikken over parate kennis, bij de OU mag de student hulpbronnen raadplegen. • SUN is theoretisch van aard, de OU is zowel praktisch als theoretisch. • Het accent van SUN ligt voor een belangrijk deel op kennis van de syntaxis van Java met inbegrip van allerlei bijzondere gevallen. Bij de OU ligt het accent op inzicht in concepten en het oplossen van programmeerproblemen toegepast op Java. • Toetsing van SUN is in multiple choice vorm, bij de OU bestaat de toetsing uit open vragen en practicumopdrachten. Vergelijking van de eisen van de Sun‐examens SCJA,SCJP en SCJD en de eisen van het CPP‐Java van de OU In bijlage 1 staat een gedetailleerde vergelijking van de exameneisen van SUN en die van (een deel van) het CPP‐Java. Omdat Het CPP‐Java uit diverse onderdelen (cursussen) bestaat, wordt binnen het CPP‐
Java ook gerefereerd aan de specifieke cursus waar een bepaald onderwerp aan de orde komt. In de gedetailleerde vergelijking zijn de exameneisen van Sun als uitgangspunt genomen. Er wordt bekeken of en zo ja waar die onderwerpen in het CPP‐Java aan de orde komen. Onderwerpen van SUN die geen onderdeel zijn van het CPP‐Java worden aangegeven. Op basis van deze gedetailleerde vergelijking is tabel 1 gemaakt met daarin de onderdelen van SUN die niet door het CPP‐Java afgedekt worden. Daarnaast is een tabel 2 gemaakt van onderdelen van het CPP‐
Java die niet door SUN afgedekt worden. 3
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) SUN EXAMEN SCJA SCJP TABEL 1 Onderdeel Inl. OO Lijst van onderwerpen die niet afgedekt worden door het CPP‐Java Native, transient en volatile Break en continue Geen expliciete behandeling van het werken met javac en classpath Niet alle ranges van primitieve typen Geen expliciete behandeling van J2SE, J2ME en J2EE Weinig aandacht voor karakteristieken van thin client en fat client met bijbehorende technieken als Javascript, midlets etc Geen aandacht voor EJB en XML‐
gerelateerde technieken Argumentenlijst van variabele lengte en covariante return waarde Stringbuilder Wait, notify en notifyAll Reguliere expressies(summier) System.gc en finalization Onderdelen van SUN die niet afgedekt worden door het CPP‐Java Opmerkingen Inleiding oo; UML‐diagrammen: use case model met use case beschrijvingen, klassendiagrammen sequencediagrammen en state diagrams komen aan de orde In de overige onderdelen worden meerdere malen gebruik gemaakt van klassendiagrammen en sequencediagrammen OPiJ1 Toestandsdiagrammen waarmee het gedrag van objecten begrepen kan worden ook bij constructie en uitvoering van methoden. Algoritmiek in de vorm van zoekalgoritmes en combineeralgoritmes waarbij een reeks doorlopen moet worden. Tweedimensionale array’s. Gregorian Calendar. Vaardigheid om de API van een onbekende klasse te kunnen lezen en de klasse te kunnen gebruiken. In staat zijn zelf klassen te specificeren , te implementeren en te voorzien van Javadoc commentaar. Bouwen van een grafische user interface Gebruik van JUnit om te testen. Gebruik applets op Web‐pagina’s OPiJ2 Toepassing klassendiagrammen en sequence diagrammen. Designpatterns: Composite pattern, MVC, Decorator. Dynamische binding met daarbij abstracte klassen en interfaces. Tekenen van componenten (paintComponent). Voorbeeld van een wat groter ontwerp waarin allerlei concepten als dynamische binding, event handling, exceptions en MVC worden toegepast. Koppeling met Database: Statement en PreparedStatement DC Ongeveer de helft gaat over networking inclusief sockets, servlets, rmi etc. Deze stof vormt een deel van Sun Certified Web Component Developer for Java 2 Platform, Enterprise Edition (J2EE[tm] Inl. D&A Een aantal datastructuren uit het Java Collection Framework. recursie , bomen, algoritmen. Programmeer‐ Het ontwikkelen van een Web‐applicatie met servlets waarbij gebruik gemaakt wordt practicum van een database en een sessionobject TABEL 2 Onderdelen van het CPP‐Java die niet afgedekt worden door de eisen van SCJP en SCDJ 4
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) Conclusie Op basis van de vergelijking mogen we stellen dat de exameneisen van SUN voor ongeveer 90‐95% afgedekt worden door het CPP‐Java. Anderzijds geldt dat de eisen van het CPP‐Java voor zoʹn 75‐85% afgedekt worden door SUN. Probleem bij de vergelijking is wel dat er geen expliciete (Java‐)eisen voor het SCJD beschikbaar zijn. Tabel 2 toont aan dat het CPP‐Java een flink aantal zaken biedt, die niet direct in de eisen van de Sun‐
certificering terug te vinden zijn. Op basis van deze vergelijking kan gesteld worden dat er een grote mate van overdekking is tussen het CPP‐Java van de Open Universiteit en de examens van Sun. Voor het beroepenveld zullen er geen grote verschillen in kennis zijn tussen een student die het CPP‐Java met goed gevolg gedaan heeft of een student die de Sun examens behaald heeft. Wel zal een student van het CPP‐Java over meer programmeerervaring beschikken door de opdrachten die in de loop van de cursussen gemaakt moeten worden. 5
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) BIJLAGE 1 Eisen Sun Certified Java Associate in relatie tot de behandelde stof in het CPP‐Java Sun Certified Java Associate CPP‐java onderdelen waarin de eisen afgedekt worden OPiJ1, meerdere leereenheden Section 1: Fundamental Object-Oriented
Concepts
Describe, compare, and contrast primitives
(integer, floating point, boolean, and character),
enumeration types, and objects.
Describe, compare, and contrast concrete classes, abstract classes, and interfaces, and how inheritance applies to them. Describe, compare, and contrast class compositions, and associations (including multiplicity: (one‐to‐one, one‐to‐many, and many‐
to‐many), and association navigation. 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. Describe polymorphism as it applies to classes and interfaces, and describe and apply the ʺprogram to an interfaceʺ principle. Section 2: UML Representation of Object-Oriented
Concepts
Recognize the UML representation of classes,
(including attributes and operations, abstract
classes, and interfaces), the UML representation of
inheritance (both implementation and interface), and
the UML representation of class member visibility
6
Opmerkingen OpiJ2: Le 1,2 , 3 en 4 OPIJ2 Inleiding OO, OPIJ1: le 6 Inleiding OO, OpiJ2: Le 1,2 , 3 en 4 Inleiding OO Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) modifiers (-/private and +/public).
. Recognize the UML representation of class associations,
compositions, association multiplicity indicators, and
association navigation indicators
Inleiding OO Section 3: Java Implementation of Object-Oriented
Concepts
OPIJ1 Develop code that uses primitives, enumeration
types, and object references, and recognize literals of these types.
OPIJ2 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.
Develop code that implements simple class
OPIJ1 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.
Develop code that uses polymorphism for both
classes and interfaces, and recognize code that
uses the "program to an interface" principle.
Section 4: Algorithm Design and Implementation
OPIJ2: le4 OPIJ1: le 9,10 en 11 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.
Given an algorithm as pseudo-code, determine the correct scope for a variable used in the algorithm,
7
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) and develop code to declare variables in any of the
following scopes: instance variable, method
parameter, and local variable.
OPIJ1: le 9,10 en 11 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),
OPIJ1: le 9,10 en 11 assignment statements, and break and continue
statements to control the flow within switch and
iteration statements.
OPIJ1: le 9,10 en 11 break en continue worden niet behandeld Given an algorithm with multiple inputs and an
OPIJ1 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.
Given an algorithm as pseudo-code, develop code OPIJ1 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.
Develop code that uses the concatenation operator OPIJ1 (+), and the following methods from class String:
charAt, indexOf, trim, substring, replace, length,
startsWith, and endsWith.
Section 5: Java Development Fundamentals
OPIJ1 Describe the purpose of packages in the Java
language, and recognize the proper use of import
and package statements.
Demonstrate the proper use of the "javac"
8
Summiere behandeling van javac Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) command (including the command-line options: -d
and –classpath), and demonstrate the proper use
of the "java" command (including the command-line
options: -classpath, -D and –version).
Describe the purpose and types of classes for the
following Java packages: java.awt, javax.swing,
java.io, java.net, java.util. Section 6: Java Platforms and Integration
Technologies
Distinguish the basic characteristics of the three
Java platforms: J2SE, J2ME, and J2EE, and given a high-level architectural goal, select the
appropriate Java platform or platforms.
Describe at a high level the benefits and basic
Distribted Computing: Veel uitgebreidere characteristics of RMI.
behandeling: student maakt rmi‐applicatie Describe at a high level the benefits and basic
OPIJ2: le 10 characteristics of JDBC, SQL, and RDBMS
technologies
Describe at a high level the benefits and basic
Distributed Computing; ook details en characteristics of JNDI, messaging, and JMS
implementatie m.b.v. jms technologies.
Section 7: Client Technologies
Describe at a high level the basic characteristics,
benefits and drawbacks of creating thin-clients
using HTML and JavaScript and the related
deployment issues and solutions.
Describe at a high level the basic characteristics,
benefits, drawbacks, and deployment issues
related to creating clients using J2ME midlets.
Describe at a high level the basic characteristics,
benefits, drawbacks, and deployment issues
related to creating fat-clients using Applets.
9
Er wordt verder geen expliciet gebruik gemaakt van de aanroep van de java compiler; Alles verloopt via Eclipse Er wordt geen expliciete aandacht besteed aan dit onderwerp Aan deze karakteriseringen wordt geen expliciete aandacht besteed idem idem Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) Describe at a high level the basic characteristics,
benefits, drawbacks, and deployment issues
related to creating fat-clients using Swing.
idem Section 8: Server Technologies
Distributed computing Geen aandacht voor EJB en de XML‐gerelateerde technieken Describe at a high level the basic characteristics of: EJB,
servlets, JSP, JMS, JNDI, SMTP, JAX-RPC, Web
Services (including SOAP, UDDI, WSDL, and XML), and
JavaMail.
Describe at a high level the basic characteristics of
Distributed computing servlet and JSP support for HTML thin-clients.
Describe at a high level the use and basic characteristics of EJB session, entity and message-driven beans.
Describe at a high level the fundamental benefits and
drawbacks of using J2EE server-side technologies, and
describe and compare the basic characteristics of the
web-tier, business-tier, and EIS tier.
Sun Certified Java Programmer Section 1: Declarations, Initialization and Scoping
Develop 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).
Develop 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.
Develop code that declares, initializes, and uses
primitives, arrays, enums, and objects as static,
instance, and local variables. Also, use legal
identifiers for variable names.
Develop code that declares both static and nonstatic methods, and - if appropriate - use method
names that adhere to the JavaBeans naming
10
CPP‐java onderdelen waarin de eisen afgedekt worden OPIJ1 en OPIJ2 Geen aandacht voor EJB Geen aandacht voor EJB Opmerkingen Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) standards. Also develop code that declares and
uses a variable-length argument list.
Given 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.
Given 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 nonnested class listing, write code to instantiate the
class.
Geen argumenten lijst met variabele lengte en covariant return type Section 2: Flow Control
Develop code that implements an if or switch
statement; and identify legal argument types for
these statements.
Develop 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.
Develop code that makes use of assertions, and
distinguish appropriate from inappropriate uses of
assertions.
Develop code that makes use of exceptions and
exception handling clauses (try, catch, finally), and
declares methods and overriding methods that
throw exceptions.
Recognize 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.
Recognize situations that will result in any of the
following being thrown:
ArrayIndexOutOfBoundsException,ClassCastException,
IllegalArgumentException, IllegalStateException,
11
OPIJ1: le 10 OPIJ1: le 11 OPIJ1: le 13 OPIJ2: le7 OPIJ2:le7 OPIJ2: le 7 Binnen JUnit Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) 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
Develop code that uses the primitive wrapper
classes (such as Boolean, Character, Double,
OPIJ1:le7 Integer, etc.), and/or autoboxing & unboxing.
Discuss the differences between the String,
StringBuilder, and StringBuffer classes.
Given a scenario involving navigating file
systems, reading from files, or writing to files,
OPIJ2: le 9 develop the correct solution using the following
classes (sometimes in combination), from java.io:
BufferedReader,BufferedWriter, File, FileReader,
FileWriter and PrintWriter.
Develop code that serializes and/or deOPIJ2:le9 serializes objects using the following APIs from
java.io: DataInputStream, DataOutputStream,
FileInputStream, FileOutputStream,
ObjectInputStream, ObjectOutputStream and
Serializable.
OPIJ1:le9 Use 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.
Write code that uses standard J2SE APIs in the
OPIJ1:le9 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
12
Geen behandeling StringBuilder Weinig aandacht voor reguliere expressies Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) 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
OPIJ2: le 8, Distributed computing Geen behandeling wait, notify., notifyall Inleiding OO OPIJ2: le2 OPIJ2: le2 en 3 OPIJ2:le3 Write code to define, instantiate, and start new
threads using both java.lang.Thread and
java.lang.Runnable.
Recognize the states in which a thread can
exist, and identify ways in which a thread can
transition from one state to another.
Given a scenario, write code that makes
appropriate use of object locking to protect static or
instance variables from concurrent access
problems.
Given a scenario, write code that makes appropriate use
of wait, notify, or notifyAll. Section 5: OO Concepts
Develop code that implements tight
encapsulation, loose coupling, and high cohesion in
classes, and describe the benefits.
Given 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.
Explain the effect of modifiers on inheritance
with respect to constructors, instance or static
variables, and instance or static methods.
Given a scenario, develop code that declares
and/or invokes overridden or overloaded methods
and code that declares and/or invokes superclass,
13
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) overridden, or overloaded constructors.
Develop code that implements "is-a" and/or "has-a"
relationships. Section 6: Collections / Generics
Given a design scenario, determine which
collection classes and/or interfaces should be used OPIJ2: le 5 to properly implement that design, including the use of the Comparable interface.
Distinguish between correct and incorrect
overrides of corresponding hashCode and equals
methods, and explain the difference between ==
and the equals method.
Write code that uses the generic versions of the Collections API, in particular, the Set, List, and Map Inleiding datastructuren interfaces and implementation classes. Recognize
OPIJ2: le5 the limitations of the non-generic Collections API
and how to refactor code to use the generic
versions.
Develop code that makes proper use of type
Inleiding datastructuren parameters in class/interface declarations, instance OPIJ2: le5 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.
Use capabilities in the java.util package to write code to
Inleiding datastructuren 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
14
Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) Given 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.
Given an example of a class and a commandline, determine the expected runtime behavior.
Determine the effect upon object references and
primitive values when they are passed into methods
that perform assignments or other modifying
operations on the parameters.
Given 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.
Given 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.
Write 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. 15
OpiJ1 en 2 OPIJ1 OPIJ1 en 2 Geen behandeling voor System.gc en finalization Vergelijking CPP Gecertificeerd Javaprogrammeur en Sun certificering (versie november 2009) 16