Banner

Advanced Java 8 Programming

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

Overview

The Advanced Java 8 Programming training course is a comprehensive Java training for experienced developers keen to learn advanced programming APIs and techniques. The course explores the new features in Java 8 and discusses how to leverage them and apply them for improving application development and application performance, using sound coding techniques and best practices. The course is a skill-centric program with equal measures of hands-on lab exercises and lectures.

What You'll Learn

  • Lifecycle of Java programs
  • Class files and package classes
  • Workbench and workspace
  • Primitive and object references
  • Methods
  • Language statements
  • Strings
  • Sub-classes
  • Fields and variables
  • Arrays
  • Inheritance and polymorphism

Curriculum

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

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

  • Workbench and Workspace
  • Views
  • Editors
  • Perspectives
  • Projects
  • Tutorial: Working with Eclipse Neon

  • Classes in Java
  • Class modifiers and types
  • Class instance variables
  • Primitives vs. object references
  • Creating objects
  • Exercise: Creating 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

  • Strings
  • String methods
  • String equality
  • StringBuffer
  • StringBuilder
  • 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

  • Class location of packages
  • The Package keyword
  • Importing classes
  • Executing programs
  • Java naming conventions

  • Polymorphism: The subclasses
  • Upcasting vs. downcasting
  • Calling super-class 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
  • Handling multiple exceptions
  • Automatic closure of resources
  • Creating your own exceptions
  • Throwing exceptions
  • Checked vs. unchecked exceptions
  • Exercise: Exceptions

  • Wrapper classes
  • The Number class
  • Random numbers
  • Auto-boxing/un-boxing
  • The Date class
  • Exercise: Using primitive wrappers

  • Enumeration syntax
  • When you should use enumerations
  • Using static imports
  • When you should use static imports
  • Exercise: Enumeration

  • Introducing the new Date/Time API
  • LocalDate, LocalDateTime, etc.
  • Formatting dates
  • Working with time zones
  • Manipulate date/time values
  • Exercise: Agenda

  • Generics and sub-typing
  • Bounded wildcards
  • Generic methods
  • Legacy calls to generics
  • When generics should be used
  • Exercise: Shopping cart

  • Characterizing collections
  • Collection interface hierarchy
  • Iterators
  • The Set interface
  • The List interface
  • Queue interface
  • Map interfaces
  • Using the right collection
  • Collections and multi-threading
  • Exercise: Using HashTable and HashMap
  • Exercise: Collections Poker
  • Exercise: Writing a collection

  • Functional vs OO programming
  • Anonymous inner-classes
  • Lambda expressions syntax
  • Functional interfaces
  • Method references
  • Constructor references

  • 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

  • Principles of multithreading
  • Creating a Threaded Class
  • Basic features of the Thread Class
  • Thread scheduling
  • Thread synchronization
  • Exercise: Simple Thread Class
  • Exercise: Simple Runnable Class

  • Concurrent Locks are Explicit and Flexible
  • Executor Interfaces Provide Thread Management
  • Challenges for Concurrent Use of Collections
  • Concurrent Collections
  • Atomic Variables Avoid Synchronization
  • Exercise: Working with Concurrent Java
  • Exercise: Sleeping Threads
  • Exercise: Safe Data Access
  • Exercise: Producer/Consumer

  • The File Class
  • File Utility Methods

  • The Java I/O mechanism
  • Subclasses accessing real data
  • Filter classes
  • New File IO – NIO
  • NIO overview
  • Exercise: Reading/Writing Byte Data
  • Exercise: Reading/Writing Character Data
  • Exercise: Reading/Writing Objects

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

  • Connecting to the Database
  • Statement and PreparedStatement
  • ResultSet
  • Executing Inserts, Updates, and Deletes
  • Controlling Transactions and Concurrency
  • Tutorial: Setup The Derby Database
  • Exercise: Reading Table Data
  • Exercise: Using JdbcRowSet
  • Exercise: Executing within a Transaction
waves
Ripple wave

Who should attend

The Advanced Java 8 programming course is highly recommended for –
  • Programmers
  • Back-end developers
  • Solution architect/specialist
  • Software engineers
  • Software developers
  • Full stack developers
  • Web developers

Prerequisites

Participants need to have hands-on experience in programming using Java.

Interested in this Course?

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

    Get in Touch
    Pattern figure
    Ripple wave