500 plus Core Java Interview Questions & Answers

Demonstrates that compiling Java code with syntax errors triggers a compiler error and prevents the dot class file from being created, shown via a practical demo with a missing semicolon.

demonstrates that a dot class file is created only when Java compilation succeeds, not when errors occur, and provides a practical semicolon error example.

Write a Java program that prints command line arguments by iterating the main method's string[] args with a for-each loop. Compile with javac, run with java, and print each argument.

Demonstrate reading user input with the scanner class in Java, using nextLine on System.in and printing the input to the console, with a user prompt and cleanly closing the scanner.

Discover the predefined Java Scanner class imported from java.util to receive user input, with a practical demo of nextLine, nextInt, and nextDouble.

This lecture demonstrates the difference between Scanner's next and nextLine methods: next reads only the first word, while nextLine captures the entire sentence as a string during user input.

Discover how the Java Scanner class captures user input during program execution, including strings with next and nextLine, integers with nextInt, booleans with nextBoolean, and decimals with nextDouble.

Master the Eclipse IDE shortcut for single-line comments in Java: select the code and press Ctrl + / to comment each selected line.

Demonstrate the Eclipse IDE shortcut for multi-line commenting Java code by selecting a code block and pressing control+shift+forward slash, with a practical walkthrough.

Learn how to uncomment single-line and multi-line comments in Eclipse IDE using keyboard shortcuts, including ctrl+/ for single-line and ctrl+shift+/ and ctrl+shift+backslash for multi-line, demonstrated with practical code examples.

See why a Java program cannot run without a main method, demonstrated with an Eclipse IDE walkthrough that shows no run option when main is missing.

Discover the Eclipse IDE shortcut to auto generate the main method by typing main and pressing ctrl+space, which produces the code public static void main(String[] args) in Java programs.

Explore how Java serves as a programming language for web, mobile, and enterprise apps, enabling platform independence via the JVM and revealing its object oriented nature with primitive types.

Identify programming languages for application development, highlighting Java and popular options like Python, C, C#, Ruby, JavaScript, PHP, Perl, Go, R, Haskell, Dart, and TypeScript.

Java remains a popular, object-oriented, platform-independent language with a large, active community and robust libraries, enabling large-scale, mission-critical applications.

Master the Eclipse IDE shortcut for writing Java print statements: type sysout (or syso) and press Ctrl+Space to auto generate System.out.println(), saving coding time.

Explain how the Java platform independence relies on the JVM to translate Java code into bytecode and run it on Windows, Mac, or Linux. Run anywhere across supported machines.

Explain why Java is not 100% object oriented, because primitive data types remain non-object oriented due to early memory constraints.

Discover what happens when you add a character to a number in Java: the character converts to its ASCII code and adds to the number, shown in a demo.

Explore what happens when you add a string with a number in Java: the string concatenates with the number, not adds, producing Arun99 or 199.

Java provides an inbuilt automatic memory cleaning mechanism via the garbage collector that frees unused memory, even when resources like a scanner are not closed.

Identify a subset of Java versions as long-term support, or LTS, offering updates, security patches, and bug fixes over years, while most versions receive updates for about six months.

Identify Java SE 21 as the latest long-term support version as of the recording, with updates through 2031; verify via Oracle Java downloads or the Wikipedia version history.

The first lts version of Java is Java SE 8, with long-term support through updates and security patches. As of Jan 5, 2024, the latest lts is Java SE 21.

Compare predefined Java classes with user defined ones; users create their own classes, while predefined classes come from the Java standard library, such as System in java.lang.

Explain the difference between JRE and JDK. The JRE runs Java applications for end users, while the JDK includes development tools for developers.

Java is free to download and use, including JRE and JDK, for personal and commercial use. Commercial support from Oracle may incur charges, while the software itself remains free.

Java is open source software published under the GNU General Public License, which lets developers view, modify, and distribute Java code.

Explore the core object-oriented features in Java, including object class, encapsulation, inheritance, polymorphism, and abstraction, plus miscellaneous concepts like coupling, cohesion, association, aggregation, and composition.

Explore why Java feels familiar to many developers. The syntax mirrors C and C++, making Java appear easy for those with a C-based background.

Java's security features verify bytecode via the JVM before execution, preventing malicious code, while the security manager enforces policies to secure mission critical applications and control access to sensitive resources.

Java has no pointers, unlike C, which stores memory addresses with pointer variables. This design avoids memory leaks and runtime errors, a common interview focus in core Java questions.

Java offers robust and reliable programming with automatic memory management via garbage collector, strong typing, exception handling, security features, and platform independence through the JVM.

The lecture explains what JIT compilation is and how the JVM uses just-in-time compilation alongside interpretation to convert bytecode into native machine code, speeding up Java execution.

Explore Java's main features: object-oriented design, platform independence via the JVM, multithreading, simple syntax, and security, robustness, and high performance from garbage collection, strong typing, and JIT compilation.

Explore how the Java virtual machine converts bytecode in dot class files into native machine code via the interpreter and the JIT compiler, enabling platform independence.

Explore how the garbage collector automatically manages Java memory, preventing memory leaks by cleaning unused objects, with examples and best practices for closing resources.

Learn how the Java platform divides into JDK and JRE, where JDK includes development tools and JRE includes JVM. Discover how JVM uses JIT to convert bytecode to native code.

Identify the Eclipse IDE as the most used editor for writing Java code, holding 48% market share, followed by IntelliJ IDEA at 33% and other editors.

eclipse ide is completely free to download and use, with step-by-step guidance to download from eclipse.org and optional sponsorship or donations.

Set Java environment variables, including JAVA_HOME and PATH, after installation to enable easy access to Java executables by the operating system and development tools.

Learn why everything in Java is enclosed inside a class, including variables, methods, constructors, inner classes, static blocks, and instance blocks.

Discover that the class keyword, written in lowercase, is required to create a class in Java, with practical demonstrations using Notepad and the Eclipse IDE.

Explore how to create everything inside a Java class, including static and instance variables, static and instance methods, constructors, inner classes, and static and instance initialization blocks.

Explain Java class naming with upper camel case, where every word starts with a capital letter, and show a practical demonstration in Eclipse IDE.

Explain that Java projects use upper camel case, contrast with lower camel case, and show a practical Eclipse IDE demo naming a project in upper camel case.

Learn the Java class syntax, using public class with a class name in upper camel case, and understand default versus illegal private or protected modifiers.

Discover that in Java, program execution starts from the main method, demonstrated with an Eclipse IDE example that runs a class after defining the main method and printing output.

Demonstrate that you cannot run Java programs without a main method, as shown with a no-main class in Eclipse. Add a main method to enable running the Java application.

Demonstrates the Java main method syntax, showing public static void main(String[] args) inside a class with a string array args and practical code examples.

Learn why the main method in Java is static by exploring object creation, static methods, and how the JVM starts program execution by loading the class.

Java main method must be void because the JVM calls it to start the program and does not expect any value back.

Explain why the main method in Java must be public so the JVM can access it from outside class and start execution, using the public static void main(String[] args) syntax.

Understand why renaming the main method in Java prevents program execution. The JVM looks for a lowercase main method signature (public static void main(String[] args)); altering it stops the run.

Learn how Java statements must end with a semicolon symbol, and explore practical demonstrations of declaring variables, initializing them, and printing values in Eclipse.

Answer is no; write print statements outside a method in Java causes compiler errors, while declarations may appear at class level, and most statements belong inside methods.

Explore how Java keywords are reserved words used to declare classes, interfaces, methods, and control structures, and why you must not use them as identifiers.

Showcases why you cannot run Java code without compiling. Demonstrates compiling with javac, generating a .class file, and running with java to avoid the class not found exception.

This lecture explains when Java compiler errors occur, showing common examples like missing semicolons, case sensitivity, braces, and undefined or unreachable code.

Explain why statements after a return in a Java method do not execute, as return terminates the method, yielding unreachable code and a compile error, shown in an Eclipse demo.

Understand why uncompiled Java code won't run, and how compiling with javac and then running with java prevents class not found exception errors.

See how Eclipse automatically compiles Java code in the background as you type, eliminating manual compilation. Compare this with Notepad and learn how to run a Java application in Eclipse.

Discover why unreachable code in Java triggers a compiler error, illustrated with a live eclipse IDE demo using a for loop and a break statement.

You can overload the main method in Java, but the overloaded versions cannot be invoked by the JVM; only the standard main is called, so there is little practical use.

Shows that the JVM only runs the default main method (public static void main(String[] args)) in Java; overloaded mains with different parameters are not invoked, as demonstrated in Eclipse.

Discover how Java constructors can be overloaded by varying the number, type, or order of parameters, with a practical Eclipse-based demo.

Removing a semicolon from Java statements causes a compiler error, since statements must end with a semicolon. The lecture demonstrates this with Eclipse IDE examples like println and variable declarations.

Java is case sensitive; predefined classes, methods, variables, and keywords must use exact casing, or compiler errors occur. A practical demonstration in Eclipse IDE shows lowercase and uppercase usage.

Creating duplicate methods with the same signature in a Java class triggers a compiler error; Java won't run the program. Overload by changing parameter count, types, or order.

Explain how a mismatch between starting and ending braces in Java programs triggers a compiler error, with a practical Eclipse IDE demonstration using a class and a main method.

Discover why the main method cannot be overridden in Java, illustrated with a practical demonstration of inheritance, the override annotation, and a comparison with normal methods.

Declare variables in Java by specifying a data type before the variable name. The data type dictates the values you can store, with examples like int, double, and boolean.

Understand how variable initialization happens on the first assignment in Java, including declaration with initialization and how subsequent assignments are reinitialization.

Explore method overloading in Java, where methods with the same name differ by parameter count, type, or order to avoid duplicate method errors.

Learn how to declare and initialize a Java variable in a single line, illustrated with an int and a value in the same statement.

Explain how variable reinitialization differs from initialization in Java by showing that first-time assignment constitutes initialization, while updates after the first assignment constitute reinitialization.

Inheritance in java lets a child class acquire properties from a parent class using extends, enabling access to inherited variables and methods through the child object.

Discover why Java requires declaring variables with a data type before use, and how undeclared variables trigger compiler errors, for example int, double, float, boolean.

Learn how method overriding works in Java: a child class extends a parent and redefines a method with the same signature, so the child method overrides the parent.

Java requires declaring a variable before use; using it first causes a compiler error like 'a cannot be resolved to a variable'. The lecture demonstrates this with sample code.

Explains why you cannot apply private before a class in Java, showing a compiler error and the need for a public class; demonstrates accessing private members through public methods.

Demonstrates a Java program that checks if a user-entered number is divisible by both 2 and 3, using a scanner, modulus checks, and optionally separating logic into a method.

Declare and print an uninitialized local variable in Java, triggering a compiler error; initialize it to proceed, as Eclipse shows zero for primitives and null for string references.

Explain polymorphism in Java as many forms, achieved through overloading and overriding, with the same name producing different behaviors in classes; constructor overloading is possible in a single class.

Explains whether static methods can access instance variables and methods; direct access is not allowed, but you can access them by creating an object, as shown.

Instance methods in Java can directly access static variables and static methods. Static methods can only access static stuff directly unless you create an object to access non-static members.

Define local variables as those declared inside a method; their scope and life are limited to that method, unlike non-local class fields accessible throughout the class.

Learn what global variables are in Java by declaring them directly under a class outside methods, contrast them with local variables inside methods, and understand their class-wide scope.

Shows that local and global variables in Java can share the same name within a program, with the local variable taking precedence in a method's scope during a practical demonstration.

Demonstrate that constructor overloading is possible in Java by showing multiple constructors with different parameter counts or types; explain why duplicates are not allowed.