Java IS-A and HAS-A Relationship With Examples

A quick guide to IS-A and HAS-A Relationship in java with examples

Overview

Nowadays, Many programmers get confused with these IS-A and HAS-A relationships in java. It is a common interview question for freshers and experienced programmers to check their basic knowledge of oops principles.


We will discuss the following

1) IS-A Relationship (Inheritance)
2) HAS-A Relationship (Association)
3) Examples for each type
4) Interview Questions

The main idea of these two principles is code reusability and easy code maintenance. You will see now how the code can be easily reusable in many places and used by many other programmers.

IS-A Relationship (Inheritance)

IS-A Relationship can be formed with a minimum of two classes with a relation. This is referred as Inheritance in java.
Let us take a simple example for our understanding. We know every four-wheeler Car is a Vehicle.
Honda is a Car
Suziki is a Car
Toyota is a Car
benz is a Car

So, From these examples all four wheeler brands are Cars and all have some common features such as color, max speed, gears type etc. These common features will be in Car class and car specific features will be in Car Brand car.

IS-A relationship is implemented by using the "extends" keyword in java inheritance. Whenever you find the "extends" keyword anywhere in your application that is IS-A Relationship.

Creating one is Car class and many car specific classes.

IS-A Relationship Example

// Common features class
class Car {
 int avgSpeed;
 int currentSpeed;

 public int getCurrentSpeed() {
  return currentSpeed;
 }

 public void setCurrentSpeed(int currentSpeed) {
  this.currentSpeed = currentSpeed;
 }

 public int getAvgSpeed() {
  return avgSpeed;
 }

 public void setAvgSpeed(int maxSpeed) {
  this.avgSpeed = maxSpeed;
 }

 public int getNoOfGears() {
  return 6;
 }

 public String getDefaultColor() {
  return "White";
 }

}

In-Car class, it has common methods which are used by all its subclasses. It has default no of gears, colour, can be set the current speed.

Below is a Honda car which is a subclass of Car. It has its own specific max speed is 120. Inside the Honda car, we can use all methods of Car class.

// Honda specific implementation class
class Honda extends Car {

 public void startHondaCar() {
  setAvgSpeed(70);
  System.out.println("Started Honda Car with average speed : " + getAvgSpeed());
 }

 public int getMaxSpeed() {
  return 120;
 }

 public void stopHondaCar() {
  System.out.println("Honda Car has stopped");
 }
}

Below is a Maruthi car which is a subclass of Car. It has its own specific max speed is 100. Inside the Honda car, we can use all methods of Car class.

// Maruthi specific implementation class
class Maruthi extends Car {

 public void startHondaCar() {
  setAvgSpeed(100);
  System.out.println("Started Maruthi Car with average speed : " + getAvgSpeed());
 }

 public int getMaxSpeed() {
  return 100;
 }

 public void stopHondaCar() {
  System.out.println("Maruthi Car has stopped");
 }

}

In these two Honda, Maruthi classes have access to Car class and all Car methods are accessible from these subclasses.

Main class of IS-A relationship.

// Main method for IS-A Relationship
public class IsARelationShip {

 public static void main(String[] args) {
  System.out.println("Honda specific implementation.");
  Honda hondaCar = new Honda();
  hondaCar.startHondaCar();
  System.out.println("Honda car max speed: " + hondaCar.getMaxSpeed());
  hondaCar.stopHondaCar();

  System.out.println("\nMaruthi specific implementation.");
  Maruthi maruthiCar = new Maruthi();
  maruthiCar.startHondaCar();
  System.out.println("Honda car max speed: " + maruthiCar.getMaxSpeed());
  maruthiCar.stopHondaCar();

 }

}

Output:

Honda specific implementation.
Started Honda Car with average speed : 70
Honda car max speed: 120
Honda Car has stopped

Maruthi specific implementation.
Started Maruthi Car with average speed : 100
Honda car max speed: 100
Maruthi Car has stopped

In this example program, Car class has all the common features of a car which all are required by all its implementation cars which can be default features. If Honda wants its own specific then they have the ability to provide its own implementation for those methods which is called as Method Overriding.

Please go through the above program and leave your questions in the comments section.

HAS-A Relationship (Association)

HAS-A relationship also can be formed by a minimum of two classes. If any class has an instance variable that referring another class.

Let us break them down into examples for better understanding. Honda car has an Engine, Maruthi car has an Engine.

HAS-A Relationship Example

Creating an Engine class that has engine related functions.

// Engine specific implementation class
class Engine {
 public void startWithDieselEngine() {
  System.out.println("Diesel engine has added and it's started");
 }

 public void startWithPetrolEngine() {
  System.out.println("Petrol engine has added and it's started");
 }

 public void startWithAutomaticEngine() {
  System.out.println("Automatic engine has added and it's started");
 }
}

Creating ToyotaDiesel class which has instance variable of Engine class. Instance variable engine calls startWithDieselEngine() method and ignore the remaining methods in the Engine class.

// Toyota Diesel car
class ToyotaDiesel {

 public Engine engine;

 public Engine getEngine() {
  return engine;
 }

 public void setEngine(Engine engine) {
  this.engine = engine;
 }

 public ToyotaDiesel() {
  System.out.println("Toyota Diesel  car has constructed");
 }

 public void startEngine() {
  engine.startWithDieselEngine();
 }
}

Another class, instance variable referring to Engine class. Invoking benz automatic engine startWithDieselEngine().

// Benz Automatic car
class BenzAutomatic {

 public Engine engine;

 public Engine getEngine() {
  return engine;
 }

 public void setEngine(Engine engine) {
  this.engine = engine;
 }

 public BenzAutomatic() {
  System.out.println("Benz Automatic car has constructed");
 }

 public void startEngine() {
  engine.startWithDieselEngine();
 }
}

Main method IS-A relationship class:

// Main method for IS-A Relationship
public class HasARelationShip {

 public static void main(String[] args) {
  // Creating Engine Object
  Engine engine = new Engine();

  // Toyota diesel car
  System.out.println("ToyotaDiesel specific implementation.");
  ToyotaDiesel toyotaDieselCar = new ToyotaDiesel();
  toyotaDieselCar.setEngine(engine);
  toyotaDieselCar.startEngine();

  // Benz Automatic car
  System.out.println("\nBenzAutomatic specific implementation.");
  BenzAutomatic benzAutomatic = new BenzAutomatic();
  benzAutomatic.setEngine(engine);
  benzAutomatic.startEngine();

 }

}

Output:

ToyotaDiesel specific implementation.
Toyota Diesel  car has constructed
Diesel engine has added and it's started

BenzAutomatic specific implementation.
Benz Automatic car has constructed
Diesel engine has added and it's started

Interview Questions

You must have a clear understanding of the following questions now.

1) What is IS-A Relationship.
2) What is HAS-A Relationship.
3) What are the differences between IS-A and HAS-A relationships?
4) When do you use both. Give some examples.

Summary

Java IS-A and HAS-A Relationship play a significant role in all applications.
IS-A relationship is declared with the "extends" keyword and helpful when all functionalities are needed in sub-classes. This is handled by the java compiler with intelligence.
Whereas HAS-A Relationship is not declared with any keyword but it comes into reality when using an instance variable to another class that has some common functionalities. You can see that only one method is used in IS-A relationship examples.

Please leave if you have interview questions on this topic.