Golang의 객체 지향 프로그래밍(OOP) 소개

프로그래밍에 대해 이야기할 때 일반적으로 일부 데이터를 수정하고 상호 작용하는 여러 함수를 작성하는 것을 의미합니다. 객체 지향 프로그래밍(OOP)은 대신 ​​데이터를 포함하고 일부 관련 기능이 연결된 "객체"에 초점을 맞춘 프로그래밍 모델입니다. 객체 지향 프로그래밍에는 상속, 캡슐화, 다형성 및 추상화의 네 가지 기둥이 있습니다. 이번 블로그에서는 예제를 통해 Golang에서 각각을 구현하는 방법을 살펴보겠습니다. OOP에 대한 몇 가지 기본 아이디어가 권장되지만, 그렇지 않은 경우 네 가지 기둥이 모두 무엇을 의미하는지 간략하게 소개하겠습니다.

클래스, 개체 및 메서드

객체 지향 프로그래밍의 핵심 아이디어는 다음 주요 항목으로 요약될 수 있습니다.

• 데이터와 해당 데이터에서 호출할 수 있는 함수의 모음인 "클래스"를 정의합니다.
• 이러한 특정 함수를 해당 클래스의 "메서드"라고 합니다.
• 클래스의 실제 인스턴스를 "객체"라고 합니다.

이 세 가지 개념을 이해하기 위해 Golang의 일부 코드를 살펴보겠습니다.

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

Golang에서 클래스는 우리가 정의한 유형일 뿐입니다. 이러한 유형은 반드시 구조체일 필요는 없지만 일반적으로 OOP에서는 모든 유형(문자열, 정수 등)이 될 수 있는 데이터 컬렉션을 사용하기 때문에 그렇습니다.

클래스는 객체의 청사진입니다. 클래스를 인스턴스화할 때마다 객체가 형성됩니다. 이 예에서 b1과 b2는 Batman 클래스의 객체입니다.

SayImBatman 함수는 클래스의 모든 개체에서 호출할 수 있습니다. 배트맨 클래스에 묶여있기 때문에 일반 함수라고 부르지 않고 클래스의 메서드라고 부릅니다.

이것은 OOP의 네 가지 기본 요소를 살펴보는 다음 섹션으로 넘어갈 수 있을 만큼 OOP의 기본 사항을 명확하게 해준다고 생각합니다.

계승

상속은 OOP의 부모 및 자식 클래스 개념을 소개합니다. 자식 클래스는 부모 클래스에서 파생된 클래스로 해당 클래스의 모든 메서드와 속성(데이터)을 상속합니다. 이를 이해하는 데 도움이 되는 몇 가지 코드를 살펴보겠습니다.

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

이 예에서 Batman과 Ironman은 Hero 상위 클래스의 하위 클래스입니다. 부모 클래스의 속성인 팀과 해당 메서드인 SayTeam에 액세스할 수 있습니다. b1 및 i1 인스턴스를 선언할 때 볼 수 있듯이 부모 클래스 속성과 각 클래스의 특정 속성을 지정합니다. 둘 다 상위 클래스에 정의된 SayTeam 메서드를 호출할 수 있습니다. 하지만 각각 고유한 별도의 속성과 메서드도 있습니다.

Golang은 구성(구조체 내부의 구조체 사용)을 사용하여 상속을 구현합니다. C나 Java와 같은 다른 OOP 언어처럼 클래스 기반 상속이 내장되어 있지 않습니다.

캡슐화

캡슐화는 객체의 내부 속성을 숨기고 직접 수정할 수 없도록 하는 원리입니다. 대신, 이러한 속성을 가져오고 업데이트하는 메서드 제공에 의존합니다. 이를 더 잘 이해하기 위해 예를 살펴보겠습니다.

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

Golang에서는 패키지 외부로 내보내는 속성과 메서드가 대문자로 시작합니다. utils 패키지에서 행위자와 연도를 소문자로 정의할 때 직접 수정할 수 없도록 보장합니다. 대신 main.go 파일에서 볼 수 있듯이 내보낸 메서드(대문자로 시작)(GetActor, SetActor 등)를 사용하여 가져오고 수정해야 합니다.

캡슐화의 핵심은 실수로 데이터가 변경되는 것을 방지하고 대신 데이터와 안전하게 상호 작용할 수 있는 방법을 제공하는 것입니다.

한 가지 다른 점은 Batman 클래스의 모든 메서드에서 이전 예제에서처럼 값 수신기 Batman 대신 포인터 수신기 *Batman을 사용하고 있다는 것입니다. 이는 Set 메서드에서 원래 구조체를 수정할 수 있기를 원하기 때문입니다. 그리고 Golang에서는 일부 메서드에 포인터 수신기가 필요한 경우 일관성을 위해 모든 메서드에서 포인터 수신기를 사용하도록 하는 것이 가장 좋습니다. 이것이 바로 Get 메소드가 원래 구조체를 수정하지 않음에도 불구하고 포인터 수신기를 사용하는 이유입니다.

또한 한 가지 더 주목해야 할 점은 포인터 수신기를 사용한다고 해서 (&b1).GetActor를 수행할 필요가 없다는 것입니다. Golang에서 포인터 인수가 있는 함수는 포인터를 가져와야 하지만 포인터 수신기가 있는 메서드는 값이나 포인터를 수신기로 사용할 수 있습니다.

요약: GetActor 메서드에 포인터 수신기가 있으므로 Golang은 자동으로 b1.GetActor를 (&b1).GetActor로 변환하지만, GetActor가 일반 함수인 경우 GetActor(b1)를 GetActor(&b1)로 변환하지 않습니다. 포인터 인수입니다.

다형성과 추상화

OOP의 다음 두 기둥은 코드 샘플이 꽤 비슷해 보이기 때문에 하나로 묶을 수 있습니다. 다형성은 서로 다른 두 클래스의 서로 다른 두 개체를 동일한 공통 슈퍼클래스의 개체로 처리할 수 있는 프로그래밍 방식을 나타냅니다. 이는 마치 동일한 클래스의 객체인 것처럼 서로 다른 두 객체에 대해 동일한 함수를 호출할 수 있음을 의미합니다. 인터페이스가 관련되어 있다는 느낌을 주기 시작해야 합니다 :)

이를 더 잘 이해하기 위해 몇 가지 코드를 살펴보겠습니다.

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

이 예에서 StartFight 함수는 b1 및 i1 개체가 서로 아무런 관련이 없더라도 모두 전달될 수 있습니다. 이것이 하위 클래스가 상위 클래스의 메서드에 액세스할 수 있는 상속과 어떻게 다른지 이해해 보세요. 이 예에는 하위 클래스와 상위 클래스가 없습니다(그리고 공유되는 메소드도 없습니다). 대신, 함수에 의해 서로 다른 두 객체가 동일한 것으로 취급됩니다. 이를 다형성이라고 합니다.

이제 이것도 추상화의 예로 취급할 수 있습니다. 이름에서 알 수 있듯이 추상화는 구현 세부 사항을 숨기고 대신 작업을 처리하는 함수를 제공하는 프로그래밍 방식입니다. 이 예에서는 개별 Hero의 메서드가 어떻게 구성되어 있는지 신경 쓸 필요가 없습니다. 영웅의 전투 기능을 사용하고 싶을 때 언제든지 StartFight 기능을 계속 사용할 수 있습니다. 이렇게 하면 구현 세부 정보가 사용자에게 숨겨지고 필수 세부 정보만 노출됩니다.

이제 다형성으로 돌아가면 두 가지 일반적인 예가 더 있는데, 바로 메서드 재정의와 오버로딩입니다.

메소드 재정의

메서드 재정의는 상위 클래스에 정의된 메소드의 자체 구현을 정의하는 하위 클래스를 의미합니다. 이제 이 구현은 원래 상위 클래스의 구현 대신 사용됩니다. 이전에 상속에 사용한 코드를 가져와 메소드 재정의를 통해 어떻게 보이는지 살펴보겠습니다.

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

이 프로그램의 출력은 다음과 같습니다.

//oops-in-go/utils/utils.go

package utils

type Batman struct {
    actor string
    year int
}

func (b *Batman) GetActor() string {
    return b.actor
}

func (b *Batman) GetYear() int {
    return b.year
}

func (b *Batman) SetActor(actor string) {
    b.actor = actor
}

func (b *Batman) SetYear(year int) {
    b.year = year
}

Batman 클래스의 개체는 이제 상위 Hero 클래스 대신 자체 SayTeam 메서드를 사용합니다. Ironman 클래스에는 자체 SayTeam 메서드가 없으므로 해당 개체는 여전히 상위 클래스의 메서드를 사용합니다. 이것이 바로 메소드 오버라이딩(Method Overriding)의 의미입니다. 하위 클래스가 상위 클래스에 정의된 메소드를 "오버라이드"합니다.

메소드 오버로딩

이는 동일한 함수가 여러 개의 서로 다른 인수를 취할 수 있음을 의미합니다. 이러한 인수는 개수나 유형이 다를 수 있습니다. Golang은 이를 달성하기 위한 두 가지 방법, 즉 가변 함수를 통해, 다른 하나는 인터페이스를 통해 제공합니다.

더 나은 이해를 돕기 위해 두 코드를 모두 살펴보겠습니다.

가변 함수 사용

// oops-in-go/main.go

package main

import (
    "fmt"
    "oops-in-go/utils"
)

func main() {
    b1 := utils.Batman{}
    b1.SetActor("Michael Keaton")
    b1.SetYear(1989)
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b1.GetActor(), b1.GetYear())

    b1.SetActor("Christian Bale")
    b1.SetYear(2005)
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b1.GetActor(), b1.GetYear())
}

여기서 개개의 인수를 사용하여 listMembers 함수를 "오버로드"할 수 있습니다.

인터페이스 사용

package main

import "fmt"

type Hero interface {
    Fight()
}

type Batman struct {
    weapon string
}

type Ironman struct {
    weapon string
}

func (b Batman) Fight() {
    fmt.Printf("Batman hits with a %s\n", b.weapon)
}

func (i Ironman) Fight() {
    fmt.Printf("Ironman hits with a %s\n", i.weapon)
}

func StartFight(h Hero) {
    fmt.Println("Fight has started.")
    h.Fight()
}

func main() {
    b1 := Batman{"Batarang"}
    i1 := Ironman{"Repulsor rays"}

    StartFight(b1)
    StartFight(i1)
}

이 프로그램의 출력은 다음과 같습니다.

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func (b Batman) SayTeam() {
    fmt.Printf("I'm Batman and my team is %s\n", b.team)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

여기서는 다양한 유형의 인수를 취하기 위해 saySomething 메소드를 "오버로딩"하고 있습니다. 임의의 유형이 될 수 있는 빈 인터페이스를 인수로 취한 다음, 스위치 케이스를 사용하여 해당 유형을 확인한 후 그에 따라 출력을 인쇄합니다.

결론

이 글이 길었다는 것을 잘 알고 있습니다. 끝까지 읽어주신다면 정말 행복하다는 점을 알아주셨으면 합니다. :) 객체지향 프로그래밍에 대해 새로운 것을 많이 배웠기를 진심으로 바랍니다. Golang에서 구현하는 방법. 저는 제 웹사이트에 다양한 기술 개념에 대한 블로그를 작성하고 있습니다. 새로운 내용을 배우고 싶다면 제 뉴스레터에 가입하시기 바랍니다.

위 내용은 Golang의 객체 지향 프로그래밍(OOP) 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!