GO언어의 주요 특성

GO언어의 특성 및 객체지향 언어와의 차이점을 자바를 예로 들어 알아봅니다.

---

클래스가 없어요

자바에서는 클래스와 객체를 통해 객체지향 프로그래밍을 합니다

// 객체지향 언어의 클래스
class Rectangle	{
	// 속성
	String Name = new String();
	Float64 Width = 0;
	Float64 Height = 0;
	// 메서드
 	Float Area() {
		return this.Width * this.Height
	}
}

GO는 구조체와 구조체를 사용하는 함수를 정의합니다

// 구조체
type Rectangle struct {
    Name    string
    Width, Height float64
}

// 구조체를 사용하는 함수
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

상속도 당연히 없어요

자바에서 상속을 통해 다른 클래스를 상속받아 확장하여 사용할 수 있습니다

//클래스
class Book {
	private String Name;
	public Book(String Name) {
		this.Name = Name;
	}
}
// 책 클래스 확장판인 만화책 클래스
class ComicBook extends Book {
	private String publisher;
	public ComicBook(String Name, String Publisher) {
		super(Name);
		this.publisher = Publisher;
	}
}

GO에서는 구조체 임베딩을 통해 임베딩한 구조체의 자원을 사용할 수 있습니다

// Person 구조체
type Person struct { 
	name string
	age  int
}
// Student 구조체 내에 Person 구조체를 임베딩
type Student struct {
	p      Person 
	school string
	grade  int
}

// Person 구조체의 greeting 메서드
func (p *Person) greeting() { 
	fmt.Println("Hello")
}


func main() {
	var s Student
	s.p.greeting() // Hello
}

구현 또한 없어요

자바에서는 인터페이스를 생성하고 인터페이스를 구현하는 클래스를 만들 수 있습니다

public interface Country {
	void gdp(String country);
	void gnp(String country);
}

public class Countryimpl implements Country {
	public void gdp(String country) {
		System.out.println("해당 나라의 gdp");
	}
	public void gnp(String country) {
		System.out.println("해당 나라의 gnp");
	}
}

하지만 GO는 구조체가 속성들의 모임이라면 인터페이스는 메서드들의 모임입니다
run() 메서드를 가지고 있는 구조체는 모두 animal 인터페이스 타입을 가집니다

// 덕 타이핑 방식
type Animal interface{
    run()
}

type Dog struct {
	name   string
	weight int
}

type Cat struct {
	name   string
	weight int
}

func (a Dog) run() {
	fmt.Println(a.name, "dog is running now!")
}

func (a Cat) run() {
	fmt.Println(a.name, "cat is running now!")
}

func (a Animal) fastRun() {
	fmt.Println(a.name, "is running fast now!")
}

func main() {
	dog1 := Dog{dog1, 40}
	cat1 := Cat{cat1, 20}
	dog1.fastRun() //dog1 is running fast now!
	cat1.fatRun() //cat1 is running fast now!
}

포인터가 있어요

Go는 포인터를 통해 call by reference 방식으로 값을 전달할 수 있습니다

type Mutatable struct {
    a int
    b int
}

// 실제 값은 변경되지 않는다.
func (m Mutatable) StayTheSame() {	
    m.a = 5
	m.b = 7
}

// 포인터를 통해 받았으므로 실제 값이 변경된다.
func (m *Mutatable) Mutate() {
    m.a = 5
	m.b = 7
}

접근 제어자 방식

//대문자로 선언 - 외부에서도 사용 가능
type Car struct { 
	name    string 
	color   string 
	company string 
	detail  spec
}

//소문자로 선언 - 내부에서만 사용 가능
type spec struct { 
	length int 
	height int 
	width  int 
}

빈 인터페이스 타입이 유용해요

GO의 빈 인터페이스 타입은 모든 타입을 담을 수 있는 컨테이너입니다

func main() {
    var x interface{}
    x = 1 
    x = "Tom"
    printInterfaceType(x)
}
 
func printInterfaceType(v interface{}) {
    fmt.Println(v) //Tom
}

빈 인터페이스는 아래와 같이 모든 타입을 받고 반환시킬 수 있습니다

//런타임에 형 변환을 한 후, 정적 타입의 값으로 변경해서 넘긴다
func checkType(a interface{}) {
	switch a.(type) {
	case bool:
		fmt.Println("This is bool,", a)
	case int, int8, int16, int32, int64:
		fmt.Println("This is int,", a)
	case float32, float64:
		fmt.Println("This is float,", a)
	case nil:
		fmt.Println("This is nil,", a)
	case string:
		fmt.Println("This is string,", a)
	default:
		fmt.Println("This is not bool, int, float, nil, string!,", a)
	}
}