S9K Training


 

Consulting & Training by Randall Nagy


Randall

Overview

Training

Community

Custom R&D

Soft9000.com

Object Oriented Java Software Development

Our custom Java training offering is unique. Designed for the complete beginner, this training opportunity uses a decidedly Agile approach. The student will continuously enhance a singe Java Application throughout the majority of this class.
Divided into an "introductory" and "advanced" class, a video version of our training is now available for immediate presentation at GoGo Training.
This training provides a requirements-grounded understanding of Java Software Development, Threads, Classes, Interfaces, as well as Requirement & Software-Documentation techniques.

Delivery

Pricing based upon attendance.
United States & Canada.

Duration

5 Days.

Overview

This intensive, hands-on course teaches programmers how to develop a single requirement set from a Console, to a Graphical, Application.
Presented as an evolving set of requirements, students will covering such advanced concepts as Streams, File-systems, Databases, and Property files. Along the way students will also learn how to create and manage Java Processes, Threads, as well as how to consume Web Services.

Training Outline

This training is 50% Lecture, and 50% Code:

Introduction To Java Programming

  • Part One: What is Programming?
  • The IPO Model
  • The Classical Programming Process
  • The Java Programming Process (WORA)
  • A Java Programming Example
  • Human View (Java)
  • Java File Names & Tools
  • Compiler
  • JVM
  • Crafting Java
  • Gedit, & Notepad
  • Comping Java
  • Running Java
  • What is an IDE?
  • How They Work
  • Popular IDEs
  • EXERCISE 1.1: Installing JAVA

Part Two: Java Programming

  • What is a Keyword?
  • Program Blocks Revisited
  • Processing: Using if
  • What is a Variable?
  • Java Variables
  • Java Variable Examples (JavaOne)
  • Java Packaging
  • Folders & Files
  • Basic Input, Output & Processing
  • Java IOP Examples
  • Note: return-ing Data:
  • EXERCISE 1.2: Reading Integral Input

Java Keywords & Primitive Types

  • Java Structure Revisited
    • Nested Blocks
    • Comments
    • Statements
  • Simple “If” “then” “else”
  • Requirement Overview
  • Flowchart Example
  • A Simple if, then, else
  • Requirement Verification
  • More Keywords
  • Java Primitives
  • Logical
    • Boolean if, then, else
    • Boolean Flowchart
  • Integer
  • Precision
  • Char & Byte Keywords
  • Putting It Together: MyInfo Class
  • Primitive –v- Complex Type Identification
  • Discussion: Our New “MyInfo” Type
  • Using Java’s ‘while’
  • Using ‘do / while’
  • Using post-increment
  • Keyword Inventory (Where Are We?)
  • EXERCISE: Classic Console Loop

More Keywords & Classes

  • Importing Packages
  • Full Qualification
  • Classic Import
  • Static Import
  • Wrapper Classes
  • New
  • Boxing & Un-boxing
  • Using Java’s String
  • Requirements: Split a String
  • Using ‘break’ & ‘continue’
  • Introduction to Array
  • String: Array of Chars!
  • String: Array of Bytes?
  • Java’s ‘for’ Keyword
  • Iteration
  • Java’s Classic ‘for’ Keyword
  • Pre-increment
  • Java Operators
  • Precedence or Parentheses?
  • EXERCISE: Using Arrays

Basic Object Relationships

  • Class Cooperation
  • Class & Package Names
  • Static & Dynamic
  • Static Imports
  • Dynamic ‘new’
  • Dynamic Class Example
  • Inheritance, Scope & Visibility
  • Default Inheritance
  • Object: Common Parent
    • .toStirng()
    • .hash Code()
    • .equals()
    • Test: .equals() -v- Equality Operators
  • A UserId Class
  • Overriding Object
  • Test: New Type, Same Results!
  • Adding @Override Annotation
  • Object.getClass() (advanced)
  • The 3P’s
    • Class Members
    • Class Attributes
    • Encapsulation
    • The Public POJO
    • Protecting POJO
  • The Switch Keyword
  • EXERCISE: Using POJO

Object-Oriented Programming

  • Constructors
  • DIAGRAM: The Free Constructor?
  • super
  • this
  • Constructor Order
  • Parameterized construction
  • Re-using Constructors
  • Nested Classes
  • Static / Non-Static
  • The Three Pillars of OOP
    • One: Encapsulation
      • Data Hiding
      • public, private & protected
    • Two: Inheritance
      • Extending a Class
      • Diagram: Using Super
      • Re-Using Parent Members
      • EXAMPLE: Extending a class
    • Three: Polymorphism
    • Trees of Objects?
    • Overloading
    • Overriding
    • Casting Revisited (instanceof)
    • Overcoming Inheritance Issues
      • Single, Multiple, or Diamond?
      • Java Solution? Interfaces!
  • EXAMPLE: Implementing an Interface
  • Abstract Classes
    • Partial Implementations
    • Tree of extension
  • Enumerations – Newfangled Class?
    • The 'public static final' revisited
    • Enumerated Anatomy
    • Exceptions -v- Enumerations
  • EXAMPLE: Adding Enumeration
  • EXERCISE: POJO Inheritance & Enumerations

Collections & Exceptions

  • Templates
  • Getting Generic?
  • Parameterized Types
  • Processing Arrays
  • Copying Arrays
  • Passing Arrays (… notation)
  • Array Support Class
  • Collections: Beyond Array?
  • Templates
  • Java Collection Types & Interfaces
  • The List Family Tree
  • The Set Family Tree
  • The Map Family Tree
  • Exception Handling
  • The try Keyword
  • The catch Keyword
  • The finally Keyword
  • The throw & throws Keywords
  • The Exception Hierarchy
  • Compile-Checked Exceptions
  • Run-Checked Exceptions
  • Managing Chaos: The throws Keyword
  • EXERCISE: Exceptions & Collections

Files & Persistence

  • New Keywords
  • Final
  • Assert
  • Persistence & The File Class
  • File Operations
  • Streams
  • isDirectory?
  • Activity: File Recursion
  • Hierarchy
  • Buffered
  • Un-buffered
  • Text & Binary
  • Object I/O
  • Useful Objects
  • Persistence Support
  • Property Files
  • Java Serialization (binary)
  • EXAMPLE: File I/O as Binary Streams
  • EXERCISE: Managing Run-Time Data (Collections & Java Serialization)

Local Processes & Threads (Part One)

  • Processes
    • What is a Process
    • Command-Line Processing
    • In, Out & Error
  • Shells - Not Just Java!
    • What is a Shell?
    • “Shelling Out” in Java (conceptual)
    • Two Ways to “Exec”
      • Internal
      • External
  • Uneven Support
    • Command-Line Support
    • Liunx & OS/X Piping
    • DOS Piping
  • ACTIVITY: Piling’s Hot!
  • Threading Techniques in Java
  • Extending the Thread Class
  • Implementing Runnable
  • Thread States
  • Synchronization
  • Create multi-threaded programs and use thread modifiers
  • EXERCISE: Executing & Testing Your Program From Another

Local Processes & Threads (Part Two)

  • Accessing Remote Applications / Processing
  • Networking Fundamentals
  • URL, Buffering, & Streaming Support
  • The final Keyword Revisited
  • public static final?
  • WHY ARE WE SHOUTING?
  • Character Serialization
  • JSON
  • XML
  • POJO Serialization & XML
  • Annotations
  • Anonymous Classes
  • Variable Argument in Java
  • What is a JAR?
  • The role of Web Service Architecture
  • SOAP
  • REST
  • BEST
  • AWS / Open Stack / Nebulae
  • EXERCISE: Adding A Thread (& Reading Soft9000.com's Log Book!)
  • (aka: Working with networked Java applications)

Graphical user interface (GUI) using Java classes

  • SWING Components
  • Program using Java event listeners
  • JOption Pane
  • Anonymous Classes
  • EXERCISE: Going GUI!

Working with Java Database Connectivity (JDBC)

  • SQL Defined
    • DDL / DDML?
    • CRUD
    • Creating Tables
  • SQLite -v- MySQL
    • Managing Databases
    • JDBC & Driver Types
    • Embedding Data
  • Testing & Testing Practice Overview
  • jUnit & Assert

Java-Oriented Programming

  • More Useful Classes
  • The Math Class
  • The Date Class
  • Big Decimals?
  • Decimal Formats
  • Parsing Data
  • Managing Chaos: Conventions & Documentation
  • Deprecation = Annotation
  • Documentation & Javadoc
  • Package & Class Documentation
  • Class Member Documentation
  • EXERCISE: Getting Professional (JavaDoc)

The Revelation & Evolution of Java

  • Java 1.4 -v- Java 1.5
  • EXERCISE: Adding Annotations
  • Java 1.5 -v- Java 1.6
  • EXERCISE: Replacing Vector
  • Java 1.6 -v- Java 1.7
  • EXERCISE: Using “Diamond Notation”
(mod) (mod)