Abstract Class & Methods

[Kalyan Naveenan]

Hi, Being new to java, i would need some help from the experts here. Can someone explain me the concepts of abstract class & methods and how would each help in polymorphism. Please give an explanation with a simple example. Also if possible, it would be of much help if explanation is given with reference to eg in ch8 of head forst java

[Vijitha Kumara]

Welcome to CodeRanch, Kalyan Naveenan!

Abstract classes can define abstract methods as well as concrete methods. Abstract methods must be implemented by the subclasses who extend the abstract class. So using this mechanism you can define more generic methods in abstract classes which are applied to subclasses as well, and still other abstract methods which needed to be implemented by the subclasses.
In this way you can have a super class reference referred an subclass and they are guaranteed to implement all the abstract methods of the super(abstract) class. So you have the polymorphism.

abstract class Shape{

  abstract void draw();
  
  // Other non-abstract/abstract methods here.
}
class Line extends Shape{

  public void draw(){
   // implementation goes here
  }
}

[Vijay Tidake]

Hi,

Please see the program and comments.

/*
 * In the following programs lets assume that you have a Vehicle and you want to drive the vehicle.
 * Now each Vehicle has a same mechanism for driving it. ie.
 * 1.Get the Key
 * 2.Start the vehicle
 * 3.Run the vehicle.
 * 
 * Now for each Vehicle to start we have to put the key in a key hole and press it.This means that each vehicle
 * has same starting mechanism.
 * So we implemented the method start() in Vehicle class.
 * 
 * Now as you know ,4 wheeler and 3 wheeler Vehicle run differently as they have different runnig mechanism(for eg Stearing and Handle)
 * So imlementing the run() in Vehicle class will not be appropriate.
 * 
 * So,we only declared the method run() in Vehicle class.By adding "abstract" keyword.
 * As we made the method abstract,we have to make the class abstract.
 * 
 * Now We have defined the DriveVehicle class,To drive the vehicle
 * 
 */

abstract class Vehicle {
	public boolean start() {
		if (haskey()) {
			return true;
		}
		return false;
	}

	private boolean haskey() {
		// Logic to get key. Suppose you have a key
		return true;
	}

	public abstract void run();
}

class ThreeWheeler extends Vehicle {

	@Override
	public void run() {
		System.out.println("Ruuning on 3 wheeler");
	}

}

class FourWheeler extends Vehicle {

	@Override
	public void run() {
		System.out.println("Running on 4 wheels");
	}

}

public class DriveVehicle {
	public static void main(String[] args) {
		Vehicle v = new FourWheeler();
		v.run();

		v = new ThreeWheeler();
		v.run();
	}
}

/*
 * Now if you say,you wants to drive FourWheeler,we have to do
 * 
 * Vehicle v = new FourWheeler();
 * 
 * v.run();
 * 
 * Now in above statement you can see that the abstarct class doen't have the
 * implimented run() method. but when you call the method on Vehicle instance
 * the program compiles fine and run properly.
 * 
 * It will call appropriate run() method from FourWheeler.This is called
 * polymorphism
 */

Hope this helps

Thanks.

[Kalyan Naveenan]

Thanks Vijay Tidake for helping me understand the concept with a simple eg. So can you explain me why and when do i use the concept of interface implementation.

[Vijay Tidake]

Hi,

Hope following example helps you to understand the concept.

/*
 * Its always a good programming practice to code to an interface
 * 
 * For example after studing following example,
 * 
 * try to think upon  a point "what if tommarow you want to introduce a
 * new type of machine"
 * 
 * 
 */

interface Machine {

	/*
	 * Each machine may or may not have a key.
	 */
	public boolean haskey();

	/*
	 * Each machine must start to do the operation
	 */
	public boolean start();

	/*
	 * Each machine may run or may not run(on wheels)to perform its operation
	 */
	public void run() throws Exception;

	public void nonRunable() throws Exception;

}

abstract class Vehicle implements Machine {
	/*
	 * Vehicles are meant for running on wheel and required a key to start
	 * 
	 * Thus start method checks if Vehicle hasKey or not
	 */
	@Override
	public boolean start() {
		if (haskey()) {
			return true;
		}
		return false;
	}

	@Override
	public boolean haskey() {
		/*
		 * return true as each vehicle has a key
		 */
		return true;
	}

	/*
	 * This is the operation is not supported here.But as we have a contract
	 * with the Machine interface we have to follow it.
	 */
	@Override
	public void nonRunable() throws Exception {
		throw new Exception("This operation not supported here.As vehicle runs");
	}

}

abstract class Pump implements Machine {
	/*
	 * Pump can start without key so simply returns true without checking
	 */
	@Override
	public boolean start() {
		return true;
	}

	/*
	 * Pump dont have any key
	 */
	@Override
	public boolean haskey() {
		return false;
	}

	/*
	 * This is the operation is not supported here.But as we have a contract
	 * with the Machine interface we have to follow it.
	 */
	@Override
	public void run() throws Exception {
		throw new Exception(
				"This operation not supported here.As pump dont runs on wheels");
	}

}

class ThreeWheeler extends Vehicle {

	@Override
	public void run() {
		System.out.println("Ruuning on 3 wheeler");
	}

}

class WaterPump extends Pump {

	@Override
	public void nonRunable() throws Exception {
		System.out.println("pump is doing operation");

	}

}

public class StartMachine {
	public static void main(String[] args) {
		try {

			/*
			 * Polymorphism
			 */
			Machine mv = new ThreeWheeler();
			mv.run();

			Machine mp = new WaterPump();
			mp.nonRunable();

		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

Thanks

[Ogeh Ikem]

Kalyan Naveenan wrote:can you explain me why and when do i use the concept of interface implementation.

Interface and abstract class are abstract reference types. An abstract reference type is a type that may contain a contract that specifies how to derive a concrete reference type. This contract is in the form of one or more abstract methods. In the example provided by Vijay Tidake,

abstract class Vehicle {
	public boolean start() {
		if (haskey()) {
			return true;
		}
		return false;
	}

	private boolean haskey() {
		// Logic to get key. Suppose you have a key
		return true;
	}

	public abstract void run();
}

Vehicle is an abstract reference type which contains a contract that specifies how to derive a concrete reference type. The contract is public abstract void run(); This contract says "in order to derive a concrete reference type from Vehicle, the concrete reference type must implement a method called 'run'. This method must be public and must not return a value". The ThreeWheeler and FourWheeler classes are concrete reference types that are derived from Vehicle.

In the example below, Vehicle is an interface

interface Vehicle {
	public abstract boolean haskey();
	public abstract void run();
}

class ThreeWheeler implements Vehicle {
	private int numberOfWheels;

	@Override
	public boolean haskey() {
		if (numberOfWheels == 3)
			return true;
		else
			return false;
	}

	@Override
	public void run() {
		System.out.println("Running on 3 wheels");
	}

}

class FourWheeler implements Vehicle {
	private int numberOfWheels;

	public boolean haskey() {
		if (numberOfWheels == 4)
			return true;
		else
			return false;
	}
	@Override
	public void run() {
		System.out.println("Running on 4 wheels");
	}
}

[Rohit Mehta]

Kalyan Naveenan wrote:... So can you explain me why and when do i use the concept of interface implementation.

In Java you can extend only one class at a time - while can implement as many interfaces as you want.

To handle scenarios where you need to define a class which display some other behavior too (other than extended class'), we require multiple inheritance - which is possible through implementing multiple interfaces.

Also when you need to define the contract ONLY, you will require interfaces - as abstract class may/may not contain a concrete method - but an interface can't contain any concrete method - it can contain method declarations only.

Hope this is helpful.

[neha singh tomar]

I just have a doubt here. Please help me with this.

If a method is declared as abstract in super class and we are defining it in sub class. Will it be called as "overriding'? I got this doubt since in the examples given in this thread, its mentioned as overriding.
Thanks in advance.

[Campbell Ritchie]

We have an FAQ which might be helpful.

[neha singh tomar]

Campbell Ritchie wrote:We have an FAQ which might be helpful.

I am still not clear. I am very new to Java and preparing for certification. It would be very helpful for me if you could explain. As per my understanding, it should be termed as implementation. Overriding is, when we have one method already defined in super class and subclass redefines it. Please correct if I am wrong. Thanks in advance.

[Campbell Ritchie]

You would have to read the Java™ Language Specification for the official definition of "overriding".

[Ogeh Ikem]

neha singh tomar wrote:As per my understanding, it should be termed as implementation

A class can override an inherited abstract method by providing another abstract method declaration. This class must be declared abstract. For example

interface Vehicle {
	public void run() throws Exception;
}

abstract class ThreeWheeler implements Vehicle {
	abstract public void run() throws IOException;
}

A class can override an inherited abstract method by providing a concrete implementation. For example

interface Vehicle {
	public void run() throws Exception;
}

class ThreeWheeler implements Vehicle {
	public void run() throws Exception {
		System.out.println("Running on 4 wheels");
	}
}

[Campbell Ritchie]

I earlier wrote:You would have to read the Java™ Language Specification for the official definition of "overriding".

It is not easy to read.

[neha singh tomar]

Thanks Ogeh. The example was really helpful.

Thanks Campbell. The link is really difficult to understand. Perhaps, after reading it 2-3 times I will be able to understand it clearly.

So, I concluded that it can actually be termed as overriding.

[Campbell Ritchie]

I did say it isn't easy to understand.

I agree with you. Yes, filling in the body of an abstract method is called overriding.

You should always use the @Override annotation on any methods you think you are overriding, but beware: @Override also works (I think this behaviour is different in Java5 and Java6) when you are implementing an interface method, which isn't overriding according to that definition.

[Ogeh Ikem]

There was a bug which disallowed usage of @Override on a method which overrides an inherited interface method. The bug was fixed here.

[Campbell Ritchie]

I didn't know about that bug. Thank you.