Introduction to Core Java Programming for OO Experienced Developers (C#, C++ etc.)

After completing this course, students will be able to:

• 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
• Take advantage of the Java tooling that is available with the programming environment being used in the class Specific Java 8 features: The new Date API, Lambda Expressions, Streams, Collectors

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. Attendees should have a working knowledge of developing OO software applications.
 

Session: Java: A First Look The Java Platform

• Java Platforms
• Lifecycle of a Java Program
• Responsibilities of JVM
• Documentation and Code Reuse

Using the JDK

• Setting Up Environment
• Locating Class Files
• Compiling Package Classes
• Source and Class Files
• Java Applications
• Lab: Exploring MemoryViewer
• Lab: Exploring ColorPicker

The Eclipse Paradigm

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

Session: Getting Started with Java Writing a Simple Class

• Classes in Java
• Class Modifiers and Types
• Class Instance Variables
• Primitives vs. Object References
• Creating Objects
• Lab: Create a Simple Class

Adding Methods to the Class

• Passing Parameters into Methods
• Returning a Value from a Method
• Overloaded Methods
• Constructors
• Optimizing Constructor Usage
• Lab: Create a Class with Methods

Language Statements

• Operators
• Comparison and Logical Operators
• Looping
• Continue and Break Statements
• The switch Statement
• The for-each() Loop
• Lab: Looping
• Lab: Language Statements

Using Strings

• Strings
• String Methods
• String Equality
• StringBuffer
• StringBuilder
• Lab: Fun with Strings
• Lab: Using StringBuffers and StringBuilders

Specializing in a Subclass

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

Session: Essential Java Programming Fields and Variables

• Instance vs. Local Variables: Usage Differences
• Data Types
• Default Values
• Block Scoping Rules
• Final and Static Fields
• Static Methods
• Lab: Field Test

Using Arrays

• Arrays
• Accessing the Array
• Multidimensional Arrays
• Copying Arrays
• Variable Arguments
• Lab: Creating an Array
• Lab: Defining the Student Array

Java Packages and Visibility

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

Session: Advanced Java Programming Inheritance and Polymorphism

• Polymorphism: The Subclasses
• Upcasting vs. Downcasting
• Calling Superclass Methods From Subclass
• The final Keyword
• Lab: Salaries - Polymorphism

Interfaces and Abstract Classes

• Separating Capability from Implementation
• Abstract Classes
• Implementing an Interface
• Abstract Classes vs. Interfaces
• Lab: Mailable - Interfaces

Exceptions

• Exception Architecture
• Handling Multiple Exceptions
• Automatic Closure of Resources
• Creating Your Own Exceptions
• Throwing Exceptions
• Checked vs. Unchecked Exceptions
• Lab: Exceptions

Session: Java Developer's Toolbox Utility Classes

• Wrapper Classes
• The Number Class
• Random Numbers
• Autoboxing/Unboxing
• The Date Class
• Lab: Using Primitive Wrappers

Enumerations and Static Imports

• Enumeration Syntax
• When You Should Use Enumerations
• Using Static Imports
• When You Should Use Static Imports
• Lab: Enumerations

The new Date/Time API

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

Session: Collections and Generics Introduction to Generics

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

Collections

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

Session: Lambda Expressions; Collections and Streams Introduction to Lambda Expressions

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

Java 8 Collection Updates

• Introduce the ConcurrentHashMap
• Lambda expressions and Collections
• Lab: Functional Collections

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
• Lab: Working with Streams

Collectors

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

Session: Multithreading and Concurrency Multithreading

• Principles of Multithreading
• Creating a Threaded Class
• Basic Features of the Thread Class
• Thread Scheduling
• Thread Synchronization
• Lab: Simple Thread Class
• Lab: Simple Runnable Class

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
• Lab: Working with Concurrent Java
• Lab: Sleeping Threads
• Lab: Safe Data Access
• Lab: Producer/Consumer

Session: Java Application Development Introduction to Annotations

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

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
• Lab: Reading Table Data
• Lab: Using JdbcRowSet
• Lab: Executing within a Transaction
• Additional Topics: Time Permitting

Formatting Strings

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

Java 8 Concurrency Updates

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