Go
ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग

टिप्पणियों

structs

गो, यूज़र डिफ़ाइंड टाइप्स इन स्ट्रक्चर्स एंड टाइप एलिज़ेस का समर्थन करता है। संरचनाएं मिश्रित प्रकार हैं, डेटा के घटक टुकड़े जो संरचना प्रकार का गठन करते हैं उन्हें फ़ील्ड कहा जाता है । एक फ़ील्ड में एक प्रकार और एक नाम होता है, जिसे यूनिक्यू होना चाहिए।

package main

type User struct {
    ID uint64
    FullName string
    Email    string
}

func main() {
    user := User{
        1,
        "Zelalem Mekonen",
        "zola.mk.27@gmail.com",
    }

    fmt.Println(user) // {1 Zelalem Mekonen zola.mk.27@gmail.com}
}

यह निश्चित संरचनाओं के लिए एक कानूनी वाक्यविन्यास भी है

type User struct {
    ID uint64
    FullName, Email string
}

user := new(User)

user.ID = 1
user.FullName = "Zelalem Mekonen"
user.Email = "zola.mk.27@gmail.com"

एंबेडेड स्ट्रक्चर्स

क्योंकि एक संरचना भी एक डेटा प्रकार है, यह एक गुमनाम क्षेत्र के रूप में इस्तेमाल किया जा सकता है, बाहरी संरचना सीधे एम्बेडेड संरचना के क्षेत्रों तक पहुंच सकती है, भले ही संरचना एक अलग पैकेज से आई हो। यह व्यवहार किसी अन्य प्रकार या आपके प्रकार के सेट से आपके या सभी कार्यान्वयन को प्राप्त करने का एक तरीका प्रदान करता है।

package main

type Admin struct {
    Username, Password string
}

type User struct {
    ID uint64
    FullName, Email string
    Admin // embedded struct
}

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "zola.mk.27@gmail.com",
        admin,
    }

    fmt.Println(admin) // {zola supersecretpassword}

    fmt.Println(user) // {1 Zelalem Mekonen zola.mk.27@gmail.com {zola supersecretpassword}}

    fmt.Println(user.Username) // zola

    fmt.Println(user.Password) // supersecretpassword
}

तरीके

गो में एक विधि है

एक फ़ंक्शन जो एक निश्चित प्रकार के चर पर काम करता है, जिसे रिसीवर कहा जाता है

रिसीवर कुछ भी हो सकता है, न केवल structs बल्कि यहां तक कि एक function , उर्फ प्रकार जैसे कि int , string , bool में एक विधि हो सकती है, इस नियम का एक अपवाद यह है कि interfaces (बाद में चर्चा की गई) तरीके नहीं हो सकते हैं, क्योंकि एक इंटरफ़ेस एक सार परिभाषा है और एक विधि एक कार्यान्वयन है, यह एक संकलन त्रुटि उत्पन्न करने की कोशिश कर रहा है।

structs और methods संयोजन से आप ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में एक class एक करीब eqivalent प्राप्त कर सकते हैं।

गो में एक विधि में निम्नलिखित हस्ताक्षर हैं

func (name receiverType) methodName(paramterList) (returnList) {}

package main

type Admin struct {
    Username, Password string
}

func (admin Admin) Delete() {
    fmt.Println("Admin Deleted")
}

type User struct {
    ID uint64
    FullName, Email string
    Admin
}

func (user User) SendEmail(email string) {
    fmt.Printf("Email sent to: %s\n", user.Email)
} 

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "zola.mk.27@gmail.com",
        admin,
    }

    user.SendEmail("Hello") // Email sent to: zola.mk.27@gmail.com

    admin.Delete() // Admin Deleted
}

सूचक बनाम मूल्य रिसीवर

एक विधि का रिसीवर आमतौर पर प्रदर्शन कारण के लिए एक संकेतक होता है क्योंकि हम उदाहरण की एक प्रति नहीं बनाते हैं, क्योंकि यह मूल्य रिसीवर में मामला होगा, यह विशेष रूप से सच है यदि रिसीवर प्रकार एक संरचना है। रिसीवर टाइप को पॉइंटर बनाने के लिए एओटर कारण होगा ताकि हम रिसीवर को डेटा को संशोधित कर सकें।

मूल्य रिसीवर का उपयोग उस डेटा के संशोधन से बचने के लिए किया जाता है जिसमें रिसीवर होता है, एक वॉइल रिसीवर एक प्रदर्शन हिट का कारण हो सकता है यदि रिसीवर एक बड़ी संरचना है।

package main

type User struct {
    ID uint64
    FullName, Email string
}

// We do no require any special syntax to access field because receiver is a pointer
func (user *User) SendEmail(email string) {
    fmt.Printf("Sent email to: %s\n", user.Email)
}    

// ChangeMail will modify the users email because the receiver type is a ponter
func (user *User) ChangeEmail(email string) {
    user.Email = email;
}

func main() {
    user := User{
        1,
        "Zelalem Mekonen",
        "zola.mk.27@gmail.com",
    }

    user.SendEmail("Hello") // Sent email to: zola.mk.27@gmail.com

    user.ChangeEmail("zola@gmail.com")

    fmt.Println(user.Email) // zola@gmail.com
}

इंटरफ़ेस और बहुरूपता

किसी वस्तु के व्यवहार को निर्दिष्ट करने के लिए इंटरफेस एक रास्ता प्रदान करते हैं, अगर कोई ऐसा कर सकता है तो इसका उपयोग यहां किया जा सकता है। एक इंटरफ़ेस विधियों के एक सेट को परिभाषित करता है, लेकिन इन विधियों में कोड शामिल नहीं है क्योंकि वे अमूर्त हैं या इंटरफ़ेस के उपयोगकर्ता पर लागू नहीं होता है। अधिकांश ऑब्जेक्ट ओरिएंटेड भाषाओं के विपरीत गो में चर हो सकते हैं।

बहुरूपता वस्तु-उन्मुख प्रोग्रामिंग का सार है: जब तक वे एक ही इंटरफ़ेस का पालन नहीं करते तब तक समान रूप से विभिन्न प्रकार की वस्तुओं का इलाज करने की क्षमता। गो इंटरफेस इस क्षमता को बहुत ही प्रत्यक्ष और सहज तरीके से प्रदान करता है

package main

type Runner interface {
    Run()
}

type Admin struct {
    Username, Password string
}

func (admin Admin) Run() {
    fmt.Println("Admin ==> Run()");
}

type User struct {
    ID uint64
    FullName, Email string
}

func (user User) Run() {
    fmt.Println("User ==> Run()")
}

// RunnerExample takes any type that fullfils the Runner interface
func RunnerExample(r Runner) {
    r.Run()
}

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "zola.mk.27@gmail.com",
    }

    RunnerExample(admin)

    RunnerExample(user)
    
}