Abstract Classes and

Interfaces in java
💡 Abstract Classes in Java
✅ Key Points:
1. An abstract class is one that can (but doesn’t have to) contain abstract
methods.
To create an abstract class, use the abstract keyword:

abstract class ClassName {

// class members
}

📝 Tip: An abstract class can also have variables, concrete

methods, and constructors.

2. An abstract method has only the prototype (no body). To define one:

abstract return-type method-name(parameter-list);

3. You cannot create an object of an abstract class, but you can create
reference variables.

4. A subclass of an abstract class must implement all abstract methods, or it

must itself be declared abstract.

5. Runtime polymorphism is achieved when a reference of an abstract class

refers to a subclass object. Method invocation is resolved using dynamic
method dispatch.

Abstract Classes and Interfaces in java 1

 We Activity – Identify and Fix Errors
❌ Faulty Code:
class A {
abstract void show();

void foo() {
[Link]("Inside foo of class A");
}

class B extends A {
void fun() {
}
}

class C extends A {
void show() {
[Link]("Inside show of class C");
}

void tez() {
[Link]("Inside tez of class C");
}

public static void main(String... args) {

A a = new A();
A temp;
temp = new C();
[Link]();
}
}

Abstract Classes and Interfaces in java 2

 ✅ Corrected Code:
abstract class A {
abstract void show();

void foo() {
[Link]("Inside foo of class A");
}
}

// Either implement 'show()' or declare B as abstract

abstract class B extends A {
void fun() {
[Link]("Inside foo of class B");
}
}

class C extends A {
@Override
void show() {
[Link]("Inside show of class C");
}

void tez() {
[Link]("Inside tez of class C");
}

public static void main(String... args) {

❌
// A a = new A(); // Cannot instantiate abstract class
A temp;
temp = new C();
[Link](); // ✔️ Dynamic method dispatch
}
}

Abstract Classes and Interfaces in java 3

 🧪 Abstract Class Example – Shape

[Link] (Abstract Superclass)

abstract class Shape {

private double dimOne;
private double dimTwo;

Shape(double dimOne, double dimTwo) {

[Link] = dimOne;
[Link] = dimTwo;
}

public double getDimOne()

return dimOne;
}

public void setDimOne(double dimOne) {

[Link] = dimOne;
}

public double getDimTwo() {

return dimTwo;
}

public void setDimTwo(double dimTwo) {

[Link] = dimTwo;
}

abstract double area();

abstract double perimeter();
}

Abstract Classes and Interfaces in java 4

 [Link] (Concrete Subclass)

public class Triangle extends Shape {

// dimOne = base, dimTwo = height
public Triangle(double dimOne, double dimTwo) {
super(dimOne, dimTwo);
}

@Override
double area() {
return 0.5 * getDimOne() * getDimTwo();
}

@Override
double perimeter() {
double hypotenuse = [Link]([Link](getDimOne(), 2) + [Link](g
etDimTwo(), 2));
double triPeri = [Link]((getDimOne() + getDimTwo() + hypotenuse)
* 100) / 100.0;
return triPeri
}
}

[Link] (Concrete Subclass)

public class Rhombus extends Shape {

// dimOne = diagonal-1, dimTwo = diagonal-2
public Rhombus(double dimOne, double dimTwo) {
super(dimOne, dimTwo);
}

Abstract Classes and Interfaces in java 5

 @Override
double area() {
return 0.5 * getDimOne() * getDimTwo();
}

@Override
double perimeter() {
double halfDiag1 = getDimOne() / 2;
double halfDiag2 = getDimTwo() / 2;
double side = [Link]([Link]([Link](halfDiag1, 2) + [Link]
(halfDiag2, 2)) * 100) / 100.0;
return 4 * si
}
}

[Link] (Driver Class)

public class AbstractTester {

public static void main(String[] args) {
Shape shape;

shape = new Triangle(7, 49);

[Link]("The area of triangle is " + [Link]());
[Link]("The perimeter of triangle is " + [Link]());
[Link]();

shape = new Rhombus(6, 8);

[Link]("The area of rhombus is " + [Link]());
[Link]("The perimeter of rhombus is " + [Link]());
}

Abstract Classes and Interfaces in java 6

 }

✅ Output:
The area of triangle is 171.5
The perimeter of triangle is 105.5

The area of rhombus is 24.0

The perimeter of rhombus is 20.0

🆚ClassDifference Between Abstract Class and Concrete

Feature Abstract Class Concrete Class

Method May have abstract (non-implemented) All methods fully

Implementation methods implemented

Instantiation ❌ Cannot be instantiated ✅ Can be instantiated

Use of final keyword ❌ Cannot be final ✅ Can be final

To provide a base for other classes to

Purpose To be used directly
extend

Subclass
✅ Must be subclassed to use ❌ No subclassing
Requirement required

🧠 Interfaces in Java
✅ Key Points:
Abstract Classes and Interfaces in java 7
 An interface defines a generic template which can be implemented by related
or unrelated classes.

All methods in an interface are abstract by default, so you don’t need to write
the abstract keyword.

All variables are public, static, and final — they must be assigned values.

🚫 No instance variables or constructors allowed in

interfaces.

To declare an interface:

[access-modifier] interface InterfaceName {

// constants and abstract methods
}

All methods are public even if not declared so. Therefore, while
implementing, you must use public (because Java doesn’t allow reducing
access during method overriding).

Use the implements keyword to implement one or more interfaces:

[access-modifier] class ClassName [extends SuperClass] implements Inte

rface1, Interface2 {
// class body
}

If the class doesn’t implement all methods, it must be declared abstract .

You can create reference variables of interfaces, but cannot instantiate an

interface.

Abstract Classes and Interfaces in java 8

 Dynamic Method Dispatch is used when calling overridden methods using
interface references.

Interfaces represent "is-a" relationship and support total abstraction.

❌ We Activity — Identify and Fix Errors

🔻 Problematic Code:
interface A {
float a = 5.7f;
void show();
}
class B implements A {
void get() {
[Link]("inside get");
a = 5.8f;
}
}

class C implements A {
void show() {
[Link]("inside show");
}

void foo() {
[Link]("inside foo");
}
}

class Demo {
public static void main(String args[]) {
A a = new A();
A a1 = new C();
[Link]();
[Link]();

Abstract Classes and Interfaces in java 9

 C c1 = new C();
[Link]();
}
}

✅ Corrected Code:
interface A {
float a = 5.7f;
void show();
}

// Either implement 'show()' or make class abstract

abstract class B implements A {
void get() {
[Link]("inside get");
// a = 5.8f; ❌
Error: 'a' is final, cannot be reassigned
}
}

publi class C implements A {

// Must use public when implementing interface methods
public void show() {
[Link]("inside show");
}

void foo() {
[Link]("inside foo");
}
}

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

Abstract Classes and Interfaces in java 10

 // A a = new A(); ❌ Cannot create object of interface
A a1 = new C();
[Link]();
// [Link](); ❌ Cannot call class-specific methods using interface referen
ce

C c1 = new C();
[Link](); // OK ✅
}
}

✅ Interface Example – Mensuration

[Link] (Interface)

public interface Mensuration {

double PI = 3.14;

public double getVolume();

public double getSurfaceArea();
}

[Link] (Implementation Class)

public class Sphere implements Mensuration {

private double radius;

public Sphere(double radius) {

[Link] = radius;
}

Abstract Classes and Interfaces in java 11

 @Override
public double getVolume() {
double volume = 4.0 / 3.0 * PI * [Link](radius, 3);
return [Link](volume * 100) / 100.0;
}

@Override
public double getSurfaceArea() {
double surfaceArea = 4 * PI * [Link](radius, 2);
return [Link](surfaceArea * 100) / 100.0;
}
}

[Link] (Implementation Class)

public class Cone implements Mensuration {

private double radius;
private double height;
private double slantHeight;

public Cone(double radius, double height) {

[Link] = radius;
[Link] = height;
[Link] = [Link]([Link](radius, 2) + [Link](height, 2));
}

@Override
public double getVolume() {
double volume = 1.0 / 3.0 * PI * [Link](radius, 2) * height;
return [Link](volume * 100) / 100.0;
}

@Override
public double getSurfaceArea() {

Abstract Classes and Interfaces in java 12

 double surfaceArea = PI * radius * (radius + slantHeight);
return [Link](surfaceArea * 100) / 100.0;
}
}

[Link] (Driver Class)

public class MensurationDemo {

public static void main(String[] args) {
Mensuration m = null;

m = new Sphere(7.0);
[Link]("The surface area of sphere is " + [Link]
());
[Link]("The volume of sphere is " + [Link]());

m = new Cone(5.0, 12.0);

[Link]("The surface area of cone is " + [Link]());
[Link]("The volume of cone is " + [Link]());
}
}

🖨️ Output:
The surface area of sphere is 615.44
The volume of sphere is 1436.03
The surface area of cone is 282.6
The volume of cone is 314.0

Abstract Classes and Interfaces in java 13

 Difference Between Abstract Class and Interface in
Java
Aspect Abstract Class Interface

Can have instance variables Cannot have instance variables or

Variables
and constructors constructors

Does not support multiple

Inheritance Supports multiple inheritance
inheritance

All methods (static and non- Static methods are not inherited by
Method
static) are inherited by implementing classes; they must be
Inheritance
subclasses accessed using the interface name

You can use any access

Access
modifier ( private , protected , All methods are public by default
Modifiers
public )

Used for creating a common

Used to define a common contract for
Purpose base implementation for
both related and unrelated classes
derived classes

Typically used for related Can be used for related or unrelated

Coupling &
classes → leads to high classes → leads to high cohesion,
Cohesion
cohesion, tight coupling loose coupling

Abstract Classes and Interfaces in java 14