Java 11 programming for OO experienced developers

Course Code: 1222



This five day, comprehensive, hands-on Java training course is targeted towards experienced developers with prior experience of working with object-oriented programming languages such as C# or C++. The course discusses best practices for writing great object-oriented programs in Java using sound development techniques, new improved features for better performance and new capabilities for addressing rapid application development. The course includes several aspects that were introduced in Java 9 or Java 10, as well as Java 11, such as, the Java modular system, local variable type inference, the HTTPClient API and several API updates.

Schedule Classes

Looking for more sessions of this class?

Course Delivery

This course is available in the following formats:

Live Classroom
Duration: 5 days

Live Virtual Classroom
Duration: 5 days

What You'll learn

  • Understand the fundamentals of the Java language
  • Understand the importance, uses strengths and weaknesses of Java
  • Understand the basics of Java and how it relates to OO programming and the Object model
  • Learn how to use the 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 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 available with the programming environment being used in the class
  • Familiarize with the APIs used to access data and other resources
  • Understand the concepts of Object-to-Relational mapping frameworks using the Java Persistence API (JPA)
  • Learn about the Dependency Injection using CDI


  • Java platforms
  • Lifecycle of a Java program
  • Responsibilities of JVM
  • Documentation and Code Reuse
  • Setting up environment
  • Locating class files
  • Compiling package class
  • 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
  • Primitive 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
  • 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 sub-classes
  • 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
  • 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
  • Java naming conventions
  • Polymorphism – The sub-classes
  • 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
  • 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 Format 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 interface 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
  • Defining module dependencies
  • Implicit dependencies
  • Implied readability
  • Exporting packages
  • Exercise: Defining modules
  • Connecting to the database
  • Statement and prepared statement
  • 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 clients
  • Context Dependency Injection (CDI)
  • The @Inject annotation
  • The @Default annotation
  • The @Alternative annotation
  • The @Named annotation
  • Exercise: Introduction to CDI
  • Exercise: Adding CDI qualifiers
  • Introduce the Java Persistence API (JPA)
  • Benefits of using an ORM framework
  • Hibernate and JPA
  • Exercise: Introduction to JPA
  • The Date and Calendar classes
  • Introduce the new Date/Time API
  • LocalDate, LocalDateTime, etc.
  • Formatting Dates
  • Working with time zones
  • Manipulate date/time values
  • Lab: Agenda
View More


Participants need to have a working knowledge of developing OO software applications.

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.

Interested in this course? Let’s connect!