Intermediate Java

Course Number:


nTier’s intermediate Java training course teaches programming focuses on core Object Orientated Principals and concepts, Unit Testing and Test Driven Development, key Java 8 functionalities. It is intended for students with some previous Java experience or training and who already know the fundamentals of the Java architecture and basic procedural programming. This course provides in-depth coverage of object-oriented concepts and how to apply them to Java software design and development.  This includes the introduction of some core design patterns and the advantages that they bring to an extensible design.

Students must be able to write, compile, test and debug simple Java programs using structured programming techniques, strong data types and flow- control constructs such as conditionals and loops. At least six months of Java experience is recommended.


Course Duration:
5 days


Students must be able to write, compile, test and debug simple Java programs using structured programming techniques, strong data types and flow- control constructs such as conditionals and loops. At least six months of Java experience is recommended.

Course Objectives:
  • Chiefly, learn to program effectively in the Java language
  • Understand Java as a purely object-oriented language, and implement software as systems of classes
  • Implement and use inheritance and polymorphism, including interfaces and abstract classes
  • Utilize Functional Interfaces i.e. Lambdas, java 8 Optional and Java 8 LocalDateTime API
  • Understand the structure of Java 8 streams in Java including predicates, mapping, reducing and finding
  • Use JUnit 5 capabilities to test java classes either vintage and/or Jupiter
  • Use Test Driven development (TDD) to evolve the design, utilize common refactoring techniques to overcome code smells
  • Learn how to leverage Files, and how to use streams to manage file I/O
  • Learn how to use Java Serialization to internalize and externalize potentially complex graphs of objects
Course Outline:
  • • Object-Oriented Software
    • Complex Systems
    • Abstraction
    • Classes and Objects
    • Responsibilities and Collaborators
    • UML
    • Relationships
    • Visibility
  • Inheritance and Polymorphism in Java
    • Extending Classes
    • Using Derived Classes
    • Type Identification
    • Compile-Time and Run-Time Type
    • Polymorphism
    • Overriding Methods
    • Superclass Reference
    • Lab – Build by extension rather than modification
  • Interfaces and Abstract Classes
    • Separating Interface and Implementation
    • UML Interfaces and Realization
    • Defining Interfaces
    • Implementing and Extending Interfaces
    • Default Methods, Static Methods and Functional Interfaces (Lambda)
    • Abstract Classes
    • Lab – Java 8 Interfaces
  • Generics
    • Raw Types
    • Generic Methods and Bounded Type Parameters
    • Upper and Lower Bounded WildCards
    • Type Erasure
    • Lab – Using Generics
  • Unit Testing
    • JUnit Jupiter and Vintage
    • JUnit 5 Life Cycle, @BeforeAll, @BeforeEach, @Test, @AfterEach, @AfterAll,
    • Using assertThat and Hamcrest Matchers
    • Parameterized Tests
    • Testing Exceptions
    • Lab – Unit Testing
  • Test Driven Development (TDD)
    • Defining your API
    • Writing tests First, Design Test, Code, refactor cycles
    • Refactoring techniques and code Smells
    • Test Antipatterns
    • Lab TDD
  • Files and Streams
    • Refactoring to Patterns
    • Factories and Builders
    • Lab – Creational pattern
    • Strategy
    • Adapter
    • Template Method
    • Lab – Structural and behavior patterns
  • Lambdas
    • Functional Interfaces
    • Java.util.function package – Consumer, BiConsumer, Function, BiFunction and Predicate
    • Generics and Type coercion in Lambdas
    • Creating your own Functional interfaces
    • Method References
    • Lab – using Lambdas
  • Java 8 Streams
    • Streams vs Collections
    • Intermediate and Terminal Operations
    • Filtering with Predicates
    • Mapping and transforming, flatMaps
    • Reducing, numeric Streams
    • Lab – simple streams
    • Collectors
    • Grouping
    • Finding elements in streams
    • Parallel Streams
    • Fork and Join framework
    • Lab – Parallel streams, executor
  • Optional
    • Representing optional values instead of using null references
    • Optional.of(), Optional.ofNullable()
    • Using get(), orElse(), isPresent()
    • Lab – using Optional
  • Date and Time API
    • LocalDateTime
    • Formatting Dates
    • Parsing date time objects
    • Lab – LocalDateTime
  • Working with Files
    • Delegation-Based Stream Model
    • InputStream and OutputStream
    • Media-Based Streams
    • Filtering Streams
    • Readers and Writers
    • File Class
    • Modeling Files and Directories
    • File Streams
    • Random-Access Files
    • Lab – Readers and writers
  • Java Serialization
    • The Challenge of Object Serialization
    • Serialization API
    • Serializable Interface
    • ObjectInputStream and ObjectOutputStream
    • The Serialization Engine
    • Transient Fields
    • readObject and writeObject
    • Externalizable Interface
    • JAXB marshalling and unmarshalling
    • Lab – Serialization

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!