Introduction to Java Training (JVA102)

Embark on an exciting journey into the world of Java with our "Introduction to Java Training" course, designed to help you master one of the most widespread and versatile programming languages. This course lays the groundwork by equipping you with the essential Java skills necessary to enhance your organization’s web solutions and software applications.

We begin with the Java Introduction module to guide you through establishing your environment, demystifying the Java setup process, and giving you hands-on experience with writing and running a simple Java program. Learn how to navigate the Java documentation to support your development process effectively.

The next phase focuses on Java Basics, where you will explore basic Java syntax, work with variables, understand data types, and use the final keyword. This module introduces you to creating and using methods, ensuring you can manage variable scope and implement foundational Java operations confidently.

Dive deeper into the essence of Java with the Java Objects lesson. This section covers object-oriented principles, class definitions, constructors, and methods to enable you to create robust, structured Java applications. With practical exercises, including the creation of an employee class and more, you'll gain a strong command of Java's object-oriented capabilities.

Explore how programs make decisions in the Comparisons and Flow Control Structures segment. Understand comparison operators, craft boolean expressions, and control program flow with constructs like if statements and loops. Hands-on projects like a modified payroll system help solidify these concepts.

Experience the power of Arrays in Java, learning how to define, declare, and manipulate arrays effectively. Through practical examples and exercises such as an array of employees, you will leverage arrays to enhance your application performance.

The course moves into Inheritance, where you'll learn to extend classes, implement polymorphism, create subclasses, and work with access controls. By the end of this section, you’ll know how to organize and optimize your Java code for reusability and maintainability.

As you progress, you'll encounter Interfaces, essential for defining contracts within your code. Learn to create interface definitions, implement interfaces, and employ them to bring increased flexibility and scalability to your Java projects.

Gain insight into Exceptions and the art of error handling. This module provides the tools to handle exceptions gracefully, ensuring your applications can manage unexpected scenarios through try-catch blocks and custom exception classes.

The course introduces you to powerful data structures in the Collections segment. Master the use of Java’s collection classes, employ generics for type safety, and extend your capabilities with streams and lambda expressions for modern Java programming practices.

Finally, explore Inner Classes to encapsulate and logically organize your code. Learn about nested classes, instantiate inner classes, and utilize java enums for better software design patterns.

Upon completion of this course, you will possess a comprehensive foundation in Java programming, prepared to tackle more advanced topics and enhance your organization’s software development capabilities. Whether expanding your team's skill set or enhancing personal expertise, this course equips you with the tools to succeed in the realm of Java.

1. Java Introduction
   1. The Java Environment - Overview
   2. Writing a Java Program
   3. Obtaining The Java Environment
   4. Setting Up Your Java Environment
   5. Creating a Class that Can Run as a Program
   6. Useful Stuff Necessary to Go Further
   7. Using an Integrated Development Environment
   8. Running a Simple Java Program
   9. Using the Java Documentation
2. Java Basics
   1. Basic Java Syntax
   2. Variables
   3. Data
   4. Constants and the final Keyword
   5. Mathematics in Java
   6. Creating and Using Methods
   7. Variable Scope
   8. Method Exercise
3. Java Objects
   1. Objects
   2. Object-oriented Languages
   3. Object Definition
   4. References
   5. Defining a Class
   6. More on Access Terms
   7. Adding Data Members to a Class
   8. Standard Practices for Fields and Methods
   9. Java Beans
   10. Bean Properties
   11. Payroll01: Creating an Employee Class
   12. Constructors
   13. Instantiating Objects Revisited
   14. Important Note on Constructors
   15. Payroll02: Adding an Employee Constructor
   16. Method Overloading
   17. Payroll03: Overloading Employee Constructors
   18. The this Keyword
   19. Using this to Call Another Constructor
   20. Payroll04: Using the this Reference
   21. static Elements
   22. The main Method
   23. Payroll05: A static Field in Employee
   24. Garbage Collection
   25. Java Packages
   26. Compiling with Packages
   27. Working with Packages
   28. Payroll06: Creating an employees Package
   29. Variable Argument Lists (varargs)
   30. Payroll07: Using KeyboardReader in Payroll
   31. Creating Documentation Comments and Using javadoc
   32. Payroll08: Creating and Using javadoc Comments
   33. Primitives and Wrapper Classes
   34. Encapsulation
   35. String, StringBuffer, and StringBuilder
   36. Compiling and Executing with Packages
   37. Object-oriented Programs
4. Comparisons and Flow Control Structures
   1. Boolean-valued Expressions
   2. Comparison Operators
   3. Comparing Objects
   4. Conditional Expression Examples
   5. Complex boolean Expressions
   6. Simple Branching
   7. The if Statement
   8. if Statement Examples
   9. Payroll-Control01: Modified Payroll
   10. Two Mutually Exclusive Branches
   11. Comparing a Number of Mutually Exclusive Options - The switch Statement
   12. Comparing Two Objects
   13. Conditional Expression
   14. Payroll-Control02: Payroll with a Loop
   15. Additional Loop Control: break and continue
   16. Continuing a Loop
   17. Classpath, Code Libraries, and Jar Files
   18. Creating and Using an External Library
   19. Compiling to a Different Directory
   20. Conditionals and Loops
   21. Game02: A Revised Guessing Game
   22. Game01: A Guessing Game
   23. Game03: Multiple Levels
   24. Game04: Guessing Game with a Loop
5. Arrays
   1. Defining and Declaring Arrays
   2. Instantiating Arrays
   3. Initializing Arrays
   4. Working with Arrays
   5. Enhanced for Loops - the For-Each Loop
   6. Array Variables
   7. Copying Arrays
   8. Using the args Array
   9. Arrays of Objects
   10. Payroll-Arrays01: An Array of Employees
   11. Multi-Dimensional Arrays
   12. Multidimensional Arrays in Memory
   13. Example - Printing a Picture
   14. Typecasting with Arrays of Primitives
   15. Java Arrays
   16. Game-Arrays01: A Guessing Game with Random Messages
6. Inheritance
   1. Inheritance
   2. Payroll with Inheritance
   3. Polymorphism
   4. Creating a Subclass
   5. Inheritance and Access
   6. Inheritance and Constructors - the super Keyword
   7. Example - Factoring Person Out of Employee
   8. Payroll-Inheritance01: Adding Types of Employees
   9. Inheritance and Default Superclass Constructors
   10. Typecasting with Object References
   11. More on Overriding
   12. Payroll-Inheritance02: Using the Employee Subclasses
   13. Other Inheritance-related Keywords
   14. Payroll-Inheritance03: Making Our Base Classes Abstract
   15. Methods Inherited from Object
   16. Checking an Object’s Type: Using instanceof
   17. The Instantiation Process at Runtime
   18. Inheritance Example - A Derived Class
   19. Inheritance Examples
   20. Derived Class Objects
   21. Derived Class Methods that Override Base Class Methods
   22. Object Typecasting Example
   23. Typecasting with Arrays of Objects
7. Interfaces
   1. Interfaces
   2. Creating an Interface Definition
   3. Implementing Interfaces
   4. Reference Variables and Interfaces
   5. Interfaces and Inheritance
   6. Exercise: Payroll-Interfaces01
   7. Some Uses for Interfaces
   8. Annotations
   9. Using Annotations
   10. Annotation Details
8. Exceptions
   1. Exceptions
   2. Handling Exceptions
   3. Exception Objects
   4. Attempting Risky Code - try and catch
   5. Guaranteeing Execution of Code - The finally Block
   6. Letting an Exception be Thrown to the Method Caller
   7. Throwing an Exception
   8. Payroll-Exceptions01: Handling NumberFormatException in Payroll
   9. Exceptions and Inheritance
   10. Creating and Using Your Own Exception Classes
   11. Payroll-Exceptions02
   12. Rethrowing Exceptions
   13. Initializer Blocks
   14. Logging
   15. Log Properties
   16. Assertions
9. Collections
   1. Collections
   2. Using the Collection Classes
   3. Using the Iterator Interface
   4. Creating Collectible Classes
   5. Generics
   6. Bounded Types
   7. Extending Generic Classes and Implementing Generic Interfaces
   8. Generic Methods
   9. Variations on Generics - Wildcards
   10. Type Erasure
   11. Multiple-bounded Type Parameters
   12. Payroll-Collections01: Payroll Using Generics
   13. Working with Streams and Lambda expressions
   14. Working with Streams and Lambda expressions
10. Inner Classes
    1. Inner Classes, aka Nested Classes
    2. Inner Class Syntax
    3. Instantiating an Inner Class Instance from within the Enclosing Class
    4. Inner Classes Referenced from Outside the Enclosing Class
    5. Referencing the Outer Class Instance from the Inner Class Code
    6. Better Practices for Working with Inner Classes
    7. Enums
    8. Inner Classes
    9. Method Inner Classes
    10. Anonymous Inner Classes

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

Experience in the following is required for this Java class:

Experience in the following would be useful for this Java class: