go언어에서 Java의 클래스, 속성, 메소드는 어떻게 구현이되?

Go 언어는 Java와 같은 전통적인 객체지향 언어와는 다르게 클래스(Class) 개념이 없습니다. 대신, 구조체(Struct), 메서드(Method), 그리고 인터페이스(Interface) 를 활용하여 객체지향적인 프로그래밍을 구현할 수 있습니다.

 

✅ 1. Java의 클래스(Class) → Go의 구조체(Struct)

Java에서는 class 키워드를 사용하여 클래스를 정의하지만, Go에서는 struct를 사용하여 데이터를 정의합니다.

📌 Java 코드 (클래스 예제)

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

📌 Go 코드 (구조체로 구현)

package main

import "fmt"

// Java의 클래스 대신 Go에서는 struct 사용
type Person struct {
    Name string
    Age  int
}

// 생성자 역할을 하는 함수 (Go는 생성자를 지원하지 않음)
func NewPerson(name string, age int) *Person {
    return &Person{Name: name, Age: age}
}

// Java의 메서드에 해당하는 함수 (struct에 메서드 추가)
func (p *Person) SayHello() {
    fmt.Println("Hello, my name is", p.Name)
}

func main() {
    p := NewPerson("Alice", 25)
    p.SayHello() // 출력: Hello, my name is Alice
}

 

 

📌 차이점

• Go에는 클래스가 없고, 대신 struct를 사용.
• 생성자는 없지만, NewPerson 같은 생성자 함수(Factory Function) 를 만들어 객체를 초기화.
• 메서드는 구조체에 func (p *Person) MethodName() 형태로 정의.

 

✅ 2. Java의 속성(Attribute) → Go의 구조체 필드(Struct Fields)

Java에서는 클래스의 속성을 private로 선언하고, getter/setter 메서드를 통해 접근합니다.

📌 Java 코드 (속성 접근)

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 

📌 Go 코드 (구조체 필드 접근)

package main

import "fmt"

type Person struct {
    Name string // 필드명이 대문자로 시작하면 public (exported)
    age  int    // 소문자로 시작하면 private (unexported)
}

// Getter 메서드 (Go에서는 직접 접근 가능하지만, 필요하면 getter 구현 가능)
func (p *Person) GetAge() int {
    return p.age
}

// Setter 메서드
func (p *Person) SetAge(age int) {
    p.age = age
}

func main() {
    p := Person{Name: "Bob", age: 30}
    fmt.Println(p.Name)     // 직접 접근 가능
    fmt.Println(p.GetAge()) // Getter 사용
}

 

📌 차이점

• Go에서는 필드명을 대문자로 시작하면 public, 소문자로 시작하면 private.
• 직접 필드에 접근 가능하지만, 필요하면 Getter/Setter를 추가할 수도 있음.

 

✅ 3. Java의 메서드(Method) → Go의 메서드(Methods)

Java에서는 클래스 내에서 public void methodName() 같은 방식으로 메서드를 정의하지만,
Go에서는 구조체에 메서드를 추가할 때 메서드 리시버(Receiver) 를 사용합니다.

📌 Java 코드 (메서드 예제)

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

 

📌 Go 코드 (구조체에 메서드 추가)

package main

import "fmt"

type Person struct {
    Name string
}

// 구조체의 메서드 정의 (리시버 사용)
func (p *Person) SayHello() {
    fmt.Println("Hello, my name is", p.Name)
}

func main() {
    p := Person{Name: "Alice"}
    p.SayHello() // 출력: Hello, my name is Alice
}

 

📌 차이점

• Go에서는 메서드 리시버(Receiver)를 사용하여 구조체에 메서드 추가.
• func (p *Person) MethodName() 형태로 정의.

✅ 4. Java의 인터페이스(Interface) → Go의 인터페이스(Interface)

Java에서는 interface를 정의하고 클래스에서 implements 키워드를 사용하여 구현합니다.

📌 Java 코드 (인터페이스 예제)

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof Woof!");
    }
}

 

📌 Go 코드 (인터페이스 구현)

package main

import "fmt"

// Go 인터페이스 정의
type Animal interface {
    MakeSound()
}

// Dog 구조체 정의
type Dog struct{}

// Dog 구조체가 Animal 인터페이스를 구현 (자동으로 인터페이스 만족)
func (d Dog) MakeSound() {
    fmt.Println("Woof Woof!")
}

func main() {
    var a Animal = Dog{} // 인터페이스 타입 변수에 할당 가능
    a.MakeSound()        // 출력: Woof Woof!
}

 

📌 차이점

• Go에서는 implements 키워드 없이, 자동으로 인터페이스를 만족하면 구현된 것으로 간주.
• Dog 구조체가 MakeSound 메서드를 가지면, 자동으로 Animal 인터페이스를 구현한 것으로 처리됨.

✅ 5. Java의 상속(Inheritance) → Go의 내장(Embedding)

Java는 extends 키워드를 사용하여 클래스 상속을 지원하지만,
Go는 상속이 없고, 대신 "구조체 내장(Embedding)"을 통해 재사용을 지원합니다.

📌 Java 코드 (상속 예제)

class Animal {
    public void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Woof Woof!");
    }
}

 

📌 Go 코드 (구조체 내장)

package main

import "fmt"

// Animal 구조체 정의
type Animal struct{}

func (a Animal) Eat() {
    fmt.Println("Eating...")
}

// Dog 구조체가 Animal을 포함 (Embedding)
type Dog struct {
    Animal // 상속 대신 포함(Embedding)
}

func (d Dog) Bark() {
    fmt.Println("Woof Woof!")
}

func main() {
    d := Dog{}
    d.Eat()  // Animal의 메서드를 직접 호출 가능
    d.Bark() // Dog의 메서드 호출
}

 

📌 차이점

• Go에는 클래스 상속이 없고, "구조체 내장(Embedding)"을 사용.
• Dog 구조체가 Animal을 포함하면, Animal의 메서드를 직접 호출 가능.

🔥 정리

클래스(Class)	class 키워드 사용	struct 사용
속성(Attribute)	private + Getter/Setter	struct 필드, 대문자 = public, 소문자 = private
메서드(Method)	클래스 내부에서 정의	func (t *Type) Method() 형태로 정의
인터페이스(Interface)	interface + implements	interface 정의, 자동으로 구현
상속(Inheritance)	extends 사용	구조체 내장(Embedding) 사용

 

💡 Go는 객체지향 언어가 아니지만, struct, method receiver, interface, embedding을 사용하여 객체지향 패턴을 지원합니다!