Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Java Programming with J2SE 5: Getting Started with Java $74.95
Java Programming with J2SE 5: Operators and Flow Control in Java $74.95
Java Programming with J2SE 5: Creating Classes in Java $74.95
Java Programming with J2SE 5: Working with Classes in Java $74.95
Java Programming with J2SE 5: Reference Types and Threading $74.95
Java Programming with J2SE 5: Exception Handling and Assertions $74.95
Java Programming with J2SE 5: Java Utilities $74.95
Java Programming with J2SE 5: Basic GUI Development in Java $74.95
Java Programming with J2SE 5: Java Applets $74.95
Java Programming with J2SE 5: Java I/O $74.95
Java Programming with J2SE 5: Generics and Annotations $74.95

Bundle Price: $379.00
Total Savings: $445.45


Java Programming with J2SE 5: Getting Started with Java

To introduce the main principles and elements of the Java language
  • Overview of the Java language - recognize the use of objects, classes, inheritance, and polymorphism in Java.
  • A first Java application - specify the code involved in declaring a main method and identify the command lines used to compile and run an application.
  • Creating and running a Java application - create, compile, and execute a Java application.
  • Basic lexical elements in Java - specify the appropriate Java lexical element to use for a given scenario.
  • Primitive types and literals in Java - specify the code involved in declaring primitive variables and defining literal values in Java.
  • Strings and arrays in Java - specify the code used to declare and initialize Java string literals and arrays.
  • Working with Java data types - declare and initialize Java data types, strings, and arrays in a given scenario.

Java Programming with J2SE 5: Operators and Flow Control in Java

To enable the learner to identify and work with Java operators, expressions, selection statements, and loop constructs
  • Java operators - use Java's operators to build expressions and determine the value of an expression variable for a given code sample.
  • Assignments and expressions in Java - use assignment operators to build and evaluate an expression, and evaluate a compound expression using operator precedence.
  • Primitive casting and conversions in Java - identify valid primitive type conversions and casting operations.
  • Working with Java operators and expressions - use Java operators to create expressions and compare integers in a specific application.
  • Selection statements in Java - write if and switch statements for a given scenario.
  • Java while and do-while loops - specify the code to use Java's while and do-while loop constructs to perform iteration, and identify the functions of the break and continue keywords.
  • The Java for loop construct - specify the code to use Java's standard and enhanced for loop constructs to perform iteration over arrays and multi-dimensional arrays.
  • Using flow control in Java - create selection statements and loop constructs for a given scenario.

Java Programming with J2SE 5: Creating Classes in Java

To enable the learner to create and work with Java classes and objects
  • Classes, objects, and messages in Java - identify how encapsulation affects a Java class, and pass messages between objects.
  • Creating Java classes - identify the code required to declare a specific class and a constructor for a class.
  • Creating methods - identify 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.
  • Creating classes and methods - write an appropriate class and method declaration, and pass variable arguments to a method.
  • Working with Java objects - create an object, call an object's method, and assign the result of the method to an existing variable for a given scenario.
  • Type safe enums - create, iterate over, and switch on type safe enums in J2SE 5.0.
  • Creating objects and enums - create a Java enumeration and object, iterate over the enumeration's values, and call one of the object's methods.
  • Declaring and importing Java packages - create a package in a given scenario, and import classes, static methods, and variables into a source file.
  • Controlling access using Java access modifiers - identify the appropriate level of access to apply to classes, variables, methods, and constructors for a given scenario.
  • Using Java packages and access modifiers - create and import a specific Java package, import static methods and variables into a source file, and identify the access levels of the class members in that package.

Java Programming with J2SE 5: Working with Classes in Java

To enable the learner to implement inheritance and polymorphism in Java and to work with Java's static and final modifiers
  • Inheritance and polymorphism in Java - identify how inheritance and polymorphism are implemented in Java.
  • Implementing inheritance in Java - specify the code required to create a subclass for a given scenario.
  • Extending a Java class - create a suitable inheritance class structure for a given scenario, and extend a superclass.
  • Abstract classes and interfaces in Java - 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.
  • Instance and class members in Java - declare, access, and initialize Java instance and class members in a given scenario.
  • The final modifier in Java - use the final modifier to declare variables, methods, and classes for a given scenario.
  • Using static and final modifiers in Java - declare and initialize Java variables, and declare and call Java methods in an enterprise scenario.
  • Garbage collection and finalization in Java - identify how garbage collection is implemented in Java, and recognize the function of the finalize method.
  • Java inner classes - declare and instantiate Java's inner classes for a given scenario.

Java Programming with J2SE 5: Reference Types and Threading

To enable the learner to work with reference types and threads in Java
  • Converting reference types in Java - identify valid reference type conversions between classes, interfaces, and arrays.
  • Casting between Java reference types - identify valid casting operations between classes, interfaces, and arrays for a given scenario.
  • Cloning and comparing Java objects - use the methods of the Object class and Comparable interface to clone and compare Java objects for a given scenario.
  • Working with Java reference types - clone, compare, and cast Java reference types.
  • Introduction to Java multithreading - use the Thread class and Runnable interface to create a multithreaded application for a given scenario.
  • Java thread states and priorities - specify the code involved in changing a thread's state and priority.
  • Synchronizing Java threads - synchronize thread access to code in a multithreaded application for a given scenario.
  • Creating a multithreaded Java program - create a multithreaded program in a given scenario.

Java Programming with J2SE 5: Exception Handling and Assertions

To enable the learner to handle exceptions and use assertions in Java
  • Try, catch, and finally blocks in Java - specify the code required to use try, catch, and finally blocks to handle exceptions in Java for a given scenario.
  • The Java Exception class hierarchy - 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.
  • Throwing exceptions in Java - handle exceptions in calling methods, create and throw exceptions explicitly, and use exception chaining to set the cause of a thrown exception.
  • Working with exceptions in Java 5.0 - create an exception subclass for a given code sample, and implement exception handlers on a thread basis.
  • Handling exceptions in Java - create, throw, catch, and handle exceptions for a given scenario.
  • The assertion mechanism in Java - identify 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.
  • Using assertions in Java - create, enable, and compile assertions in Java.

Java Programming with J2SE 5: Java Utilities

To enable the learner to use the classes and methods of the java.lang, java.util, java.io, and java.nio packages
  • The Java Math class - 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.
  • Java wrapper classes - use the utility methods of the Java wrapper classes to compare wrapper objects, transform values into strings, and extract values from wrapper objects.
  • Managing Java wrapper types - 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.
  • Java String, StringBuffer, and StringBuilder classes - 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.
  • Manipulating Java strings - use the Java String class to manipulate strings and define regular expressions.
  • Java system operations - specify the code required to modify system resources for a given scenario.
  • Interacting with the system - specify the code required to access, modify, and launch system properties, and create operating system processes for a given scenario.
  • Using system operations - access and edit system environmental variables, launch system processes, and retrieve system timing information.
  • Collection Framework interfaces - manipulate and traverse the elements of a collection for a given scenario.
  • Using the Collection Framework in Java - use Java's Collection class to modify, sort, and search a collection in a given scenario.
  • Working with collection classes - 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.
  • Using Collection classes - select the appropriate Collection classes, interfaces, and method implementation to meet the requirements of a given scenario.

Java Programming with J2SE 5: Basic GUI Development in Java

To demonstrate how to build GUI applications using the Swing API
  • Overview of Swing and the JFC - associate the components of the Swing architecture with their corresponding functionality, and identify the guidelines associated with using Swing's components.
  • Swing components and containers - specify the code to create and use the containers required for a Swing application in a given scenario.
  • Creating a simple Swing application - set up and display Swing container objects in a specific Swing application and launch that application.
  • Basic Swing components - specify the code used to create labels, text, buttons, and menus for a given application.
  • Handling events in Swing - implement an event handler for a specific event in a given scenario.
  • Using Swing layout managers - specify the code involved in using Swing's layout manager classes to display and arrange components in an application.
  • Painting Swing components - identify the guidelines associated with painting in Swing and AWT.
  • Handling events and laying out a Swing application - write the code involved in handling events for Swing components and displaying these components in a GUI application.

Java Programming with J2SE 5: Java Applets

To demonstrate how to build applets and place them on web pages
  • Introducing applets - identify the code required to create and initialize an applet for a given scenario.
  • Adding an applet to a web page - 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.
  • Creating and deploying an applet - specify the code required to create and deploy a Java applet.
  • The sandbox security model - associate the features of the applet security model with the functions they provide and identify the restrictions that it imposes on applets.
  • Building useful applets - specify the code required to play sound files and display images, documents, and status information in a given applet.
  • Advanced applets - specify the code required to support applet persistence, locate applets for communication, and access JApplet panes for a given scenario.
  • Adding functionality to an applet - locate applets for communication, add an audio clip to an applet, and display status information in an applet.

Java Programming with J2SE 5: Java I/O

To enable the learner to use Java's I/O facilities to read and write data, and format input or output
  • The java.io package - use the classes of the java.io package to access files, and read and write data for a given scenario.
  • The java.nio package - use the classes of the java.nio package to modify buffers, retrieve a channel, and transfer data between channels.
  • Reading and copying files in Java - write code to read and copy files in Java.
  • The Scanner class - use a scanner to retrieve input from a specific source.
  • Formatting output - use the printf method and the Formatter class to format output for a given scenario.
  • Handling complex I/O - format specific output, and use the Scanner class to retrieve input.

Java Programming with J2SE 5: Generics and Annotations

To explain what metadata is and how it can be used to provide annotation source to third-party tools and to outline J2SE 1.5 tool changes
  • Introducing generics - identify the advantages and disadvantages of using generics in code, and outline how generics are used to make raw code type safe.
  • Using generics - specify the generic, type safe version of a given piece of legacy code.
  • Building a simple generic class - specify the code involved in building a generic class for a given scenario.
  • Implementing generic class hierarchies - specify the code required to declare a generic subclass, test generic object types, and cast a generic object.
  • Developing applications using generics - convert a given application's legacy code into a generic type safe equivalent.
  • Introducing annotations - associate Java's retention policies and built-in annotations with their corresponding features and functionality.
  • Using Java's standard annotations - specify the code to annotate an overriding method, a deprecated method, and to suppress compiler warnings.
  • Declaring custom and meta-annotations - specify the code to declare custom and meta-annotations.
  • Implementing custom annotations - specify the code to inspect and represent a custom annotation, write an annotation processor, and run the processor against a set of annotations.
  • Developing custom annotations - create and implement a custom annotation for a given scenario.
Register Now
Java Programming with J2SE 5.0 e-learning bundle
  • Course ID:
    271381
  • Duration:
    n/a
  • Price:
    $379