Fast Track To Core Java 17 Programming for Object Oriented (OO) Experienced Developer (TT2104) Certification Training

•    Introduce the Java Platform
•    Explore the Java Standard Edition
•    Discuss the lifecycle of a Java Program
•    Explain the responsibilities of the JVM
•    Executing Java programs
•    Garbage Collection
•    Documentation and Code Reuse

•    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

•    Become more familiar with Eclipse workbench concepts
•    Explore the paradigm used by Eclipse, consisting of editors, views, and perspectives in detail
•    Introduce some commonly used views
•    Explain Perspectives

•    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
•    Java keywords and reserved words

•    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 this keyword to distinguish local variables from instance variables

•    Arithmetic operators
•    Operators to increment and decrease numbers
•    Comparison operators
•    Logical operators
•    Return type of comparison and logical operators
•    Use for loops
•    Switch Expressions
•    Switch Expressions and yield

•    Create an instance of the String class
•    Test if two strings are equal
•    Perform a case-insensitive equality test
•    Contrast String, StringBuffer, and StringBuilder
•    Compact Strings
•    Text Blocks
•    Unicode support

•    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

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

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

•    Data objects in Java
•    Introduce records as carriers of immutable data
•    Defining records
•    The Canonical constructor
•    Compact constructors

•    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

•    Introduce the wrapper classes
•    Explain Autoboxing and Unboxing
•    Converting String representations of primitive numbers into their primitive types
•    Defining Enumerations
•    Using static imports
•    Deprecating classes and methods

•    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

•    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 the advantage of interfaces over abstract classes
•    Explain the advantage of abstract classes over interfaces

•    Introduce the Exception architecture
•    Defining a try/catch blocks
•    Checked vs. Unchecked exceptions

•    Defining your own application exceptions
•    Automatic closure of resources
•    Suppressed exceptions
•    Handling multiple exceptions in one catch
•    Enhanced try-with-resources
•    Helpful NullPointerException(s)

•    Explain the steps involved in building applications
•    Define the build process
•    Introduce build scripts
•    Explain the standard folder layout
•    Resolving project dependencies
•    Tutorial: Importing code Using Maven

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

•    Understanding the concept of functional programming
•    Understanding functional interfaces
•    Lambdas and type inference

•    Writing lambda expressions
•    Explore the difference between anonymous classes and lambda expressions
•    Consumer, Predicate, and Function interfaces

•    Provide an overview of the Collection API
•    Review the different collection implementations (Set, List, and Queue)
•    Explore how generics are used in collections
•    Examine iterators for working with collections

•    Collection Sorting
•    Comparators
•    Using the Right Collection
•    Lambda Expressions in Collections

•    Introduce sealed classes
•    The sealed and permitted modifier
•    Sealed interfaces
•    Sealed classes and pattern matching

•    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

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