Interview Questions
1. Question: - What is a class?
Answer: - A class is nothing but a description of a set
of objects that represent the same category/kind of entity. Each class describes a specific type of
object e.g. class Customer, class Employee, and class Bird
Every object is an instance of some class.
A class can be treating as a template from which different objects can be
created.
2. Question:- What is Encapsulation?
Answer:- Encapsulation is a process of hiding the implementation details
of the object with binding the data and methods into a single unit and keeping the data safe from outside world. Once the object is encapsulated, Its
implementation details are not immediately accessible any more.
Encapsulation hides the implementation of an abstraction from its clients.
Encapsulation can also be treat as a concept through which we can protect
variables, functions from outside access by the clients. Using encapsulation we can better
manage the piece of code So that it will not create ripples on other parts of
program due to change in preserved code. In Java we can completely encapsulate
a member variable or method by using the private access-modifiers. Even we can use
protected or public access-modifiers. Data hiding means we are providing security to data within the
class. It allows us to hide, how the state of an object is represented and how
the object’s method works.
Below is the way to
achieve encapsulation:-
- By protecting the instance variables i.e. making it private. Some methods also may be private. Constructors and public methods of a class serve as the interface to class’s clients.
- Forcing the calling code to use public accessor method rather than directly using the instance variables.
- Providing the setter and getter methods in order to access instance variables by the clients.
Advantage
- Encapsulation provides flexibility, maintainability and extensibility.
- It is providing the ability to make changes in our implementation code without breaking the code of others who are using our code.
- Main motive is to hide implementation details behind a public programming interface.
- It provides the controlling about accessing the code.
- It helps to reduce dependencies among parts of the program.
- It helps us to follow Factory Design pattern and Singleton design pattern.
Example to achieve Encapsulation:-
package
com.gaurav.encapsulation;
public class
CustomerTransaction {
// Trying to get Encapsulation by making the instance
variables private
private int custId;
private String custName;
private String transactionId;
private double transactionAmount;
private String bankName;
private String accountNumber;
/**
* By making the
constructor private we can also protect it from outside world.
* Then In that
case we have to create a getInstance() factory method which will return this
* class object.
*/
public CustomerTransaction(int customerId, String
customerName,
String transactionID, double
transactionAmt, String bankName,
String accNum) {
this.custId = customerId;
this.custName = customerName;
this.transactionId = transactionID;
this.transactionAmount = transactionAmt;
this.bankName = bankName;
this.accountNumber = accNum;
}
/**
* @return the
custId
*/
public int getCustId() {
return custId;
}
/**
* @param custId
* the custId to set
*/
public void setCustId(int custId) {
this.custId = custId;
}
/**
* @return the
custName
*/
public String getCustName() {
return custName;
}
/**
* @param custName
* the custName to set
*/
public void setCustName(String custName) {
this.custName = custName;
}
/**
* @return the transactionAmount
*/
public double getTransactionAmount() {
return transactionAmount;
}
/**
* @param
transactionAmount
* the transactionAmount to set
*/
public void setTransactionAmount(double
transactionAmount) {
this.transactionAmount = transactionAmount;
}
/**
* @return the
bankName
*/
public String getBankName() {
return bankName;
}
/**
* @param bankName
* the bankName to set
*/
public void setBankName(String bankName) {
this.bankName = bankName;
}
/**
* @return the
transactionId
*/
public String getTransactionId() {
return transactionId;
}
/**
* @param
transactionId the transactionId to set
*/
public void setTransactionId(String transactionId) {
this.transactionId = transactionId;
}
/**
* @return the
accountNumber
*/
public String getAccountNumber() {
return accountNumber;
}
/**
* @param
accountNumber the accountNumber to set
*/
public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
public boolean getPaymentStatus() {
boolean TransactionFlag = false;
if (transactionAmount != 0)
TransactionFlag = true;
return TransactionFlag;
}
/**
* Note:- In this example, we see all instance
variables are made private
* for protecting it from direct access from
outside.
* If you want that from outside users can
access these variables then the better
* approach is to create setter and getters.
* */
}
Encapsulated class Caller:-
package com.gaurav.encapsulation;
public class
CallCustomerTransaction {
public static void main(String args[]) {
int custId = 12345;
String custName = "KUMAR GAURAV";
String transactionID = "IAHDFC09876543";
double transactionAmount = 1999.75;
String bankName = "HDFC BANK";
String accountNumber = "5436758698";
CustomerTransaction ct = new
CustomerTransaction(custId, custName,
transactionID,
transactionAmount, bankName, accountNumber);
System.out.println(ct.getPaymentStatus());
ct.setCustId(354364);
ct.setCustName("SACHIN");
ct.setTransactionId("3254765987QAW");
ct.setTransactionAmount(0);
ct.setBankName("ICICI");
ct.setAccountNumber("425364758");
System.out.println(ct.getPaymentStatus());
}
}
/**
* Note:- CallCustomerTransaction class can't
access instance variables of the
* class CustomerTransaction , without going
through the public accessor getter
* and setter methods as those variables are
marked as private and only accessor
* methods are public.
*/
Here in ct.setCustName("SACHIN"), the name data “SACHIN”
is bonded with the method setCustName, so it is nothing but Data Binding. We cannot
directly access the instance variable “custName” declared in the encapsulated
class CustomerTransaction from outside. So, it is nothing but Data
Hiding and using both(Data Binding and Data Hiding) we are achieving
Encapsulation. So we can say that Data Binding proceed towards the Data Hiding and Data
Hiding proceed towards the Encapsulation.
3. Question:- What is Abstraction?
Answer:- We can achieve Abstraction during the design of the class. When
designing a class we must provide a set of methods that accurately captures the
behaviour of entities of that type. Abstraction is hiding the implementation
details by providing a layer over the basic functionality. It’s a process of
separating the presentation details from the implementation details. Abstractions
provide an external view of the entity. How that interface is implemented is
hidden from clients/Users. We can provide several layers of abstraction to a
system.
Example related to Real world :- Think about a human body, Internally many complexities are there
like how intestine works, how blood circulates inside body, how blood forms,
how it fights with bacteria's but it hides each complexities and provides the
outside view or external view with muscles and skin.
Example related to Java API W.R.T Interface :- About Map interface and we know about the
implementation HashMap class which stores key-value pair and it searches based on keys and
having other public methods for different manipulations, So we know only about
method names and method behaviour but we don't know about How HashMap works?
This is actually what abstraction means.
Example related to Java API W.R.T Abstract Class : - A very good example of Abstraction in Java API is abstract Number class. Signature is:-
- public abstract class Number implements java.io.Serializable
This class contains below abstract methods
- public abstract int intValue();
- public abstract long longValue();
- public abstract float floatValue();
- public abstract double doubleValue();
This class is also having implemented methods like
- public byte byteValue() {
return (byte)intValue();
}
- public short shortValue() {
return (short)intValue();
}
The well known subclasses for this Number class is BigDecimal, BigInteger, Byte,
Double, Float, Integer, Long, Short classes. These classes are providing the concrete implementation of the abstract methods by hiding the internal
complexities and providing the external view which users can use in their classes.
4. Question:- What is the difference between Encapsulation and Abstraction?
Answer:-
Difference between Encapsulation and Abstraction:-
- We can achieve encapsulation using access modifiers in a class and on the other way we can achieve Abstraction using interface and Abstract class. In order to use interface or abstract class we need to extend and implement abstract method with concrete behavior.
- Abstraction focuses on the outside view of an object where as Encapsulation prevents clients from inside accessing, where the behavior of the abstraction is implemented.
Or
we can say that:-
- Abstraction is more about 'What a class can do'? (Refers a scheme/idea – like a Book Index).
- Encapsulation is more about 'How to achieve that functionality'? (Refers an Implementation – like a Book Contents which is associated with Book index).
No comments:
Post a Comment