This course provides hands-on Java 8 training for developers who have little or no prior working knowledge of object-oriented programming languages such as C, COBOL, and 4GL. You will gain the best practices for writing great object-oriented programs, using sound development techniques, new improved features for better performance, and new capabilities for addressing rapid application development. Special emphasis is placed on object oriented concepts and best practices. In addition, you will explore new features in Java 9 and Java 10, including the Java Modular System and Local Variable Type Inference. You will leave this course able to participate in projects that are still on Java 8, while also ready to move onto projects using Java 10


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

Learning Objectives

This skills-centric course is about 50% hands-on lab and 50% lecture, designed to train attendees in core OO coding and Java development skills, coupling the most current, effective techniques with the soundest industry practices. Our engaging instructors and mentors are highly experienced practitioners who bring years of current "on-the-job" experience into every classroom.
Working in a hands-on learning environment, guided by our expert team, attendees will learn to:
Understand what OO programming is and what the advantages of OO are in today's world
Work with objects, classes, and OO implementations
Understand the basic concepts of OO such as encapsulation, inheritance, polymorphism, and abstraction
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
Understand and use classes, inheritance and polymorphism
Understand and use collections, generics, autoboxing, and enumerations
Become familiar with the concept of functional programming using Lambda Expressions
Process large amounts of data using the Stream API introduced in Java 8
Discover the new Date/Time API
Use the JDBC API for database access
Work with annotations
Take advantage of the Java tooling that is available with the programming environment being used in the class
Java 8 Features: Lambda Expressions, Method and Constructor references, The Streams API, Collectors, The Optional class

  • The Java Platform

  • The Java Platform

    Lifecycle of a Java Program

    Responsibilities of JVM

    Documentation and Code Reuse

  • Using the JDK

  • Explain the JDK’s file structure

    Use the command line compiler to compile a Java class

    Use the command line Java interpreter to run a Java application class

  • The IntelliJ Paradigm

  • Introduce the IntelliJ IDE

    The Basics of the IntelliJ interface

    IntelliJ Projects and Modules

    Creating and running Java applications

  • Writing a Simple Class

  • Write a Java class that does not explicitly extend another class

    Define instance variables for a Java class

    Create object instances

    Primitives vs Object References

    Implement a main method to create an instance of the defined class

  • Adding Methods to the Class

  • Write a class with accessor methods to read and write instance variables

    Write a constructor to initialize an instance with data

    Write a constructor that calls other constructors of the class to benefit from code reuse

    Use the this keyword to distinguish local variables from instance variables

  • Object-Oriented Programming

  • Real-World Objects

    Classes and Objects

    Object Behavior

    Methods and Messages

  • Inheritance, Abstraction, and Polymorphism

  • Encapsulation


    Method Overriding


  • Essential Java Programming

  • Essential Java Programming

  • Language Statements

  • Arithmetic operators

    Operators to increment and decrement numbers

    Comparison operators

    Logical operators

    Return type of comparison and logical operators

    Use for loops

    Switch Expressions

    Switch Expressions and yield

  • Using Strings and Text Blocks

  • 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

    Compact Strings

    Text Blocks

  • Specializing in a Subclass

  • Constructing a class that extends another class

    Implementing equals and toString

    Writing constructors that pass initialization data to parent constructor

    Using instanceof to verify type of an object reference

    Pattern matching for instanceof

    Overriding subclass methods

    Safely casting references to a more refined type

  • Fields and Variables

  • Discuss Block Scoping Rules

    Distinguish between instance variables and method variables within a method

    Explain the difference between the terms field and variable

    List the default values for instance variables

    Final and Static fields and methods

    Local Variable type inference

  • Using Arrays

  • Declaring an array reference

    Allocating an array

    Initializing the entries in an array

    Writing methods with a variable number of arguments

  • Records

  • Data Objects in Java

    Introduce records as carrier of immutable data

    Defining records

  • Java Packages and Visibility

  • Use the package keyword to define a class within a specific package

    Discuss levels of accessibility/visibility

    Using the import keyword to declare references to classes in a specific package

    Using the standard type naming conventions

    Visibility in the Java Modular System Correctly executing a Java application class

    The Java modular system

    Defining Modules

  • Inheritance and Polymorphism

  • Write a subclass with a method that overrides a method in the superclass

    Group objects by their common supertype

    Utilize polymorphism

    Cast a supertype reference to a valid subtype reference

    Use the final keyword on methods and classes to prevent overriding

  • Interfaces and Abstract Classes

  • Define supertype contracts using abstract classes

    Implement concrete classes based on abstract classes

    Define supertype contracts using interfaces

    Implement concrete classes based on interfaces

    Explain advantage of interfaces over abstract classes

    Explain advantage of abstract classes over interfaces

    Static, default and private methods in interfaces

  • Sealed classes

  • Introduce Sealed classes

    The sealed and permits modifiers

    Sealed Interfaces Exception Handling

  • Introduction to Exception Handling

  • Introduce the Exception architecture

    Defining a try/catch blocks Checked vs Unchecked exceptions

  • Exceptions

  • Defining your own application exceptions

    Automatic closure of resources

    Suppressed exceptions

    Handling multiple exceptions in one catch

    Helpful Nullpointers

    Enhanced try-with-resources Java Developer's Toolbox

  • Developing applications

  • Introduce the wrapper classes

    Explain Autoboxing and Unboxing

    Converting String representations of primitive numbers into their primitive types

    Defining Enumerations

    Using static imports

    Deprecating methods Advanced Java Programming

  • Introduction to Generics

  • Generics and Subtyping

    Bounded Wildcards

    Generic Methods

    Legacy Calls To Generics

    When Generics Should Be Used

  • Lambda Expressions and Functional Interface

  • Understanding the concept of functional programming

    Writing lambda expressions

    Understanding functional interfaces

  • Collections

  • Provide an overview of the Collection API

    Review the different collection implementations (Set, List and Queue)

    Explore how generics are used with collections

    Examine iterators for working with collections

  • Using Collections

  • Collection Sorting


    Using the Right Collection

    Lambda expressions in Collections

    Bonus Topics: Time Permitting

  • Streams

  • Understanding the problem with collections in Java

    Thinking of program solutions in a declarative way

    Use the Stream API to process collections of data

    Understand the difference between intermediate and terminal stream operations

    Filtering elements from a Stream

    Finding element(s) within a Stream

    Collecting the elements from a Stream into a List takeWhile and dropWhile intermediate operations

  • Collectors

  • Using different ways to collect the items from a Stream

    Grouping elements within a stream

    Gathering statistics about numeric property of elements in a stream


This is a basic-level programming course designed for attendees with prior development experience in another language, such as COBOL, 4GL, Mainframe or other non-object oriented languages. This course is not geared for non-developers.




Continued Java & JEE training: Intermediate to Advanced Java, JEE Essentials, Java for Web, Spring / Spring Boot, Microservices / Web Services / REST, RXJava, Tuning, Patterns & More TDD / Test Driven Development, JUnit / Unit Testing, Agile development training Secure Java Coding / Java Security and secure application development training Mobile developer / Android training Please contact us for recommended next steps tailored to your longer-term education, project, role or development objectives.


Length: 5.0 days (40 hours)


Not Your Location? Change

Course Schedule:

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