Advanced Java 8 Programming

Learn Java features like functional interfaces, Lambda expressions, Streams and the new Java API

Course Code : 1177
Advanced Java 8 Programming 0 5 0

$2395

Contact Us

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.

Schedule Classes

Looking for more sessions of this class?
Talk to us

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

  • 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

Outline

Module 1: The Java Platform

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

Module 2: Using the JDK

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

Module 3: The Eclipse Paradigm

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

Module 4: Writing a simple class

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

Module 5: Adding methods to the class

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

Module 6: Language Statements

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

Module 7: Using Strings

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

Module 8: Specializing in a subclass

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

Module 9: Fields and Variables

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

Module 10: Using Arrays

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

Module 11: Java packages and visibility

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

Module 12: Inheritance and Polymorphism

  • Polymorphism: The subclasses
  • Upcasting vs. downcasting
  • Calling super-class methods from sub-class
  • The Final keyword
  • Exercise: Salaries – Polymorphism

Module 13: Interfaces and Abstract classes

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

Module 14: Exceptions

  • Exception architecture
  • Handling multiple exceptions
  • Automatic closure of resources
  • Creating your own exceptions
  • Throwing exceptions
  • Checked vs. unchecked exceptions
  • Exercise: Exceptions

Module 15: Utility Classes

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

Module 16: Enumeration and Static Imports

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

Module 17: The New Date/Time API

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

Module 18: Introduction to Generics

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

Module 19: Collections

  • 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

Module 20: Introduction to Lambda Expressions

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

Module 21: Streams

  • 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

Module 22: Collectors

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

Module 23: Multithreading

  • 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

Module 24: Concurrent Java

  • 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

Module 25: File System Access

  • The File Class
  • File Utility Methods

Module 26: Java I/O

  • 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

Module 27: Introduction to Annotations

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

Module 28: Java Data Access JDBC API

  • 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
View More

Prerequisites

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

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

Interested in this course? Let’s connect!

Related Courses

SharePoint Site Owner
SharePoint Site Owner and Power User Boot Camp
Apache Spark Basics
Apache Spark Basics – Quick Start to Spark
Perl Programming
Perl Programming Essentials
Best Practices in C++
Object-Oriented Design Patterns and Best Practices in C++

Popular Courses

ITIL-4-foundation
ITIL® 4 Foundation
ITIL-v3-Foundation-Exam-Preparation
ITIL® Foundation (v3, 2011)
CISSP
Certified Information Systems Security Professional (CISSP)
Mastering Python Programming
Mastering Python Programming

Recent Posts

ITIL 4

New Elements of ITIL 4

June 10, 2019
ITIL service management

Cognixia and the Service Management Commitment

June 3, 2019
Meaningful Living with Eternal Learning

Meaningful Living with Eternal Learning

January 28, 2019
Impactful Technology Events in 2018: Lest We Forget!

Impactful Technology Events in 2018: Lest We Forget!

January 18, 2019

Customer Reviews

Name
Email
Review Title
Rating
Review Content

No reviews yet