Java Interview preparation

Java does not treat nonzero values or non-empty strings as true and flags 0 or empty values as false; code examples show type errors from attempting to convert to boolean.

Learn how non static methods cannot be invoked from a static context in Java, with examples of static calls, static main, and the resulting errors.

Understand static global versus static local variables in Java concept 3, demonstrating why static global variables are allowed inside a class while static local variables inside methods are not.

Java concept 4 explains method overriding in a parent-child class, where a parent reference holds a child object and the child’s print method overrides parent with same name and signature.

Explain Java concept five: pattern class references can store child class objects, but child class references cannot store pattern class objects, demonstrated through inheritance and print methods.

Explore inheritance and polymorphism in Java concept 6 by comparing a phone and smartphone class, showing that method calls resolve to the child class while variables reference the parent class.

Learn the initialization order in Java concepts: a global variable is assigned before the constructor runs during object creation, as shown by Java concept and Python class examples.

Explore how Java access modifiers range from private to public, including default and protected, and distinguish overwriting from overloading with practical examples of restricted versus less restricted access.

Explore how Java concept 9 demonstrates method overloading, showing the compiler selects the most specific type, such as string over object, and handles no-value calls.

Explore how Java overload resolution at compile time selects the most specific method, focusing on string versus object parameters and how null or ambiguity affects choices for interview preparation.

Compare string and String: strings are immutable, while string buffer is mutable, enabling insert and delete; concatenation creates a new string and changes memory locations.

Explore how Java handles the plus operator with strings and integers. A leading string causes concatenation of subsequent integers, while a trailing string preserves numeric addition before concatenation.

Explore how Java inheritance runs constructors: when you create a smartphone object, the grandparent's constructor runs first, followed by the parent's, and finally the child's constructor, showing the call order.

Understand inheritance and how a parent class with parameterized constructors affects child class constructors, and learn to use super to call the correct parent constructor to avoid errors.

This lecture demonstrates that an object reference of type Object can store the address of objects from any class, including string, string buffer, integer, and user-defined Java concepts.

Explore variable scope in Java concept 16 by distinguishing global and local variables, and using this to access global variables inside methods, with practical class examples.

Explore how inheritance affects method calls: non-static methods resolve to the child class, while static methods resolve to the parent class, demonstrated with computer and laptop examples.

Java concept 18 explains how the equals operator compares memory addresses for strings versus primitive value comparison, and how the equals method compares actual values in strings and objects.

This lecture explains static variables and static methods in Java, showing how to access them using the class name, a class object, or a reference variable with practical examples.

Explore how static variables in Java are created once, and non-static variables initialize with each new object.

Learn how Java loads a class and initializes static variables when loaded, either by calling a static variable or by creating an object, with constructors executing afterward.

Explore how Java initializes static and non static variables: static fields load at class initialization, while non static fields initialize when an object is created; see practical demonstrations.

Discover how static blocks execute when a class loads, enabling initialization of static variables and calls to static methods, while showing why non-static members cannot be accessed from static blocks.

Discover the order of static variable initialization and static blocks in Java, by loading a class through object creation or static access, and observe the execution sequence.

Explores how final methods affect inheritance in java, showing when a method can or cannot be overridden in parent and child classes, with practical examples of final methods.

Learn why variable length arguments simplify Java methods, implement a single variable length argument multiply method, and understand why only one such argument is allowed.

Explore how a single length argument of string type and a variable length argument interact in Java concept 27, and learn why the variable length argument must be last.

Explore the Java try-catch-finally flow, the execution order of try, catch, and finally, and how System.exit(0) can terminate the program to bypass finally.

Explore Java concept 29: how try, catch, and finally manage exceptions, showing that finally runs regardless of errors and that zero catch blocks require a finally block for compilation.

Learn that non static variables cannot be accessed from a static nested class; use instances to access them, as shown with the outer class and static inner class.

Understand how overriding in Java requires the child method to throw the same or broader checked exceptions as the parent, with practical examples of io exception, try-catch, and method signatures.

This lecture shows that try and catch cannot be inside a class, but can be inside a method or constructor to handle exceptions and avoid termination.

Explore how Java interface members are public by default and why nested interfaces cannot have private or protected modifiers, with practical compile-time demonstrations.

Learn Java concept 34: a constructor can throw an exception but cannot return anything, with a practical example that throws an automatic exception out of the constructor.

Explore how Java constructors work: a constructor shares the class name and has no return type, while declaring a return type converts it into a regular method, with practical initialization.

Explore how constructors can be default, private, protected, or public, and why a private constructor cannot create an object outside the class, while the new keyword works inside.

Learn why a class with a private constructor cannot be instantiated outside the class using new, and how a public static method creates and returns the object.

Learn how the super keyword calls the parent constructor and why it must be the first statement in the child constructor, with practical examples and common Java pitfalls.

Explain how to declare and define methods inside an anonymous inner class, enforce interface declarations, and use get value and set value to manage data.

Explore nested interfaces and outer-inner interface inheritance using the implements keyword, and implement a single call me method with a unified return type to resolve multiple inheritance conflicts.

Discover how Java interfaces evolved from declaring methods without bodies in Java 7 to supporting default methods with bodies in Java 8. See practical demonstrations of defining, implementing, and calling interface methods, and learn platform-specific implications when running code on Java 7 versus Java 8.

Demonstrate how Java interface methods are public by default and must remain public when overridden, while exploring default interface methods and how restrictive access causes compile errors.

Shows how to declare static variables and static methods in an interface, and access them via the interface name; Java 8 supports it while Java 7 reports errors.

Explore how interfaces in Java treat variables as static by default, contrasted with class variables. Learn why static methods access only static members, while non-static variables require an instance.

Explain how interface members in Java are limited to public access, while class members support public, private, protected, and default access; private and protected are not allowed in interfaces.

Java concept 46 explains how a class can achieve multiple inheritance via interfaces with default methods having the same signature, and why overriding these in the implementing class is mandatory.

Explore how the and operator and or operator in java use the left side to decide whether the right side is evaluated, illustrating true, false, and divide-by-zero scenarios.

Learn why primitive data types cannot be assigned null, while reference types can, and how null values affect variables in Java concept 48.

Java concept 49 clarifies that a child class cannot override a parent method with a different return type; the return types must match to avoid errors.

Explore how Java concept 50 teaches exception class hierarchies, including pattern class and subclasses IO exception and arithmetic exception. Practice overriding methods and managing exception flow with throws and try-catch.

Learn Java inheritance, method overriding, and using the super keyword to call parent class methods from a child class, with practical examples of get info and value methods.

Explore why a final class cannot be inherited in Java, using a shape and rectangle example to show how final prevents extending a class and triggers compile-time errors.

Explore how static blocks, instance initializer blocks, and constructors execute in Java, with static blocks first, then instance blocks, then constructors; multiple blocks allowed, but only one constructor.

Explore how final methods cannot be overridden in Java and how private final methods affect inheritance. The lecture shows through code that private methods are not inherited, impacting method overriding.

Demonstrates typecasting in Java by converting from larger to smaller data types and the resulting lossy conversions, as well as safe upcasting and ASCII value intuition for char types.

Master java exception handling by defining parent and child exception classes and ordering catch blocks in try catch blocks. Explore predefined and user defined exceptions further.

Explain local versus global variables in Java and show that local variables must be initialized to avoid errors, with global variables introduced in the next concept.

Explore how Java initializes variables: class (global) fields get default values (0 for primitives, null for objects) while local variables must be initialized before use, with practical examples.

Discover how final variables are initialized once and cannot be reassigned, and why increment operators cannot apply to final variables, with practical code examples in Java.

Explore how Java's finalize method interacts with the garbage collector: override it with protected or public access, and observe finalization before object destruction.

Explain how the garbage collector calls the finalize method on objects eligible for garbage collection, with examples from the Java concept class and the String class.

Learn how garbage collector calls finalize method and how exceptions inside finalize affect execution, including divide by zero causing termination when finalize is invoked explicitly, not by the garbage collector.

Abstract classes cannot be instantiated, the caption shows. Constructors in abstract classes can initialize non-static variables during inheritance, and a child’s constructor calls the parent’s constructor.

This lecture explains abstract vs non-abstract methods in Java, showing how abstract methods require overriding and cannot be private, while non-abstract methods can be private; includes practical compilation examples.

Explore abstract vs non-abstract methods in java concept 67, showing that abstract methods have no body while non-abstract methods do, and that final cannot pair with abstract, causing compile-time errors.

Explore abstract classes and methods, why static and abstract cannot combine, and how non-abstract methods may be static. See inheritance, abstract signatures, and compile-time errors in Java concept 68.

this lecture explains that interfaces cannot be instantiated, shows how an interface reference can hold an object of the implementing class, and demonstrates calling only interface-declared methods through that reference.