# 23) Abstract Keyword

## **What is abstract Keyword?**

**abstract** is a non-access modifier in java applicable for classes and methods but **not for variables**. It is used to achieve abstraction which is one of the pillars of Object Oriented Programming (OOP). 

Following are different contexts where abstract can be used in Java.

1. Abstract classes
2. Abstract methods

**Abstract classes**

We know that every java program must start with a concept of class that is without classes concept there is no java program perfect.

In java programming we have two types of classes they are

1\.     Concrete class

2\.     Abstract class

**Concrete class**

A concrete class is one which is containing fully defined methods or implemented method.

**Example**

```java
package com.gs.ilp.corejava.abstractKeyword;

public class Helloworld {
	void display() {
		System.out.println("Good Morning........");
	}
}
```

**Abstract class**

A class that is declared with **abstract** keyword is known as abstract class. 

OR, the class which is having partial implementation (i.e. not all methods present in the class have method definition).

In short, an abstract class is one which is containing some defined method and some undefined method. 

In java programming undefined methods are known as un-Implemented or abstract method.

**Syntax**

**abstract** **class** className

{

......

}

**Example**

**abstract** **class** Vehicle

{

......

}

**Abstract method**

An abstract method is one which contains only declaration or prototype but it never contains body or definition. In order to make any undefined method as abstract whose declaration is must be predefined by **abstract** keyword.

If any class has any abstract method then that class becomes an abstract class.

**Example**

**class** Vehicle 

{

**abstract** **void** Bike(); 

}

Class Vehicle is become an abstract class because it have abstract Bike() method.

**Key Points:**

An instance of an abstract class cannot be created; we can have references of abstract class type though.

```java
package com.gs.ilp.corejava.abstractKeyword;

abstract class Base {
	abstract void fun();
}

class Derived extends Base {
	void fun() {
		System.out.println("Derived fun() called");
	}
}

public class Main {
	public static void main(String args[]) {
		// Uncommenting the following line will cause compiler error as the
		// line tries to create an instance of abstract class.
		// Base b = new Base();
		// We can have references of Base type.
		Base b = new Derived();
		b.fun();
	}
}
```

**Output:**

Derived fun() called

An abstract class can contain constructors in Java. And a constructor of abstract class is called when an instance of an inherited class is created.

```java
package com.gs.ilp.corejava.abstractKeyword;

//An abstract class with constructor
abstract class BaseCLass {
	BaseCLass() {
		System.out.println("Base Constructor Called");
	}

	abstract void fun();
}

class DerivedClass extends BaseCLass {
	DerivedClass() {
		System.out.println("Derived Constructor Called");
	}

	void fun() {
		System.out.println("Derived fun() called");
	}
}

public class MainClass {
	public static void main(String args[]) {
		DerivedClass d = new DerivedClass();
	}
}
```

**Output:**

Base Constructor Called

Derived Constructor Called

We can have an abstract class without any abstract method. This allows us to create classes that cannot be instantiated, but can only be inherited.

// An abstract class without any abstract method

```java
package com.gs.ilp.corejava.abstractKeyword;

abstract class BaseClass1 {
	void fun() {
		System.out.println("Base fun() called");
	}
}

class DerivedClass1 extends BaseClass1 {
}

public class MainClass1 {
	public static void main(String args[]) {
		DerivedClass1 d = new DerivedClass1();
		d.fun();
	}
}
```

**Output:**

Base fun() called

Abstract classes can also have final methods (methods that cannot be overridden).

// An abstract class with a final method

```java
package com.gs.ilp.corejava.abstractKeyword;

abstract class BaseB {
	final void fun() {
		System.out.println("Derived fun() called");
	}
}

class DerivedD extends BaseB {
}

public class MainM {
	public static void main(String args[]) {
		BaseB b = new DerivedD();
		b.fun();
	}
}
```

**Output:**

Derived fun() called

**Why can’t we create the object of an abstract class?**

Because these classes are incomplete, they have abstract methods that have no body so if java allows you to create object of this class then if someone calls the abstract method using that object then what would happen? There would be no actual implementation of the method to invoke.\
 Also because an object is concrete. An abstract class is like a template, so you have to extend it and build on it before you can use it.

### Summary :

![](/files/-LTvCF3-5yrQNXyNIZ_L)

![](/files/-LTvCIk_nDW9WfHXwvNX)

![](/files/-LTvCPPWVzq11aExrg6c)

![](/files/-LTvCU3gs3ffgvdC8iMG)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://gyansetu-java.gitbook.io/core-java/abstract.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.