Your Career
Training Marketplace

Questions? Call Toll-Free: 1-866-540-9677

Course ID: 252604

e-Learning Bundle

Java Programming with J2SE 5.0 Part 1

When you register for training with, you are also supporting local education. Find out how.

  • Instant Access
    From Anywhere
  • Unlimited
  • 6-12 Months
    To Complete


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.
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.
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.
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.
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.

Join The 50,000+ Companies That Have Purchased Training from

  • 50K+ Companies Trained

    Including 90% Of Fortune 500 Companies Have Purchased Training With

  • 300K+ Courses & Videos

    Live Instructor-Led (Classroom & Virtual), Self-Paced E-learning & Custom OnSite Training Solutions From Leading Training Providers

  • 800+ Expert Instructors

    Industry-Leading Subject Matter Experts (SMEs).Tenured &
    Award-Winning Instructor Network

Get the latest industry news, recommended courses, & promotions from sent straight to your inbox.