Chapter 6

Abstract Classes ,Interfaces, and Encapsulation

Abstract Classes
A class which cannot be instantiated is known as abstract class. In
other words –you are not allowed to create object of Abstract class.
Abstract class declaration

Specifying abstract keyword before the class during declaration, makes

it abstract class.
Have a look at below code:

abstract class AbstractDemo{

public void myMethod(){
//Statements here
}
}

Abstract vs Concrete
A class which is not abstract is referred as Concrete class.

Abstract methods
Apart from having abstract class you can have abstract methods as well.
Syntax of abstract method:
public abstract void display();
Points to remember about abstract method:
1) Abstract method has no body.
2) Always end the declaration with a semicolon(;).
3) It must be overridden.
• An abstract class must be extended and in a same wayabstract
method must be overridden.
4) Abstract method must be in a abstract class.

Note: The class which is extending abstract class must override (or
implement) all theabstract methods.
I
Example of Abstract class and method
abstract class Demo1
{
public void disp1(){
System.out.println("Concrete method of abstract class");
}

abstract public void disp2();

}

class Demo2 extends Demo1{

public void disp2()
{
System.out.println("I'm overriding abstract method");
}
public static void main(String args[]){
Demo2 obj = new Demo2();
obj.disp2();
}
}

Output:
I'm overriding abstract method

II
Interface in JAVA
Declaration

Interfaces are created by specifying a keyword “interface”. E.g.:

interface MyInterface
{
//All the methods are public abstract by default
public void method1();
public void method2();
}

class XYZ implements MyInterface

{
public void method1()
{
System.out.println("implementation of method1");
}
public void method2()
{
System.out.println("implementation of method2");
}
public static void main(String arg[])
{
MyInterface obj = new XYZ();
obj. method1();
}
}
Output:
implementation of method1

III
Key points:

1. While providing implementation of any method of an interface,

it needs to bementioned as public.
2. Class implementing any interface must implement all the methods.
3. Interface cannot be declared as private, protected or transient.
4. All the interface methods are by default abstract and public.
5. Variables declared in interface are public, static and final by default.
interface Try
{
int a=10;
public int a=10;
public static final int a=10;
final int a=10;
static int a=10;
}
All the above statements are identical.

6. Interface variables must be initialized at the time of declaration otherwise

compiler will through an error.
interface Try
{
int x;//Compile-time error
}
Above code will throw a compile time error as the value of the
variable x is notinitialized at the time of declaration.

7. Inside any implementation class, you cannot change the variables declared in
interface because by default, they are public, static and final.

IV
 Class Sample implements Try
{
public static void main(String arg[])
{
x=20; //compile time error
}
}
8. Any interface can extend any other interface but cannot implement it. Class
implements interface and interface extends interface.
9. A class can implements any number of interfaces.
10. If there are having two or more same methods in two interfaces and a
class implements both interfaces, implementation of one method is enough.

interface A
{
public void aaa();
}
interface B
{
public void aaa();
}
class Central implements A,B
{
public void aaa()
{
//Any Code here
}
public static void main(String arg[])
{
//Statements
}
}

V
 11. Variable names conflicts can be resolved by interface name e.g:
interface A
{
int x=10;
}
interface B
{
int x=100;
}
class Hello implement A,B
{
public static void Main(String arg[])
{
System.out.println(A.x);
System.out.println(B.x);
}
}

Interface and Inheritance

As I discussed above that one interface can not implement another
interface. It has toextend the other interface if required.
See the below example where I have two interfaces Inf1 and Inf2. Inf2
extends Inf1 so If class implements the Inf2 it has to provide
implementation of all the methods of interfaces Inf1 and Inf2.
public interface Inf1
{
public void method1();
}
public interface Inf2 extends Inf1
{
public void method2();
}
public class Demo implements Inf2
{
public void method1(){
//Implementation of method1
}
public void method2(){
//Implementation of method2

VI
 }
}

Benefits of having interfaces: Following are the benefits of interfaces:

1. achieve the security ofimplementation.
2. In java, multiple inheritance is not allowed, However by using
interfaces you can achieve the same .

VII
Encapsulation in Java

What is encapsulation?

 The whole idea behind encapsulation is to hide the

implementation details from users.

 If a data member is private it means it can only be

accessed within the same class.

 No outside class can access private data member

(variable) of other class.

 However if we setup public getter and setter methods to

update the private data fields then the outside class can
access those private data fields via public methods.

 This way data can only be accessed by public methods

thus making the private fields and their implementation
hidden for outside classes. That’s why encapsulation is
known as data hiding.

VIII
Lets see an example to understand this concept better.

public class EncapsulationDemo{

private int ssn;
private String empName;
private int empAge;

//Getter and Setter methods

public int getEmpSSN() {

return ssn;
}

public String getEmpName(){

return empName;
}

public int getEmpAge(){

return empAge;
}

public void setEmpAge(int newValue){

empAge = newValue;
}

public void setEmpName(String newValue){

empName = newValue;
}

public void setEmpSSN(int newValue){

ssn = newValue;
}
}

public class EncapsTest{

public static void main(String args[]){
EncapsulationDemo obj = new EncapsulationDemo();
obj.setEmpName("Mario");
obj.setEmpAge(32);
obj.setEmpSSN(112233);
System.out.println("Employee Name: " + obj.getEmpName());
System.out.println("Employee SSN: " + obj.getEmpSSN());
System.out.println("Employee Age: " + obj.getEmpAge());

IX
 }
}

Output:
Employee Name: Mario
Employee SSN: 112233
Employee Age: 32

Advantages of encapsulation:
1. It improves maintainability and flexibility and re-usability
2. The fields can be made read-only (If we don’t define setter
methods in the class) orwrite-only (If we don’t define the getter
methods in the class).
3. User would not be knowing what is going on behind the scene.