Basic Java Programming for Developers New to OO (TT2120)

The Java Platform

Lifecycle of a Java Program

Responsibilities of JVM

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

Introduce the IntelliJ IDE

The Basics of the IntelliJ interface

IntelliJ Projects and Modules

Creating and running Java applications

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

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

Real-World Objects

Classes and Objects

Object Behavior

Methods and Messages

Encapsulation

Inheritance

Method Overriding

Polymorphism

Essential Java Programming

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

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

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

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

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 carrier of immutable data

Defining records

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

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

Explain advantage of abstract classes over interfaces

Static, default and private methods in interfaces

Introduce Sealed classes

The sealed and permits modifiers

Sealed Interfaces Exception Handling

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

Helpful Nullpointers

Enhanced try-with-resources Java Developer's Toolbox

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 Advanced Java Programming

Generics and Subtyping

Bounded Wildcards

Generic Methods

Legacy Calls To Generics

When Generics Should Be Used

Understanding the concept of functional programming

Writing lambda expressions

Understanding functional interfaces

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

Collection Sorting

Comparators

Using the Right Collection

Lambda expressions in Collections

Bonus Topics: Time Permitting

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

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