Java 8 Programming for OO Experienced Developers (C#, C++, etc.)

Course Code: 1224

$2495

Overview
Schedule classes
What you'll learn
Outline
Prerequisites
Who should attend

Overview

Java 8 Programming for Object Oriented Experienced Developers is a five-day, comprehensive hands-on introduction to Java training course geared for developers who have prior working knowledge of object-oriented programming languages such as C# or C++. The course covers best practices for writing great object-oriented programs in Java 8 using appropriate development techniques, new features for improved performance and new capabilities for handling rapid application development. The course also involves discussion on a real-world case study that would also serve as a reference for the participants during the course and after its completion.

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 not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses
Understand the basics of the Java language and how it relates to OO programming and the Object Model
Learn to use Java multi-threading and exception handling features
Understand and use classes, inheritance and polymorphism
Understand and use collections, generics, autoboxing, and enumerations including new Java features and capabilities
Become familiar with the concept of functional programming using Lambda Expressions
Process large amounts of data using the Stream API introduced in Java 8
Use the JDBC API for database access
Work with annotations
Understand and work with the classes in the concurrent package
Take advantage of the Java tooling that is available with the programming environment being used in the class

Outline

Part I: Java – A First Look

Module 1: The Java platform

Java Platforms
Lifecycle of a Java Program
Responsibilities of 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 MemoryViewer
Exercise: Exploring ColorPicker

Module 3: The eclipse paradigm

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

Part II: Getting started with Java

Module 4: Writing a simple class

Classes in Java
Class Modifiers and Types
Class Instance Variables
Primitives vs. Object References
Creating Objects
Exercise: Create 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
Exercise: Language Statements

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 sub-class

Extending a Class
Casting
The Object Class
Default Constructor
Implicit Constructor Chaining
Exercise: Creating Subclasses
Exercise: Defining the Student Subclass

Part III: Essential Java programming

Module 9: Fields and variables

Instance 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 Array
Multidimensional Arrays
Copying Arrays
Variable Arguments
Exercise: Creating an Array
Exercise: Defining the Student Array

Module 11: Java packages and visibility

Class Location of Packages
The Package Keyword
Importing Classes
Executing Programs
Java Naming Conventions

Part IV: Advanced Java programming

Module 12: Inheritance and polymorphism

Polymorphism: The Subclasses
Upcasting vs. Downcasting
Calling Superclass Methods From Subclass
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

Part V: Java Developers’ Toolbox

Module 15: Utility classes

Wrapper classes
The number class
Random numbers
Autoboxing/unboxing
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: Enumerations

Module 17: the new Date/Time API

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

Module 18: Formatting strings (optional)

StringJoiner
format
out.printf
The Formatter class
Using the formatting syntax

Part VI: Collection and generics

Module 19: Introduction to generics

Generics and Subtyping
Bounded Wildcards
Generic Methods
Legacy Calls To Generics
When Generics Should Be Used
Exercise: DynamicArray
Exercise: Adding Generics to Dynamic Array

Module 20: Collections

Characterizing Collections
Collection Interface Hierarchy
Iterators
The Set Interface
The List Interface
Queue Interface
Map Interfaces
Using the Right Collection
Collections and Multithreading
Exercise: Using Hashtable and HashMap
Exercise: Collections Poker
Exercise: Writing a Collection

Part VII: Lambda expressions, collections and streams

Module 21: Introduction to Lambda expressions

Functional vs OO Programming
Anonymous Inner-classes
Lambda Expression Syntax
Functional Interfaces
Method references
Constructor references

Module 22: Java 8 collection updates

Introduce the ConcurrentHashMap
Lambda expressions and Collections
Exercise: Functional Collections

Module 23: 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 24: Collectors

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

Part VIII: Multithreading and concurrency

Module 25: 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 26: 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 27: Java 8 concurrency updates (optional)

The common thread pool
Atomic variables
LongAdder and LongAccumulator
CompletableFuture
Non-blocking asynchronous tasks
Exercise: CompletableFuture

Part IX: Java I/O

Module 28: Java I/O

The Java I/O Mechanism
Subclasses Accessing Real Data
Filter Classes
New File IO – NIO
NIO Overview
Exercise: Files

Part X: Java application development

Module 29: Introduction to annotations

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

Module 30: 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

Module 31: Formatting Strings

StringJoiner
format
out.printf
The Formatter class
Using the formatting syntax

Module 32: Java 8 Concurrency Updates

The common thread pool
Atomic variables
LongAdder and LongAccumulator
CompletableFuture
Non-blocking asynchronous tasks
Lab: CompletableFuture

Prerequisites

Participants need to have a working knowledge of developing object-oriented 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.