Gino's Java 8 and 11 Certification + Interview Guide

Explore integer data types in Java, including byte, short, int, and long, with memory usage, value ranges, and exam tips to memorize type names and ranges.

Practice tricky integer datatype questions by examining byte, short, int, and long storage rules, ranges, and the need for a trailing L on long values to ensure compilation.

Explore floating point numbers in Java by comparing float and double, their memory usage, and how to use the F suffix to store a float, with double as default.

Explore tricky cases of floating point numbers with zero in java, including float and double infinities and nan, type suffix f, and how java.lang.Float and java.lang.Double report these values.

Discover the decimal number system and how it differs from decimal numbers in Java, as you compare representations across decimal, octal, hexadecimal, and binary systems.

Identify octal numbers by their leading zero and digits 0–7. Java prints decimal values after converting octal inputs, using powers of eight from the right.

Master hexadecimal numbers by recognizing the 0x prefix, digits 0–9 and A to F, and converting hex to decimal using powers of 16, with examples like C4 equals 196.

Learn the binary number system in Java, using the 0b prefix and digits 0 and 1, and how Java converts binary literals to decimal. Compare with octal and hexadecimal.

Compare the char and string data types in Java, noting that char is primitive and string is non-primitive, uses single vs double quotes, and covers encoding for non-English characters.

Explore character encoding, comparing ascii and Unicode, and learn how Java uses the Unicode scheme with a two-byte char type. Understand backslash-u notation and how codes map letters and symbols.

Explore how Java handles characters, ASCII codes, and the char data type, including single-quote rules, spaces, and Unicode escapes for symbols like pi, with notes on setting UTF-8 encoding.

Discover how Java escape sequences let you print quotes, newlines, and tabs by using backslashes; learn the common sequences and how to escape backslashes correctly.

Explore tricky escape sequence and unicode questions in Java, including backslash u0022 for double quote, backslash u000a for newline, and why Unicode is processed even in comments.

Master the boolean datatype in Java by learning true and false values, lowercase requirements, and how conditions produce boolean results with valid and invalid examples.

Explore keywords and identifiers in Java, including reserved words, true/false caveats, and naming rules. Learn valid identifier syntax, camel case for variables and methods, and Pascal case for classes.

Learn to declare and initialize Java variables with int and string, manage semicolons and commas, and recognize final constants like pi whose names are usually uppercase.

Explore the Java seven feature of using underscores in numbers to improve readability, with rules on placement between digits and examples of multiple underscores; the compiler ignores the underscores.

Explore Java arithmetic operators, including addition, subtraction, multiplication, division, and modulus, with integer division rules, negative number behavior, and character arithmetic using ASCII codes.

Master compound arithmetic operators and the pre/post increment and decrement forms in Java, with examples like x += y, x++ and ++x, x-- and --x.

Master rule-based arithmetic type promotion across int, byte, char, float, and double, including compound and increment operators, with practical examples and common compilation pitfalls.

Practice tricky arithmetic in Java by converting hexadecimal, octal, and binary numbers to decimal, and explore how the plus operator behaves with numbers and strings, including concatenation and operator precedence.

Write a program to sum the digits of 574 by extracting digits from right to left with modulus 10 and division by 10, then add the digits.

Relational operators evaluate conditions and return true or false, using double equals for equality and single equals for assignment, plus <, <=, >, and >= for comparisons.

Learn how boolean logical operators combine relational conditions, including and, or, their short-circuit versions, not, xor, and the ternary operator, with practical examples.

Practice exam questions reinforce understanding of logical operators, ternary expressions, and short-circuit behavior in Java, using pre/post increments and comparisons like X<Y and Y>Z to determine outcomes.

Explore bitwise operators for binary numbers, including and, or, xor, and not, plus left and right bit shifts, with shortcuts for quick calculations and practice questions.

Practice questions on bitwise operators using x=7 and y=5 illustrate and, or, xor, not, and left and right shifts. Convert to binary, apply operators, and map results back to decimal.

Explore type conversion in Java, including when automatic conversion occurs, the rules of compatibility and destination size, and examples converting byte to int but not int to byte.

Explore typecasting in Java, manually converting between data types, understanding byte and int ranges, wrap-around behavior, and how compilation affects casting.

Convert strings to numeric types in Java using wrapper classes and parse methods, and handle runtime no format exception.

Learn to accept dynamic input via command line arguments in Java by reading args in main and converting them from string to numbers using wrapper classes.

Learn to build a Java program that reads two integers from command line arguments, converts from strings, adds them, and displays the result, with error handling.

Learn how control statements govern program flow by using if statements to test boolean conditions and execute or skip code blocks accordingly.

Master if else control structures in Java through if statements, else blocks, and else-if ladders, including nested forms, short-circuit logic, and pre/post increment nuances.

Explore advanced if-else concepts in java, including boolean conditions in if statements, using parentheses for conditions, allowed assignments inside brackets, and common pitfalls demonstrated through practice questions and output examples.

Compare switch with if-else, explain when to use switch, and demonstrate a day-of-week program that validates input between one and seven with case statements, break, and a default in Java.

Explore tricky switch case scenarios in Java 8 and 11, including optional default blocks, break versus fall-through, and grouping cases to avoid compilation errors.

Discover how switch works with literals and variables of char, byte, short, int, and string in Java. Learn case labeling rules, breaks, and final constants constraints.

Master the while loop in Java by understanding boolean conditions, loop bodies, and how to avoid infinite loops and semicolon mistakes while performing repetitive tasks.

Use a while loop to sum the six numbers from 10 to 15, storing the result in sum. Track the loop and final sum, which is 75.

Understand the do while loop: it runs the body at least once before the condition is checked, using do {…} while (condition) syntax, unlike the pre-check of while.

Create a program that uses a do-while loop to accumulate a running total from 10 through 15, incrementing a each iteration until a reaches 16, and print the final sum.

Explore the Java for loop syntax, including initialization, boolean condition, and iteration, through a real time simulation that adds numbers from 10 to 15 and demonstrates loop execution until completion.

Master tricky loop questions from Java exams, covering while, for, and do-while loops, infinite loops, and common compilation errors.

Explore tricky loop questions covering for and while loops, scope and initialization. See compilation failures, infinite loops, unreachable code, and runtime handling of command line arguments.

Explore nested loops by building a Java multiplication table for two (and three later), using an outer and inner loop to print 1 to 10.

Demonstrate real-time simulation of nested loops by printing the multiplication tables for two and three from one to five, using an outer loop and an inner loop.

Explore how the break keyword controls flow in loops and switch cases. See a for loop example where break ends the loop when A equals 104, followed by hello.

Learn how the continue keyword works inside Java loops, skipping the rest of an iteration and moving to the next one, with break, while and if condition examples.

Learn how Java classes serve as blueprints for objects, describe properties and behavior, and how to create objects in heap memory using a reference variable and the new keyword.

Learn to encapsulate reusable logic in Java by creating functions (methods), defining return types (including void), and calling them from main with an object, and see return values.

Write a Java program that accepts two integers via command line, uses a generic find max function to return the larger value, prints the result, and analyzes tricky return-type questions.

explore the different types of variables in java, including local and instance variables, primitive and reference variables, their default values, and accessing them with this in a rectangle example.

Explore invoking instance methods from a static main method or from another instance method, in the same or different classes, using direct calls, this keyword, or object creation.

Create and invoke static methods by calling them from instance methods or other static methods. Call within the same class directly, or from different classes using the class name.

Demonstrate how primitive data is passed to functions as parameters by copying the data, so the original variable remains unchanged, and how returning a value can update the caller.

Learn how to pass objects to functions by sending the reference variable, not the object; both references point to the same object, so changes reflect outside, illustrating pass-by-value for references.

Learn how Java packages group related classes into a unit with dot-separated names, not folders. The video covers the first-line package declaration and matching folder structure.

Use the javac -d option to automatically create package folders and place class files, then run from the parent directory and ensure the path exists.

Learn how to use packages in Java by importing classes with import statements or wildcards, using fully qualified names, and calling static and instance methods across packages.

Explore Java's inbuilt packages, including java.util, java.io, and java.lang, and learn how to import classes, use the random class for nextInt, and call Math.sqrt with System.out.println.

Discover how inheritance promotes reusability by letting a child class extend a parent and inherit its properties, with dog and husky illustrating the extends keyword and visibility rules.

Learn how Java access specifiers control the visibility of class members, including public, private, and default, and how packages and imports affect cross-package access.

Explore Java class access specifiers, focusing on public versus default, and explain how packages and imports affect cross-package usage, with practice questions to test your understanding.

Understand protected access: a member is visible within the same package and to subclasses in other packages; inheritance does not guarantee access in all cases.

Explore the tricky rules of protected access in Java, comparing same package and different package scenarios, and contrast with public and default access through practical examples.

Master the correct order of elements in a Java file: package, then imports, then classes, with at most one public class and a file name matching it.

Resolve naming conflicts when two classes share the same name by organizing them into separate packages. Use fully qualified names or selective imports to avoid ambiguity.

Master how to declare Java functions with access specifiers and optional modifiers, and the correct order of return type. Explore function name rules and parameter basics: valid characters and parentheses.

Explain encapsulation by making fields private and exposing them through public getters and setters, enforcing validation rules to prevent invalid values and secure access to sensitive data.

Learn how static and instance fields differ: instance variables belong to each object, while static variables are shared by all objects, with examples such as circle pi and employee company.

Compare static and instance methods in Java, clarify when to use each, and advise minimizing static usage for maintainable, multi-department designs.

Learn the rules for static and instance methods: static calls use direct access or class name; static cannot call instance methods directly; instance methods access static variables.

Explore how to access local, static, and instance variables in Java, including using this for instance variables and creating objects to access them in static methods.

Explore java constructors: initialize object data with the class-named constructor that also initializes final fields, invoked automatically on new object creation, with no return type and compiler-provided defaults.

Explore parameter rise constructors, default constructors (DC), and constructor overloading, and learn how Java selects which constructor to call by parameter count and data type, with an example.

Explore datatype promotion in Java by examining constructor overloading, default and parameterized constructors, and how Java promotes int, long, float, and double to match arguments, including compilation outcomes.

Demonstrates building a rectangle class with constructors, tracking object count with static vs instance variables, using this keyword, and calling a static display method from a main class.

understand constructor chaining by using this with brackets to call one constructor from another on the same object, ensuring x and y initialize correctly and avoiding unintended extra objects.

Explore inheritance in Java, including how a subclass inherits from a superclass using the extends keyword. Understand single and multilevel inheritance, access modifiers, and why Java disallows multiple inheritance.

Explore constructor behavior with inheritance, using super to invoke the parent constructor and this for chaining, and why Java auto-invokes the parent's default constructor.

Practice questions on Java inheritance with constructors, exploring how constructors call super, default constructors, and access rules for static and instance variables to prevent compilation errors.

Explore function overloading in Java by using the same name with different argument counts, types, or order, and see how the print function handles booleans, strings, and numbers.

Delve into function overloading in Java, including same-class and parent-child scenarios, static and instance methods, type promotion, and how to resolve ambiguous invocations with a concrete fix.

Learn the difference between function overriding and overloading in Java, including when to use each with instance versus static methods, arguments, and return type rules.

Discover how the override annotation prevents logical errors when overriding a parent method in Java. See how @Override triggers a compilation error if names don’t match, and why it’s optional.

Learn how incorrect calls to an overridden method can create recursion in Java, and discover how to use super to invoke the parent method while displaying name, age, and salary.

Explore how method overriding and method hiding operate in inheritance, compare non-static overriding with static hiding, and see how the object and super keyword determine the invoked method.

Explore method hiding in inheritance, focusing on static methods like F1, F2, and F3, and how calls via object or class name determine which method executes.

Understand variable hiding in inheritance by examining when parent and child classes declare the same name and data type; whether static or not, two rules decide which variable function sees.

Learn to override the toString method in Java by customizing how a Person object's name and age are displayed, replacing Object's default class name@hashcode output with a readable string.

Explore the is-a relationship and inheritance, where a manager extends the employee class and a fiction book extends the book class, showing how child and parent classes relate.

Explore polymorphism by using a superclass reference to access subclass objects, and understand the is-a relationship and difference between reference type and object type in A, B, and C.

Explore how the compiler resolves method calls for polymorphic and normal references, focusing on reference type vs object type, and using typecasting to access inherited methods in Java.

Explore the runtime behavior of polymorphic references with method overriding, where the JVM uses the object type for dynamic binding and dispatch, determining which overridden method runs.

Explore runtime behavior of polymorphism, noting dynamic binding applies to method overriding, not method hiding or variable hiding. See how polymorphic references affect which method or variable is used.

Learn how typecasting works with polymorphic references, including upcasting from child to parent and downcasting from parent to child, and the required is-a relationship for safe casts.

The lecture explains how the compiler verifies object creation and typecasting for reference variables, detailing level one and level two checks, including upcasting, downcasting, and inheritance rules.

Explore the JVM's runtime checks when casting reference variables and why compile-time checks can still fail with a class cast exception. Learn about downcasting, the is-a rule, and runtime safety.

Explore how to prevent class cast exceptions by using the instance of operator to check whether a value can be cast before performing the typecast, avoiding runtime crashes.

Learn how to prevent inheritance in Java by using final on methods and classes, including method hiding with static and preventing overrides for a robust design.

Explore abstract classes and methods by examining how shapes and animals use abstract methods for specific behavior, and learn why subclasses must override or declare themselves abstract.

Explore tricky aspects of abstract classes from the exam perspective, including optional abstract methods, future use, instantiation limits, and how polymorphism with abstract references enables dynamic binding.

Explore the mystery of abstract classes and constructors in Java, showing that abstract class constructors run when concrete subclasses are instantiated and how default and parameterized constructors initialize variables.

Explain why interfaces are needed in Java to enable multiple inheritance, compare interfaces with abstract classes, and cover extends and implements rules, default public methods, and mandatory overrides.

Understand how interfaces enable multiple inheritance in Java by providing static, public, final variables. Access them via the interface name to avoid ambiguity and see 25 and 50.

Explore how Java eight introduces default methods in interfaces, allowing methods with bodies so new interface methods don't break existing implementations, and learn how to call and override them.

Explore how Java 8 adds static interface methods, why they cannot be overridden, and how to access them via the interface name, distinguishing them from default methods.

Discover how Java 9 introduces private methods for interfaces, enabling private helpers used by default and static methods while preventing inheritance or external access.

Explore how Java handles multiple inheritance after Java 8, including resolving variable access across interfaces and classes and overriding abstract and default methods with interface super calls when needed.

Learn how Java 8 introduces functional interfaces with a single abstract method, how to identify them, and how the optional @FunctionalInterface annotation prevents mistakes.

Explore how the object class's public methods toString, hashCode, and equals interact with functional interfaces, and distinguish overriding from overloading, with the role of @FunctionalInterface in compilation.

Understand why functional programming matters in Java and how lambda expressions implement the single abstract method of a functional interface. Balance functional and object-oriented approaches.

Learn the syntax of lambda expressions in Java and how they implement the abstract method of a functional interface. Compare lambdas to ordinary methods, and understand their invocation and compilation.

Practice tricky questions on lambda expressions to master functional interfaces and lambda syntax. Explore static versus non-static method calls, arrow and semicolon correctness, and default methods via real compilation scenarios.

Discover four lambda body patterns in Java 8 and 11, including single-statement void and non-void forms, with and without braces or return, and multi-statement requirements.

Explore how to write lambda arguments in Java for zero, one, and multiple parameters, including var inference and other syntaxes. Identify which styles compile and common pitfalls.

Master void compatible lambdas in Java, distinguishing void from non-void abstract methods, and apply shorthand syntax and statement expressions in functional interfaces.

Explore void compatible lambdas in Java by examining shorthand versus traditional syntax, the invisible return keyword, and how they handle void versus non void methods.

Master the exam tip: Java lambda expressions use only local variables that are final or effectively final, while instance and static variables are not restricted.

Explore method references as an alternative to lambdas in Java, learn when to use static or instance method references, the two-colon syntax, and when they reduce code complexity.

Explore calling void and non-void functions with method references, using one-statement lambdas and rules on return types, covariance, and argument matching.

Explore how method references invoke static methods in Java 8, handling non-void and void abstract methods with one or two arguments, and contrast with lambda expressions.

Learn to use method references to invoke non static instance methods in Java 8, matching abstract method signatures and return types with the target method.

Call instance methods using method references on parameters with the class name and object as first parameter, covering available and not available cases, while updating abstract method and functional interface.

Explore method reference on parameters in Java, mapping the abstract method’s parameters so the first is the object and the rest match the target method’s arguments.

Learn Java 8 constructor references and how they pair with lambdas, functional interfaces, and method references. Understand syntax, argument matching, and how return types determine object creation and retrieval.