Java Programming Training for Experienced Programmers

Java Programming Training for Experienced Programmers

4.5 out of 5 - Read Testimonials
Course Length: 5 days
Delivery Methods: Multiple delivery options
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 the Java Logging API.
  • Understand and use inner classes.
  • Understand Generics and use them with the Collections API.
  • Learn about Java's Streams concept, and how to appy that to files using text and binary data.
  • Create and run JUnit tests for Java classes.
Available Delivery Methods
Public Class
Public expert-led online training from the convenience of your home, office or anywhere with an internet connection. Guaranteed to run .
Private Class
Private classes are delivered for groups at your offices or a location of your choice.
Course Overview

This Java training course is intended for students with experience in a procedural or object-oriented language. It covers most Java syntax elements, including recent additions such as Generics and AutoBoxing. In addition to the fundamental library classes that would be needed in any Java program, it also covers several other important APIs, including Collections and Streams.

The class introduces the concept of objects as one of the first topics, in order that the later concepts are covered with an OO perspective. The material is based on Java 10.

If you are new to object-oriented programming, you should take our Introduction to Java for New Programmers class instead.

Course Outline
  1. Java Introduction
    1. Conventions in These Notes
    2. The Java Environment - Overview
    3. Writing a Java Program
    4. Obtaining The Java Environment
    5. Setting up Your Java Environment
    6. Creating a Class that Can Run as a Program
      1. The main() Method
    7. Useful Stuff Necessary to Go Further
      1. System.out.println()
    8. Using an Integrated Development Environment
    9. Exercise: Running a Simple Java Program
    10. Using the Java Documentation
  2. Java Basics
    1. Basic Java Syntax
      1. General Syntax Rules
      2. Java Statements
      3. Blocks of Code
    2. Variables
      1. Declaring Variables
      2. Advanced Declarations
    3. Data
      1. Primitive Data Types
      2. Object Data Types
      3. Literal Values
    4. Constants and the final Keyword
    5. Mathematics in Java
      1. Basic Rules
      2. Expressions
      3. Operator Precedence
      4. Multiple Assignments
      5. Order of Evaluation
      6. Bitwise Operators
      7. Compound Operators
      8. Expressions that Mix Data Types: Typecasting
    6. Creating and Using Methods
      1. Creating Methods
    7. Variable Scope
    8. Exercise: Method Exercise
  3. Java Objects
    1. Objects
    2. Object-oriented Languages
    3. Object-oriented Programs
    4. Encapsulation
      1. OOP as a Messaging System
    5. Exercise: Object Definition
      1. Creating and Using an Instance of an Object
    6. References
      1. Reference Example
      2. Reference Expressions
    7. Defining a Class
      1. Access to Data
    8. More on Access Terms
    9. Adding Data Members to a Class
      1. Adding Method Members (Functions) to a Class
    10. Standard Practices for Fields and Methods
      1. Order of Elements within a Class
    11. Java Beans
    12. Bean Properties
    13. Exercise: Payroll01: Creating an Employee Class
    14. Constructors
    15. Instantiating Objects Revisited
    16. Important Note on Constructors
    17. Exercise: Payroll02: Adding an Employee Constructor
    18. Method Overloading
    19. Exercise: Payroll03: Overloading Employee Constructors
    20. The this Keyword
    21. Using this to Call Another Constructor
    22. Exercise: Payroll04: Using the this Reference
    23. static Elements
    24. The main Method
    25. Exercise: Payroll05: A static field in Employee
    26. Garbage Collection
    27. Java Packages
    28. Compiling and Executing with Packages
    29. Working with Packages
    30. Exercise: Payroll06: Creating an employees package
    31. Variable Argument Lists (varargs)
      1. Keyboard I/O Using the Console Class
      2. Keyboard Input Without the Console
    32. Exercise: Payroll07: Using KeyboardReader in Payroll
    33. String, StringBuffer, and StringBuilder
    34. Creating Documentation Comments and Using javadoc
      1. Javadoc Comments
    35. Exercise: Payroll08: Creating and Using javadoc Comments
    36. Primitives and Wrapper Classes
      1. Autoboxing and Unboxing
  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
      1. Absolute Value
      2. Random Selection
    9. Exercise: Game01: A Guessing Game
    10. Exercise: Payroll-Control01: Modified Payroll
    11. Two Mutually Exclusive Branches
      1. The if . else Statement
      2. Nested if . else Statements - Comparing a Number of Mutually Exclusive
      3. Options
    12. Exercise: Game02: A Revised Guessing Game
    13. Comparing a Number of Mutually Exclusive options - The switch Statement.175
      1. The switch Statement
      2. switch Statement Examples
    14. Exercise: Game03: Multiple Levels
    15. Comparing Objects
      1. Testing Strings for Equivalence
    16. Conditional Expression
      1. while and do . . . while Loops
      2. for Loops
      3. For-Each Loops
    17. Exercise: Payroll-Control02: Payroll With a Loop
    18. Exercise: Game04: Guessing Game with a Loop
    19. Additional Loop Control: break and continue
    20. Breaking Out of a Loop
    21. Continuing a Loop
    22. Classpath, Code Libraries, and Jar Files
      1. Using CLASSPATH
      2. Creating a jar File (a Library)
    23. Exercise: Creating and Using an External Library
    24. Compiling to a Different Directory
  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. Exercise: Using the args Array
    9. Exercise: Game-Arrays01: A Guessing Game with Random Messages222
    10. Arrays of Objects
    11. Exercise: Payroll-Arrays01: An Array of employees
    12. Multi-Dimensional Arrays
    13. Multidimensional Arrays in Memory
    14. Example - Printing a Picture
    15. Typecasting with Arrays of Primitives
  6. Inheritance
    1. Inheritance
    2. Inheritance Examples
    3. Payroll with Inheritance
    4. Derived Class Objects
    5. Polymorphism
      1. Inheritance and References
      2. Dynamic Method Invocation
    6. Creating a Derived Class
    7. Inheritance Example - A Derived Class
    8. Inheritance and Access
    9. Inheritance and Constructors - the super Keyword
    10. Derived Class Methods that Override Base Class Methods
    11. Inheritance and Default Base Class Constructors
    12. The Instantiation Process at Runtime
      1. Inheritance and static Elements
    13. Example - Factoring Person Out of Employee
    14. Exercise: Payroll-Inheritance01: Adding Types of Employees
    15. Typecasting with Object References
    16. More on Object Typecasts
    17. Typecasting, Polymorphism, and Dynamic Method Invocation
      1. More on Overriding
      2. Changing Access Levels on Overridden Methods
    18. Redefining Fields
    19. Object Typecasting Example
    20. Checking an Object's Type: Using instanceof
    21. Typecasting with Arrays of Objects
    22. Exercise: Payroll-Inheritance02: Using the Employee Subclasses
    23. Other Inheritance-related Keywords
      1. abstract
      2. final
    24. Exercise: Payroll-Inheritance03: Making our base classes abstract
    25. Methods Inherited from Object
  7. Interfaces
    1. Interfaces
    2. Creating an Interface Definition
    3. Implementing Interfaces
    4. Implementing Interfaces - Example
    5. Reference Variables and Interfaces
    6. Calling an Interface Method
    7. Interfaces and Inheritance
    8. Exercise: Exercise: Payroll-Interfaces01
    9. Some Uses for Interfaces
    10. Interfaces and Event-Handling
    11. Interfaces and "Pluggable Components"
    12. Marker Interfaces
    13. Annotations
    14. Annotation Details
    15. Using Annotations
  8. Exceptions
    1. Handling Exceptions
    2. Exception Objects
    3. Attempting Risky Code - try and catch
      1. try . catch Blocks and Variable Scope/Initialization
      2. Example - An Exception You Must Handle
      3. Using Multiple catch Blocks
    4. Guaranteeing Execution of Code - The finally Block
    5. Letting an Exception be Thrown to the Method Caller
    6. Throwing an Exception
    7. Exercise: Payroll-Exceptions01: Handling NumberFormatException in
    8. Payroll
    9. Exercise: Payroll-Exceptions01, continued
    10. Exceptions and Inheritance
      1. Exception Class Constructors and Methods
    11. Creating and Using Your Own Exception Classes
    12. Exercise: Payroll-Exceptions02
    13. Rethrowing Exceptions
    14. Initializer Blocks
      1. Static Initializer Blocks
    15. Logging
      1. Creating a Logger
      2. Logger Hierarchy and Naming
      3. Log Handlers
      4. Log Formatters
    16. Log Properties
    17. Assertions
  9. Collections
    1. Collections
    2. Using the Collection Classes
    3. Using the Iterator Interface
    4. Creating Collectible Classes
      1. hashCode and equals
      2. Comparable and Comparator
    5. Generics
    6. Bounded Types
    7. Extending Generic Classes and Implementing Generic Interfaces
    8. Generic Methods
    9. Variations on Generics - Wildcards
    10. Exercise: Payroll Using Generics
  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. static Inner Classes
    7. Better Practices for Working with Inner Classes
    8. Enums
      1. Why Another Syntax Element for a Set of Constants?
      2. Defining an enum Class
      3. More Complex Enums
  11. Java Streams and Stream Classes
    1. Introducing Streams
    2. Input Stream Classes
    3. Output Stream Classes
    4. Using Systemin
    5. File and Directory Information
      1. Improved Version
      2. Filename Filters
    6. Exercise: Creating a Directory Listing
    7. Files and Streams
      1. Writing to a File
    8. Exercise: Creating a File Copying Program
    9. Dealing with Binary Data
    10. Java Primitives as Binary Data
    11. Sending and Receiving Objects - Serialization
      1. Object I/O Examples
    12. Exercise: Payroll-Streams01
    13. Properties
  12. Unit Testing with JUnit
    1. Software Testing Concepts
    2. Unit Testing
    3. Using JUnit
      1. Creating a Test Case
    4. Exercise: JUnit in Payroll
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 Fundamentals class:

  • Significant Object-oriented Programming Experience in a language such as C++ or C#.
Register for a Live Class
Please select a class.
Request a Private Class
  • Private Class for your Team
  • Online or On-location
  • Customizable
  • Expert Instructors
Request Pricing