Objectives

  • Solidify Java foundational knowledge, including the important contracts of class Object
  • Understand the uses and consequences of inheritance and composition, and reinforce the role of interfaces
  • Reinforce fundamental OO principles such as cohesion, coupling, and polymorphism
  • Use the JUnit testing framework and become fluent in writing assertions to verify correct program behavior
  • Familiarity with UML modeling in class diagrams and sequence diagrams
  • Use advanced techniques for object creation, including factories and singletons
  • Use established design patterns for object composition, including Strategy, Decorator, and Facade
  • Write and use generic classes and methods
  • Learn the use cases for inner classes and refactor existing code to use them when appropriate
  • Create and use custom annotations
  • Be familiar with reflection and how to use it
  • Understand the role of functional interfaces introduced in Java 8
  • Understand lambda expressions and method references, and use them to pass behavior (methods)
  • Use the Stream API to perform complex processing of collections and other input sources
  • Learn the new Date/Time API and use it to solve date-oriented business problems
  • Use Javadoc to write professional-grade API comments for your classes
  • Understand build tools such as Ant and Maven, and how to manage application dependencies
  • Write appropriate log statements in your code and configure logging with Log4j

Prerequisites

 No programming experience necessary

Duration

Five Days

Outline for Intermediate & Advanced Java (Java 8 based)

Chapter 1: Review - Basics

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

Chapter 2: Review (Inheritance and Interfaces)

  • UML Overview
  • Inheritance
  • Definition and IS-A Relationship
  • Method Overriding, @Override
  • OO Principles: Principle of Substitutability, Polymorphism and Encapsulation of Type, Coupling, Open-Closed Principle
  • Constructor Chaining
  • Interfaces
  • Defining and Implementing, Interface Types
  • Interface Inheritance
  • New Interface Features in Java 8
  • Default Methods, Static Methods
  • Functional Interfaces
  • Guidelines

Chapter 3: JUnit

  • Overview
  • Tests, Assertions, and Fixtures
  • Writing and Running Tests
  • Assertions
  • Test Fixtures, @Before and @After, @BeforeClass and @AfterClass
  • Testing for Exceptions
  • Best Practices and Test-Driven Development Overview (TDD)

Chapter 4: Collections and Generics

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

Chapter 5: Techniques of Object Creation

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

Chapter 6: Using Composition and Inheritance Effectively

  • 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

Chapter 7: 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

Chapter 8: Annotations

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

Chapter 9: Reflection

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

Chapter 10: 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

Chapter 11: 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, Consumer, Supplier
  • Stream Processing
  • Filtering, Sorting, Mapping
  • Terminal Operations
  • Collectors
  • Partitioning and Grouping
  • Reducing and Summarizing
  • Downstream Reductions

Chapter 12: Date/Time API

  • Overview
  • Dates, Times, and Instants
  • Creating, Parsing, and Formatting
  • Accessing Date and Time Fields
  • Deriving New Values
  • Time Zones
  • Periods and Durations
  • Intervals of Time: Date-Based and Time-Based
  • Adding and Subtracting Intervals

Chapter 13 (optional): Overview of Build Tools

  • Javadoc
  • Generating API Documentation
  • Doc Comments and Doc Tags
  • Ant
  • History and Overview
  • Buildfiles, Targets, and Tasks
  • Maven
  • Maven Concepts: Project, POM, Artifact, Naming, Dependency, Plugin, Repository
  • Convention over Configuration
  • Lifecycles and Phases
  • Plugins and Goals

Chapter 14 (optional): Logging and Log4j

  • Overview
  • Popular Logging Frameworks
  • Writing Log Messages
  • Creating Loggers and Writing Log Messages
  • Log Levels
  • Configuration
  • Appenders and Layouts
  • Logger Configuration and Logger Hierarchy