Introduction to Java 9/10 programming for developers new to OO programming

Live Classroom
Duration: 5 days
Live Virtual Classroom
Duration: 5 days
Pattern figure


This five-day, hands-on Java training is targeted towards developers with little to no prior working knowledge of object-oriented programming languages. The course covers best practices for writing great object-oriented programs in Java, using sound development techniques, new and improved features for better performance and new capabilities for addressing rapid application development. The course lays great emphasis on object-oriented concepts and best practices. The course discusses many concepts that were introduced in Java 9 and Java 10, including the Java modular system and local variable type inference.

What You'll Learn

  • Understand what is OO programming
  • Advantages of OO in today’s times
  • Work with objects, classes and OO implementations
  • Understand the basic concepts of OO such as encapsulations, inheritance, polymorphism and abstraction
  • Understand the fundamentals of Java language and how it relates to OO programming and the Object model
  • 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
  • Use the JDBC API for database access
  • Take advantage of the Java tooling that is available with the programming environment being used in the class


  • Java platforms
  • Lifecycle of a Java program
  • Responsibilities of JVM
  • Documentation and code reuse

  • Setting up environment
  • Locating class files
  • Compiling package classes
  • Source and class files
  • Java applications
  • Exercise: Exploring MemoryViewer
  • Exercise: Exploring ColorPicker

  • Workbench and Workspace
  • Views
  • Editors
  • Perspectives
  • Projects
  • Tutorial: Setup projects in Eclipse

  • Classes in Java
  • Class modifiers and types
  • Class instance variables
  • Primitives vs. Object references
  • Creating objects
  • Exercise: Create a simple class

  • Passing parameters into methods
  • Returning a value from a method
  • Overloaded methods
  • Constructors
  • Optimizing constructor usage
  • Exercise: Create a Class with methods

  • Real-World Objects
  • Classes and Objects
  • Object Behavior
  • Methods and Messages
  • Exercise: Define and use a New Java class

  • Encapsulation
  • Inheritance
  • Method Overriding
  • Polymorphism
  • Exercise: Define and use Another Java Class

  • Operators
  • Comparison and Logical operators
  • Looping
  • Continue and break statements
  • The switch statements
  • The For-Each() loop
  • Exercise: Looping
  • Exercise: Language statements

  • Strings
  • String methods
  • String equality
  • StringBuffer
  • StringBuilder
  • Exercise: Fun with strings
  • Exercise: Using StringBuffers and StringBuilder

  • Extending a class
  • Casting
  • The Object class
  • Default constructor
  • Implicit constructor chaining
  • Exercise: Creating subclasses

  • Instance vs. Local variables – Usage differences
  • Data types
  • Default values
  • Block scoping rules
  • Final and static fields
  • Static methods
  • Exercise: Field test

  • Arrays
  • Accessing the arrays
  • Multi-dimensional arrays
  • Copying arrays
  • Variable arguments
  • Exercise: Creating an array

  • Type inference
  • Inferring types of local variables
  • The var reserved type name
  • Benefits of using var
  • Backward compatibility

  • Class location of packages
  • The package keyword
  • Importing classes
  • Executing programs
  • Visibility in the modular system
  • Java naming conventions

  • Polymorphism: The Subclasses
  • Upcasting vs. Downcasting
  • Calling Superclass Methods From Subclass
  • The final Keyword
  • Exercise: Salaries – Polymorphism

  • Separating Capability from Implementation
  • Abstract Classes
  • Implementing an Interface
  • Abstract Classes vs. Interfaces
  • Exercise: Mailable – Interfaces

  • Exception architecture
  • Throwing exceptions
  • Checked vs. unchecked exceptions
  • Exercise: Exceptions

  • Handling multiple exceptions
  • Automatic closure of resources
  • Creating your own exceptions
  • Exercise: Exceptional

  • Wrapper Classes
  • Autoboxing/Unboxing
  • Enumeration Syntax
  • Using Static imports
  • Exercise: Using Primitive Wrappers
  • Exercise: Enumerations

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

  • format
  • out.printf
  • The Formatter class
  • Using the formatting syntax

  • Introduction to JShell
  • Running Expressions in JShell
  • Importing packages
  • Defining methods and types
  • Using the JShell editor
  • Save and loading state
  • Exercise: Working With JShell

  • Generics and Subtyping
  • Bounded Wildcards
  • Generic Methods
  • Legacy Calls To Generics
  • When Generics Should Be Used
  • Exercise: DynamicArray
  • Exercise: Adding Generics to Dynamic Array

  • Lambda Expression Syntax
  • Functional Interfaces
  • Type Inference in Java 8
  • Method references
  • Exercise: Using Lambd

  • Characterizing Collections
  • Collection Interface Hierarchy
  • The Set, List and Queue Interfaces
  • Map Interfaces
  • Exercise: Create a simple Game using Collections

  • Collection Sorting
  • Comparators
  • Using the Right Collection
  • Lambda expressions in Collections
  • Exercise: Comparators
  • Exercise: Using Collections

  • 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
  • Exercise: Working with Streams

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

  • 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
  • Exercise: Defining Modules

  • Connecting to the Database
  • Statement and PreparedStatement
  • ResultSet
  • Executing Inserts, Updates, and Deletes
  • Controlling Transactions and Concurrency
  • Exercise: Intro to JDBC

  • Annotations Overview
  • Working with Java Annotations
  • Exercise: Using Annotations
Ripple wave

Who should attend

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.


Participants need to have prior practical programming experience in another language apart from Java.

Interested in this Course?

    Ready to recode your DNA for GenAI?
    Discover how Cognixia can help.

    Get in Touch
    Pattern figure
    Ripple wave