Acing Your DigitalOcean Interview: The Complete Guide

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you think the tutorial could be better, please let us know by clicking the “report an issue” button at the bottom of the page.

Core Java interview questions help you in preparing for java based interviews. Core Java is an important part of any Java/JEE interview, no matter how much experience you have or how new you are to the field.

Core Java is the most-asked question in most interviews, and how well you do on it can make or break your chances of getting the job.

This post comes directly from my 14+ years of Java programming and lots of interviewing experience. Since Java 16 came out not long ago, I updated the post to include some of the questions from the new versions.

It’s been a while since I wrote anything about Java interview questions for certain subjects like Strings, Collections, and Multithreading.

Here I am providing some of the important core java interview questions with answers that you should know. You can bookmark this post to brush up on your knowledge before heading for an interview.

Java 14 was released on March 17, 2020. It is a Non-LTS version. Some of the developer specific Java 14 Features are:

Java 13 was launched on Sept 17, 2019. It is a Non-LTS version. Some of the developer specific Java 13 Features are:

Java 12 was launched on March 19, 2019. It is a Non-LTS version. Some of the Java 12 Features are:

Java 11 is the second LTS release after Java 8. They changed the way they license and support software, so if you want to use the Java 11 Oracle JDK for business, you will have to pay for it. If you want to use a free version, you can download it from the OpenJDK website.

Java 10 is the first every-six-months from Oracle corporation, so it’s not a major release like earlier versions. However, some of the important features of Java 10 are:

Java 10 is mostly a maintenance release, however I really liked the local variable type inference feature. For a detailed overview of Java 10, please go through Java 10 Features.

Java 9 was a major release and brought a lot of features. Some of the important features are:

Since Java 8 came out in March 2014, it’s one of the most-asked-about topics in java interviews. That you like to keep up with the latest technologies will be clear from how you answer this question.

Java 8 has been one of the biggest releases after Java 5 annotations and generics. Some of the important features of Java 8 are:

I strongly advise that you read through the links above to fully understand each one. You should also read Java 8 Features.

Object-oriented programming (OOPS) ideas are at the heart of Java. Here are some OOPS ideas that are used in Java programming:

Platform independence means that you can run the same Java Program in any Operating System. For example, you can write java program in Windows and run it in Mac OS.

Java Virtual Machine (JVM) is the heart of java programming language. JVM is responsible for converting byte code into machine-readable code. JVM is not platform-independent, that’s why you have different JVM for different operating systems. We can customize JVM with Java Options, such as allocating minimum and maximum memory to JVM. It’s called virtual because it provides an interface that doesn’t depend on the underlying OS.

With the Java Virtual Machine (JVM), you can run Java programs. The Java Development Kit (JDK) is used for development.

JDK provides all the tools, executables, and binaries required to compile, debug and execute a Java Program. The execution part is handled by JVM to provide machine independence.

Java Runtime Environment (JRE) is the implementation of JVM. JRE consists of JVM and java binaries and other classes to execute any program successfully. JRE doesn’t contain any development tools like java compiler, debugger, etc. If you want to execute any java program, you should have JRE installed.

java.lang.Object is the root class for all the java classes and we don’t need to extend it.

Java doesn’t support multiple inheritance in classes because of “Diamond Problem”. To know more about diamond problem with example, read Multiple Inheritance in Java.

However multiple inheritances are supported in interfaces. Because they only list the methods, an interface can extend other interfaces. The implementation will be in the implementing class. So there is no issue of the diamond problem with interfaces.

Folks don’t say that Java is only object-oriented because it has primitive types like int, byte, short, long, and more. I believe it brings simplicity to the language while writing our code. Java could have had wrapper objects for the primitive types, but they would have only helped with representation and not done anything else.

We all know that there are wrapper classes for all primitive types, like Integer, Long, etc., that give those types extra methods.

PATH is an environment variable used by the operating system to locate the executables. So, when we install Java or want the OS to find any executable, we need to add the path to the directory to the PATH variable. Do you work with Windows OS? Read this post to find out how to set up the PATH variable on Windows.

Classpath is specific to Java and used by java executables to locate class files. When running a Java application, we can tell it where to find the classpath. This can be a directory, a ZIP file, a JAR file, or something else.

The main() method is the entry point of any standalone java application. The syntax of the main method is public static void main(String args[]).

Java’s main method is public and static so that Java runtime can access it without initializing the class. There is a list of strings in the input parameter that lets us give runtime arguments to the Java program. Check this post to learn how to compile and run a java program.

Method overloading is when a class has more than one method with the same name, but different arguments.

The idea of overriding comes up with inheritance when there are two methods in the parent class and one in the child class that have the same signature. If the method in the parent class changes, the overridden method in the child class will also change. This is possible with the @Override annotation.

Yes, we can have multiple methods with the name “main” in a single class. When we run the class, however, Java will look for the main method, which is written as public static void main(String args[]).

We can’t have more than one public class in a single java source file. A single source file can have multiple classes that are not public.

Java package is the mechanism to organize the java classes by grouping them. The grouping logic can be based on functionality or modules based. A java class fully classified name contains package and class name. For example, java. lang. Object is the fully classified name of Object class that is part of java. lang package.

The java. lang package is imported by default and we don’t need to import any class from this package explicitly.

Java provides access control through public, private and protected access modifier keywords. When none of these are used, it’s called default access modifier.

A java class can only have public or default access modifier. Read Java Access Modifiers to learn more about these in detail.

The final keyword is used with Class to make sure no other class can extend it. For example, the String class is final and we can’t extend it.

We can use the final keyword with methods to make sure child classes can’t override it.

Java’s final keyword can be used with variables to make sure that it can be assigned only once. The state of the variable, on the other hand, can be changed. For example, we can only assign a final variable to an object once, but the variables on the object can change in the future.

The static keyword can be used with class-level variables to make it global i. e all the objects will share the same variable.

We can use static keyword with methods also. A static method can access only static variables of class and invoke only static methods of the class.

When you use try-catch with the finally block, you can put code that should always be run, even if the try-catch block throws an exception. finally block is mostly used to release resources created in the try block.

The finalize() is a special method in Object class that we can override in our classes. This method gets called by the garbage collector when the object is getting garbage collected. This method is usually overridden to release system resources when the object is garbage collected.

We can’t declare a top-level class as static however an inner class can be declared as static. If the inner class is declared as static, it’s called a static nested class.

There is no difference between the static nested class and any other top-level class. It is only nested for ease of packaging.

Usually, we import the class and then use the method or variable with the class name if we need to use a static variable or method from another class.

It’s also possible to import just the static method or variable and then use it in the class as if it were part of it.

Use of static import can cause confusion, so it’s better to avoid it. Overuse of static import can make your program unreadable and unmaintainable.

One of the Java 7 features is the try-with-resources statement for automatic resource management. Before Java 7, there was no auto resource management and we should explicitly close the resource. Usually, it was done in the finally block of a try-catch statement. This approach used to cause memory leaks when we forgot to close the resource.

From Java 7, we can create resources inside try block and use it. Java takes care of closing it as soon as try-catch block gets finished. Read more at Java Automatic Resource Management.

One of the new features in Java 7 is the multi-catch block, which lets us catch more than one exception in a single catch block. This makes our code shorter and cleaner when every catch block has a similar code.

You can use a pipe (|) to separate exceptions in a catch block. In this case, the exception parameter (ex) is final, which means you can’t change it.

The Java static block is a set of statements that are run when the Java ClassLoader loads the class into memory. It is used to initialize static variables of the class. Mostly it’s used to create static resources when class is loaded.

Interfaces are one of the most important ideas in the programming language Java. They are used a lot in the JDK, in Java design patterns, and in most frameworks and tools. In Java, interfaces are a way to achieve abstraction and set the rules for how subclasses should work.

Interfaces are good for starting point to define Type and create top level hierarchy in our code. A Java class can implement more than one interface, so most of the time it’s better to use an interface as the superclass. Read more at java interface.

Abstract classes are used in java to create a class with some default method implementation for subclasses. It is possible for an abstract class to have both an abstract method and a method with implementation.

The abstract keyword is used to create a abstract class. It is not possible to instantiate an abstract class. Instead, they are mostly used as a base for subclasses that want to add to or change the methods in an abstract class. Read important points about abstract classes at java abstract class.

Interfaces don’t implement another interface, they extend it. Since interfaces can’t have method implementations, there is no issue of diamond problem. That’s why we have multiple inheritances in interfaces i. e an interface can extend multiple interfaces.

From Java 8 onwards, interfaces can have default method implementations. To solve the diamond problem when the same default method is used in more than one interface, it must be implemented in the class that implements the interfaces. For more details with examples, read Java 8 interface changes.

A marker interface is a blank interface that doesn’t have any methods but is used to force methods to work in Java classes. Some of the well known marker interfaces are Serializable and Cloneable.

Java wrapper classes are the Object representation of eight primitive types in java. All the wrapper classes in java are immutable and final. Java 5 autoboxing and unboxing allows easy conversion between primitive types and their corresponding wrapper classes.

Enum was introduced in Java 1. 5 as a new type whose fields consist of a fixed set of constants. In Java, we can make Direction an enum with fixed fields like EAST, WEST, NORTH, and SOUTH.

enum is the keyword to create an enum type and similar to the class. Enum constants are implicitly static and final. Read more in detail at java enum.

Java Annotations provide information about the code and they have no direct effect on the code they annotate. Annotations are introduced in Java 5. Annotation is metadata about the program embedded in the program itself. It can be parsed by the annotation parsing tool or the compiler. We can also specify annotation availability to either compile-time only or till runtime. Java Built-in annotations are @Override, @Deprecated and @SuppressWarnings. Read more at java annotations.

Java Reflection API provides the ability to inspect and modify the runtime behavior of java application. We can inspect a java class, interface, enum and get their methods and field details. Reflection API is an advanced topic and we should avoid it in normal programming. Reflection API usage can break the design pattern such as Singleton pattern by invoking the private constructor i. e violating the rules of access modifiers.

Even though we don’t use Reflection API in normal programming, it’s very important to have. We can’t have any frameworks such as Spring, Hibernate or servers such as Tomcat, JBoss without Reflection API. They use the reflection API to call the right methods and create classes, and they do a lot of other work with it as well.

Composition is the design technique to implement has-a relationship in classes. We can use Object composition for code reuse.

Java composition is achieved by using instance variables that refer to other objects. Composition is helpful because it lets us decide which other objects client classes can see and reuse only what we need. Read more with example at Java Composition example.

One of the best practices of Java programming is to “favor composition over inheritance”. Some of the possible reasons are:

You can read more about above benefits of composition over inheritance at java composition vs inheritance.

We need to implement Comparable interface to support sorting of custom objects in a collection. The Comparable interface has a method called compareTo(T obj) that is used by sorting methods. By implementing this method, we can give custom object collections a default way to be sorted.

But if you want to sort based on something different, like age or salary, you can make a Comparator instance and pass it as the sorting method. For more details read Java Comparable and Comparator.

We can define a class inside a class and they are called nested classes. Any non-static nested class is known as an inner class. The object of the class is linked to the inner class, which can access all of the outer class’s variables and methods. Since inner classes are associated with the instance, we can’t have any static variables in them.

We can have local inner class or anonymous inner class inside a class. For more details read java inner class.

A local inner class without a name is known as an anonymous inner class. An anonymous class is defined and instantiated in a single statement. Anonymous inner class always extend a class or implement an interface.

It is not possible to set up a constructor for an anonymous class because it does not have a name. Anonymous inner classes are accessible only at the point where it is defined.

This is the program that loads byte code programs into memory when we need to use a class. We can create our own classloader by extending ClassLoader class and overriding loadClass(String name) method. Learn more at java classloader.

Java ternary operator is the only conditional operator that takes three operands. It’s a one liner replacement for if-then-else statement and used a lot in java programming. We can use ternary operator if-else conditions or even switch conditions using nested ternary operators. An example can be found at java ternary operator.

You can use the “super” keyword to get to the method in the superclass when you have changed it in the child class.

The super keyword can be used to call superclass constructors from a child class constructor, but in this case, it should be the first line of the constructor method.

We can use break statement to terminate for, while, or do-while loop. We can use a break statement in the switch statement to exit the switch case. You can see the example of break statement at java break. We can use a break with the label to terminate the nested loops.

The continue statement skips the current iteration of a for, while, or do-while loop. We can use the continue statement with the label to skip the current iteration of the outermost loop.

This keyword points to the current object and is mostly used to make sure that object variables are used instead of local variables with the same name.

No argument constructor of a class is known as default constructor. If we don’t define a constructor for the class, the Java compiler makes the default no-args constructor for the class. If there are other constructors defined, then compiler won’t create default constructor for us.

Garbage Collection looks at heap memory to see which objects are being used and which are not, and then deletes the objects that are not being used. In Java, the process of deallocating memory is handled automatically by the garbage collector.

We can run the garbage collector with code Runtime. getRuntime(). gc() or use utility method System. gc(). For a detailed analysis of Heap Memory and Garbage Collection, please read Java Garbage Collection.

We can convert a Java object to a Stream that is called Serialization. When you change an object to Stream, you can save it to a file, send it over the network, or use it in a socket connection.

The object should implement a Serializable interface and we can use java. io. ObjectOutputStream to write objects to file or to any OutputStream object. Read more at Java Serialization.

The process of converting stream data created through serialization to Object is called deserialization. Read more at Java Deserialization.

We can run a jar file using java command but it requires Main-Class entry in jar manifest file. Main-Class is the entry point of the jar and used by java command to execute the class. Learn more at java jar file.

Java System Class is one of the core classes. One of the easiest ways to log information for debugging is System. out. print() method.

System class is final so that we can’t subclass and override its behavior through inheritance. System class doesn’t have any public constructors, so we can’t make an instance of it. All of its methods are static because of this.

There are useful methods in the System class that let you copy arrays, get the current time, and read environment variables. Read more at Java System Class.

We can use the instanceof keyword to check if an object belongs to a class or not. We should avoid it’s usage as much as possible. Sample usage is:

At runtime, str is of type String, so the first if statement is true and the second one is false.

One of the Java 7 feature was improvement of switch case of allow Strings. So if you are using Java 7 or higher version, you can use String in switch-case statements. Read more at Java switch-case String example.

This question is very hard to understand. We know that object variables hold references to objects in heap space. There is a copy of these variables sent to and stored in the stack memory of any method that is called. A simple generic swap method lets us test any language, whether it’s pass by reference or pass by value. To learn more, read Java is Pass by Value and Not Pass by Reference.

The task of java compiler is to convert java program into bytecode, we have javac executable for that. It needs to be kept in JDK since we don’t need it in JRE and JVM is only for specs.

Answer: The code won’t compile because we can’t have an Object class method with the static keyword. Note that the Object class has toString() method. You will get a compile-time error as “This static method cannot hide the instance method from Object”. Since every class base is an Object, we can’t have the same method in both the instance and the class. This is because the static method is part of the class. If you change the name of the method from toString() to something else that isn’t in the Object superclass, you won’t get this error.

Answer: Well this is a strange situation. We all have seen NullPointerException when we invoke a method on the object that is NULL. But here this program will work and prints “Test foo called”.

The reason for this is the java compiler code optimization. It finds out that foo() is a static method and should be called using class when the Java code is compiled to byte code. So it changes the method call obj. foo() to Test. foo() and hence no NullPointerException.

There’s no doubt that this is a tough question. If you’re interviewing someone, it will really stump them. 🙂.

That’s all for core java interview questions and answers. The list will keep getting longer. If you think I missed an important question, please let me know in the comments.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Get our biweekly newsletter

Sign up for Infrastructure as a Newsletter.

Try DigitalOcean for free

Click below to sign up and get $200 of credit to try our products over 60 days!

Please complete your information!

Interview Tips with Hiring Manager – DigitalOcean

FAQ

How to prepare for a digital transformation interview?

What is asked in Cisco interview?

What is the interview process like at DigitalOcean?

I interviewed at DigitalOcean (Islamabad, Islamabad) in Apr 2023 The interview process went smoothly. It started with an initial interview with the HR team, which lasted about 10 minutes. Then I had a casual chat with the hiring manager where we discussed my previous experience and job expectations. After that, I scheduled my technical interviews.

What are core Java interview questions?

Core Java interview questions help you in preparing for java based interviews. Whether you are a fresher or highly experienced professional, core java plays a vital role in any Java/JEE interview. Core Java is the favorite area in most of the interviews and plays a crucial role in deciding the outcome of your interview.

How many spring interview questions are there?

Here I am providing almost 50 spring interview questions and their answers. It’s updated up to Spring 5, so it covers all the latest features such as Spring WebFlux for reactive programming. 1. What is Spring Framework? Spring is one of the most widely used Java EE frameworks.

What are the hot topics in Java interview questions?

Java 8 has been released in March 2014, so it’s one of the hot topics in java interview questions. If you answer this question clearly, it will show that you like to keep yourself up-to-date with the latest technologies. Java 8 has been one of the biggest releases after Java 5 annotations and generics. Some of the important features of Java 8 are: