Fast Track to Java 8
CLASS DATE(s):
Request a Class

COURSE LENGTH: 5 Days

COURSE COST: $2795.00

COURSE TIMES: 9:00am - 4:30pm

Printable version of this course
print

COURSE OVERVIEW

Introductory Java Course starting with basic principles providing:
* A solid foundation in object-oriented concepts and good practices
* Coverage of all core Java Technology
* Skills needed to write good Java-based technology
* Coverage of database access with JDBC/JPA

Be prepared to work hard and learn a great deal!

There are numerous hands-on labs
* Exercising all the important concepts discussed * Lab solutions are provided
The course supports all recent versions of Java
Learn Java's architecture and uses
Understand Java language basics
Compile and execute Java programs
Learn object-oriented (OO) programming and the object model
Learn (and practice!) Java naming conventions and good Java coding style
Create well-structured Java programs

AUDIENCE AND PREREQUISITES

This course is intended for individuals who are Java programmers and have worked with databases and with object-oriented programming techniques, who are now ready to create more complex and advanced programs using Java SE 8. Students should be skilled and experienced in using Java. They should have knowledge of database structures and terminology. Also, they should be familiar with object-oriented programming. To ensure your success, we recommend you first take the Logical Operations courses or have equivalent knowledge.

Introduction to Programming Using Java
Object-Oriented Programming and Design Using Java (Third Edition)
Java Fundamentals (Java SE 7)

  

This course is subject to a minimum enrollment. If the minimum enrollment is not met the class may run as a virtual instructor led class. Courseware is not included it is an additional cost. Electronic Courseware. For more details, please contact email: learn@vtec.org or call: 207.775.0244.

COURSE TOPICS:


Fast Track to Java 8 and OO Development
Course Overview
Course Objectives
Labs
Typographic Conventions
Course Outline

Session 1 - A Simple Java Class and Running a Java Program
A Simple Application Class
The HelloWorld Program Broken Down
Compiling HelloWorld
Lab 1.1 - HelloWorld

Session 2 - Java Overview
Language and Platform Features
What is Java, Java is Modern & Object-Oriented, Portable and Safe, Java has Multiple Platforms
Program Life Cycle
Java Source and Java Bytecode, Life Cycle of Java Program,
Java Programs Insulated From Environment
Java is Dynamic - The Runtime Process
The Java SE Development Kit (JDK)
The Java API, Downloading & Installing the JDK
Lab 2.1 The Development Environment

Session 3 - Class and Object Basics
Object-Oriented Programming
What is an Object?
Important Characteristics of Objects?
About Object-Oriented Programming (OOP)
What's a Type? Types, Instances, and Property Values
Classes and Objects
Lab 3.1 - Exploring Types, Lab 3.2 - Identity and Object References
Classes, References, and Instantiation
The Class in Java, Class Definition, A Class Definition is a Blueprint, Creating & Referencing Objects
Methods and Data in a Class
Behavior & Methods, Invoking Methods, Storing Data in Objects, About Instance Variables
Data Access and Return Values in Methods, Accessing Data (Another Way)

.
Pretty Pictures, More About Variables,
About Java Primitive Data Types, Numeric Literals
Non-Numeric Literals, Strings, Primitive Types and Value Types
Arithmetic Operations
Primitive Type Conversion and Casting
Lab 3.3 - Writing a Class Definition

Session 4 - More on Classes and Objects
Working With Methods and Data
Calling Methods, Local Variables, The this Variable and Instance Data
Pretty Pictures, Overloading Methods, Calling Overloaded Methods
The toString() Method
Encapsulation and Access Control, Black Boxes
Key Advantages of Encapsulation, Program Correctness
Access Control, Access for Data Members and Methods
Constructors, Using Constructors
Explicit Constructor Call
Lab 4.2 - Adding Constructors to a Class
Static or Class Members, Static Data members and Methods
Declaring Static Members, Accessing Data in Static Methods, Final Variables

.
Lab 4.3 - using static Members (Optional Lab)
Type-Safe Enums, Enumerated Types Defined, Enum Types
More enum Examples, enum Features, switch on enum, for-each with enum
Advanced enum Features
Problems with int Enumerated Types
Lab 4.4 - Thinking About enums (Discussion-Only Lab)
Other Language Details
Scopes and Blocks, Scope Example, Assignment, Comparison, Null Objects,
Wrapper Classes
Reference Types and method Parameters,
Final method Parameters
Lab 4.5 - Debugging

Session 5 - Flow of Control
Branching Statements, Program Execution Sequence in Java
The Comparison Operators, The Logical Operators
if-else Statement, switch Statement
Iteration Statements, while Statement
do-while Statement
for Statement
break Statement
continue Statement
Lab 5.1 - Data Validation

Session 6 - Strings and Arrays
String and StringBuffer/String Builder
Using Strings, Changing Strings
Classes String Buffer and String Builder
Regular Expressions
Arrays, Creating Arrays and Accessing Elements
Arrays of Object References, Array of Strings
args Array, Iterating Over Arrays
varargs, Multidimensional Arrays
Lab 6.1 - Arrays

Session 7 - Packages
Packages Overview
Dealing with Complexity, Packages, Package Statement
The Default (or Unnamed) Package
Import Statement, The import Statement
Importing a Complete Package, Importing a Single Package Member
Using the Fully Qualified Name, Standard Imports
Resolving Naming Conflicts
Creating Packages, Access Control for Class Members

Session 8 - Composition and Inheritance
Dealing With Complexity and Composition
Composition, Delegation, Benefits of Composition, Delegation
Benefits of Composition, Issues with Composition
Object Relationships, Other Kinds of Relationships
Lab 8.1 - Composition
Inheritance and Dealing with Complexity
Inheritance Hierarchy, The extends Keyword
Inheriting from the Superclass, Inheritance and Superclass Data Members
A Subclass IS-A Superclass, Accessing Superclass members, Constructors and Inheritance, Final Classes,
Lab 8.2 - Inheritance
Overriding & Polymorphism
Changing Behavior with method Overriding, OO Concepts - Polymorphism

.
Importance of Polymorphism, The super Keyword, Access Control - protected Access
@Override,
Lab 8.3 - Polymorphism
Class Object, Methods of Class Object, class Object, Methods of Class Object
Automatic Storage Management
Abstract Classes, Abstract methods, Using Abstract Classes

Session 9 - Interfaces
Interface Basics
What if All You Have to Share is an Idea
Interface Types, Interface Definitions, The implements Keyword
Example of Using Interface Types, Interface Types as References
Interface Types as References, Extending Interfaces
Implementing Extended Interfaces
Example of Using Interface Types
Interfaces are Abstract
Data members in Interfaces, Data Members in Interfaces
Implementing Multiple Interfaces
Lab 9.1 - Interfaces
Default Methods and static Methods (Java 8+)

.
Using and Uses Default Methods, Static Methods in Interfaces (Java 8+)
Lab 9.2 Default method

Session 10 - Exceptions
Exception Hierarchy, Overview of Exceptions, Exception Hierarchy
Checked and Unchecked Exceptions, Core Exception Classes
Handling Exceptions try and catch
Exceptions and Program Flow, Variable Scope, The throws Clause
Throwing Exceptions with throw, User-Defined Exceptions, Multiple catch Blocks, finally Block
Runtime Exceptions, Multicatch (Java7)
Using try-with-resources (Java 7)
Lab 10.1 - Using Exceptions

Session 11 - Collections and Generics
Java Collections Framework Overview
java.util Collection Interfaces, Collection Interfaces
Collection Interface, Generics and Type-Safe Collections
List and ArrayList, List Interface, ArrayList, Using ArrayList - Example
Autoboxing and collections of Object, Autoboxing
Using Autoboxing/Unboxing - Example
Summarizing collection Features
Collections of Object, Issues with Collection of Object
Lab 11.1 - using collections, Other Collection Types
Set Interface, using Sets, map Interface, HashMap, HashMaps
Creating and Using HashMap, Iterating Through a HashMap
lab 11.2 - Using Sets

.
Iterator, Processing items with an Iterator
Iterator Interface, using Iterator - Example
[Optional] More About Generics, What Are Generics
Declaring a Generic Class, Summary - Basic Generics Usage
Using Generics - Example, Inheritance with Generic Types
Assignment with Generic Types, Wildcard Parameter types, Generic Methods
[Optional] The Collections Class, Collections Class
Unmodifiable Wrappers, Example, Checked Interface Example,
Algorithms, Sort Example, Review Questions

Session 12 - Database Access with JDBC and JPA
JDBC Overview, What is JDBC?
JDBC Architecture, The Fundamentals JDBC API,
Common JDBC Types, Naming Databases with URLs, The Item Database Table
Database Connection - Example, Using Statement - Example
Using Prepared Statement - Example
JPA Overview, Java Persistence API (JPA) Overview
JPA Architecture - High Level View
JPA Architecture - Programming View
Working with JPA, Entity Classes, MusicItem Entity Class
Annotations in Brief, Additional MusicItem Annotations
Lab 12.1 - Mapping an Entity Class
The Persistence Unit, persistence.xml Structure, The Entity Manager

.
JpA EM and EMF Example, Working with Transactions
Complete JPA Example
Lab 12.2 - using JPA
Persisting a New Entity, Updating a Persistent Instance
Removing an Instance, Executing a Query
Lab 12.3 - Insert/ Query Demo

Session 13 - Additional Language Features
Date / Time Support
Previous Java Date / Time Support - History
Java 8 Date / Time Support - Overview
Creating Dates and Times - now () and of ()
Creating Dates and Times - parse (), Formatting Dates and Times - format ()
Accessing Date/Time Fields - getXXX(), get ()
Comparing Instances, Deriving New Values Using with (), Adding / Subtracting Time, Duration and Period, Instance, Time Zones
[Optional] Lab 13.1: Working with Dates and Times
Assertions, Defined, Uses, Non-Uses, Syntax
Using Assertions to Check State - Example, Flow of control
Enabling/Disabling Assertions at Runtime,
Enabling/Disabling Assertions - Examples

.
Annotations, the Issue, Annotations - The Solution
Using Annotations Example
Lambda Expressions (Java 8)
Motivation: Common Actions are Verbose, Solution: Lambda Expressions
How Lambda Expressions Work, Lambda Expression Syntax
Lab 13.2: Working with Lambdas (Demo)
Other Java Features
XML and Web Service Support, Java DB
Scripting Language Integration , Monitoring and Management Tools
Other Features

Session 14 - I/O Streams (optional)
Readers's and Writiers
Overview of I/O Streams, Character Streams, Class Reader & Writer
Common Reader Subclasses, Writer Subclasses
Using Readers and Writers, - Example
Path Separators, High-Level (Filtering) Streams, BufferedReader - Filtering Stream Example
Converting Between Streams and Readers/Writers
Byte Stream Classes, Common Stream Subclasses,
Converting Between Byte & Character Streams
Character Stream & Byte Stream Equivalents
Formatted Output, Integer Format Specifiers
Format Specifier Modifiers Example, Other Format Specifiers
The File Class, The java.io.File Class, File Example (1 of 2), (2 of 2)

New I/O (NIO) and (NIO.2 (Java 7+)
New I/I (NIO and NIO.2)
NIO Features, NIO.2: Package java.nio.file
Using Paths, Working with Paths / Files
Reading/Writing/Creating Files
Other NIO.2 Capabilities
Lab 14.1 - Formatted Output