Java Phone Interview Questions - Beginner Level
Tags: java, beginners, career
Published: 2022-03-01 10:06:43

Do you have a phone interview coming up soon? This article can help you!

I will cover common beginner-level phone interview questions, and I'm going to show you how you can best address these questions to increase your chances of succeeding at the interview.
### What is a class?

A class is a set of instructions used to create a specific object. A class describes what an object will be. However, it is NOT the object itself.


![personClass.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1645983494802/p02gLFye8.png)

### What is an object?

An object is an entity that encapsulates data (=attributes or states ) and actions(=behaviour).

An example of an object can be a Person object with a name as an attribute and an action such as walking.

An object doesn't always have to be something physical. It can be something invisible (for example, a bank account).

### What is object-oriented programming? 

When answering this question, don't be afraid to give an extensive reply.

Object-oriented programming is a paradigm in which we use classes and objects to organize software.

The four key pillars of object-oriented programming are:

- Inheritance: when a class (child/subclass) inherits the attributes and behaviours of another class (parent/superclass). Inheritance is possible through the ```extends``` keyword. For example, we have a person superclass and a student subclass.

- Polymorphism: when a class can be inherited and overridden. For example, the superclass Person has a method called 

Encapsulation is also known as data hiding. It's the principle by which we combine both attributes and behaviour in a class.

- Abstraction: when we hide the implementation details and leave the functionalities visible to the user.

### What's the difference between method overloading and method overriding?

To answer this question, it's best to:

- Explain method overloading conceptually and then provide an example.

- Explain method overriding conceptually and then provide an example.

- In the end, compare both.

You have methods with the same name but different parameters with method overloading. 

```
int addNumber(int number)
float addNumber (float number)
double addNumber(double number, double number1, double number2)
```

With method overloading, you have a subclass method with the same signature as the parent class.

```
public class Animal() {

void sound() {
System.out.println("Animals make a sound");
}

class Dog extends Animal {

void sound() {
System.out.println("Animals make a sound");
}
}
}
```

In method overloading, methods have the same name but different argument lists (this is a must!). The return type may or may not be different. It happens in the same class. Method overloading is how we achieve compile-time polymorphism. 

In method overriding, methods have a "personalized" implementation already provided by the parent class. Since we mentioned earlier about superclass and subclass, method overriding only happens when there is a relationship of inheritance between two classes. 

Method overriding is how we achieve run-time polymorphism. The return type must be the same or covariant.

### Does Java support multiple inheritance?

The answer to this question is NO. Extend the answer by explaining the Diamond problem and what you would do to address multiple inheritance.

Java doesn't support a class inheriting properties from more than one class. 

To solve this problem, we can use default methods, which have been introduced from Java 8.

Before Java 8, interfaces could only have methods with no implementation.

From Java 8, you can have a method with implementation, and there's no need to override these methods.

### What does static keyword mean?

Explain the concept and then provide an example.

Static is a keyword (meaning that it has a special meaning for the compiler), and it means that members of a class (a variable or a method) belong to the class itself.

This means that you don't need to create an object to access a class member. To be more precise, when you declare a class member as static, only a single instance of that member gets created and distributed among all objects. You don't need to use the new keyword normally used to create an object to access that static member.

Please look at one of my previous articles to learn more about the [static keyword](https://techwithmaddy.com/what-does-static-mean-in-java).

### What does final mean?

When addressing this question, specify that a final member cannot be reassigned, but it is still mutable.

Final is a keyword that can be applied to variables, methods and classes.

Variables: a final variable becomes a constant. 

```
final double PI = 3.14;
```

Methods: a final method is a method that you cannot override.

```
public class Circle {

    final double PI = 3.14;

     final double calculateArea(int radius) {
        double areaOfCircle = PI * radius * radius;
        return areaOfCircle;
    }
}
```

Class: a final class is a class that you cannot override. It gives a compilation error.

![image.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1645880145962/4mj_D0SxR.png)

### What does "thread safety" mean?

Thread is an advanced topic, but it's good to have a basic answer to provide so that you don't lose "points".

Thread safety is the code’s ability to deal with and handle concurrent/multi-threaded access to resources.

It's also good to know that a hash map is NOT thread-safe. An alternative would be to use a ConcurrentHashMap.

### How do you handle exceptions in Java?

This question requires you to discuss try/catch block, checked and unchecked exceptions.

A try/catch is a block split into two sections:

1. The try block, where you write the code that may or may not throw an exception.

2. The catch block is the block that will handle the exception.

Other questions that the interviewer may ask you are:

> Can a try/catch block have multiple catch blocks?

The answer is YES.

Something like this can exist:

```
try {

} catch {

} catch {

}
```

> Can you have a try without a catch?

The answer is YES. You can have a try block without a catch block if you add a *finally* block.

```
try {

} finally {

}
```

The finally block executes regardless of whether there will be an exception thrown or not.

It's also worth knowing about checked and unchecked exceptions. 

A checked exception is an exception that happens during compile-time. You can d two things to handle checked exceptions:

- Enclose the code within a try/catch block

```
    public void checkedException() {
        File file = new File("This_File_Does_Not_Exist.txt");

        try {
            FileInputStream fileInputStream = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
```

- Use the throws keyword in the method signature:

```
    public void checkedException() throws FileNotFoundException {
        File file = new File("This_File_Does_Not_Exist.txt");

        FileInputStream fileInputStream = new FileInputStream(file);
    }
```

An unchecked exception is an exception that tells there is something wrong with the logic of the program. A popular example is when you try to divide a number by zero.

Common examples of unchecked exceptions are:

- NullPointerException: when an object points to nothing. 
- ArrayIndexOutOfBounce: when you try to access an element out of the scope of the array
- IllegalArgumentException: when you pass an illegal or inadequate argument to a method.

### How come Strings are immutable in Java?

"Immutable" means that you create a String, you won't be able to change it. Instead, you're going to create a new one. 

Let's look at this scenario:

```
    public static void main(String[] args) {

        String laptop = "MacBook";

        System.out.println("Printing " + laptop);

        laptop.concat(" Pro");

        System.out.println(" ' Pro' is not printed " + laptop);

        laptop = laptop.concat(" Pro");

        System.out.println("Printing full laptop name " + laptop);

     }
```

The result is:

```
Printing MacBook
 ' Pro' is not printed MacBook
Printing full laptop name MacBook Pro
```

![immutableString.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1645979411285/no2KO7Jt_.png)

The reasons why a String is immutable are:

- String pool: with immutability, we save memory in the heap. The compiler will check if a String literal already exists in the pool. If it does, we match the reference of the already existing String and avoid creating a new object. 

- Thread safety: a String is unchangeable. This means that different threads can use a String without synchronization.

- Caching: a String generates a hashcode stored at the time of creation. 

- Security: we use String all the time, for example, when creating a new password. If a String is mutable, it will pose a major security threat. 


### How does an interface work?

To address this question, explain what an interface is. Give an example and explain in which context you would use one. Mention that interfaces use the implements keyword instead of extends (used with inheritance).

An interface is a fully abstract class. This means that all the interface methods do not have a body (also known as implementation).

To benefit from an interface, we need to implement it. This means that you'll have to use the **implements** keyword to create a class where the methods will have a body.

```
public interface Animal {
    
    public void makeSound();
    
    class Dog implements Animal {

        @Override
        public void makeSound() {
            System.out.println("Uof Uof!");
        }
    }
}
```

An interface can implement multiple interfaces.

An interface can extend another interface.

Interfaces are great because they allow you to define the specification that a class has to follow. 

Please note that with Java 8, an interface can have methods with an implementation. These methods are known as default methods.

I hope you've found this article helpful! Good luck. 🍀🍀🍀

**ARTICLES THAT YOU MAY ENJOY READING**
- [Java Interview Questions](https://techwithmaddy.com/java-interview-questions)
- [Top 10 Technical Terms Every Software Engineer Should Know](https://techwithmaddy.com/top-10-technical-terms-every-software-engineer-should-know)
- [Java 8: Functional Interfaces](https://techwithmaddy.com/java-8-functional-interfaces)