Java Programming Training Course

Module 1: Java Fundamentals and Environment Setup

• Introduction to the Java Virtual Machine (JVM) and Java Development Kit (JDK)
• Understanding Data Types, Variables, and Operators
• Writing and compiling the first Java program
• Naming conventions and basic code structure
• Using command-line tools for Java compilation and execution
• Practical session: Setting up the JDK and IDE (e.g., IntelliJ/VS Code) and running the first "Hello, World!" application

Module 2: Object-Oriented Programming (OOP) Concepts

• The Four Pillars of OOP: Encapsulation, Inheritance, Polymorphism, Abstraction
• Advantages of using an object-oriented paradigm
• Class vs. Object: Definition and instantiation
• Constructors and initialization blocks
• Understanding object references and memory allocation
• Practical session: Designing a simple class diagram illustrating the four pillars of OOP (Encapsulation, Inheritance, Polymorphism, Abstraction)

Module 3: Control Flow and Arrays

• Conditional statements: if, else, else if, and the ternary operator
• Looping constructs: for, enhanced for, while, and do-while
• Using break and continue keywords effectively
• Single-dimensional and multi-dimensional arrays
• Array initialization, traversal, and memory representation
• Practical session: Writing a program that uses nested loops (for, while) to process elements in a two-dimensional array

Module 4: Classes, Objects, and Methods

• Defining instance variables and methods
• Method overloading and signature rules
• Understanding the this keyword and its usage
• Static members (static keyword) vs. instance members
• Parameter passing mechanisms (pass-by-value)
• Practical session: Creating classes with overloaded constructors, instance methods, and static members to manage a simple inventory system

Module 5: Inheritance, Polymorphism, and Abstract Classes

• Implementing inheritance using the extends keyword
• Method overriding and the use of the super keyword
• Defining and using abstract classes and abstract methods
• Upcasting and Downcasting objects
• The final keyword in classes, methods, and variables
• Practical session: Implementing a class hierarchy (e.g., Animal -> Mammal -> Dog) and demonstrating method overriding and dynamic method dispatch

Module 6: Interfaces and Packages

• Defining and implementing interfaces
• New features in interfaces: default and static methods
• Understanding packages and the import statement
• Access modifiers (public, private, protected, default)
• Best practices for package structure and organization
• Practical session: Defining a functional interface and implementing it in multiple classes to showcase polymorphism and API design

Module 7: Exception Handling

• Understanding the Exception Hierarchy (Checked vs. Unchecked)
• The purpose and usage of try-catch-finally blocks
• Throwing exceptions using the throw and throws keywords
• Creating custom exception classes
• Using the try-with-resources statement for automatic resource closing
• Practical session: Developing a robust method that reads data from a file, demonstrating the use of try-catch-finally blocks and custom checked exceptions

Module 8: Collections Framework Part 1 (Lists and Sets)

• Overview of the Collections Framework architecture
• The List interface and concrete classes (ArrayList, LinkedList)
• The Set interface and concrete classes (HashSet, TreeSet)
• Understanding sorting with Comparable and Comparator
• Performance characteristics and choosing the right List or Set implementation
• Practical session: Writing a utility to store user input in an ArrayList, sort it using Collections.sort(), and remove duplicates using a HashSet

Module 9: Collections Framework Part 2 (Maps and Iterators)

• The Map interface and concrete classes (HashMap, TreeMap, LinkedHashMap)
• Storing key-value pairs and handling collisions
• Iterating over Collections using the Iterator interface
• Iterating over Maps using keySet(), values(), and entrySet()
• Fail-fast vs. Fail-safe Iterators
• Practical session: Building a frequency counter for words in a text using a HashMap and iterating through its keys and values using a Map.Entry set

Module 10: Input/Output (I/O) Streams

• Understanding Byte Streams (InputStream, OutputStream)
• Understanding Character Streams (Reader, Writer)
• Using Buffered Streams for improved performance
• Reading and writing primitive data using Data Streams
• Serialization and Deserialization of objects
• Practical session: Implementing logic to read data line-by-line using a BufferedReader and writing formatted data to a file using a PrintWriter

Module 11: Generics

• Introduction to Generics and type safety
• Generic classes and interfaces
• Wildcards in Generics (Upper Bounded, Lower Bounded)
• Generic methods and type inference
• Type erasure and its implications at runtime
• Practical session: Creating a generic method and a generic class (e.g., a simple Box<T>) that can handle different types safely

Module 12: Multithreading and Concurrency Basics

• Core concepts: Process vs. Thread
• Creating threads using the Runnable interface and Thread class
• Managing thread states and the thread lifecycle
• Synchronization, locks, and the synchronized keyword
• Introduction to the ExecutorService for managing thread pools
• Practical session: Writing two runnable tasks and demonstrating how to start them using the Thread class and the ExecutorService for concurrent execution

Module 13: Introduction to Lambda Expressions and the Stream API

• Syntax and usage of Lambda Expressions
• Functional Interfaces and the @FunctionalInterface annotation
• Overview of the Stream API: lazy evaluation and pipeline operations
• Intermediate Stream operations (filter, map, sorted)
• Terminal Stream operations (collect, reduce, forEach)
• Practical session: Using the Stream API to filter, map, and reduce a list of complex objects (e.g., employees) in a single chain of operations

Module 14: Java Database Connectivity (JDBC)

• Architecture of JDBC and driver types
• Establishing a connection using DriverManager
• Executing SQL queries using Statement and PreparedStatement
• Processing results with the ResultSet object
• Handling SQL exceptions and closing resources
• Practical session: Establishing a connection to a local H2 or SQLite database, executing a SELECT query, and processing the results using a ResultSet

Module 15: Unit Testing with JUnit

• Importance of unit testing and Test-Driven Development (TDD) principles
• Setting up and configuring JUnit 5
• Basic test annotations (@Test, @BeforeEach, @AfterEach)
• Using assertion methods for verifying results (e.g., assertEquals, assertTrue)
• Testing for expected exceptions
• Practical session: Writing JUnit 5 test cases (@Test) for a simple calculator class, including assertions for success and expected exceptions

Module 16: Introduction to Design Patterns

• The concept of Design Patterns and the Gang of Four (GoF)
• Creational Patterns: Implementing the Singleton pattern
• Creational Patterns: Implementing the Factory pattern
• Structural Patterns: Understanding the Adapter pattern
• Behavioral Patterns: Introduction to the Observer pattern
• Practical session: Implementing the Singleton design pattern and the Factory design pattern in Java to manage object creation

Module 17: Build Tools and Project Management (Maven/Gradle)

• Introduction to project build tools (Maven vs. Gradle)
• Setting up a Maven project structure (pom.xml configuration)
• Managing external dependencies with Maven repositories
• Maven lifecycle phases (validate, compile, test, package, install)
• Using common Maven goals and profiles
• Practical session: Setting up a new Java project using Maven, defining dependencies in the pom.xml, and running clean and build goals

Module 18: Advanced Topics and Modern Java Features

• New Features since Java 8: Records, Sealed Classes, and Text Blocks
• Introduction to the Java Module System (JPMS)
• Basics of Annotation Processing
• Introduction to reflection and its limitations
• Basics of performance considerations (Garbage Collection concepts)
• Practical session: Experimenting with new language features like Records and Sealed Classes to model immutability and restricted class hierarchies

Requirements:

·       Participants should be reasonably proficient in English.

·       Applicants must live up to Armstrong Global Institute admission criteria.

Terms and Conditions

1. Discounts: Organizations sponsoring Four Participants will have the 5th attend Free

2. What is catered for by the Course Fees: Fees cater for all requirements for the training – Learning materials, Lunches, Teas, Snacks and Certification. All participants will additionally cater for their travel and accommodation expenses, visa application, insurance, and other personal expenses.

3. Certificate Awarded: Participants are awarded Certificates of Participation at the end of the training.

4. The program content shown here is for guidance purposes only. Our continuous course improvement process may lead to changes in topics and course structure.

5. Approval of Course: Our Programs are NITA Approved. Participating organizations can therefore claim reimbursement on fees paid in accordance with NITA Rules.

Booking for Training

Simply send an email to the Training Officer on training@armstrongglobalinstitute.com and we will send you a registration form. We advise you to book early to avoid missing a seat to this training.

Or call us on +254720272325 / +254725012095 / +254724452588

Payment Options

We provide 3 payment options, choose one for your convenience, and kindly make payments at least 5 days before the Training start date to reserve your seat:

1. Groups of 5 People and Above – Cheque Payments to: Armstrong Global Training & Development Center Limited should be paid in advance, 5 days to the training.

2. Invoice: We can send a bill directly to you or your company.

3. Deposit directly into Bank Account (Account details provided upon request)

Cancellation Policy

1. Payment for all courses includes a registration fee, which is non-refundable, and equals 15% of the total sum of the course fee.

2. Participants may cancel attendance 14 days or more prior to the training commencement date.

3. No refunds will be made 14 days or less before the training commencement date. However, participants who are unable to attend may opt to attend a similar training course at a later date or send a substitute participant provided the participation criteria have been met.

Tailor Made Courses

This training course can also be customized for your institution upon request for a minimum of 5 participants. You can have it conducted at our Training Centre or at a convenient location. For further inquiries, please contact us on Tel: +254720272325 / +254725012095 / +254724452588 or Email training@armstrongglobalinstitute.com

Accommodation and Airport Transfer

Accommodation and Airport Transfer is arranged upon request and at extra cost. For reservations contact the Training Officer on Email: training@armstrongglobalinstitute.com or on Tel: +254720272325 / +254725012095 / +254724452588