Java Interview Questions for Freshers

“In my library management project I had an abstract class called Member. Encapsulation: the fine balance was a private field, and the only way to change it was through methods like addFine and payFine, so nobody could set it to a negative number. Inheritance: Student and Faculty both extended Member and reused its code. Polymorphism: each subclass overrode getBorrowLimit, so when the checkout code called member.getBorrowLimit it got the right number without checking the type. Abstraction: the checkout screen only knew about Member and its public methods, not how each type worked inside. The nice part was that when we added a Guest member late in the project, the checkout code didn't change at all.”

“A constructor is a special block with the same name as the class and no return type, and it runs when I write new to set up the object's starting state. If I don't write any, Java gives me a default no-argument one, but only if I've written none at all. this() lets one constructor call another in the same class, which avoids repeating code: a two-argument constructor can pass a default value to the three-argument one. super() calls the parent class's constructor. If I don't write it, Java inserts a call to the parent's no-argument constructor for me, so the parent part of the object is always built before the child part. Traditionally both this() and super() have to be the first statement, so you can't use both in one constructor.”

“From tightest to loosest: private means only code inside the same class can see it, which is what I use for fields. Default, which is what you get when you write no modifier at all, means anything in the same package can see it; people call it package-private. protected includes the same package and also subclasses, even when they're in a different package. public means any class anywhere can use it. My rule in college projects was to make fields private and expose only the methods other classes really needed. A detail that surprises people is that protected is actually wider than default, not narrower, because it adds subclasses on top of the package.”

“If a class could extend two classes that both define the same method, or both carry state, it would be unclear which version the child inherits. That's the diamond problem, and Java avoids it by allowing only one parent class. A class can implement many interfaces, and for a long time that was safe because interfaces had no method bodies. Default methods brought the clash back: if two interfaces both give a default hello method, a class implementing both won't compile until it overrides hello itself. Inside that override it can pick one side with First.super.hello(), or combine both. Also, if a parent class already has a hello method, the class's version wins over any interface default.”

“A shallow copy creates a new outer object but copies each field as it is, so if a field is a reference to a list, both copies point to the same list. Add a mark to one student's list and the other student's list changes too. A deep copy also copies the inner mutable objects, so the two are fully independent. Object's clone method does a shallow copy by default, and it only works if the class implements Cloneable, otherwise it throws CloneNotSupportedException, which makes it awkward. I'd rather write a copy constructor that creates a new list with the same elements. Immutable fields like Strings can be shared safely, so only the mutable ones need copying.”

“When I compile a Java file with javac, it doesn't produce machine code for my laptop. It produces a .class file full of bytecode, which is a set of instructions for the Java Virtual Machine rather than for a real processor. Every operating system has its own JVM, and each one knows how to run that same bytecode, interpreting it and compiling the hot parts to native code as it goes. So I can compile on Windows and run the same .class file on Linux or a Mac without changing anything. That's what platform independent means. The small catch is that the JVM itself is platform dependent: you install a different one for each system, which is exactly what lets the program stay the same.”

“public means the JVM, which sits outside my class, is allowed to call it. static means the method belongs to the class, not to an object, so the JVM can call it without first creating an instance. void means it returns nothing to the caller. main is simply the name the launcher looks for as the starting point. And String[] args holds whatever I type after the class name on the command line, so java App hello world gives me an array of two strings. In the classic form, static is needed because at the moment the program starts, no object of my class exists yet. Newer Java releases also accept a simpler main method, but interviewers usually mean this classic version.”

“Java is always pass-by-value. With a primitive, the method gets a copy of the number, so changing it inside the method doesn't affect the caller. With an object, the variable holds a reference, and it's that reference that gets copied. So the method's parameter and the caller's variable point to the same object. If the method changes a field through that reference, the caller sees the change, which is why people think it's pass-by-reference. But if the method reassigns the parameter to a new object, only its local copy moves; the caller's variable still points to the original. In this example the dog ends up called Max, not Rex. With true pass-by-reference, the reassignment would have changed the caller too.”

“Every primitive has a wrapper class, like int and Integer or double and Double. We need them because collections only hold objects, so a List can't store a plain int, and because a wrapper can be null. Autoboxing is the compiler turning an int into an Integer for me, using Integer.valueOf, and unboxing is the reverse. The == puzzle comes from that valueOf call: Java caches Integer objects from minus 128 to 127, so two boxed 100s are literally the same object and == is true. Two boxed 1000s are usually separate objects, so == compares references and gives false. The fix is simple: compare wrapper objects with equals, or unbox to int first. Also, unboxing a null Integer throws a NullPointerException.”

“== compares references: it's true only if both variables point to the exact same object in memory. equals, on a String, compares the actual characters. The confusing part is that two identical string literals usually point to the same object because of the string pool, so == happens to return true and the bug hides. But if one string comes from new String, from user input or from joining strings at run time, it's a different object, and == returns false even though the text is the same. So for comparing text I always use equals, or equalsIgnoreCase when case doesn't matter. I also write "yes".equals(input) with the literal first, so a null input just gives false instead of a NullPointerException.”

“A String can't change once it's created, so every time I write s = s + something inside a loop, Java builds a brand new String and copies all the old characters into it. In a loop of thousands of iterations that's a lot of copying and garbage. StringBuilder holds a growable buffer of characters that I change in place with append, so it's the one I use to build a long string. StringBuffer does the same job but its methods are synchronized, which makes it safe to share between threads but a bit slower. In practice I almost never share a string being built across threads, so I pick StringBuilder, and I call toString once at the end.”

“static means the thing belongs to the class, not to any one object. A static variable has a single copy that all objects share, so if I keep a counter of how many Student objects were created, I make it static and every constructor increments the same number. A static method is called on the class name, like Math.max, and because there's no object involved it can't use this or touch instance fields directly. A static block is code that runs once, when the class is first initialised, before any object is created, so it's a place to set up static data like a lookup table. The common mistake is making things static just to call them from main, which ends up turning everything into global state.”

“They sound alike but do completely different jobs. final is a keyword: a final variable can be assigned only once, a final method can't be overridden, and a final class, like String, can't be extended. finally is a block that goes with try and catch; it runs whether the try finishes normally or throws, so it's where I used to close files or database connections. finalize is a method on Object that the garbage collector might call before reclaiming an object. It was never guaranteed to run at a predictable time, and it's now deprecated, so I wouldn't use it. For cleanup I use try-with-resources instead. One detail people miss: a final reference to a list stops me reassigning the variable, but I can still add items to the list.”

“I'd use two pointers. One starts at the first character and one at the last. While left is less than right, I compare the two characters; if they differ it's not a palindrome and I return false straight away. If they match, I move left forward and right back. If the pointers meet or cross without a mismatch, it's a palindrome. That's O(n) time and no extra space, because I never build a reversed copy. Before coding I'd ask whether case and spaces count. If the interviewer says 'Madam' should pass, I lower-case the string first, and for phrases I'd skip anything that isn't a letter or digit. An empty string or a single character counts as a palindrome and falls out of the loop naturally.”

“The first idea is two nested loops comparing every pair, which works but is O(n squared). A better way is to walk the array once with a HashSet called seen. HashSet's add method returns false if the value is already there, so the moment add fails I know it's a repeat. To avoid printing a value three times when it appears three times, I keep a second set of duplicates and print that at the end. Both sets give average constant-time lookups, so the whole thing is O(n) time and O(n) extra space. If the interviewer says I can't use extra memory, I'd sort the array first and then compare neighbours, which is O(n log n) time.”

“The recursive version reads just like the definition: if n is 0 or 1, return n, otherwise return fib of n minus 1 plus fib of n minus 2. It's short, but it recomputes the same values again and again, so the number of calls grows exponentially, and for large n it can also overflow the stack. The loop version keeps two variables, the previous two numbers, and slides them forward n times, so it's O(n) time and constant space. That's the one I'd use. If the interviewer wants recursion anyway, I'd add memoization, storing each result in an array so each value is computed once. I'd also mention that int overflows fairly early, so for bigger n I'd switch to long or BigInteger.”

“I keep two trackers, largest and second. In the code they're long values starting at Long.MIN_VALUE, so even Integer.MIN_VALUE in the array counts as a real number. For each number, if it's bigger than largest, the old largest drops to second and the number becomes largest. Otherwise, if it's bigger than second and not equal to largest, it becomes the new second. I'd first ask whether they mean the second largest distinct value; usually they do, so in 9, 9, 4 the answer is 4, and the not-equal check handles that. It's one pass, O(n) time and constant space, which beats sorting at O(n log n). If second was never updated, there's no answer, for example with one element or all values equal, so I return an empty OptionalInt instead of a misleading number.”

“I pick based on what the data needs. A List keeps things in order and allows duplicates, so in my quiz app the questions for a test were an ArrayList, because order mattered and I read them by index. A Set doesn't allow duplicates and answers contains quickly, so I used a HashSet of question ids a student had already attempted, to avoid showing one twice. A Map stores key-value pairs, so scores were a HashMap from student id to their total, which let me update one student's score directly instead of searching a list. If I needed the keys sorted, say for a leaderboard by name, I'd switch to a TreeMap, and LinkedHashMap if I wanted insertion order.”

“Comparable is implemented by the class itself: Student implements Comparable and writes compareTo, which gives it one natural order, say by roll number. Then Collections.sort on a list of students uses that order. Comparator is a separate object that describes an order from the outside, so I can have as many as I like, by marks, by name, by marks then name, without touching the Student class. That also works for classes I can't edit. In modern Java I build comparators with Comparator.comparing, so sorting by marks highest first, then by name, is one readable line. When writing compareTo by hand I use Integer.compare rather than subtracting two numbers, because subtraction can overflow and give the wrong sign.”

“throw is an action: inside a method I write throw new IllegalArgumentException with a message, and that exception starts travelling immediately. throws is a declaration in the method signature, like throws IOException, telling callers this method might pass that exception up to them, and for checked exceptions the compiler makes them handle it or declare it too. When an exception is thrown and not caught, Java looks up the call stack: the current method ends, then its caller, and so on, until some method has a matching catch. If none does and it reaches the top of the thread, in a simple program that's main, the thread ends and the stack trace is printed. In a console program that means the program crashes with that trace.”

“A NullPointerException happens when I use a reference that points to nothing: calling a method on it, reading a field, taking the length of a null array, or unboxing a null Integer. When I hit one, I start with the line in the stack trace, and newer Java versions even say which variable was null. To avoid them, I initialise fields when I declare them, for example a list starts as an empty ArrayList instead of null. Methods that return collections return an empty list rather than null, so callers can loop safely. I check parameters at the start of a method with Objects.requireNonNull, so the error appears where the bad value came in, not three calls later. And for string comparisons I put the literal first.”

“The two basic ways are extending Thread and overriding run, or writing a Runnable and passing it to a new Thread. I prefer Runnable, usually as a lambda, because Java only allows one parent class, and it keeps the task separate from the thread that runs it. In real code I'd hand tasks to an executor rather than making threads by hand. The start versus run difference is a classic trap. start asks the JVM to create a new thread, and that new thread calls run. If I call run directly, no new thread is created; the code just runs on the current thread like any normal method call. Also, a thread can be started only once. Calling start a second time throws IllegalThreadStateException.”

“In my final year, three of us built an attendance system for our department in Java with a MySQL database. I wrote the part that marked attendance and produced the monthly report. I designed a small Student class and an AttendanceRecord class, and used a HashMap from student id to their records so the report didn't query the database once per student. The trickiest bug was duplicate entries when a teacher clicked submit twice, which I fixed with a unique constraint and a check before inserting. Looking back, I put SQL strings directly into the screen classes, which made testing hard. Now I'd move all database code into one data-access class and write unit tests for the report logic.”

“In my internship I built a small dashboard that showed what share of support tickets each team closed on time. Almost every team showed zero, and one showed exactly a hundred. I assumed the database query was wrong and lost most of a day there. Then I stopped guessing, printed the raw counts, and they were correct. So I put a breakpoint on the line that did the maths: closedOnTime divided by total, times 100, all ints. Integer division threw away the fraction, so anything below one became zero before the multiply. I changed it to closedOnTime times 100.0 divided by total, and added a guard for teams with no tickets. Since then, whenever a number looks wrong, I check the types in the calculation first, and I write a small test with numbers I've worked out by hand.”