24.

Java Abstraction Java

As per dictionary, abstraction is the quality of dealing with ideas rather than events. For
example, when you consider the case of e-mail, complex details such as what happens as
soon as you send an e-mail, the protocol your e-mail server uses are hidden from the
user. Therefore, to send an e-mail you just need to type the content, mention the address
of the receiver, and click send.

Likewise in Object-oriented programming, abstraction is a process of hiding the

implementation details from the user, only the functionality will be provided to the user.
In other words, the user will have the information on what the object does instead of how
it does it.

In Java, abstraction is achieved using Abstract classes and interfaces.

A class which contains the abstract keyword in its declaration is known as abstract class.

Abstract classes may or may not contain abstract methods, i.e., methods without
body ( public void get(); )

But, if a class has at least one abstract method, then the class must be declared
abstract.

If a class is declared abstract, it cannot be instantiated.

To use an abstract class, you have to inherit it from another class, provide
implementations to the abstract methods in it.

If you inherit an abstract class, you have to provide implementations to all the
abstract methods in it.

Example
This section provides you an example of the abstract class. To create an abstract class,
just use the abstract keyword before the class keyword, in the class declaration.

/* File name : [Link] */

public abstract class Employee
{
private String name;
private String address;
private int number;
public Employee(String name, String address, int number)

320
 Java

{
[Link]("Constructing an Employee");
[Link] = name;
[Link] = address;
[Link] = number;
}
public double computePay()
{
[Link]("Inside Employee computePay");
return 0.0;
}
public void mailCheck()
{
[Link]("Mailing a check to " + [Link]
+ " " + [Link]);
}
public String toString()
{
return name + " " + address + " " + number;
}
public String getName()
{
return name;
}
public String getAddress()
{
return address;
}
public void setAddress(String newAddress)
{
address = newAddress;
}

321
 Java

public int getNumber()

{
return number;
}
}

You can observe that except abstract methods the Employee class is same as normal class
in Java. The class is now abstract, but it still has three fields, seven methods, and one
constructor.

Now you can try to instantiate the Employee class in the following way:

/* File name : [Link] */

public class AbstractDemo
{
public static void main(String [] args)
{
/* Following is not allowed and would raise error */
Employee e = new Employee("George W.", "Houston, TX", 43);

[Link]("\n Call mailCheck using Employee reference--");

[Link]();
}
}

When you compile the above class, it gives you the following error:

[Link]: Employee is abstract; cannot be instantiated

Employee e = new Employee("George W.", "Houston, TX", 43);
^
1 error

322
 Java

We can inherit the properties of Employee class just like concrete class in the following
way:

/* File name : [Link] */

public class Salary extends Employee
{
private double salary; //Annual salary
public Salary(String name, String address, int number, double
salary)
{
super(name, address, number);
setSalary(salary);
}
public void mailCheck()
{
[Link]("Within mailCheck of Salary class ");
[Link]("Mailing check to " + getName()
+ " with salary " + salary);
}
public double getSalary()
{
return salary;
}
public void setSalary(double newSalary)
{
if(newSalary >= 0.0)
{
salary = newSalary;
}
}
public double computePay()
{
[Link]("Computing salary pay for " + getName());
return salary/52;
}
}

323
 Java

Here, you cannot instantiate the Employee class, but you can instantiate the Salary Class,
and using this instance you can access all the three fields and seven methods of Employee
class as shown below.

/* File name : [Link] */

public class AbstractDemo
{
public static void main(String [] args)
{
Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);

[Link]("Call mailCheck using Salary reference --");

[Link]();

[Link]("\n Call mailCheck using Employee reference--");

[Link]();
}
}

This produces the following result:

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
ailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--

Within mailCheck of Salary class
ailing check to John Adams with salary 2400.

If you want a class to contain a particular method but you want the actual implementation
of that method to be determined by child classes, you can declare the method in the parent
class as an abstract.

abstract keyword is used to declare the method as abstract.

324
 Java

You have to place the abstract keyword before the method name in the method
declaration.

An abstract method contains a method signature, but no method body.

Instead of curly braces, an abstract method will have a semoi colon (;) at the end.

Following is an example of the abstract method.

public abstract class Employee

{
private String name;
private String address;
private int number;

public abstract double computePay();

//Remainder of class definition

}

Declaring a method as abstract has two consequences:

The class containing it must be declared as abstract.

Any class inheriting the current class must either override the abstract method or
declare itself as abstract.

Note: Eventually, a descendant class has to implement the abstract method; otherwise,
you would have a hierarchy of abstract classes that cannot be instantiated.

Suppose Salary class inherits the Employee class, then it should implement
the computePay() method as shown below:

/* File name : [Link] */

public class Salary extends Employee
{
private double salary; // Annual salary

public double computePay()

{
[Link]("Computing salary pay for " + getName());
return salary/52;
}
//Remainder of class definition
}

325
 25. Java Encapsulation Java

Encapsulation is one of the four fundamental OOP concepts. The other three are
inheritance, polymorphism, and abstraction.

Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on
the data (methods) together as a single unit. In encapsulation, the variables of a class will
be hidden from other classes, and can be accessed only through the methods of their
current class. Therefore, it is also known as data hiding.

To achieve encapsulation in Java:

Declare the variables of a class as private.

Provide public setter and getter methods to modify and view the variables values.

Example
Following is an example that demonstrates how to achieve Encapsulation in Java:

/* File name : [Link] */

public class EncapTest{

private String name;

private String idNum;
private int age;

public int getAge(){

return age;
}

public String getName(){

return name;
}

public String getIdNum(){

return idNum;
}

326
 Java

public void setAge( int newAge){

age = newAge;
}

public void setName(String newName){

name = newName;
}

public void setIdNum( String newId){

idNum = newId;
}
}

The public setXXX() and getXXX() methods are the access points of the instance variables
of the EncapTest class. Normally, these methods are referred as getters and setters.
Therefore, any class that wants to access the variables should access them through these
getters and setters.

The variables of the EncapTest class can be accessed using the following program:

/* File name : [Link] */

public class RunEncap{

public static void main(String args[]){

EncapTest encap = new EncapTest();
[Link]("James");
[Link](20);
[Link]("12343ms");

[Link]("Name : " + [Link]() + " Age : " +

[Link]());
}
}

This will produce the following result:

Name : James Age : 20

327
 Java

The fields of a class can be made read-only or write-only.

A class can have total control over what is stored in its fields.

The users of a class do not know how the class stores its data. A class can change
the data type of a field and users of the class do not need to change any of their
code.

328
 26. Java Interfaces Java

An interface is a reference type in Java. It is similar to class. It is a collection of abstract

methods. A class implements an interface, thereby inheriting the abstract methods of the
interface.

Along with abstract methods, an interface may also contain constants, default methods,
static methods, and nested types. Method bodies exist only for default methods and static
methods.

Writing an interface is similar to writing a class. But a class describes the attributes and
behaviors of an object. And an interface contains behaviors that a class implements.

Unless the class that implements the interface is abstract, all the methods of the interface
need to be defined in the class.

An interface is similar to a class in the following ways:

An interface can contain any number of methods.

An interface is written in a file with a .java extension, with the name of the
interface matching the name of the file.

The byte code of an interface appears in a .class file.

Interfaces appear in packages, and their corresponding bytecode file must be in a

directory structure that matches the package name.

However, an interface is different from a class in several ways, including:

You cannot instantiate an interface.

An interface does not contain any constructors.

All of the methods in an interface are abstract.

An interface cannot contain instance fields. The only fields that can appear in an
interface must be declared both static and final.

An interface is not extended by a class; it is implemented by a class.

An interface can extend multiple interfaces.

329