If you're an experienced OO developer (coming from a C# or C++ background, etc.) who needs to transition to programming in Java, this fast-paced, hands-on course will get you there quickly. In this lab-intensive class, you'll quickly be immersed in working with the latest Java 11 programming techniques, using best practices for writing solid, robust (and well-written!) modern object-oriented applications. In addition to learning excellent, current coding skills in Java, you'll explore the new improved features for better performance and new capabilities for addressing rapid application development that Java 11 brings to the table. This course includes several key aspects that were introduced in Java 9, Java 10, and Java 11 including the Java Modular System, Local Variable Type Inference, and several API updates. This course also includes a Quick Look at what’s next in Java – Java 12, Java 13, Java 14 and beyond.


* Actual course outline may vary depending on offering center. Contact your sales representative for more information.

Learning Objectives

Working in a hands-on learning environment, guided by our expert team, attendees will learn to:
Understand not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses
Understand the basics of the Java language and how it relates to OO programming and the Object Model
Learn to use Java exception handling features
Work with the Modular system (Project Jigsaw)
Understand and use classes, inheritance and polymorphism
Understand and use collections, generics, autoboxing, and enumerations
Process large amount of data using Lambda expressions and the Stream API
Abstract, static and private methods in interfaces
Take advantage of the Java tooling that is available with the programming environment being used in the class
Specific Java 11 features covered: Using the Local Variable Type in Lambda expressions; Updates made to the String AP
Time Permitting: Quick look ahead – Java 12, Java 13, Java 14 and Beyond

  • The Java Platform

  • Java Platforms
    Lifecycle of a Java Program
    Responsibilities of JVM
    Documentation and Code Reuse

  • Using the JDK

  • Setting Up Environment
    Locating Class Files
    Compiling Package Classes
    Source and Class Files
    Java Applications

  • The Eclipse Paradigm

  • Workbench and Workspace

  • Writing a Simple Class

  • Classes in Java
    Class Modifiers and Types
    Class Instance Variables
    Primitives vs. Object References
    Creating Objects

  • Adding Methods to the Class

  • Passing Parameters into Methods
    Returning a Value from a Method
    Overloaded Methods
    Optimizing Constructor Usage

  • Language Statements

  • Operators
    Comparison and Logical Operators
    Continue and Break Statements
    The switch Statement
    The for-each() Loop

  • Using Strings

  • Create an instance of the String class
    Test if two strings are equal
    Get the length of a string Parse a string for its token components
    Perform a case-insensitive equality test
    Build up a string using StringBuffer
    Contrast String, StringBuffer, and StringBuilder

  • Specializing in a Subclass

  • Extending a Class
    The Object Class
    Default Constructor
    Implicit Constructor Chaining

  • Fields and Variables

  • Instance vs. Local Variables:
    Usage Differences
    Data Types
    Default Values
    Block Scoping Rules
    Final and Static Fields
    Static Methods

  • Using Arrays

  • Arrays
    Accessing the Array
    Multidimensional Arrays
    Copying Arrays
    Variable Arguments

  • Local-Variable Type Inference

  • Type inference
    Infering Types of Local Variables
    The var Reserved Type name
    Benefits of Using var
    Backward Compatibility

  • Java Packages and Visibility

  • Class Location of Packages
    The Package Keyword
    Importing Classes
    Executing Programs
    Visibility in the Modular System
    Java Naming Conventions

  • Inheritance and Polymorphism

  • Polymorphism: The Subclasses
    Upcasting vs. Downcasting
    Calling Superclass Methods from Subclass
    The final Keyword

  • Interfaces and Abstract Classes

  • Separating Capability from Implementation
    Abstract Classes
    Implementing an Interface
    Abstract Classes vs. Interfaces

  • Introduction to Exception Handling

  • Exception Architecture
    Throwing Exceptions
    Checked vs. Unchecked Exceptions

  • Exceptions

  • Handling Multiple Exceptions
    Automatic Closure of Resources
    Creating Your Own Exceptions

  • Utility Classes

  • Wrapper Classes
    Enumeration Syntax
    Using Static imports

  • Introduction to Generics

  • Generics and Subtyping
    Bounded Wildcards
    Generic Methods
    Legacy Calls to Generics
    When Generics Should Be Used

  • Lambda Expressions and Functional Interface

  • Lambda Expression Syntax
    Functional Interfaces
    Type Inference in Java 8
    Method references

  • Collections

  • Characterizing Collections
    Collection Interface Hierarchy
    The Set, List and Queue Interfaces
    Map Interfaces

  • Using Collections

  • Collection Sorting
    Using the Right Collection
    Lambda expressions in Collections

  • Streams

  • Processing Collections of data
    The Stream interface
    Reduction and Parallelism
    Filtering collection data
    Sorting Collection data
    Map collection data
    Find elements in Stream
    Numeric Streams
    Create infinite Streams
    Sources for using Streams

  • Collectors

  • Creating Collections from a Stream
    Group elements in the Stream
    Multi-level grouping of elements
    Partitioning Streams

  • Introduction to the Module System

  • Introduce Project Jigsaw
    Classpath and Encapsulation
    The JDK internal APIs
    Java 9 Platform modules
    Defining application modules
    Define module dependencies
    Implicit dependencies
    Implied Readability
    Exporting packages

  • Java Date/Time

  • The Date and Calendar classes
    Introduce the new Date/Time API
    LocalDate, LocalDateTime, etc.
    Formatting Dates
    Working with time zones
    Manipulate date/time values

  • Java 12 and beyond

  • Provide an overview of changes since Java 11
    Introduce Preview Features
    Records (Java 14)
    Switch Expressions (Java 12, Java 13, Java 14)
    Text Blocks (Java 13, Java 14)
    Helpful NullPointerExceptions (Java 14)
    Pattern Matching for instanceof (Java 14)


This is an introductory-level Java programming course, designed for experienced developers who wish to get up and running with Java, or who need to reinforce sound Java coding practices, immediately.




Attendees should have a working knowledge of developing OO software applications (coming from C++, C# or other OO programming backgrounds).


Length: 4.0 days (32 hours)


Not Your Location? Change

Course Schedule:

Schedule select
10:00 AM ET -
6:00 PM ET
Filling Fast