CHAPTER 01
OOPs Concepts
001. Explain method overloading and method overriding.
Answer:
Method overloading occurs when there are two or more methods in a class with the same name but with different number/type of arguments. The following code demonstrates this:
public class Calculator {
public int add (int a, int b) {
return a+b;
}
public double add (double a, double b) {
return a+b;
}
public int add (int a) {
return a+a;
}
}
Method overriding occurs when there is a method in a subâclass that has the same name and number of arguments as a superâclass method. The following code demonstrates this:
public class Animal {
public void saySomething () {
System.out.println(âI am an animalâ);
}
}
public class Dog extends Animal {
public void saySomething () {
System.out.println(âI am a dogâ);
}
}
002. Explain the benefits of OOPs.
Answer:
Following are the benefits of OOPs:
a. Reusability: OOPs principles like Inheritance, Composition and polymorphism help in reusing existing code
b. Extensibility: Code written using OOPs principles like Inheritance makes code extensible
c. Security: OOPs principles like encapsulation help to keep the data and the code that operates on the data together and makes the code secure
d. Simplicity: Java classes represent real world objects. This makes code very easy to understand
e. Maintainability: Code written using OOPs principles is easier to maintain
003. Write a code snippet that demonstrates encapsulation.
Answer:
Encapsulation refers to keeping the data and the code that operates on the data together as a single unit. Simply creating a class with private fields and public getter/setter methods is an example of encapsulation. The following code snippet demonstrates this:
public class Laptop {
private String memory;
public String getMemory () {
return memory;
}
public String setMemory (String newMemory){
memory = newMemory;
}
}
Here, there is a class called Laptop. It has a private field called memory and public getter and setter methods to access/modify the memory field. So, the memory field cannot be accessed directly outside the class, it can only be accessed via its getter/setter methods.
004. What are the types of inheritance relationships?
Answer:
Inheritance relationships specify how code can be reused. There are two types of inheritance relationships.
They are as follows:
a. ISâA
An ISâA relationship is implemented via inheritance, that is by creating a subâclass. Assume that, Camera is a subclass and Electronics is a super class. In that case, we can say that, Camera ISâA Electronic product
b. HASâA
A HASâA relation can be created via composition, that is by creating a field corresponding to another class. Assume that, inside the Camera class, there is an object called Battery. In that case, we can say that Camera HASâA object called Battery
005. What is the best practice in declaring instance variables?
Answer:
Instance variable should always be declared as private. They should have public getter/setter methods. This helps to protect the instance variable as they can only be modified under the programmerâs control. This is as per the Encapsulation principle.
Declaring instance variables as public violates the encapsulation principle and poses a security issue. Public instance variables can be maliciously modified outside your class. If at all an instance variable needs to be accessed from a subâclass, it can be made protected.
006. What is a singleton class?
Answer:
A class which lets you create only one instance at any given time is termed a Singleton class. A Singleton class can be implemented via a private constructor and a public getter method. The following code demonstrates this.
public class MySingleton {
private static MySingleton mySingletonInstance;
private MySingleton () {
}
public static MySingleton getInstance () {
if (mySingletonInstance == null) {
mySingletonInstance = new MySingleton (); //
create the object only if it is null
}
return mySingletonInstance;
}
public void doSomething () {
System.out.println(âI am here....â);
}
public static void main(String a[]) {
MySingleton mySingleton = MySingleton.getInstance();
mySingleton.doSomething();
}
}
Here, a private constructor and a public getInstance method is defined. The getInstance checks if an instance exists. If an instance does not exist, it creates one using...