4.02 পলিমরফিজমের প্রকার

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
}
class Main {
  public static void main(String[] args) {
    Calculator myCalculator  = new Calculator ();  // Create a Calculator object
    System.out.println(“Sum of the two integer numbers = “+ myCalculator.add(3,5));
    System.out.println(“Sum of the two double numbers = “+ myCalculator.add(5.5,6.5));
    System.out.println(“Sum of the three integer numbers = “+ myCalculator.add(5,4,2));
  }
}

Sum of the two integer numbers = 8
Sum of the two double numbers = 12.0
Sum of the three integer numbers = 11

using System;
class Calculator
{
    public int Add(int a, int b) {
        return a + b;
    }
    public double Add(double a, double b) {
        return a + b;
    }
    public int Add(int a, int b, int c) {
        return a + b + c;
    }
}
class Program
{
    static void Main(string[] args)
    {
        Calculator myCalculator = new Calculator();  // Create a Calculator object
        Console.WriteLine(“Sum of the two integer numbers = ” + myCalculator.Add(3, 5));
        Console.WriteLine(“Sum of the two double numbers = ” + myCalculator.Add(5.5, 6.5));
        Console.WriteLine(“Sum of the three integer numbers = ” + myCalculator.Add(5, 4, 2));
    }
}

Sum of the two integer numbers = 8
Sum of the two double numbers = 12.0
Sum of the three integer numbers = 11

using System;
public class ComplexNumber
{
    public double Real { get; }
    public double Imaginary { get; }
    public ComplexNumber(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }
    // Overload the + operator to add two complex numbers
    public static ComplexNumber operator +(ComplexNumber c1, ComplexNumber c2)
    {
        double realSum = c1.Real + c2.Real;
        double imaginarySum = c1.Imaginary + c2.Imaginary;
        return new ComplexNumber(realSum, imaginarySum);
    }
    // Overload the == operator to compare two complex numbers for equality
    public static bool operator ==(ComplexNumber c1, ComplexNumber c2)
    {
        return c1.Real == c2.Real && c1.Imaginary == c2.Imaginary;
    }
    // Overload the != operator to compare two complex numbers for inequality
    public static bool operator !=(ComplexNumber c1, ComplexNumber c2)
    {
        return !(c1 == c2);
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        ComplexNumber c1 = new ComplexNumber(1.0, 2.0);
        ComplexNumber c2 = new ComplexNumber(3.0, 4.0);
        // Overloaded + operator
        ComplexNumber sum = c1 + c2;
        Console.WriteLine($”c1 + c2 = {sum}”);
        // Overloaded == and != operators
        Console.WriteLine($”c1 == c2: {c1 == c2}”);
        Console.WriteLine($”c1 != c2: {c1 != c2}”);
    }
}

c1 + c2 = 4 + 6i
c1 == c2: False
c1 != c2: True

class Animal {
    void makeSound() {
        System.out.println(“Animal makes a sound”);
    }
}
class Dog extends Animal {
    void makeSound() {
        System.out.println(“Dog barks”);
    }
}
class Cat extends Animal {
    void makeSound() {
        System.out.println(“Cat meows”);
    }
}
class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // Calls the makeSound() method of Dog
        Animal myCat = new Cat();
        myCat.makeSound(); // Calls the makeSound() method of Cat
    }
}

Dog barks
Cat meows

using System;
class Animal
{
    public virtual void MakeSound() {
        Console.WriteLine(“Animal makes a sound”);
    }
}
class Dog : Animal
{
    public override void MakeSound() {
        Console.WriteLine(“Dog barks”);
    }
}
class Cat : Animal
{
    public override void MakeSound() {
        Console.WriteLine(“Cat meows”);
    }
}
class Program
{
    public static void Main(string[] args) {
        Animal myDog = new Dog();
        myDog.MakeSound(); // Calls the MakeSound() method of Dog
        Animal myCat = new Cat();
        myCat.MakeSound(); // Calls the MakeSound() method of Cat
    }
}

Dog barks
Cat meows

using System;
class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine(“Animal makes a sound”);
    }
}
class Cat: Animal
{
    // Without the ‘override’ keyword, this is not an override.
    public void MakeSound()
    {
        Console.WriteLine(“Cat meows”);
    }
}
class Program
{
    static void Main(string[] args)
    {
        Animal myCat = new Cat();
        myCat.MakeSound(); // Output: “Animal makes a sound.”
        Cat myRealCat = new Cat();
        myRealCat.MakeSound(); // Output: “Cat meows.”
    }
}

Animal makes a sound
Cat meows

class Animal {
  // method in the superclass
  void makeSound() {
    System.out.println(“Animal makes a sound”);
  }
}
// Cat inherits Animal
class Cat extends Animal {
  // overriding the eat() method
  void makeSound() {
    // call method of superclass
    super.makeSound();
    System.out.println(“Cat meows”);
  }
}
class Main {
  public static void main(String[] args) {
    Cat myCat = new Cat();
    // call the makeSound() method
    myCat.makeSound();
  }
}

Animal makes a sound
Cat meows

using System;
class Animal
{
    public virtual void MakeSound() {
        Console.WriteLine(“Animal makes a sound”);
    }
}
class Cat : Animal
{
    // overriding method from Animal
    public override void MakeSound() {
         // call method from Animal class
        base.MakeSound();
        Console.WriteLine(“Cat meows”);
    }
}
class Program
{
    public static void Main(string[] args) {
        Cat myCat = new Cat();
        myCat.MakeSound();
    }
}

Animal makes a sound
Cat meows

class Shape {
    // Calculate area for a circle
    double area(double radius) {
        return 3.14 * radius * radius;
    }
    // Calculate area for a rectangle
    double area(double length, double width) {
        return length * width;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape shapeCalculator = new Shape();
        // Calculate the area of a circle
        double circleArea = shapeCalculator.area(5.0);
        System.out.println(“Area of the circle: ” + circleArea);
        // Calculate the area of a rectangle
        double rectangleArea = shapeCalculator.area(4.0, 6.0);
        System.out.println(“Area of the rectangle: ” + rectangleArea);
    }
}

Area of the circle: 78.5
Area of the rectangle: 24.0

using System;
class Shape
{
    // Calculate area for a circle
    public double Area(double radius)
    {
        return 3.14 * radius * radius;
    }
    // Calculate area for a rectangle
    public double Area(double length, double width)
    {
        return length * width;
    }
}
class MainClass
{
    public static void Main(string[] args)
    {
        Shape shapeCalculator = new Shape();
        // Calculate the area of a circle
        double circleArea = shapeCalculator.Area(5.0);
        Console.WriteLine(“Area of the circle: ” + circleArea);
        // Calculate the area of a rectangle
        double rectangleArea = shapeCalculator.Area(4.0, 6.0);
        Console.WriteLine(“Area of the rectangle: ” + rectangleArea);
    }
}

abstract class Shape {
    abstract double calculateArea();
}
class Rectangle extends Shape {
    private double width;
    private double height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    double calculateArea() {
        return width * height;
    }
}
class Circle extends Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Rectangle(5, 4);
        Shape shape2 = new Circle(3);
        System.out.println(“Area of Rectangle: ” + shape1.calculateArea()); // Output: Area of Rectangle: 20.0
        System.out.println(“Area of Circle: ” + shape2.calculateArea());    // Output: Area of Circle: 28.274333882308138
    }
}

Area of Rectangle: 20.0
Area of Circle: 28.274333882308138

using System;
abstract class Shape
{
    public abstract double CalculateArea();
}
class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    public override double CalculateArea()
    {
        return Width * Height;
    }
}
class Circle : Shape
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}
class Program
{
    static void Main()
    {
        Shape shape1 = new Rectangle(5, 4);
        Shape shape2 = new Circle(3);
        Console.WriteLine(“Area of Rectangle: ” + shape1.CalculateArea()); // Output: Area of Rectangle: 20
        Console.WriteLine(“Area of Circle: ” + shape2.CalculateArea());    // Output: Area of Circle: 28.274333882308138
    }
}

Area of Rectangle: 20.0
Area of Circle: 28.274333882308138

interface Shape {
    double calculateArea();
}
class Rectangle implements Shape {
    private double width;
    private double height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return width * height;
    }
}
class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Rectangle(5, 4);
        Shape shape2 = new Circle(3);
        System.out.println(“Area of Rectangle: ” + shape1.calculateArea()); // Output: Area of Rectangle: 20.0
        System.out.println(“Area of Circle: ” + shape2.calculateArea());    // Output: Area of Circle: 28.274333882308138
    }
}

Area of Rectangle: 20.0
Area of Circle: 28.274333882308138

using System;
interface IShape
{
    double CalculateArea();
}
class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    public double CalculateArea()
    {
        return Width * Height;
    }
}
class Circle : IShape
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}
class Program
{
    static void Main()
    {
        IShape shape1 = new Rectangle(5, 4);
        IShape shape2 = new Circle(3);
        Console.WriteLine(“Area of Rectangle: ” + shape1.CalculateArea()); // Output: Area of Rectangle: 20
        Console.WriteLine(“Area of Circle: ” + shape2.CalculateArea());    // Output: Area of Circle: 28.274333882308138
    }
}

Area of Rectangle: 20
Area of Circle: 28.2743338823081