Font size:

Description:

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

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

Bundle Price: $379.00
Total Savings: $445.45


Java Programming with Java SE 6.0: 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 Java SE 6.0: 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 from a given list of examples.
  • 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 Java SE 6.0: 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 Java SE 6.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 Java SE 6.0: 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 for 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 Java SE 6.0: 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 generics in Java.
  • 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 standard Java 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.

Java Programming with Java SE 6.0: 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 Java SE 6.0: 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 6.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 Java SE 6.0: 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 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.
  • The wrapper classes - recognize what wrapper classes are and how they're used, and also use the utility methods of the Java wrapper classes to parse strings into numeric values, transform values back into strings or other primitive types, and test values.
  • Managing Java wrapper types - use the new methods of the Integer and Long wrapper classes to manipulate bits for a given scenario, and identify the function and benefits associated with autoboxing and auto-unboxing in Java SE 6.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.
  • The Arrays class and its methods - use the copyOf and copyOfRange methods of the Arrays class to copy arrays in a given scenario.
  • Java system operations - specify the code required to modify system resources for a given scenario.
  • Interacting with the system - specify the code required to launch system properties, load resources, and handle dates and times.
  • 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.
  • Monitoring and management - identify the monitoring and management support features and enhancements in Java SE 6.0.

Java Programming with Java SE 6.0: 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 in a given scenario, and recognize how a Console class works.
  • The java.nio package - use the classes of the java.nio package to modify buffers, get information about disk usage, retrieve a channel, and transfer data between channels.
  • 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.
  • Serialization - recognize what serialization enables you to do, write objects to a file, and read objects from a file.

Java Programming with Java SE 6.0: Basic GUI Development in Java

To demonstrate how to build GUI applications using the Swing API
  • Overview of Swing and Java Foundation Classes - associate the components of the Swing architecture with their corresponding functionality and identify the guidelines associated with using Swing components.
  • Swing components and containers - specify the code that enables you to create and use containers required for a Swing application in a given scenario.
  • Introduction to Swing Components - specify the code to create labels, text, buttons, and a menu for a given application.
  • Using Swing layout managers - specify the code involved in using Swing's layout manager classes to display and arrange components in an application.
  • Handling events in Swing - implement an event handler for a specific event in a given scenario.
  • Painting Swing components - identify the guidelines associated with painting in Swing and AWT.

Java Programming with Java SE 6.0: Java Applets

To demonstrate how to build applets and place them on web pages
  • Introducing Java 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.
  • The sandbox security model - understand the sandbox security model, its features, and the restrictions it imposes on the operations an applet can perform, as well as what a signed applet is and the role of trust levels.
  • 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.
Register Now
Java Programming with Java SE 6.0 e-learning bundle
  • Course ID:
    271382
  • Duration:
    n/a
  • Price:
    $379