Introduction to Java 11 programming for developers new to object oriented programming (such as C, Mainframe, 4GL)

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


This five day hands-on Java training course is targeted towards developers with little or no prior working knowledge of object-oriented programming languages. The course talks about the best practices for writing exceptional object-oriented programs in Java using sound development techniques, new improved features for better performance and new capabilities for addressing rapid application development. Java 11 Programming for Object Oriented Experienced Developers includes several aspects that were introduced in Java 9, Java 10 and Java 11 including the Java Modular System, Local Variable Type Inference, the HTTP Client API and several API updates.

What You'll Learn

  • Understand what is object-oriented programming
  • What are the advantages of object-oriented programming in today’s world
  • Working with objects, classes and object-oriented implementations
  • Understand the basic concepts of object-oriented programming such as encapsulation, inheritance, polymorphism and abstraction
  • Understand the fundamentals of Java and its importance, uses, strength and weaknesses
  • Understand the basics of Java and how it relates to OO programming and the Object Model
  • Working with Modular system (Project Jigsaw)
  • Understand and use collections generics, autoboxing and enumerations
  • Process large amounts 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 Java program
  • Responsibilities of JVM
  • Documentation and code reuse

  • Setting up the 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

  • Polymorphism: The subclasses
  • Upcasting vs. Downcasting
  • Calling Superclass methods from Sub-class
  • The final keyword
  • Exercise: Salaries – Polymorphism

  • Separating capability from implementation
  • Abstract classes
  • Implementing an interface
  • Abstract classes vs. interfaces
  • Exercise: Mailable – Interfaces

  • Operators
  • Comparison and logical operators
  • Looping
  • Continue and break statements
  • The Switch statement
  • The For-Each() loop
  • Exercise: Looping
  • Exercise: Language statements

  • Strings
  • String methods
  • String equality
  • StringBuffer, StringBuilder and StringJoiner
  • Handling whitespaces
  • Exercise: Fun with Strings
  • Exercise: Using StringBuffers and StringBuilders

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

  • Instances 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

  • 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

  • Generics and sub-typing
  • Bounded wildcards
  • Generic methods
  • Legacy calls to generics
  • When generics should be used
  • Exercise: Dynamic array
  • Exercise: Adding generics to dynamic array

  • Lambda expression syntax
  • Functional interfaces
  • Type inference in Java 8
  • Method references
  • Using the var reserved type in Lambda expressions
  • Exercise: Using Lambda

  • 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: Introduction to JDBC

  • Annotations overview
  • Working with Java annotations
  • Exercise: Using annotations

  • The HTTP2 client API
  • Building the request
  • Handling the response
  • Exercise: HTTP client
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 programming experience in another language.

Interested in this Course?

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

    Get in Touch
    Pattern figure
    Ripple wave