Como implementar conceitos de programação orientada a objetos em Go

A Programação Orientada a Objetos (POO) é um paradigma de programação baseado em objetos como conceito central. Na OOP, o código é formatado com base na funcionalidade, permitindo a manutenção do código, abstração, reutilização, eficiência e inúmeras funcionalidades no objeto.

O objeto possui atributos (variáveis) que definem suas características, propriedades e métodos (funções) que definem as ações (procedimentos) e comportamentos do objeto.

A programação orientada a objetos em Go é diferente de outras linguagens. Os conceitos orientados a objetos são implementados em Go usando estruturas, interfaces e tipos personalizados.

Personalizando tipos em Go

Os tipos personalizados facilitam o agrupamento e a identificação de códigos semelhantes para reutilização.

O código para declarar tipos personalizados é:

tipo typeName dataType 

Ao criar um tipo personalizado e atribuir uma variável, você pode verificar o tipo usando refletir. Tipo de() que recebe uma variável e retorna o tipo da variável.

importar





instagram viewer
( "fm"
 "refletir")
tipo dois int// cria o tipo "dois"
var número dois // variável do tipo "dois"
fmt. Println (refletir. TypeOf (número))

​​​

o número variável é um tipo de dois que é um número inteiro. Você pode ir além para criar mais do tipo personalizado.

Criando estruturas em Go

Structs (estruturas) são os blueprints para programação orientada a objetos em Go. Estruturas são coleções de campos definidas pelo usuário.

Uma estrutura pode conter uma variedade de tipos de dados, incluindo tipos e métodos compostos.

Você pode criar uma estrutura usando esta sintaxe:

tipo Nome da estrutura estrutura {
// algum código
}

Convencionalmente, os nomes de struct são geralmente em maiúsculas e em camel case para facilitar a leitura.

O tipo struct aceita nomes de campo e tipos de dados. Os structs podem receber qualquer tipo de dados Go, incluindo tipos personalizados.

tipo Do utilizador estrutura {
 campo1 fragmento
 campo2 int
 fieldMap mapa[fragmento]int
}

Você pode instanciar um tipo de estrutura atribuindo a estrutura como uma variável.

instância := Usuário{
// algum código
}

A instância struct pode ser preenchida com campos na instanciação conforme definido na inicialização ou definido como nulo.

instância := Usuário{
 campo1: "um fragmento campo",
 campo2: 10,
 campoMapa: mapa[fragmento]int{},
 }

Acessando elementos estruturais

Você pode acessar os campos de uma instância de struct usando uma notação de ponto no campo.

fmt. Println("Acessando um campo de valor", instance.field2)

Isso produz o campo2 da instância struct instanciada.

Atribuindo métodos a estruturas

Funções (métodos) são atribuídas a tipos de estrutura especificando um nome de receptor e o nome de estrutura antes do nome da função, conforme mostrado na sintaxe abaixo.

função(Receptor Nome da Estrutura)nome da função() {
// algum código
}

O método nome da função só pode ser usado no tipo de estrutura especificado.

Implementando a herança em Go

A herança é a capacidade de objetos e tipos de acessar e usar métodos e atributos de outros objetos. Go não tem Herança como recurso, mas você pode usar composições. Em Go, a composição envolve a referência a uma superestrutura (a estrutura a ser herdada) em uma subestrutura, fornecendo o nome da superestrutura à subestrutura.

Usando o exemplo de estrutura acima:

tipo Do utilizador estrutura {
 campo1 fragmento
 campo2 int
 fieldMap mapa[fragmento]int
}
tipo Usuário2 estrutura {
 Do utilizador
}

Ao passar o Do utilizador nome da estrutura no Usuário2 estrutura, o Usuário2 struct pode acessar todos os métodos e atributos do Do utilizador struct na instanciação, exceto que as técnicas de abstração são empregadas.

filho := Usuário2{
 Do utilizador{
 campo1: "bebê",
 campo2: 0,
 campoMapa: nada,
 },
 }
fmt. Println (filho.campo2)

o filho A variável acima é uma instanciação da Usuário2 estrutura. Como visto no exemplo, o filho variável pode acessar e instanciar valores do tipo User e usá-los.

Encapsulando campos de tipo em Go

O encapsulamento, também conhecido como “ocultação de informações”, é uma técnica de agrupar os métodos e atributos de um objeto em unidades para restringir o uso e o acesso, exceto especificado (habilitando privilégios de leitura/gravação).

O encapsulamento é implementado em Go usando identificadores exportados e não exportados em pacotes.

Identificadores exportados (leitura e gravação)

Os identificadores exportados são exportados de seus pacotes definidos e acesso a outros programas. Capitalizar um identificador de campo exporta o campo fo.

tipo Do utilizador estrutura {
 Campo1 fragmento
 Campo2 int
 FieldMap mapa[fragmento]int
}
tipo Usuário2 estrutura {
 Do utilizador
}

Identificadores não exportados (somente leitura)

Os identificadores não exportados não são exportados do pacote definido e são convencionalmente em minúsculas.

tipo Do utilizador estrutura {
 campo1 fragmento
 campo2 int
 fieldMap mapa[fragmento]int
}
tipo Usuário2 estrutura {
 Do utilizador
}

O conceito de identificadores exportados e não exportados também se aplica aos métodos de um objeto.

Polimorfismo em Go

O polimorfismo é uma técnica usada para dar formas diferentes a um objeto para flexibilidade.

Go implementa polimorfismo usando interfaces. Interfaces são tipos personalizados usados ​​para definir assinaturas de métodos.

Declarando Interfaces

Declarar interfaces é semelhante a declarar estruturas. No entanto, as interfaces são declaradas usando o interface palavra-chave.

tipo Nome da interface interface{
// alguns métodos
}

As declarações de interface contêm métodos que devem ser implementados por tipos de estrutura.

Implementando interfaces em estruturas

Os tipos que implementam a interface devem ser declarados, após o que os métodos do tipo implementam a interface.

// A interface
tipo Cor interface{
 Pintar() fragmento
}
// Declarando as estruturas
tipo Verde estrutura {
// algum código específico de struct
}
tipo Azul estrutura {
// algum código específico
}

O trecho de código acima tem um Cor interface declarada com um Pintar método a ser implementado pelo Verde e Azul tipos de estrutura.

As interfaces são implementadas atribuindo métodos a tipos de estrutura e, em seguida, nomeando o método pelo método de interface a ser implementado.

função(g Verde)Pintar()fragmento {
Retorna "pintado de verde"
}
função(b Azul)Pintar()fragmento {
Retorna "pintado de azul"
}

O método Paint é implementado pelos tipos Green e Blue que agora podem chamar e usar o Pintar método.

pincel := Verde{}
fmt. Println (pincel. Pintar())

“Pintado de verde” é impresso no console, validando que a interface foi implementada com sucesso.

Abstraindo campos em Go

A abstração é o processo de ocultar métodos e atributos sem importância de um tipo, tornando mais fácil proteger partes do programa contra uso anormal e não intencional.

Go não tem abstração implementada logo de cara; no entanto, você pode trabalhar nosso caminho através da implementação de abstração usando interfaces.

// humanos podem correr
tipo Humano interface {
 correr() fragmento
}
// Menino é um humano com pernas
tipo Garoto estrutura {
 Pernas fragmento
}
// um método em boy implementa o método run da interface Human
função(h Menino)correr()fragmento {
Retorna h. Pernas
}

O código acima cria um Humano interface com um correr interface que retorna uma string. o Garoto tipo implementa o correr método do Humano interface e retorna uma string na instanciação.

Uma das maneiras de implementar a abstração é fazendo com que uma struct herde a interface cujos métodos devem ser abstraídos. Existem muitas outras abordagens, mas esta é a mais fácil.

tipo Pessoa estrutura {
 Nome fragmento
 Idade int
 Status Humano 
}
funçãoa Principal() {
 pessoa1 := &Menino{Pernas: "duas pernas"}
 pessoa2 := &Pessoa{ // instância de uma pessoa
 Nome: "amina",
 Idade: 19,
 Status: pessoa1,
 }
 fmt. Println (pessoa. Status.run()) 
}

o Pessoa struct herda o Humano interface e pode acessar todos os seus métodos usando a variável Status herdar a interface.

Na instanciação por referência (usando um ponteiro), a instância do Pessoa estrutura Pessoa2 referencia uma instância do Garoto estrutura Pessoa1 e obtém acesso aos métodos.

Dessa forma, você pode especificar métodos específicos a serem implementados pelo tipo.

POO vs Programação Funcional

A programação orientada a objetos é um paradigma importante, pois oferece mais controle sobre seu programa e incentiva a reutilização de código de maneiras que a programação funcional não permite.

Isso não torna a programação funcional uma má escolha, pois a programação funcional pode ser útil e melhor para alguns casos de uso.

O que é programação orientada a objetos? O básico explicado em termos de leigo

Leia a seguir

Sobre o autor