Dinesh on Java

abstract class Shape{
    abstract void draw();
}

class Rectangle extends Shape{
   void draw(){
     System.out.println("Drawing Rectangle");
   }
}

class Traingle extends Shape{
   void draw(){
     System.out.println("Drawing Traingle");
   }
}

class AbstractDemo{
   public static void main(String args[]){  
       Shape s1 = new Rectangle();
       s1.draw();
       s1 = new Traingle();
       s1.draw();
    }
}

public class Car {
  
    int price;
    String name;
    String color;

    int engineCapacity;
    int engineHorsePower;
    
    String wheelName;
    int wheelPrice;
    
    void move(){
    //move forward  
    }

    void rotate(){
      //Wheels method
    }
    
    void internalCombustion(){
      //Engine Method
    }
    
}

public class Car {
  
    Engine engine = new Engine();
    Wheel wheel = new Wheel();
    
    int price;
    String name;
    String color;
     
    
    void move(){
    //move forward  
    }
  }

public class Engine {
  int engineCapacity;
  int engineHorsePower;
  
  
  void internalCombustion(){
    //Engine Method
  }
  
}

public class Wheel {
  String wheelName;
  int wheelPrice;
  
  void rotate(){
    //Wheels method
  }
  
}

Abstract Method :
Abstract methods are those which need to be implemented in subclass / child class. Abstract methods are only defined in superclass / parent class but with no body.

Syntax of Abstract Method:

abstract class clsName
{
// Variable declaration

// Constructor

// Method
abstract rtype mthName(params);
}

clsName is a valid identifier in java. It is a class name.
abstract is a keyword to define that method an abstract method.
rtype is return type of a method.
mthName is a method name and valid java identifier.

Example of an Abstract Method:

abstract class Shape
{
public static float pi = 3.142;
protected float height;
protected float width;

abstract float area();
}

class Square extends Shape
{
Square(float h, float w)
{
height = h;
width = w;
}

float area()
{
return height * width;
}
}

class Rectangle extends Shape
{
Rectangle(float h, float w)
{
height = h;
width = w;
}

float area()
{
return height * width;
}
}

class Circle extends Shape
{
float radius;

Circle(float r)
{
radius = r;
}

float area()
{
return Shape.pi * radius *radius;
}
}

class AbstractMethodDemo
{
public static void main(String args[])
{
Square sObj = new Square(5,5);
Rectangle rObj = new Rectangle(5,7);
Circle cObj = new Circle(2);

System.out.println("Area of square : " + sObj.area());
System.out.println("Area of rectangle : " + rObj.area());
System.out.println("Area of circle : " + cObj.area());
}
}

Declaring a method as abstract has two results:

• The class must also be declared abstract. If a class contains an abstract method, the class must be abstract as well.
• Any child class must either override the abstract method or declare itself abstract.

A child class that inherits an abstract method must override it. If they do not, they must be abstract,and any of their children must override it.
Eventually, a descendant class has to implement the abstract method; otherwise, you would have a hierarchy of abstract classes that cannot be instantiated.