Go’da Nesne Yönelimli Programlamaya Giriş

Go'da Nesne Yönelimli Programlamaya Giriş

Java ve C++ gibi birçok popüler dilin aksine Go, başlı başına nesne yönelimli bir dil değildir. Go programlama dilinde, geliştiricilerin sağladığı minimum dil desteği ile nesne yönelimli stil oluşturmaya zorlaması gerekir. Nesne yönelimli teknoloji paradigmasının, onu destekleyen dilin yapısında kavramsal olarak daha fazla yer aldığını anlayın. Bununla birlikte, nesne yönelimli olmayabilecek çoğu genel amaçlı dil Yapabilmek nesne yönelimli ilkeleri taklit eder. Bir programlama dili, nesne yönelimli programlama ilkelerinin uygulanmasında doğası gereği çok az veya sınırlı desteğe sahip olabilir. Bununla birlikte, saf nesne yönelimli bir dil, nesne yönelimli ilkelere daha uygundur ve kalıtım, çok biçimlilik, kapsülleme vb. gibi özelliklerini açık bir şekilde destekler. Burada, bu programlama eğitiminde, Go ve Golang programlama dilinin bazı temel OOP özelliklerini tanıtacağız.

Okumak: Go’da Çöp Toplama Anlama

Go bir OOP Dili mi?

Go bir OOP dili değil – bu kadarı kesin. Ancak, nesne yönelimli metodolojilerin ilkelerini karşılamak için go dili özelliklerini kullanabilir miyiz? Evet, geliştiriciler bir dereceye kadar yapabilir. Örneğin, Go’nun kalıtım desteği yoktur, ancak fikir, kompozisyon desteğiyle telafi edilebilir. Benzer şekilde, bir tür polimorfizm Yapabilmek arayüzler kullanılarak oluşturulabilir. Şunu anlayın ki, kişi gerçekten nesne yönelimli metodolojilere göre bir uygulama geliştirmek istiyorsa, Go’nun kesinlikle iyi bir seçim olmadığını anlayın. Bunun yerine Java, C++, Python gibi diller veya nesne yönelimli özellikleri destekleyen diğer yüksek işlevli diller aranmalıdır.

Polimorfizm ve OOP kavramlarını taklit etmek için Go’da Arayüzleri kullanmakla ilgileniyorsanız, eğiticimize göz atabilirsiniz: Go’da Arayüzlere Giriş.

Go ve Golang’da Nesneler Nasıl Oluşturulur

Nesne yöneliminin arkasındaki ana fikir, kodu yönetilebilir birkaç parçaya ayırmak veya nesneler. Her nesne tarafından belirlenen kendi kimliği vardır. veri (Öznitellikler) ve yöntemler (davranış) veriler üzerinde çalışır. Nitelikler tipik olarak gizlidir ve yalnızca nesne içinde tanımlanan yöntemlerle erişilebilir. buna denir kapsülleme. Her ikisi de kapsayıcıyı veya soyut veri türünü oluşturmak için sınıfları kullanan Java veya C++’dan farklı olarak Go, özniteliklerini kullanarak kapsülleyebilir. yapı.

Yukarıdaki resimde, nesne açıklaması şu Go örnek koduna benzeyebilir:

package payroll

type Employee struct {
	Id    int
	name  string
	phone string
	email string
}

Yukarıdaki Golang kodu, özniteliklerle soyut veri türünü tanımlar. Oluşturulduktan sonra, onu aşağıdaki gibi somutlaştırabiliriz:

e1 := payroll.Employee{Id: 101}

veya:

e1 := payroll.Employee{}

veya:

var ep1 *payroll.Employee
ep1 = &payroll.Employee{Id: 102}
ep1.SetEmployee("Anita", "4787753", "[email protected]")

Go’da Veri Gizleme

Ancak kodu şu şekilde yazarsak:

e1 := payroll.Employee{Id: 101, name:"Anita",phone:"2783648",email:"[email protected]" } // Error!

Bu işe yaramayacak. Nedeni erişilebilirlik. Java veya C++’dan farklı olarak özel veya halka açık özniteliklerin erişilebilirliğini kısıtlamak için Go’nun böyle bir özelliği yoktur. Bunun yerine, paket düzeyinde erişilebilirlik için bir araçtır. Not yazmışız İD içinde Çalışan yapı, içindeki ilk harfle büyük harf. Bu, özniteliğin İD nesne oluşturulduğunda doğrudan paketin dışından erişilebilirken, özniteliklere aşağıdaki gibi erişilebilir: isim, telefonve e-posta içinde yazılır küçük harf ve yalnızca Go’da aşağıdaki gibi tanımlanan üye yöntemlerle erişilebilir:

func (e *Employee) GetName() string {
	return e.name
}
func (e *Employee) SetName(name string) {
	e.name = name
}

Yukarıdaki kod, Go’da bir tür kapsülleme uygulamak için bir araç sağlar. Fikri hızlı bir şekilde test etmek için işte tam kod:

package payroll

type Employee struct {
	Id    int
	name  string
	phone string
	email string
}

func (e *Employee) SetEmployee(name, phone, email string) {
	e.SetName(name)
	e.SetPhone(phone)
	e.SetEmail(email)
}

func (e *Employee) GetId() int {
	return e.Id
}
func (e *Employee) GetName() string {
	return e.name
}
func (e *Employee) GetPhone() string {
	return e.phone
}
func (e *Employee) GetEmail() string {
	return e.email
}
func (e *Employee) SetId(id int) {
	e.Id = id
}
func (e *Employee) SetName(name string) {
	e.name = name
}
func (e *Employee) SetPhone(phone string) {
	e.phone = phone
}
func (e *Employee) SetEmail(email string) {
	e.email = email
}

//-------------------------------------------------------------
package main

import (
	"fmt"
	"oop_prog/payroll"
)

func main() {
	e1 := payroll.Employee{Id: 101}
	e1.SetEmployee("Bob", "82347783", "[email protected]")
	fmt.Println(e1.GetId(), ":", e1.GetName(), ":", e1.GetPhone(), ":", e1.GetEmail())
}

hakkında daha fazla bilgi edinmek istiyorum yapı? Size daha fazlasını öğretecek bir programlama eğitimimiz var: Go’da Yapıları Anlamak.

Go’da Kompozisyona Göre Kalıtım

Kalıtım doğrudan Go’da desteklenmediğinden programcıların yapabileceği şey kompozisyon onun etkisinin bir kısmını elde etmek için. Kompozisyon temel olarak bir veya daha fazla nesneyi bir öznitelik gibi başka bir nesneye koymak anlamına gelir. Bu nedenle, bir oluşturabiliriz yapı diğerini gömen tür yapı türleri. Örneğin, bir bilgisayar CPU, RAM, HDD, Anakart ve diğer şeyler gibi bileşenlerin bir bileşimidir.

Go’da kompozisyona göre kalıtımı gösteren bazı örnek kodlar:

package computer

import "fmt"

type CPU struct {
	architecture string
}

func (cpu *CPU) SetArchitecture(arch string) {
	cpu.architecture = arch
}

func (cpu *CPU) GetArchitecture() string {
	return cpu.architecture
}

type RAM struct {
	size int
}

func (ram *RAM) SetSize(size int) {
	ram.size = size
}

func (ram *RAM) GetSize() int {
	return ram.size
}

type Motherboard struct {
	category string
}

func (m *Motherboard) SetCategory(cat string) {
	m.category = cat
}

func (m *Motherboard) GetCategory() string {
	return m.category
}

type Computer struct {
	cpu    CPU
	ram    RAM
	mboard Motherboard
}

func (c *Computer) SetSpecification(cpu CPU, ram RAM, mboard Motherboard) {
	c.cpu.SetArchitecture(cpu.GetArchitecture())
	c.ram.SetSize(ram.GetSize())
	c.mboard.SetCategory(mboard.GetCategory())
}

func (c *Computer) ShowSpecification() {
	fmt.Println("CPU: ", c.cpu.GetArchitecture(), ", RAM: ", c.ram.GetSize(), "GB, Motherboard: ", c.mboard.GetCategory())
}

//-------------------------------------

package main

import (
	"fmt"
	"oop_prog/computer"
)

func main() {
	cpu := computer.CPU{}
	cpu.SetArchitecture("64-bit")

	ram := computer.RAM{}
	ram.SetSize(8)

	mboard := computer.Motherboard{}
	mboard.SetCategory("Micro ATX")

	c1 := computer.Computer{}
	c1.SetSpecification(cpu, ram, mboard)
	c1.ShowSpecification()
}

Normal kalıtımla ilgili sorun, bir sınıf hiyerarşisine yol açmasıdır. Nihai nesnenin davranışı genellikle gömülüdür veya hiyerarşiye yayılır. Ayrıca, üst sınıfta veya hiyerarşideki herhangi bir sınıfta herhangi bir değişiklik dalgalanma etkisine sahip olabilir. Kalıtımın dallarına sızan bir hatayı ayıklamak çok zordur. Go’da kullanılan kompozisyon, aslında nesnenin davranışını devretmek için iyi bir yoldur. Nesne yönelimli metodolojiye göre kompozisyon, bir sahip nesneler arasındaki ilişki, oysa normal kalıtımda nesneler arasındaki ilişkiye denir. is-a ilişki.

Kompozisyonun güzelliği, yalnızca gerektiğinde daha karmaşık bir nesne oluşturmak için birçok basit nesne yapısının birleştirilebilmesidir. Bu, geliştiricilerin yapabileceği anlamına gelir tembel-yaratmak nesneleri yalnızca gerektiğinde Bu, bellek tahsisini minimumda tutar ve programın daha az bellek ayak izine yol açar.

Yukarıdaki örneğimizde CPU, RAM ve Anakart gibi nesneler oluşturduk ve bunların niteliklerini ve yöntemlerini tanımladık. Biz bir oluştururken Bilgisayartek tek nesneleri daha karmaşık bir nesnede birleştirebiliriz.

Okumak: Go’da Çöp Toplama Anlama

Go’da polimorfizm

polimorfizm nesne yönelimli programlamanın bir diğer önemli özelliğidir. Çalışma zamanında farklı davranışlarda bulunabilen türlerin uygulanması yoluyla kod yazma yeteneği sağlar. Go’da polimorfizm, yalnızca arayüzler ve arayüzler aracılığıyla elde edilir. Bir arabirim bir türü uyguladığında, içinde tanımlanan işlevsellik o türden herhangi bir değere açıktır. Standart kitaplık bu uygulama ile doludur. Örneğin, io paketi, kodumuzda verimli bir şekilde veri akışı sağlamak için kapsamlı bir arabirim ve işlev kümesine sahiptir. Go’daki arabirimler aracılığıyla polimorfik davranışın nasıl elde edildiğini gösteren hızlı bir örnek:

package polymorph

import (
	"fmt"
	"math"
)

type Shape interface {
	area()
}

type Rectangle struct {
	X1, Y1, X2, Y2 float64
}

type Circle struct {
	Xc, Yc, Radius float64
}

func (r *Rectangle) area() {
	fmt.Println("Rectangle Area : ", (r.X2-r.X1)*(r.Y2-r.Y1))
}

func (c *Circle) area() {
	fmt.Println("Circle Area: ", math.Pi*math.Pow(c.Radius, 2))
}

func GetArea(s Shape) {
	s.area()
}

//--------------------------------------------------

package main

import "oop_prog/polymorph"
func main() {
	r := polymorph.Rectangle{10, 10, 20, 20}
	polymorph.GetArea(&r)
	c := polymorph.Circle{5, 5, 30}
	polymorph.GetArea(&c)

}

Yukarıdaki kodda iki yapı türü Dikdörtgen ve Daire uygulamak Şekil arayüz. Sonuç olarak, yapı tür olur Şekil ve fonksiyona geçirilebilir GetArea. Bu şekilde istediğimiz veya ihtiyaç duyduğumuz kadar çok yapı türü ekleyebiliriz; uyguladığı sürece Şekil arayüzü, dinamik davranışı GetArea yöntem çalışma zamanında kararlaştırılacaktır.

Bir kenara, hakkında daha fazla bilgi edinebilirsiniz. io Bu Golang programlama eğitimindeki paket: Go’da Temel G/Ç İşlemleri Nasıl Gerçekleştirilir.

OOP ve Go Üzerine Son Düşünceler

Nesne yönelimli metodolojilerin çoğu aslında kavramsaldır. Bu nedenle, tasarım dikkatli bir şekilde düşünülürse, herhangi bir dilde nesne yönelimli programlama yapmak aslında mümkündür. Saf nesne yönelimli diller sadece ekstra destek sağlar. Go’da her nesne yönelimli özelliği uygulamak mümkün olmasa da, bazı temel özellikler kolayca uygulanabilir. Nesne yönelimliliği unutun, bu özellikler programcının istediği şekilde kullanılabilir. İşin püf noktası bu aslında.

Devamını oku Go ve Golang programlama eğitimleri.

Bir cevap yazın

E-posta hesabınız yayımlanmayacak.