برنامه‌نویسی شیءگرا در Go

برنامه‌نویسی شیءگرا در Go

برنامه‌نویسی شیءگرا (OOP) یکی از رایج‌ترین الگوهای طراحی در دنیای برنامه‌نویسی است. با اینکه زبان Go به‌طور مستقیم از کلاس‌ها پشتیبانی نمی‌کنه، اما می‌تونیم مفاهیم شیءگرا رو از طریق ساختارها (structs) و اینترفیس‌ها به‌خوبی پیاده‌سازی کنیم. در این بخش از آموزش Go، با تفاوت‌های Go در برنامه‌نویسی شیءگرا، نحوه استفاده از اینترفیس‌ها، Polymorphism و ترکیب آشنا می‌شویم.

 تفاوت با OOP کلاسیک

در زبان‌های برنامه‌نویسی شیءگرا کلاسیک مثل Java یا C++, از کلاس‌ها برای تعریف داده‌ها و متدهای مرتبط استفاده میشه. در مقابل، Go از ساختارها (structs) به‌عنوان جایگزین کلاس‌ها استفاده می‌کنه و شیءگرایی رو با استفاده از ترکیب و اینترفیس‌ها پیاده‌سازی می‌کنه.

• 
  

  در Go: هیچ مفهوم «کلاس» وجود ندارد، بلکه از ساختارها (structs) برای ذخیره داده‌ها و از متدها برای اضافه کردن رفتار به این ساختارها استفاده می‌شود.

  
  


• 
  

  در زبان‌های کلاسیک: کلاس‌ها شامل داده‌ها و متدهای مرتبط هستند و امکان وراثت و polymorphism (چندشکلی) از طریق کلاس‌ها صورت می‌گیرد.

  
  

 تعریف اینترفیس‌ها (Interfaces)

اینترفیس‌ها در Go ابزاری برای تعریف رفتارها هستند. به‌عبارت ساده، اینترفیس‌ها مجموعه‌ای از توابع هستند که یک نوع داده باید پیاده‌سازی کنه. تفاوت عمده‌ی Go با زبان‌های شیءگرا در این هست که نیازی به وراثت از یک اینترفیس نیست. کافی است یک نوع داده تمام توابع مشخص‌شده در اینترفیس رو پیاده‌سازی کنه.

تعریف یک اینترفیس:

type Speaker interface {
    Speak() string
}

در اینجا، اینترفیس Speaker توابعی که هر نوع داده‌ای که بخواد رفتار «صحبت کردن» داشته باشه باید پیاده‌سازی کنه، مشخص می‌کنه.

 ایمپلیمنت کردن اینترفیس

برای اینکه یک نوع داده (مثل ساختار) از یک اینترفیس پیروی کنه، نیازی به کلمه‌کلیدی خاصی نیست. کافی است فقط توابع اینترفیس رو پیاده‌سازی کنید.

پیاده‌سازی اینترفیس:

type Person struct {
    Name string
}


func (p Person) Speak() string {
    return "سلام، من " + p.Name + " هستم!"
}
func main() {
    var speaker Speaker = Person{Name: "Ali"}
    fmt.Println(speaker.Speak())  // خروجی: سلام، من Ali هستم!
}

در اینجا، نوع Person با پیاده‌سازی تابع Speak()، اینترفیس Speaker رو پیاده‌سازی کرده.

 Polymorphism (چندشکلی)

در زبان‌های شیءگرا، Polymorphism به این معناست که می‌تونید از یک اینترفیس یا متد برای کار با انواع مختلف داده‌ها استفاده کنید. Go این ویژگی رو با استفاده از اینترفیس‌ها پیاده‌سازی می‌کنه. به‌این‌صورت که می‌تونید انواع مختلف داده‌ها رو به یک اینترفیس نسبت بدید و تابعی که برای این اینترفیس تعریف شده اجرا میشه.

مثال Polymorphism در Go:

type Animal interface {
    Speak() string
}
type Dog struct{}
type Cat struct{}
func (d Dog) Speak() string {
    return "Woof"
}
func (c Cat) Speak() string {
    return "Meow"
}
func main() {
    var a Animal
    a = Dog{}
    fmt.Println(a.Speak())  // خروجی: Woof
    a = Cat{}
    fmt.Println(a.Speak())  // خروجی: Meow
}

در اینجا، از یک اینترفیس Animal برای انواع مختلف حیوانات (Dog و Cat) استفاده کردیم و هرکدام رفتار خاص خودشون رو با پیاده‌سازی Speak() ارائه دادن.

ترکیب (Composition)

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

ترکیب ساختارها:

type Address struct {
    Street string
    City   string
}
type Person struct {
    Name    string
    Address Address  // ترکیب ساختارها
}
func main() {
    p := Person{
        Name: "Ali",
        Address: Address{
            Street: "Elm St.",
            City:   "Tehran",
        },
    }
    fmt.Println(p.Name)        // خروجی: Ali
    fmt.Println(p.Address.City)  // خروجی: Tehran
}

در اینجا، ساختار Person از ساختار Address استفاده می‌کنه و به‌این‌ترتیب می‌تونه به ویژگی‌های Street و City دسترسی پیدا کنه.

 متدها (Methods)

در Go، می‌تونید به ساختارها متدهایی اضافه کنید تا رفتار خاصی رو به اون‌ها بدید. متدهای Go مشابه متدهای کلاس‌ها در زبان‌های شیءگرا هستند، ولی به جای استفاده از کلاس‌ها، روی ساختارها اعمال می‌شن.

تعریف متد:

type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}
func main() {
    circle := Circle{Radius: 5}
    fmt.Println("Area:", circle.Area())  // خروجی: Area: 78.5
}

در اینجا، متد Area() به ساختار Circle اضافه شده تا مساحت دایره رو محاسبه کنه.

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