Intermediate/Advanced Java 11+

Course Number:

NTX335

Audience:

Course Duration:
5 days

Prerequisites:

Working knowledge of Java programming, including use of inheritance, interfaces, and exceptions.

Course Objectives:
  • Solidify Java foundational knowledge
  • Understand the uses and consequences of inheritance and composition
  • Reinforce fundamental OO principles
  • Test code by using JUnit
  • Model class diagrams using in UML
  • Implement popular design patterns
  • Leverage generic typing
  • Create and use custom annotations
  • Use reflection to read and modify code at runtime
  • Understand the role of functional interfaces, lambda expressions, and method references
  • Use the Stream API to perform complex processing of data
  • Create and use Java modules
  • Understand the structure and behavior of the modular JDK, and how it supports modular applications as well as legacy classpath-based code
  • Migrate classpath-based applications to Java 11, understanding the stages of migration and options available
Course Outline:

Review of Java Basics

  • Java Environment
  • Classes and Objects
    • Instance Variables, Methods, Constructors, Static Methods
    • OO Principles: Data Encapsulation, Cohesion
    • Object Contracts: toString(), equals() and hashCode(), Comparable and Comparator
  • Packages, Enums, Arrays
  • Exceptions
  • Date and Time API
  • New Language Features

Review of Inheritance and Interfaces

  • UML Overview
  • Inheritance
    • Definition and IS-A Relationship
    • Method Overriding
    • OO Principles
    • Constructor Chaining
  • Interfaces
    • Defining and Implementation
    • Interface Inheritance
  • Interface Features (Java 8+)
    • Default Methods, Static Methods
  • Guidelines

JUnit

  • Tests, Assertions, and Fixtures
    • Writing and Running Tests
    • Assertions
    • Testing for Exceptions
  • Best Practices in Testing
  • Test-Driven Development (TDD)

Collections and Generics

  • Collections Overview
    • Generics and Type-Safe Collections
    • Diamond Operator
  • Lists, Sets, and Maps
    • Interfaces and Contracts
    • Iteration and Autoboxing
    • Utility Classes
  • Writing Generic Classes
    • Inheritance with Generic Types
    • Wildcard Parameter Types
    • Type Erasure

Techniques of Object Creation

  • What are Design Patterns?
  • Controlling Object Creation
    • Limitations of new Operator, Alternative Techniques
  • Singleton Pattern
  • Simple Factory
  • Factory Pattern
  • Other Techniques
    • Named Objects, JNDI
    • Dependency Injection Frameworks

Effective Use of Composition and Inheritance

  • Inheritance and Composition – Pros and Cons
    • Composition and Delegation
    • HAS-A, USES Relationships
  • Strategy Pattern
  • Decorator Pattern
  • Façade and Other Patterns
    • Façade, Proxy, Template Method

Inner Classes

  • Overview and Motivation
    • Stronger Encapsulation, Rules and Caveats
  • Defining and Using Inner Classes
    • Member-Level, Method-Local, Anonymous Classes
  • Static Nested Classes
    • Nested Classes, Nested Interfaces, Nested Enums

Annotations

  • What are Annotations?
  • Using Annotations
    • Target and Retention Policy
    • Annotation Parameters, Parameter Shortcuts
  • Writing Custom Annotations
    • Syntax, Using the Meta-Annotations
    • Using a Custom Annotation

Reflection

  • Overview and API
    • The Class Called Class
    • Obtaining and Inspecting Class Objects
  • Working with Objects Reflectively
    • Creating Instances, Invoking Methods, Setting Field Values

Lambda Expressions

  • Functional Interfaces and Lambdas
  • Target Context
  • Using Lambda Expressions
    • Syntax, Lambda Compatibility
    • Variable Capture
    • Type Inference
  • Method References
    • Three Types of Method References
    • Refactoring Lambdas into Method References
  • Strategy Pattern

Streams

  • Overview
    • Streams vs. Collections
    • Anatomy of a Stream
  • Understanding the Stream API
    • Intermediate Operations and Stream Pipeline
    • Java 8 Functional Interfaces: Predicate, Comparator, Function
  • Stream Processing
    • Filtering, Sorting, Mapping
    • Terminal Operations
  • Collectors
    • Concepts
    • Partitioning and Grouping

Introduction to Modules

  • Motivation and Overview
  • Types of Modules
  • Modular JDK
  • Our Approach

Working with Modules

  • Defining and Using Modules
  • Services
  • Compatibility and Migration
  • Conclusion
Share on facebook
Share on twitter
Share on linkedin
Share on email

Related Posts

About Us

IT Training, Agile Ways of Working and High Impact Talent Development Strategies

Let Us Come to You!

Classes recently delivered in: Atlanta, Boston, Chicago, Columbus, Dallas, Detroit, Indianapolis, Jerusalem, London, Milan, New York, Palo Alto, Phoenix, Pittsburgh, Portland, Raleigh, San Antonio, San Diego, San Francisco, San Jose, Seattle, Springfield, Mass., St. Louis, Tampa and more!