JAVA and OOPS multiple choice questions Test with answeres

Since now a days the number of candidates appearing for a job has increased, companies have started keeping screening process. This screening process consist of objective questions which can be answered online. Only those candidates which score good marks in Objective questions are called for personal interviews.

This blog has multiple choice OOPS and Java  questions. It is a mix of topics like Inheritance, overriding, static, constructor etc.

Read the question and try to solve it yourself. Then you can click on the Answer button to verify your answer.


Core Java Test 1 >> Core Java Test 2 >> Exception Handling Test 3




1.

public class BankDetails {

 private int accountNumber;
 private boolean accountExpired;
 private int balance;
 private boolean isSaving;
 private boolean isCurrent;

 public boolean isSaving() {
  return isSaving;
 }

 public boolean isCurrent() {
  return isCurrent;
 }

 public BankDetails(int accountNumber, boolean accountExpired, int balance,
   boolean isSaving, boolean isCurrent) {
  this.accountNumber = accountNumber;
  this.accountExpired = accountExpired;
  this.balance = balance;
  this.isSaving = isSaving;
  this.isCurrent = isCurrent;
 }

 public static void main(String[] args) {
  BankDetails bankDetails = new BankDetails(14523, false, 500, true,
    false);

  System.out.println(getCurrentSalary(bankDetails));
  
 }

 private static int getCurrentSalary(BankDetails bankDetails) {
  if (bankDetails.isSaving() && !bankDetails.accountExpired && 
   (bankDetails.balance > 100)) {
   return bankDetails.balance;
  }
  return 0;
 }
}

Output 
1. 0
2. 500
3. Compile error

---

Answer : 2. 500.
Explanation :
This one is quite straight forward and uses if condition to check some properties of class BankDetails. The if condition checks if it is a saving account and if the account has not expired and the balance is grater than 100.
If the condition is true the if block is executed and it returns the balance which is 500.

2.

package my;
public class Dog extends Animal {}

package my;
public class Animal {
 
 public void eat()
 {
  System.out.println("Animal is eating");
 }
 
 public static void main(String[] args) {
  
i. Object obj = new Animal();
ii. Animal animal = new Dog();
iii. Object obj1 = new Dog();

iv. obj.eat();
v. animal.eat();
vi. obj1.eat();


vii. boolean areObjectEqual=obj.equals(obj1);

viii. Animal a = (Animal)obj;
ix. a.eat();


x. Dog dog = (Dog)obj1;
xi. dog.eat();
 }
}

Which of the lines will not compile?
1. i, iii, iv, vi
2. iv, vi
3. ix, xi

Answer : 2. iv, vi.

This is a good one.
Remember that it is the reference on which the method is called. So the reference type should be aware about the method being called.
At runtime the actual object attached to that reference is called. But at compile time the Reference on which the method is called should have the method. In this case Object obj and Object obj1 do not have eat method. So they will fail to compile obj.eat() and obj1.eat().

But Animal class has method eat so animal.eat() will compile fine. When you run the program the method in Dog will get called. This is overriding.

3.

package my;

public class Dog extends Animal {
 
 int i;
 public Dog(int i){
  this.i=i;
 }
 public void eat()
 {
  System.out.println("Dog "+i+" is eating");
 }
}

package my;

public class Animal {
 
 public void eat()
 {
  System.out.println("Animal is eating");
 }
 
 public static void main(String[] args) {
  Object object = new Object();
  Object animal = new Animal();
  Animal dog1 = new Dog(1);
  Object dog2 = new Dog(2);
  
  callEat(object);
  callEat(animal);
  callEat(dog1);
  callEat(dog2);
 }
 
 public static void callEat(Object ref){
  if(ref instanceof Animal){
   Animal a = (Animal)ref;
   a.eat();
  }
  if(ref instanceof Dog){
   Dog a = (Dog)ref;
   a.eat();
  }
 }
}

1.
Animal is eating
Dog 1 is eating
Dog 2 is eating

2.
Animal is eating
Dog 1 is eating
Dog 1 is eating
Dog 2 is eating
Dog 2 is eating

Answer : 2.
Let me first explain how instanceof works.
instanceof is used to check the actual object attached to the reference. When we do a instanceof A. We are checking if A is the class whose object is been attached to reference a. So when we do Object a = new Animal(); The reference is of Object but the object attached is of Animal. so a instanceof Animal will return true. Remember Object is the super class for all classes. So it is the super class of Animal also.
The question is will below statement return true. a instanceof Object The answer is yes. Because Animal is also an Object (is - a relationship)

4.

package my;

public class BankAccount {
 
 public BankAccount(int accountNumber) {
  numberOfAccounts++;
  this.accountNumber=accountNumber;
 }
 
 public static int numberOfAccounts;

 public int accountNumber;
 
 
 public static int getNumberOfAcoounts(){
  return numberOfAccounts;
 }
 
 public static void main(String[] args) {
  System.out.println(BankAccount.numberOfAccounts);
  
  BankAccount firstAccount = new BankAccount(1449);
  
  System.out.println(BankAccount.numberOfAccounts);
  System.out.println(firstAccount.numberOfAccounts);
  
  
  BankAccount secondAccount = new BankAccount(1449);
  System.out.println(secondAccount.numberOfAccounts);
  
  System.out.println(firstAccount.getNumberOfAcoounts());
 }
}

Output:
1. Compilation error instance variable cannot access static variables
2. Constructor cannot access static variables
3. 0 1 1 2 2 
4. 0 1 1 2 1

Answer : 3. 0 1 1 2 2
This question uses static variable.
A static variable belongs to the class. That means no matter how many instance of the class you have. There will be only one instance of the static variable.
A static variable can be accessed by Class as well as through the objects.
Here numberOfAccounts is the static variable and it gets incremented in the constructor. So every time we create a instance of BankAccount, static variable will get incremented.

5.

package my;

public class BankAccount {
 
 public BankAccount(int accountNumber) {
  numberOfAccounts++;
  this.accountNumber=accountNumber;
 }
 
 public static int numberOfAccounts;

 public int accountNumber;
 
 
 public static int getNumberOfAcoounts(){
  return numberOfAccounts;
 }
 
 public static int getAccountNumber(){
  return accountNumber;
 }
 
 public static void main(String[] args) {
  
  BankAccount bankAccount = new BankAccount(1221);
  System.out.println(BankAccount.getAccountNumber());
 }
}

Output:
1. Compilation error at line return numberOfAccounts; Can not access instance variable
 from static method
2. 1221

Answer : 1. As mentioned in the above question. A static variable is for a class. Similarly a static method can only access static variable and not a non static variable.
Imagine that you have loaded the class but not created the instance. A a static method is trying to access a instance variable. The instance variable is not yet created because not instance of class is created. Hence accessing instance variables from static class is not allowed.

6.

package my;

public class Animal {
 {
  System.out.println("In instance block");
 }
 
 static{
  System.out.println("In Static block");
 }
 
 public Animal(){
  System.out.println("In Default constructor");
 }
 
 
 public static void main(String[] args) {
  Animal a = new Animal();
 }
}

Output:
In instance block
In Static block
In Default constructor

In Static block
In instance block
In Default constructor

In Static block
In Default constructor
In instance block

Answer : 2
A static block gets called when the class is loaded. A instance block is the method with no name. It gets called before the constructors.

And finally the constructor get called.

A class can have multiple static and instance blocks. Their execution will happen one after another as they are declared.

For more objective question click OOPS and JAVA Objective questions part 2