Basic Java Programming for Developers New to OO (C, Mainframe, COBOL)

1. The Java Platform

• The Java Platform
• Lifecycle of a Java Program
• Responsibilities of JVM
• Documentation and Code Reuse

2. Using the JDK

• Explain the JDK’s file structure
• Use the command line compiler to compile a Java class
• Use the command line Java interpreter to run a Java application class
• Lab: Exploring MemoryViewer

3. The IntelliJ Paradigm

• Introduce the IntelliJ IDE
• The Basics of the IntelliJ interface
• IntelliJ Projects and Modules
• Creating and running Java applications
• Tutorial: Working with IntelliJ

Getting Started with Java

4. Writing a Simple Class

• Write a Java class that does not explicitly extend another class
• Define instance variables for a Java class
• Create object instances
• Primitives vs Object References
• Implement a main method to create an instance of the defined class
• Lab: Create a Simple Class

5. Adding Methods to the Class

• Write a class with accessor methods to read and write instance variables
• Write a constructor to initialize an instance with data
• Write a constructor that calls other constructors of the class to benefit from code reuse
• Use the this keyword to distinguish local variables from instance variables
• Lab: Create a Class with Methods

OO Concepts

6. Object-Oriented Programming

• Real-World Objects
• Classes and Objects
• Object Behavior
• Methods and Messages
• Lab: Define and use a New Java class

7. Inheritance, Abstraction, and Polymorphism

• Encapsulation
• Inheritance
• Method Overriding
• Polymorphism
• Lab: Define and use Another Java Class

8. Essential Java Programming
9. Language Statements

• Arithmetic operators
• Operators to increment and decrement numbers
• Comparison operators
• Logical operators
• Return type of comparison and logical operators
• Use for loops
• Switch Expressions
• Switch Expressions and yield
• Lab: Looping
• Lab: Language Statements

10. Using Strings and Text Blocks

• Create an instance of the String class
• Test if two strings are equal
• Get the length of a string Parse a string for its token components
• Perform a case-insensitive equality test
• Build up a string using StringBuffer
• Contrast String, StringBuffer, and StringBuilder
• Compact Strings
• Text Blocks
• Lab: Fun with Strings
• Lab: Using StringBuffers and StringBuilders

11. Specializing in a Subclass

• Constructing a class that extends another class
• Implementing equals and toString
• Writing constructors that pass initialization data to parent constructor
• Using instanceof to verify type of an object reference
• Pattern matching for instanceof
• Overriding subclass methods
• Safely casting references to a more refined type
• Lab: Creating Subclasses

12. Fields and Variables

• Discuss Block Scoping Rules
• Distinguish between instance variables and method variables within a method
• Explain the difference between the terms field and variable
• List the default values for instance variables
• Final and Static fields and methods
• Local Variable type inference
• Lab: Field Test

13. Using Arrays

• Declaring an array reference
• Allocating an array
• Initializing the entries in an array
• Writing methods with a variable number of arguments
• Lab: Creating an Array

14. Records

• Data Objects in Java
• Introduce records as carrier of immutable data
• Defining records
• Lab: Record

15. Java Packages and Visibility

• Use the package keyword to define a class within a specific package
• Discuss levels of accessibility/visibility
• Using the import keyword to declare references to classes in a specific package
• Using the standard type naming conventions
• Visibility in the Java Modular System
• Correctly executing a Java application class
• The Java modular system
• Defining Modules
• Lab: Defining Modules

Object Oriented Development

16. Inheritance and Polymorphism

• Write a subclass with a method that overrides a method in the superclass
• Group objects by their common supertype
• Utilize polymorphism
• Cast a supertype reference to a valid subtype reference
• Use the final keyword on methods and classes to prevent overriding
• Lab: Salaries - Polymorphism

17. Interfaces and Abstract Classes

• Define supertype contracts using abstract classes
• Implement concrete classes based on abstract classes
• Define supertype contracts using interfaces
• Implement concrete classes based on interfaces
• Explain advantage of interfaces over abstract classes
• Explain advantage of abstract classes over interfaces
• Static, default and private methods in interfaces
• Lab: Mailable - Interfaces

18. Sealed classes

• Introduce Sealed classes
• The sealed and permits modifiers
• Sealed Interfaces

Exception Handling

19. Introduction to Exception Handling

• Introduce the Exception architecture
• Defining a try/catch blocks
• Checked vs Unchecked exceptions
• Lab: Exceptions

20. Exceptions

• Defining your own application exceptions
• Automatic closure of resources
• Suppressed exceptions
• Handling multiple exceptions in one catch
• Helpful Nullpointers
• Enhanced try-with-resources
• Lab: Exceptional

Java Developer's Toolbox

21. Developing applications

• Introduce the wrapper classes
• Explain Autoboxing and Unboxing
• Converting String representations of primitive numbers into their primitive types
• Defining Enumerations
• Using static imports
• Deprecating methods
• Lab: Using Primitive Wrappers
• Lab: Enumerations (optional)

Advanced Java Programming

22. Introduction to Generics

• Generics and Subtyping
• Bounded Wildcards
• Generic Methods
• Legacy Calls To Generics
• When Generics Should Be Used
• Lab: DynamicArray

23. Lambda Expressions and Functional Interface

• Understanding the concept of functional programming
• Writing lambda expressions
• Understanding functional interfaces
• Lab: Using Lambda

Working with Collections

24. Collections

• Provide an overview of the Collection API
• Review the different collection implementations (Set, List and Queue)
• Explore how generics are used with collections
• Examine iterators for working with collections
• Lab: Create a simple Game using Collections

25. Using Collections

• Collection Sorting
• Comparators
• Using the Right Collection
• Lambda expressions in Collections
• Lab: Using Collections

Bonus Topics: Time Permitting

26. Streams

• Understanding the problem with collections in Java
• Thinking of program solutions in a declarative way
• Use the Stream API to process collections of data
• Understand the difference between intermediate and terminal stream operations
• Filtering elements from a Stream
• Finding element(s) within a Stream
• Collecting the elements from a Stream into a List
• takeWhile and dropWhile intermediate operations
• Lab: Working with Streams

27. Collectors

• Using different ways to collect the items from a Stream
• Grouping elements within a stream
• Gathering statistics about numeric property of elements in a stream
• Lab: Collecting