Sun Java Boot Camp Class

Sun Java 2.0 J2SE 5.0 Training for Certification Exam 310-055

Course Overview
Our Java training course is designed to provide programmers with an understanding of procedural programming concepts who want to learn Java and object-oriented programming; programmers proficient in another object-oriented programming language who want to move to Java; programmers experienced in the language who want to take the Sun Certified Programmer for the 2 Platform, Standard Edition 5.0 certification exam 310-055.

Prerequisites
Knowledge of programming principles and experience in procedural programming or scripting languages, such as Visual Basic, C, or JavaScript; understanding of object-oriented languages, such as C++ or C#, is an advantage

Your Training Includes

• Twenty Seven hours of multi-media interactive training
• Hands-on Labs - a perfectly simulated, real-world environment to test skills without risk.
• Engaging course demos and real-world examples
• Practice Exams - Simulated certification exams designed to validate exam readiness. 
• Online Mentoring 24 7
  Mentoring provides personal access to our talented corps of expert instructors in a unique collaborative environment. Students can correspond with the Instructor Team 24x7.

Online Sun JAVA 310-055  Course One Year Access	sk055o	$495.00
CD-ROM Sun Java 310-055 Course	sk055c	$595.00
CDs Sun Java Library Java J2SE 5.0  Exam 310-055 Retail $595.00 J2SE Course Update from 1.4 to 2.0 Retail $395.00 Enterprise Client Retail $295.00 JSP and Servlets Retail $295.00 JavaBeans Retail $295.00 JDBC, RMI and COBRA Retail $295.00 Java Web Services Retail $295.00 Over a 50% Savings	skjapc	$995.00
Online Sun Java Library One Year Access Java J2SE 5.0  Exam 310-055 Retail $595.00 J2SE Course Update from 1.4 to 2.0 Retail $395.00 Enterprise Client Retail $295.00 JSP and Servlets Retail $295.00 JavaBeans Retail $295.00 JDBC, RMI and COBRA Retail $295.00 Java Web Services Retail $295.00 Over a 50% Savings	skjapo	$895.00

Training Content

Getting Started with Sun Java

• The use of objects, classes, inheritance, and polymorphism.
• Code involved in declaring a main method and identify the command lines used to compile and run an application.
• Create, compile, and execute a application.
• The appropriate Java lexical element to use for a given scenario.
• The code involved in declaring primitive variables and defining literal values.
• The code used to declare and initialize string literals and arrays.
• Declare and initialize data types, strings, and arrays in a given scenario.

Operators and Flow Control

• Use Java's operators to build expressions and determine the value of an expression variable for a given code sample.
• Use assignment operators to build and evaluate an expression, and evaluate a compound expression using operator precedence.
• Valid primitive type conversions and casting operations.
• Use operators to create expressions and compare integers in a specific application.
• Write if and switch statements for a given scenario.
• Specify the code to use Java's standard and enhanced for loop constructs to perform iteration over arrays and multi-dimensional arrays.
• Specify the code to use while and do-while loop constructs to perform iteration, and identify the functions of the break and continue keywords.
• Create selection statements and loop constructs for a given scenario.

 Creating Classes

• How encapsulation affects a class, and pass messages between objects.
• The code required to declare a specific class and a constructor for a class.
• The code required to declare a method and implement a variable argument list in a method for a given scenario, and declare a variable in a class based on that variable's scope.
• Write an appropriate class and method declaration, and pass variable arguments to a method.
• Create an object, call an object's method, and assign the result of the method to an existing variable for a given scenario.
• Create, iterate over, and switch on type safe enums in J2SE 5.0.
• Create a enumeration and object, iterate over the enumeration's values, and call one of the object's methods.
• Create a package in a given scenario, and import classes, static methods, and variables into a source file.
• The appropriate level of access to apply to classes, variables, methods, and constructors for a given scenario.
• Create and import a specific package, import static methods and variables into a source file, and identify the access levels of the class members in that package.

Working with Classes

• How inheritance and polymorphism are implemented.
• Specify the code required to create a subclass for a given scenario.
• Create a suitable inheritance class structure for a given scenario, and extend a superclass.
• Specify the code required to create abstract classes and methods for a given scenario, and recognize the code required to create a class that implements an interface.
• Declare, access, and initialize Java instance and class members in a given scenario.
• Use the final modifier to declare variables, methods, and classes for a given scenario.
• Declare and initialize variables, and declare and call Java methods in an enterprise scenario.
• Identify how garbage collection is implemented, and recognize the function of the finalize method.
• Declare and instantiate  inner classes for a given scenario.

Generics and Annotations

• The advantages and disadvantages of using generics in code, and outline how generics are used to make raw code type safe.
• Specify the generic, type safe version of a given piece of legacy code.
• Specify the code involved in building a generic class for a given scenario.
• Specify the code required to declare a generic subclass, test generic object types, and cast a generic object.
• Convert a given application's legacy code into a generic type safe equivalent.
• Retention policies and built-in annotations with their corresponding features and functionality.
• Specify the code to annotate an overriding method, a deprecated method, and to suppress compiler warnings.
• Specify the code to declare custom and meta-annotations.
• Specify the code to inspect and represent a custom annotation, write an annotation processor, and run the processor against a set of annotations.
• Create and implement a custom annotation for a given scenario.

Reference Types and Threading

• Valid reference type conversions between classes, interfaces, and arrays.
• Valid casting operations between classes, interfaces, and arrays for a given scenario.
• Use the methods of the Object class and Comparable interface to clone and compare Java objects for a given scenario.
• Clone, compare, and cast reference types.
• Use the Thread class and Runnable interface to create a multithreaded application for a given scenario.
• Specify the code involved in changing a thread's state and priority.
• Synchronize thread access to code in a multithreaded application for a given scenario.
• Create a multithreaded program in a given scenario.

Exception Handling and Assertions

• Specify the code required to use try, catch, and finally blocks to handle exceptions in Java for a given scenario.
• Specify the appropriate method of the Throwable class to use in a given piece of code, and associate runtime and checked exceptions with the events that throw them.
• Handle exceptions in calling methods, create and throw exceptions explicitly, and use exception chaining to set the cause of a thrown exception.
• Create an exception subclass for a given code sample, and implement exception handlers on a thread basis.
• Create, throw, catch, and handle exceptions for a given scenario.
• The code used to create a Java assertion statement for a given scenario, and specify the commands and flags used to create and compile assertions.
• Create, enable, and compile assertions.

Java Utilities

• Use the methods of the Java Math class to determine the value of a variable in a given piece of code, and associate the new methods of the Math class with their corresponding functions.
• Use the utility methods of the Java wrapper classes to compare wrapper objects, transform values into strings, and extract values from wrapper objects.
• Use the new methods of the Integer and Long wrapper classes to manipulate bits for a given scenario, and specify the code required to perform automatic conversions between primitive and wrapper types in J2SE 5.0.
• Specify the code required to test the equality of strings, carry out pattern matching in regular expressions, and modify strings and string buffers for a given scenario.
• Ue the Java String class to manipulate strings and define regular expressions.
• Specify the code required to modify system resources for a given scenario.
• Specify the code required to access, modify, and launch system properties, and create operating system processes for a given scenario.
• Access and edit system environmental variables, launch system processes, and retrieve system timing information.
• Manipulate and traverse the elements of a collection for a given scenario.
• Use the Collection class to modify, sort, and search a collection in a given scenario.
   use iterators to traverse the elements of a list in a given code sample, and sort and modify the list elements using the Collections class.
• Select the appropriate Collection classes, interfaces, and method implementation to meet the requirements of a given scenario.

I/O

• Use the classes of the java.io package to access files, and read and write data for a given scenario.
• Use the classes of the java.nio package to modify buffers, retrieve a channel, and transfer data between channels.
• Write code to read and copy files.
• Use a scanner to retrieve input from a specific source.
• Use the printf method and the Formatter class to format output for a given scenario.
• Format specific output, and use the Scanner class to retrieve input.

Basic GUI Development

• Associate the components of the Swing architecture with their corresponding functionality, and identify the guidelines associated with using Swing's components.
• The code to create and use the containers required for a Swing application in a given scenario.
• Set up and display Swing container objects in a specific Swing application and launch that application.
• The code used to create labels, text, buttons, and menus for a given application.
• Implement an event handler for a specific event in a given scenario.
• Specify the code involved in using Swing's layout manager classes to display and arrange components in an application.
• Identify the guidelines associated with painting in Swing and AWT.
• Write the code involved in handling events for Swing components and displaying these components in a GUI application.

Java Applets

• The code required to create and initialize an applet for a given scenario.
• Embed an applet in a web page using the APPLET tag, customize an applet in a web page using the PARAM tag, and convert applet tags using the HTML converter tool.
• The code required to create and deploy a Java applet.
• Associate the features of the applet security model with the functions they provide and identify the restrictions that it imposes on applets.
• Specify the code required to play sound files and display images, documents, and status information in a given applet.
• Specify the code required to support applet persistence, locate applets for communication, and access japplet panes for a given scenario.
• Locate applets for communication, add an audio clip to an applet, and display status information in an applet.

This Study guide and/or material is not sponsored by, endorsed by or affiliated with Cisco Systems, Inc. Cisco®, Cisco Systems®, CCDA™, CCNA ™, CCDP™, CCNP ™, CCIE™, CCSI™, the Cisco Systems logo and the CCIE logo are trademarks or registered trademarks of Cisco Systems, Inc.

sales@cdicomp.com
webmaster@netwind.com
Copyright  © CDi Communications Inc. 1996-2003
Netwind Learning Center is a registered trademark of CDi Communications, Inc.