Intermediate/Advanced Java Training

Intermediate/Advanced Java Training (JVA104)

Course Length: 5 days
Delivery Methods: Available as private class only
Course Overview

This modern, fast-paced Intermediate Java Programming course is suitable for developers with previous experience in Java and Object-Oriented (OO) programming. It is also ideal for developers proficient in other OO languages, such as Python, C++, or C#, who want to deepen their Java skills. The course includes numerous optional parts, allowing customization based on your group’s needs, making it flexible enough for advanced Java developers seeking to enhance their knowledge.

The course begins with an accelerated yet thorough hands-on review of Java foundational concepts, focusing on OO design and implementation principles. This review covers essential topics such as Java syntax, control structures, and object-oriented principles, alongside newer language features like the Date/Time API (Java 8+), type inference with var, and switch expressions. This section ensures all participants are aligned on core Java concepts before moving into more complex material.

Next, you’ll explore Advanced Object-Oriented Programming (OOP) concepts, including inheritance, polymorphism, abstract classes, interfaces, and design patterns such as Singleton and Factory. You’ll learn to make critical decisions about using composition versus inheritance, a key skill for creating well-structured OO systems. This section emphasizes OO design principles that enhance code maintainability and scalability.

The Java Collections and Generics module covers advanced data structures like linked lists, hash maps, and trees, with a focus on type-safe collections using generics. You’ll learn to implement custom collections, optimize data storage, and perform complex data manipulations, enhancing your ability to work efficiently with data.

In the Functional Programming module, you’ll dive into lambdas, streams, and functional interfaces, learning to write cleaner, more efficient code. You’ll also explore the Java Platform Module System (JPMS), which represents a fundamental shift in application organization and library integration. Migration strategies and a step-by-step case study provide practical insights into adopting JPMS in existing projects.

Exception Handling and Debugging are emphasized throughout, where you’ll learn advanced techniques for managing exceptions and using try-with-resources for I/O operations. You’ll gain hands-on experience in debugging with IDE tools, step through code, and optimize performance, essential skills for professional Java development.

The Input/Output (I/O) and Serialization module teaches you to read and write files, manage streams, and handle object serialization, ensuring you can manage data efficiently within your applications. The Networking and Sockets section covers client-server application development, focusing on TCP and UDP protocols, sockets, and secure data exchange.

Concurrency and Multithreading are explored in-depth, focusing on creating responsive applications that perform multiple tasks simultaneously. You’ll learn about thread synchronization, the Executor framework, and techniques for avoiding concurrency pitfalls like deadlock. This module prepares you to build high-performance applications that leverage Java’s concurrency capabilities.

The Database Integration with JDBC module covers connecting Java applications to relational databases, performing CRUD operations, and managing database connections. This section equips you with the skills to integrate Java with databases, ensuring data is handled efficiently and securely in your applications.

JavaFX and GUI Programming provide an introduction to building interactive graphical user interfaces, with coverage of scene graphs, layout managers, and event handling. This module helps you develop visually appealing and user-friendly applications that enhance the overall user experience.

Beyond core Java programming, the course includes important topics such as UML and Design Patterns, equipping you with the skills to model and design complex systems effectively. You’ll also learn about best practices in Java development, including code optimization, test-driven development (TDD) with JUnit, and clean code principles.

Unit testing is integrated throughout the course, with most labs implemented as JUnit tests, reinforcing the importance of testing in software development. The hands-on nature of the course, with numerous code examples and programming labs, ensures you can immediately apply what you’ve learned to your current projects.

This course is designed to be highly flexible and can be tailored to fit your specific learning needs. Be prepared to work hard, dive deep into advanced Java topics, and significantly enhance your programming skills, setting you on the path to becoming a more proficient and productive Java developer.

Course Benefits
  • 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.
  • 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.
  • Create and use Java modules, understanding module descriptors, modular JARs, exports and dependencies, and the modulepath.
  • 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
  1. Java State of the Union
    1. Java Release Cycle
    2. New Java Versions
  2. Review - Basics
    1. Java Environment
    2. Classes and Objects
      1. Instance Variables, Methods, Constructors, Static Members
      2. OO Principles: Data Encapsulation, Cohesion
      3. Object Contracts: toString(), equals() and hashCode(), Comparable and Comparator
    3. Packages, Enums, Arrays
    4. Exceptions
    5. Date and Time API
    6. New Language Features
  3. Review (Inheritance and Interfaces)
    1. UML Overview
    2. Inheritance
      1. Definition and IS-A Relationship
      2. Method Overriding, @Override
      3. OO Principles: Principle of Substitutability, Polymorphism and Encapsulation of Type, Coupling, Open-Closed Principle
      4. Constructor Chaining
    3. Interfaces
      1. Defining and Implementing, Interface Types
      2. Interface Inheritance
    4. New Interface Features (Java 8+)
      1. Default Methods, Static Methods
      2. Functional Interfaces
    5. Guidelines
  4. JUnit
    1. Overview
    2. Tests, Assertions, and Fixtures
      1. Writing and Running Tests
      2. Assertions
      3. Test Fixtures, @Before and @After, @BeforeClass and @AfterClass
      4. Testing for Exceptions
    3. Best Practices and Test-Driven Development Overview (TDD)
  5. Collections and Generics
    1. Collections Overview
      1. Generics and Type-Safe Collections
      2. Diamond Operator
    2. Lists, Sets, and Maps
      1. Interfaces and Contracts
      2. Iteration and Autoboxing
      3. Utility Classes - Collections and Arrays
    3. Writing Generic Classes
      1. Inheritance with Generic Types
      2. Wildcard Parameter Types
      3. Type Erasure
  6. Techniques of Object Creation
    1. Design Patterns Overview
    2. Controlling Object Creation
      1. Limitations of new Operator, Alternative Techniques
    3. Singleton Pattern
    4. Simple Factory
    5. Factory Method Pattern
    6. Other Techniques
      1. Named Objects, JNDI
      2. Dependency Injection Frameworks
  7. Using Composition and Inheritance Effectively
    1. Inheritance and Composition - Pros and Cons
      1. Composition and Delegation
      2. HAS-A, USES Relationships
    2. Strategy Pattern
    3. Decorator Pattern
    4. Façade and Other Patterns
      1. Façade, Proxy, Template Method
  8. Inner Classes
    1. Overview and Motivation
      1. Stronger Encapsulation, Rules and Caveats
    2. Defining and Using Inner Classes
      1. Member-Level, Method-Local, Anonymous Classes
    3. Static Nested Classes
      1. Nested Classes, Nested Interfaces, Nested Enums
  9. Annotations
    1. Overview
    2. Using Annotations
      1. Target and Retention Policy
      2. Annotation Parameters, Parameter Shortcuts
    3. Writing Custom Annotations
      1. Syntax, Using the Meta-Annotations
      2. Using a Custom Annotation
  10. Reflection
    1. Overview and API
      1. The Class Called Class
      2. Obtaining and Inspecting Class Objects
    2. Working with Objects Reflectively
      1. Creating Instances, Invoking Methods, Setting Field Values
  11. Lambda Expressions
    1. Functional Interfaces and Lambdas
    2. Target Context
  12. Using Lambda Expressions
    1. Syntax, Lambda Compatibility
    2. Variable Capture
    3. Type Inference
  13. Method References
    1. Three Types of Method References
    2. Refactoring Lambdas into Method References
Class Materials

Each student will receive a comprehensive set of materials, including course notes and all the class examples.

Class Prerequisites

Experience in the following is required for this Java class:

  • Working knowledge of Java programming, including use of inheritance, interfaces, and exceptions
Prerequisite Courses

Courses that can help you meet these prerequisites:

Live Private Class
  • Private Class for your Team
  • Live training
  • Online or On-location
  • Customizable
  • Expert Instructors
Request Proposal