Introduction to Java Training

Introduction to Java Training (JVA102)

Course Length: 5 days
Delivery Methods: Multiple delivery options
Course Overview

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.

Course Benefits
  • Learn how Java works.
  • Understand the "write once, run anywhere" concept.
  • Understand and learn how to create basic Java objects.
  • Learn how to implement flow-control concepts in Java.
  • Understand Java's package concept and create packages of Java classes.
  • Understand Java arrays and write code to create and use arrays.
  • Learn how to write Java classes using inheritance.
  • Learn how to create and use interfaces.
  • Understand and use the concept of polymorphism in an application
  • Understand how Java's exception-handling mechanism works and learn how to apply exception-handling to Java applications.
  • Understand and use inner classes.
  • Learn how to use elements from the Java API library, including the Collections classes.
Available Delivery Methods
Private Class
Private classes are delivered for groups at your offices or a location of your choice.
Self-Paced
Learn at your own pace with 24/7 access to an On-Demand course.
Course Outline
  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
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:

  • Some prior programming experience in a procedural or object-oriented language.

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

  • Knowledge of Object-oriented Analysis and Design (OOAD) is extremely helpful in Java (and other) programming. We recommend learning OOAD, but you can do so at any stage of your learning. It will make you a better programmer, especially in a team environment.
Follow-on Courses
Live Private Class
  • Private Class for your Team
  • Live training
  • Online or On-location
  • Customizable
  • Expert Instructors
Request Proposal
Self-Paced Course
5 coupons
  • On Demand 24/7
  • Readings
  • Presentations
  • Exercises
  • Quizzes
  • Full Year of Access
  • Learn more
Register Now