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: Generics and Annotations $74.95

Bundle Price: $199.00
Total Savings: $175.75


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: 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 Part 1 e-learning bundle
  • Course ID:
    252604
  • Duration:
    12 hours
  • Price:
    $199