Java Programming Level 1: Introduction for Programmers (Live Online)

In this live, instructor-led training course, programmers with existing experience in other languages will learn to program in Java using Java 12. Attendees will gain comprehensive knowledge of Java fundamentals, including how Java works and its role among programming languages; working with and manipulating strings; performing mathematical operations; using Java operators and control flow structures; mastering Object Oriented Programming concepts; leveraging the Java collections framework; implementing best practices for exception handling; organizing code with packages; and integrating with external data storage systems.

Audience:

Programmers new to Java who already have experience with other programming languages and understand Object Oriented Programming fundamentals.

Prerequisites:

This course requires prior programming experience and solid working knowledge of Object Oriented Programming concepts. Participants without prior programming experience should consider the "Java Programming Level 1: Introduction for Non-Programmers" course instead.

Course Outline:

Getting Started with Java

Learn to write, compile, and execute your first Java program. This section covers basic syntax, naming conventions, data types, including primitive versus reference types, variable declaration and initialization, working with strings and characters, performing mathematical operations, and command-line execution. Hands-on exercises include creating Hello World programs, printing various data types, declaring strings, solving trigonometry problems, and running code from the command-line interface.

• Introduction to Java
• Writing, Compiling, and Executing Programs
• Basic Syntax and Naming Conventions
• Printing Different Data Types
• Variables and Variable Types
• Primitive versus Reference Data Types
• Working with Null References
• Working with Chars and Strings
• Mathematical Operations and Calculations
• Comments and Code Documentation
• Command-Line Interface versus Graphical User Interface

Learning the Basics of Flow Control

Master the fundamental control structures that govern program flow. This section covers conditional statements, comparison operators, nested conditionals, if-else branching, complex conditional logic using logical operators, arithmetic operators in conditions, ternary operators, switch statements including Java 12 enhancements, loops including for, enhanced for, while, and do-while loops, and command-line argument handling. Practical exercises reinforce understanding through the implementation of real-world conditional and looping scenarios.

• Controlling Program Flow
• Comparison Operators and Equality Testing
• Conditional Statements and Branching
• Complex Conditionals with Logical Operators
• The Ternary Operator
• Switch Statements and Case Handling
• Java 12 Enhanced Switch Statements
• For, Enhanced For, While, and Do-While Loops
• Loop Control with Break and Continue
• Handling Command-Line Arguments
• Converting Command-Line Arguments
• Variables, Immutability, and Final Declarations
• Static Values and Local Variable Type Inference

Object Oriented Programming in Java

Develop a deep understanding of Object Oriented Programming concepts in Java. Learn class structure and anatomy, creating and working with objects, using instanceof for type checking, method overriding and method hiding, preventing unwanted overriding with final declarations, method and constructor overloading, recursion, annotations, interfaces, inner classes, and documentation with JavaDoc. Apply these concepts through exercises building practical class hierarchies and implementing inheritance relationships.

• Class Structure and Anatomy
• Creating and Working with Objects
• The instanceof Operator
• Inheritance and Extending Classes
• Overriding and Hiding Methods
• Method and Constructor Overloading
• Recursion and Recursive Methods
• Annotations and Metadata
• Interfaces and Implementation
• Inner Classes and Nested Types
• JavaDoc Documentation Standards

Collections, Lists, and Java's Built-In APIs

Work with Java's comprehensive collections framework for managing groups of objects. This section covers arrays and array operations, Sets for unique collections, Lists for ordered collections, Maps for key-value associations, iterating through collections using various approaches, sorting collections with comparators, Properties for configuration management, and best practices for choosing appropriate collection types. Hands-on exercises include searching arrays, creating collections, performing analytics, and sorting data.

• Arrays and Array Operations
• Sets and Unique Collections
• Lists and Ordered Collections
• Maps and Key-Value Associations
• Iterating through Collections
• Sorting Collections and Custom Comparators
• Properties and Configuration Files
• Choosing Appropriate Collection Types

Exception Handling and Error Management

Master the mechanisms for handling errors and exceptional conditions in Java. Learn to identify where exceptions originate, use try-catch blocks for error handling, understand NullPointerException and common exceptions, implement throws declarations, use throw statements to signal errors, implement finally blocks for cleanup operations, and apply best practices for exception handling. This section ensures robust code that handles unexpected situations gracefully.

• Exception Fundamentals and Examples
• Common Exceptions and NullPointerException
• Catching and Handling Exceptions
• Throws and Throw Statements
• Finally Blocks and Resource Cleanup
• Best Practices for Exception Handling
• Creating Custom Exception Classes

Libraries, Packages, Modules, and Code Organization

Organize Java code effectively through packages and modules. Learn to structure code into logical packages, import classes and manage fully qualified names, avoid naming conflicts, use static imports, create package hierarchies, and build JAR files, including executable JARs with manifest files. Explore build tools including Maven and Gradle, use third-party libraries and dependencies, find and integrate external libraries, and create modular Java applications. Exercises include creating packages, building JAR files, configuring Maven and Gradle projects, and integrating the Apache Commons Lang library.

• Organizing Code into Packages
• Importing Classes and Managing Names
• Fully Qualified Class Names
• Static Imports
• Creating Package Hierarchies
• Building JAR Files and Executables
• Manifest Files and Executable JARs
• Build Tools: Maven Overview and Usage
• Build Tools: Gradle Overview and Usage
• Finding and Integrating Third-Party Libraries
• Project Dependencies and Library Management
• Using Apache Commons Lang Library
• Creating Modular Java Applications

Sockets, Files, and Streams for Data I/O

Work with files, directories, and network communication through sockets. Learn to list files and directories, distinguish between files and folders, create and write to files, read existing files, work with Properties files, understand streams and different stream types, use sockets for network communication, implement socket servers and clients, and understand blocking versus non-blocking I/O operations. Practical exercises include listing directory contents, writing and reading files, working with properties, and creating socket-based communication applications.

• Listing Files and Directories
• File and Directory Operations
• Creating and Writing Files
• Reading Files and File Content
• Properties Files and Configuration
• Streams and I/O Operations
• Java Streams Overview
• Socket Communication
• Socket Servers and Clients
• Blocking and Non-Blocking Calls
• Network Communication Patterns