JAV160 - Fast Track to Java and OO Development

Course Description

Short Course | 30 hours | 3.0 CEUs | $2,995

This course provides a comprehensive introduction to Java. It is suitable for programmers with good working programming experience (no Java experience needed).

In addition to covering basic Java programming, the course provides a solid understanding of the core OO and Java concepts and practices needed to create well-designed Java programs. This includes creating well-designed Java classes, encapsulation, composition, and inheritance/interfaces.

The material and labs include coverage of useful new Java capabilities such as the new module structure (Java 9), type inference (Java 10-11), and API enhancements. It also introduces important APIs such as the Java Collections Framework, and JDBC/JPA. This course is suitable for environments using Java 9-12. It also covers details of the Java release cycle, and Long Term Support (LTS) releases.

Be prepared to work hard and learn a great deal!

Course Outline

• Session 1: A First Look
  • A Simple Java Class
  • Java’s “Hello World” Program
  • The Java Shell (REPL)
    • LABS:
    • Hello World: A Simple Application
• Session 2: Java Basics
  • Language and Platform Features
  • The Java Release Cycle
  • Program Life Cycle
  • The Java SE Development Kit (JDK)
    • LABS:
    • Working with the Development Environment
• Session 3: Class and Object Basics
  • The Object Model and Object-Oriented Programming
  • Classes, References, and Instantiation
  • Adding Data to a Class Definition
  • Adding Methods (Behavior)
    • LABS:
    • Exploring Types and Object Instances
    • Writing and Using a Class Definition with Fields and Methods
• Session 4: More on Classes and Objects
  • Accessing data, the "this" variable
  • Encapsulation and Access Control, public and private Access
  • Constructors and Initialization
  • Static Members of a Class
  • Type Inference (Java 10+)
  • Scopes, Blocks, References to Objects
  • Type-safe Enums
    • LABS:
    • Encapsulation / Access Protection
    • Writing and Using Constructors
    • (Optional) Static Members
    • Using enums
    • Using the Debugger
• Session 5: Flow of Control
  • Branching: if, if-else, switch
  • Iteration: while, do-while, for, break, continue
    • LABS:
    • Flow of Control / Data Validation
• Session 6: Strings, Arrays, and Dates/Times
  • String, StringBuffer, StringBuilder
  • Arrays, Primitive Arrays, Arrays of Reference Types
  • varargs
  • LocalDate/LocalTime (Java 8+)
    • LABS:
    • Using Strings and Arrays
• Session 7: Packages and Modules
  • Package Overview - Using Packages to Organize Code
  • import statements
  • Creating Packages, package Statement, Required Directory Structure
  • Java 9 Module Overview
  • Defining Modules, Requires, and Exports
  • Module Path and Classpath - Differences and Coexistence
    • LABS:
    • Using Packages and Modules
• Session 8: Composition and Inheritance
  • Using Composition to Deal With Complexity
  • Composition/HAS-A, Delegation
  • Using Inheritance and Polymorphism to share commonality
  • IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
  • Class Object
  • Abstract Classes
    • LABS:
    • (Optional) Working with Composition
    • Using Inheritance to Specialize Classes
• Session 9: Interfaces
  • Using Interfaces to Define Types
  • Interfaces and Abstract Classes
  • Default Methods and static Methods (Java 8)
    • LABS:
    • Using Interfaces to Remove Implementation Dependencies
• Session 10: Exceptions
  • Exceptions and the Exception Hierarchy
  • Try and catch
  • Handling Exceptions
  • Program Flow with Exceptions
  • Finally
    • LABS:
    • Throwing and Handling Exceptions
• Session 11: Java Collections and Generics
  • The Collections Framework and its API
  • Collections and Java Generics
  • Collection, Set, List, Map, Iterator
  • Autoboxing
  • Collections of Object (non-generic)
  • Using ArrayList, HashSet, and HashMap for each Loop
  • Processing Items With an Iterator
  • More About Generics
    • LABS:
    • Using Lists and Generics
    • Using Sets
• Session 12: Database Access with JDBC and JPA
  • li>JDBC Overview
  • JDBC Architecture and API
  • Using DriverManager, Connection, Statement and ResultSet
  • JPA Overview
  • JPA Architecture and Programming View
  • Entity Classes and Annotations
  • Mapping an Entity Class
  • EntityManagerFactory and EntityManager
  • Working with JPA (Find by primayry key and inserts)
    • LABS:
    • Mapping an Entity Class
    • Working with JPA
• Session 13: Additional Java Features
  • Annotations
  • Lambda Expressions and Method References (Java 8+)
  • Additional Features
• Session 14: I/O Streams (As Time Allows)
  • Readers and Writers
  • Filter Streams
  • Byte Streams
  • Formatted Output
  • The File Class
  • New I/O (NIO) APIs
    • LABS:
    • Formatting Output

Learner Outcomes

• Understand Java’s importance, uses, strengths and weaknesses
• Understand the release cycle and Long Term Support (LTS) releases
• Understand Java language basics
• Write, compile, and run Java programs
• Use the Java shell (JShell - Java 9+) for interactive programming
• Understand the Object Model and Object Oriented Programming
• Understand and use classes, inheritance, polymorphism
• Create well designed classes and use them in your Java programs
• Use composition and delegation to create objects from other objects
• Understand & use packages to organize code
• Understand and use Java 9 modules
• Understand interfaces, their importance, and their uses
• Use interfaces to implement abstraction
• Learn good Java coding style
• Create well structured Java programs
• Compile and execute programs with the JDK development tools and with an Integrated Development Environment (IDE) of your choice
• Use the core Java libraries (java.lang, java.util)
• Understand & use exceptions for error handling
• Understand the basics of using JDBC and JPA, and use them to access databases from Java
• Use the Java Collections Framework including new API introduced in Java 9-11
• Use other new features such as type inference
• Be aware of, and use the new features of Java 9-11, as well as important advanced features of earlier Java versions
• Understand and use basic I/O streams (As Time Allows)

Duration