Java Certifications Masterclass

Build a Java hello world program to grasp syntax, classes, and the main entry point. Learn how to write, compile, and print output using a text editor.

Demonstrates compiling the Hello World Ajala Java program with the Java compiler and running it using the java command to display hello in the command prompt.

Explore the Java 11 feature that lets you run a single class with java Hello World, skipping the separate compile and run steps while still producing the Hello World output.

Master compiling multiple Java programs to class files, running them from different directories, and organizing outputs in a bin folder, including Java 11's run without compile feature and -D properties.

Learn to build and run a Java hello world program, exploring compilation, class naming, and main method syntax, while handling compile and runtime errors and command line arguments.

Master Java comments, including // and /* */ syntax, and their placement in a hello world program. Compile and run to see how comments work and note Unicode support.

Learn to declare variables in Java, use strings and integers, and concatenate values to print dynamic messages like hello world and a name.

Master variable concepts in Java by declaring and initializing them in a Hello World class, exploring static versus non-static context, and noting default values and compile-time errors.

Declare constants in Java using the final keyword to prevent modification. Declare inside a class or method, typically uppercase, and expect a compile-time error if changed.

Understand how to name variables, constants, classes, and methods. Identifiers may include letters, digits, underscores, and dollar signs, but must not start with a digit or be a keyword.

Explore how a method groups statements to perform tasks, defines a class’s behavior, and enables reusability through parameters, return types, signatures, and invocation, with system and user methods and overloading.

Explore system-defined methods and how they print messages, such as println, in this Java certifications masterclass lesson on methods.

Java 12 adds Unicode 11.0.0 support, introducing 684 new characters, 11 blocks, and seven new scripts, including 66 emoji and several symbols.

Java 13 adds Unicode 12.1 support, expanding to 137,928 characters across four new scripts and 150 scripts, with 61 new emojis and support for Unicode annexes 9 and 15.

Explore Java data types, from primitive and non primitive categories to exact ranges and usage, including byte, short, int, long, float, double, char, and boolean, with practical examples.

Master Java type casting by distinguishing narrowing and widening conversions, learning compatibility rules, and using casts to handle wrap around and ascii character mapping in numeric to char conversions.

Explore the Java string non-primitive datatype, its immutability, creation methods (literals, new, char array), and the string constant pool mechanism.

Explore how Java 13 introduces multiline strings using three double quotes to replace manual line breaks, with the feature standardized in Java 15.

Explore Java's inbuilt string methods for manipulation, including charAt, compareTo, compareToIgnoreCase, contains, endsWith, equals, equalsIgnoreCase, and format.

Modify a Java hello program to see how class names, file names, and braces affect compilation and execution, including main method signatures and command-line arguments.

Learn how string buffer differs from string by being mutable, enabling in-place edits with better performance; explore append, capacity, substring, insert, reverse, delete, and replace methods.

Explore string builder in Java as a mutable, faster alternative to strings for single-thread string manipulation, and contrast it with string buffer's thread-safe behavior for multi-thread use.

Learn Java operators, including arithmetic, relational, logical, and built-in operators, and explore arithmetic operations, compound assignment, pre and post increment and decrement, and unary plus and minus with practical examples.

Learn how pre and post increment and decrement operators work in Java, understanding use-before-increment versus increment-before-use, through step-by-step examples and evaluations.

Master relational operators in Java, including equals, not equals, less than, less than or equal, greater than, and greater than or equal, plus the instance of operator for type checks.

Learn boolean logical operators in Java, including and, or, xor, short-circuit and, short-circuit or, not, assignment, xor assignment, and the ternary operator, with truth tables and evaluative examples.

Explore bitwise operators in Java, including and, or, xor, shifts (left, right, zero-filled), and not, with practical examples and truth tables.

Explore Java control flow: selection statements such as if and switch, hydration statements (loops) like for and while, and jump statements such as break and return, with practical examples.

Learn how the switch statement works, including cases, default, break, and nested switches, with runtime expressions and examples showing uppercase and lowercase outputs.

Master the Java 13 switch expression that returns a value with a lambda-style syntax, avoiding break issues, and see how it coexists with the traditional switch in Java 14.

Explore the Java 17 switch feature that lets you pass objects into a switch, return switch results, and handle types like integer, long, double, and string with a default case.

Explore while and do-while loops in Java, learn entry and exit control behavior, print sequences, manage boolean conditions, and avoid infinite loops.

explains standard for loops and the for each loop in java, including initialization, condition, and increment, and iterating over arrays from first to last with single statements versus braces.

Explore nested for loops to generate numeric patterns by printing sequences from zero to ten and variations, mastering outer and inner loops, spaces, and line breaks.

Explore the Java jump statements break, continue and their labeled forms, plus the return and exit statements, with loop and switch examples and notes on unreachable code and compile-time errors.

Explore arrays in the Java certifications masterclass, covering one- and multi-dimensional arrays, declaring and initializing primitive and object arrays, and printing elements with for loops, for-each, and toString.

Java arrays in this lesson demonstrate default values when declaring with new, implement linear search with a loop and break, and compare arrays using built-in methods.

Identify and fix an issue in a code snippet from the arrays part 2 module. Complete the homework to reinforce debugging skills for Java certifications.

Explore multi-dimensional arrays in Java, declare and print elements with nested for loops over rows and columns, and compute the sum of elements, including varying column lengths.

Define a class as a template of state and behavior. Show an employee example with first name, last name, and methods for full name and contact details.

Explore how to create and use objects from a class in an object oriented program, using the new keyword to allocate memory and the Dart operator to access members.

Explore Java constructors, including default and parameterized forms, how new invokes them, and how fields are initialized using this keyword and parameter passing.

Extend the java program to take console input with a buffered reader, create employee objects, and print their details while managing up to five employees in an array.

Extend the example to display all employees, handle empty slots with an if check, and implement a menu-driven interface using for loops, switch statements, and a labeled break.

Explore building a Java console app that displays, adds, updates, and deletes employees, using an array, ID generation, a static buffer reader, and guard checks.

Explore how nested inner classes operate inside an outer class, including static and non-static variants, how they access outer members, and how to instantiate and compile them.

Explore inheritance in Java: how a subclass extends a superclass to inherit methods and fields, with public versus private access, and learn single, multilevel, hierarchical, and interface-based inheritance.

Learn how Java constructors in super and subclass execute in order, and how this and super calls manage default and parameterized constructors.

Explore abstract classes in Java, including abstract and non abstract methods and constructors. See how derived classes implement abstract methods to become complete when all methods are implemented.

Explore how interfaces define method templates and fields, how classes implement multiple interfaces, and that interfaces cannot be instantiated, while interface extension enables multiple inheritance with default and static methods.

Compare interfaces and abstract classes in Java: an abstract class can have abstract and concrete methods and a constructor, while an interface has no constructors and mainly abstract methods.

Learn how to declare sealed classes to prevent extending, use permits to list allowed subclasses, and ensure that subclasses must be sealed, non-sealed, or final.

Explain the is-a relationship in inheritance and the has-a relationship based on containment and aggregation, using rose and plant and a student with an address.

Explore reference variable casting in Java, differentiating upcasting and downcasting between superclasses and subclasses. See how interface and abstract class references access only base methods.

Learn about anonymous classes in Java. These unnamed inner classes implement one interface or extend a class, access host class members, and cannot be static or abstract.

Explore how java packages organize related classes, enforce naming conventions, and manage access with private, default, protected, and public modifiers, including import and static import concepts.

Explore how packages and access modifiers in Java govern visibility across files and packages, including public, private, default, and protected. See how to organize files into package folders, use imports, respect case-sensitive package names, compile across packages, and run with the package name dot class name.

Package your Java applications using the packaging tool added in Java 14, an incubator that bundles dependencies into platform-specific installers for Linux, macOS, and Windows.

Explore static variables and methods, static code and initialization blocks, and the public static void main entry point, plus static inner classes and imports in Java.

Explore the final non-access modifier in Java, including final variables, final parameters, final methods, and final classes, and learn how final prevents reassignment, overriding, and subclassing.

Explore non access modifiers in Java, including abstract classes and methods, final constraints, and how synchronized, volatile, transient, and native modifiers shape threading, serialization, and native integration.

Explore how Java implements polymorphism through static overloading and dynamic overwriting, using the same method name with different parameters and subclass-specific behavior, guided by compile-time versus runtime binding.

Explore recursion, a function that calls itself, using the factorial example to illustrate the base case and how n reduces until zero.

Explore the Java object hierarchy, identifying how string, boolean, and number types are objects, with numbers subdividing into integer, float, long, double, and byte, and relations to the number class.

Explore the four oops concepts in Java, including abstraction, encapsulation, inheritance, and polymorphism, with practical definitions and examples of how to use abstract classes and interfaces.

Explore the difference between overloading and overriding in Java, compare parameter lists and polymorphism, and learn when to use each, including static, private, and final methods.

discover how Java 14 records replace boilerplate data classes with concise record syntax, using a point with x and y, and learn their evolution to production in Java 16.

Explore stack and heap memory allocation in Java, where primitives and locals live on the stack for fast access. Store objects on the heap with dynamic allocation.

Learn how garbage collection frees heap memory by destroying unreachable objects and how the JVM automatically reclaims memory across the young and old generations.

Java 12 introduces concurrent class unloading in garbage collection to free unused data structures and shrink memory footprint; enabled by default, can be disabled with a command line option.

Java 12 garbage collection introduces allocating all generations of the heap on alternate memory devices, letting the old generation use such memory with no extra flag required.

Java 13 garbage collection releases unused heap memory back to the operating system after a configurable idle delay, default enabled, and increases maximum heap size to 16 terabytes.

Explore the Java 14 garbage collection feature, including the removal of the concurrent smart sweep garbage collector and the introduction of a new experimental garbage collector.

Master Java exception handling by learning runtime errors, checked and unchecked exceptions, and errors, and applying try-catch-finally with proper catch order and throw or throws usage.

Learn Java exception handling with try-catch-finally, throw and throws, including input validation and common exceptions like null pointer exception, arithmetic exception, and array index out of bounds.

Master try-with-resources in Java seven to enable automatic resource management, declare resources in parentheses, and close file readers and streams at block end.

Create and use user defined exceptions by extending the exception class, adding constructors, and overriding toString. Throw a sample exception for negative numbers and catch it to display the message.

Learn what assertions are in Java, how they validate development-time assumptions, and how the JVM throws AssertionError when false. Enable or disable assertions with -ea and -da during execution.

Explore how java 14 enhances null pointer exception details by revealing when a field cannot be assigned on a null reference, and learn practical implications for exception handling.

Explore Java enums as named constants with examples like Mercury to Pluto, showing switch statements, iteration with values(), constructors or methods, and that enums are not instantiated with new.

Explore autoboxing and unboxing in Java, and learn how primitive types and wrapper classes interact, including when generics require wrappers and how conversions work.

Explore Java annotations, including built-in ones like @Override, @SuppressWarnings, @Deprecated, and @Target, and learn to create custom annotations with retention policies and marker, single value, and multi value forms.

Create and use custom annotations in Java, specifying runtime retention, targets for types, fields, and methods, and retrieve annotation values at runtime via reflection.

Learn to read from a file using a buffer reader and file reader, print each line to the console, and write to a file with a file writer using try-with-resources.

Explore java file constructors and file operations by creating file instances, checking existence, and using methods like createNewFile, mkdir, delete, isDirectory, isFile, and renameTo.

Compare scanner and buffer reader in Java. The scanner uses a large character buffer and is slower and single-threaded; the buffer reader uses a smaller byte buffer and is faster.

Explore Java NIO fundamentals by studying channels and buffers, including FileChannel, scatter/gather read and write, and buffer operations like allocate, flip, clear, and compact.

Explore java nio part 2 concepts like path and file handling, dot and dot-dot semantics, and file operations to create, copy, move, delete, read, and write files.

Compare java.io and java.nio, highlighting that java.io is stream-oriented with blocking I/O, while java.nio is buffer-oriented, non-blocking, and based on channels and selectors.