M

MLOG

فارسی

چندریختی، یک مفهوم بنیادی در برنامه‌نویسی شیءگرا را کاوش کنید. بیاموزید که چگونه با مثال‌های کاربردی برای توسعه‌دهندگان، انعطاف‌پذیری، قابلیت استفاده مجدد و نگهداری کد را افزایش می‌دهد.

درک چندریختی: راهنمای جامع برای توسعه‌دهندگان جهانی

چندریختی (Polymorphism)، که از واژه‌های یونانی "poly" (به معنای "چند") و "morph" (به معنای "ریخت" یا "شکل") گرفته شده است، یکی از سنگ‌بناهای برنامه‌نویسی شیءگرا (OOP) است. این مفهوم به اشیاء کلاس‌های مختلف اجازه می‌دهد تا به یک فراخوانی متد یکسان، به روش‌های خاص خود پاسخ دهند. این مفهوم بنیادی، انعطاف‌پذیری، قابلیت استفاده مجدد و نگهداری کد را افزایش می‌دهد و آن را به ابزاری ضروری برای توسعه‌دهندگان در سراسر جهان تبدیل می‌کند. این راهنما یک نمای کلی از چندریختی، انواع آن، مزایا و کاربردهای عملی آن را با مثال‌هایی ارائه می‌دهد که در زبان‌های برنامه‌نویسی و محیط‌های توسعه مختلف قابل درک هستند.

چندریختی چیست؟

در هسته خود، چندریختی یک رابط واحد را قادر می‌سازد تا چندین نوع را نمایندگی کند. این بدان معناست که شما می‌توانید کدی بنویسید که بر روی اشیاء کلاس‌های مختلف طوری عمل کند که گویی آن‌ها اشیاء یک نوع مشترک هستند. رفتار واقعی اجرا شده به شیء خاص در زمان اجرا بستگی دارد. این رفتار پویا چیزی است که چندریختی را بسیار قدرتمند می‌کند.

یک قیاس ساده را در نظر بگیرید: تصور کنید یک کنترل از راه دور با دکمه "play" دارید. این دکمه روی دستگاه‌های مختلفی کار می‌کند – یک پخش‌کننده DVD، یک دستگاه استریمینگ، یک پخش‌کننده CD. هر دستگاه به دکمه "play" به روش خود پاسخ می‌دهد، اما شما فقط باید بدانید که فشار دادن این دکمه پخش را شروع می‌کند. دکمه "play" یک رابط چندریختی است و هر دستگاه در پاسخ به همان عمل، رفتار متفاوتی (شکل متفاوتی) از خود نشان می‌دهد.

انواع چندریختی

چندریختی به دو شکل اصلی ظاهر می‌شود:

۱. چندریختی زمان کامپایل (چندریختی ایستا یا سربارگذاری)

چندریختی زمان کامپایل، که به عنوان چندریختی ایستا یا سربارگذاری (Overloading) نیز شناخته می‌شود، در مرحله کامپایل حل می‌شود. این شامل داشتن چندین متد با نام یکسان اما امضاهای متفاوت (تعداد، نوع یا ترتیب پارامترهای متفاوت) در یک کلاس است. کامپایلر بر اساس آرگومان‌های ارائه شده در هنگام فراخوانی تابع، تعیین می‌کند که کدام متد را فراخوانی کند.

مثال (جاوا):


class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }

    double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));       // خروجی: 5
        System.out.println(calc.add(2, 3, 4));    // خروجی: 9
        System.out.println(calc.add(2.5, 3.5));   // خروجی: 6.0
    }
}

در این مثال، کلاس Calculator سه متد به نام add دارد که هر کدام پارامترهای متفاوتی می‌گیرند. کامپایلر بر اساس تعداد و نوع آرگومان‌های ارسال شده، متد add مناسب را انتخاب می‌کند.

مزایای چندریختی زمان کامپایل:

۲. چندریختی زمان اجرا (چندریختی پویا یا بازنویسی)

چندریختی زمان اجرا، که به عنوان چندریختی پویا یا بازنویسی (Overriding) نیز شناخته می‌شود، در مرحله اجرا حل می‌شود. این شامل تعریف یک متد در یک کلاس والد (superclass) و سپس ارائه پیاده‌سازی متفاوتی از همان متد در یک یا چند کلاس فرزند (subclass) است. متد خاصی که باید فراخوانی شود، در زمان اجرا بر اساس نوع واقعی شیء تعیین می‌شود. این معمولاً از طریق وراثت و توابع مجازی (در زبان‌هایی مانند C++) یا اینترفیس‌ها (در زبان‌هایی مانند Java و C#) به دست می‌آید.

مثال (پایتون):


class Animal:
    def speak(self):
        print("صدای حیوان عمومی")

class Dog(Animal):
    def speak(self):
        print("هاپ!")

class Cat(Animal):
    def speak(self):
        print("میو!")

def animal_sound(animal):
    animal.speak()

animal = Animal()
dog = Dog()
cat = Cat()

animal_sound(animal)  # خروجی: صدای حیوان عمومی
animal_sound(dog)     # خروجی: هاپ!
animal_sound(cat)     # خروجی: میو!

در این مثال، کلاس Animal متد speak را تعریف می‌کند. کلاس‌های Dog و Cat از Animal ارث‌بری می‌کنند و متد speak را با پیاده‌سازی‌های خاص خود بازنویسی می‌کنند. تابع animal_sound چندریختی را نشان می‌دهد: این تابع می‌تواند اشیاء هر کلاسی که از Animal مشتق شده است را بپذیرد و متد speak را فراخوانی کند، که منجر به رفتارهای متفاوت بر اساس نوع شیء می‌شود.

مثال (C++):


#include 

class Shape {
public:
    virtual void draw() {
        std::cout << "در حال ترسیم یک شکل" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "در حال ترسیم یک دایره" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "در حال ترسیم یک مربع" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Shape();
    Shape* shape2 = new Circle();
    Shape* shape3 = new Square();

    shape1->draw(); // خروجی: در حال ترسیم یک شکل
    shape2->draw(); // خروجی: در حال ترسیم یک دایره
    shape3->draw(); // خروجی: در حال ترسیم یک مربع

    delete shape1;
    delete shape2;
    delete shape3;

    return 0;
}

در C++، کلمه کلیدی virtual برای فعال کردن چندریختی زمان اجرا حیاتی است. بدون آن، متد کلاس پایه همیشه فراخوانی می‌شد، صرف نظر از نوع واقعی شیء. کلمه کلیدی override (که در C++11 معرفی شد) برای نشان دادن صریح این موضوع استفاده می‌شود که یک متد کلاس مشتق شده قصد دارد یک تابع مجازی از کلاس پایه را بازنویسی کند.

مزایای چندریختی زمان اجرا:

چندریختی از طریق اینترفیس‌ها

اینترفیس‌ها مکانیزم قدرتمند دیگری برای دستیابی به چندریختی فراهم می‌کنند. یک اینترفیس قراردادی را تعریف می‌کند که کلاس‌ها می‌توانند آن را پیاده‌سازی کنند. کلاس‌هایی که یک اینترفیس را پیاده‌سازی می‌کنند، تضمین می‌کنند که پیاده‌سازی‌هایی برای متدهای تعریف شده در آن اینترفیس ارائه دهند. این به شما امکان می‌دهد تا با اشیاء کلاس‌های مختلف طوری رفتار کنید که گویی اشیاء از نوع آن اینترفیس هستند.

مثال (C#):


using System;

interface ISpeakable {
    void Speak();
}

class Dog : ISpeakable {
    public void Speak() {
        Console.WriteLine("هاپ!");
    }
}

class Cat : ISpeakable {
    public void Speak() {
        Console.WriteLine("میو!");
    }
}

class Example {
    public static void Main(string[] args) {
        ISpeakable[] animals = { new Dog(), new Cat() };
        foreach (ISpeakable animal in animals) {
            animal.Speak();
        }
    }
}

در این مثال، اینترفیس ISpeakable یک متد واحد به نام Speak را تعریف می‌کند. کلاس‌های Dog و Cat اینترفیس ISpeakable را پیاده‌سازی کرده و پیاده‌سازی‌های خود را برای متد Speak ارائه می‌دهند. آرایه animals می‌تواند اشیاء هر دو کلاس Dog و Cat را در خود جای دهد زیرا هر دو اینترفیس ISpeakable را پیاده‌سازی می‌کنند. این به شما امکان می‌دهد تا در آرایه پیمایش کرده و متد Speak را روی هر شیء فراخوانی کنید، که منجر به رفتارهای متفاوت بر اساس نوع شیء می‌شود.

مزایای استفاده از اینترفیس‌ها برای چندریختی:

چندریختی از طریق کلاس‌های انتزاعی

کلاس‌های انتزاعی (Abstract classes) کلاس‌هایی هستند که نمی‌توان مستقیماً از آن‌ها نمونه‌سازی کرد. آن‌ها می‌توانند هم شامل متدهای واقعی (متدهایی با پیاده‌سازی) و هم متدهای انتزاعی (متدهایی بدون پیاده‌سازی) باشند. زیرکلاس‌های یک کلاس انتزاعی باید پیاده‌سازی‌هایی برای تمام متدهای انتزاعی تعریف شده در کلاس انتزاعی ارائه دهند.

کلاس‌های انتزاعی راهی برای تعریف یک رابط مشترک برای گروهی از کلاس‌های مرتبط فراهم می‌کنند در حالی که همچنان به هر زیرکلاس اجازه می‌دهند پیاده‌سازی خاص خود را ارائه دهد. آن‌ها اغلب برای تعریف یک کلاس پایه استفاده می‌شوند که برخی رفتارهای پیش‌فرض را ارائه می‌دهد در حالی که زیرکلاس‌ها را مجبور به پیاده‌سازی برخی متدهای حیاتی می‌کند.

مثال (جاوا):


abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();

    public String getColor() {
        return color;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5.0);
        Shape rectangle = new Rectangle("Blue", 4.0, 6.0);

        System.out.println("مساحت دایره: " + circle.getArea());
        System.out.println("مساحت مستطیل: " + rectangle.getArea());
    }
}

در این مثال، Shape یک کلاس انتزاعی با یک متد انتزاعی getArea() است. کلاس‌های Circle و Rectangle از Shape ارث‌بری کرده و پیاده‌سازی‌های مشخصی برای getArea() ارائه می‌دهند. از کلاس Shape نمی‌توان نمونه‌سازی کرد، اما می‌توانیم نمونه‌هایی از زیرکلاس‌های آن ایجاد کرده و با آن‌ها به عنوان اشیاء Shape رفتار کنیم و از چندریختی بهره ببریم.

مزایای استفاده از کلاس‌های انتزاعی برای چندریختی:

نمونه‌های واقعی از چندریختی

چندریختی به طور گسترده در سناریوهای مختلف توسعه نرم‌افزار استفاده می‌شود. در اینجا چند نمونه واقعی آورده شده است:

مزایای چندریختی

استفاده از چندریختی در کد شما چندین مزیت قابل توجه دارد:

چالش‌های چندریختی

در حالی که چندریختی مزایای زیادی دارد، چالش‌هایی را نیز به همراه دارد:

بهترین شیوه‌ها برای استفاده از چندریختی

برای بهره‌برداری مؤثر از چندریختی و کاهش چالش‌های آن، این بهترین شیوه‌ها را در نظر بگیرید:

نتیجه‌گیری

چندریختی یک مفهوم قدرتمند و همه‌کاره است که برای برنامه‌نویسی شیءگرا ضروری است. با درک انواع مختلف چندریختی، مزایا و چالش‌های آن، می‌توانید به طور مؤثری از آن برای ایجاد کدی انعطاف‌پذیرتر، قابل استفاده مجدد و قابل نگهداری‌تر استفاده کنید. چه در حال توسعه برنامه‌های وب، اپلیکیشن‌های موبایل یا نرم‌افزارهای سازمانی باشید، چندریختی ابزاری ارزشمند است که می‌تواند به شما در ساخت نرم‌افزار بهتر کمک کند.

با اتخاذ بهترین شیوه‌ها و در نظر گرفتن چالش‌های بالقوه، توسعه‌دهندگان می‌توانند از پتانسیل کامل چندریختی برای ایجاد راه‌حل‌های نرم‌افزاری قوی‌تر، قابل توسعه‌تر و قابل نگهداری‌تر که پاسخگوی نیازهای روزافزون چشم‌انداز فناوری جهانی است، بهره‌مند شوند.

درک چندریختی: راهنمای جامع برای توسعه‌دهندگان جهانی | MLOG