Advanced Java 8 Programming

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

Course Code : 1177

$2395

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

Delivery Format
Starting Date
Starting Time
Duration

Live Classroom
Monday, 19 August 2019
10:00 AM - 6:00 PM EST
4 Days (Mon-Thu)

$2395 Add to cart

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

  • 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

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

Customer Reviews

Name
Email
Rating
Comments

No reviews yet