Golang: P.O.

O
Programação Orientada a Objetos em Go

Introdução
A Programação Orientada a Objetos (POO) é um paradigma
fundamental na engenharia de software, e muitas linguagens
de programação, incluindo Go, suportam conceitos de POO.
No entanto, Go tem uma abordagem única para POO em
comparação com outras linguagens. Este artigo irá explorar os
conceitos de POO em Go com exemplos práticos.

Conceitos Básicos de POO

Tipos e Métodos em Go
Em Go, não temos classes tradicionais como em outras
linguagens orientadas a objetos. Em vez disso, podemos
definir tipos e associar métodos a esses tipos. Vamos criar um
exemplo simples para ilustrar isso:

package main

import "fmt"
// Definindo um tipo 'Pessoa'
type Pessoa struct {
Nome string
Idade int
}
// Adicionando um método 'Apresentar' ao tipo 'Pessoa'
func (p Pessoa) Apresentar() {
fmt.Printf("Olá, eu sou %s e tenho %d anos.\n", p.Nome,
p.Idade)
}
func main() {
// Criando uma instância da 'Pessoa'
 pessoa := Pessoa{Nome: "Alice", Idade: 30}
// Chamando o método 'Apresentar'
pessoa.Apresentar()
}

Neste exemplo, Pessoa é um tipo, e Apresentar é um método

associado a esse tipo.

Encapsulamento em Go
Go não possui modificadores de acesso tradicionais
como public, private ou protected. No entanto, podemos usar
convenções para alcançar o encapsulamento. Vamos modificar
nosso exemplo:
package main

import "fmt"
// Definindo um tipo 'Pessoa'
type Pessoa struct {
nome string // tornamos minúsculo para indicar que é
"privado"
idade int
}
// Adicionando um método 'SetNome' para modificar o campo 'nome'
func (p *Pessoa) SetNome(novoNome string) {
p.nome = novoNome
}
// Adicionando um método 'Apresentar' para acessar o campo 'nome'
func (p Pessoa) Apresentar() {
fmt.Printf("Olá, eu sou %s e tenho %d anos.\n", p.nome,
p.idade)
}
func main() {
pessoa := Pessoa{nome: "Alice", idade: 30}
// Chamando o método 'Apresentar'
pessoa.Apresentar()
// Modificando o nome usando o método 'SetNome'
pessoa.SetNome("Bob")
// Chamando novamente o método 'Apresentar'
pessoa.Apresentar()
}

Neste exemplo, nome é "privado" porque começamos com letra

minúscula. O método SetNome permite modificar esse campo,
enquanto o método Apresentar permite acessá-lo.
Herança e Polimorfismo
Go não possui herança clássica, mas podemos usar
composição para alcançar um comportamento semelhante.
Além disso, o polimorfismo é alcançado implicitamente
através da interface em Go.
Composição e Herança “Light”

package main

import "fmt"
// Definindo um tipo 'Animal'
type Animal struct {
Nome string
}
// Definindo um método 'FazerBarulho' para 'Animal'
func (a Animal) FazerBarulho() {
fmt.Println("Barulho genérico de animal.")
}
// Definindo um tipo 'Cachorro' que "herda" de 'Animal'
type Cachorro struct {
Animal // Composição
}
// Sobrescrevendo o método 'FazerBarulho' para 'Cachorro'
func (c Cachorro) FazerBarulho() {
fmt.Println("Au au!")
}
func main() {
cachorro := Cachorro{Animal: Animal{Nome: "Rex"}}
// Chamando o método 'FazerBarulho' do 'Cachorro'
cachorro.FazerBarulho()
// Chamando o método 'FazerBarulho' do 'Animal' (herança
"light")
cachorro.Animal.FazerBarulho()
}

Neste exemplo, Cachorro possui um campo Animal, alcançando a

composição. Podemos acessar os métodos
de Animal diretamente de uma instância de Cachorro.
Polimorfismo com Interfaces

package main

import "fmt"
// Definindo uma interface 'SerVivo' com um método 'Som'
type SerVivo interface {
Som() string
}
// Implementando 'SerVivo' para 'Cachorro'
type Cachorro struct{}
func (c Cachorro) Som() string {
return "Au au!"
}
// Implementando 'SerVivo' para 'Gato'
type Gato struct{}
func (g Gato) Som() string {
return "Miau!"
}
// Função que aceita qualquer coisa que implemente 'SerVivo'
func EmitirSom(s SerVivo) {
fmt.Println(s.Som())
}
func main() {
cachorro := Cachorro{}
 gato := Gato{}
// Chamando a função 'EmitirSom' com diferentes tipos
EmitirSom(cachorro)
EmitirSom(gato)
}

Neste exemplo, SerVivo é uma interface que define um

método Som. Ambos Cachorro e Gato implementam esta
interface, permitindo que sejam tratados polimorficamente.
Conclusão
Embora Go não siga o modelo clássico de POO encontrado em
outras linguagens, ele fornece mecanismos para alcançar os
princípios fundamentais da POO, como encapsulamento,
herança e polimorfismo. A abordagem única de Go enfatiza a
simplicidade e a eficiência. Ao compreender os conceitos
apresentados neste artigo, você estará pronto para aplicar a
POO de maneira eficaz em seus projetos Go.

Até á próxima!