Programação Orientada a Objetos: Abstração
Tags: programming, braziliandevs, poo
Published: 2024-06-13 20:36:03

---
title: "Programação Orientada a Objetos: Abstração"
published: true
description: Abstração
series: Programação Orientada a Objetos
tags: programming, braziliandevs, poo
cover_image: https://i.ibb.co/m69Qnf6/Screenshot-2024-06-26-at-21-39-20.png
---

# Abstração

Em ciência da computação, abstração é a habilidade de se concentrar nos aspectos essenciais de um contexto, ignorando características menos importantes ou acidentais. Em programação orientada a objetos, uma classe é uma abstração de entidades existentes no contexto de uma aplicação. Como exemplo, uma classe Usuario pode representar um usuário de um sistema que pode se dividir em subclasses como UsuarioAdministrador, UsuarioComum, UsuarioVisitante, etc.

## Principais Conceitos

Uma classe abstrada é criada para representar entidades e conceitos abstratos. A classe abstrata é sempre uma "Super classe" que não possui instâncias, que implementa métodos que são de uso comum a todas as subclasses. As subclasses são classes que herdam os métodos e atributos da classe abstrata, podendo implementar métodos específicos.

## Como funciona em Go

Em Go, não existe o conceito de classes, mas podemos alcançar a abstração por meio de interfaces. Uma interface é um tipo abstrato que define um conjunto de métodos que um tipo deve possuir. Em Go, a implementação das interfaces é implícita, o que significa que qualquer tipo que tenha os métodos exigidos por uma interface automaticamente a implementa, sem a necessidade de uma declaração explícita. Isso permite que um tipo concreto seja tratado como uma interface, sem a necessidade de conhecer a implementação específica do tipo.

```go
package usuario

type Usuario interface {
    Nome() string
    Email() string
}
```

```go
package usuario

// Struct que representa um usuário administrador
type UsuarioAdministrador struct {
	nome  string
	email string
}

// Método que retorna o nome do usuário administrador
func (ua UsuarioAdministrador) Nome() string {
	return ua.nome
}

// Método que retorna o email do usuário administrador
func (ua UsuarioAdministrador) Email() string {
	return ua.email
}

// Função que registra um usuário administrador
func RegistraUsuarioAdministrador(nome, email string) Usuario {
	return UsuarioAdministrador{nome, email}
}
```

```go
package usuario

// Struct que representa um usuário comum
type UsuarioComum struct {
	nome  string
	email string
}

// Método que retorna o nome do usuário comum
func (uc UsuarioComum) Nome() string {
	return uc.nome
}

// Método que retorna o email do usuário comum
func (uc UsuarioComum) Email() string {
	return uc.email
}

// Função que registra um usuário comum
func RegistraUsuarioComum(nome, email string) Usuario {
	return UsuarioComum{nome, email}
}
```

```go
package usuario

import "fmt"

// PrintUsuarioComum imprime os dados de um usuario
func PrintUsuario(u Usuario) {
	fmt.Printf("Nome: %s, Email: %s\n", u.Nome(), u.Email())
}
```

```go
package main

import "abstracao/usuario"

func main() {
	// Registra um usuário comum
	usuario_comum := usuario.RegistraUsuarioComum("Usuario Commum", "usuario_comum@email.com")

	// Registra um usuário administrador
	usuario_administrador := usuario.RegistraUsuarioAdministrador("Usuario Administrador", "usuario_administrador@email.com")

	// Imprime os dados dos usuários
	usuario.PrintUsuario(usuario_comum)
	usuario.PrintUsuario(usuario_administrador)
}
```

```shell
abstracao ➜ go run main.go
Nome: Usuario Commum, Email: usuario_comum@email.com
Nome: Usuario Administrador, Email: usuario_administrador@email.com
```

Neste exemplo, temos uma interface `Usuario` que define os métodos `Nome` e `Email`. As structs `UsuarioAdministrador` e `UsuarioComum` implementam a `interface Usuario`, fornecendo suas próprias versões dos métodos `Nome` e `Email`. As funções `RegistraUsuarioAdministrador` e `RegistraUsuarioComum` são responsáveis por criar instâncias de `UsuarioAdministrador` e `UsuarioComum`, respectivamente. No arquivo `main.go`, instanciamos objetos de `UsuarioAdministrador` e `UsuarioComum`, e chamamos os métodos Nome e Email de cada um para demonstrar a implementação da interface.

# Conclusão

A abstração é fundamental no design de software, permitindo a definição de contratos de comportamento independentes das implementações específicas. Em Go, embora não existam classes como nas linguagens orientadas a objetos tradicionais, a abstração é alcançada eficientemente através de interfaces. Interfaces permitem a criação de tipos que aderem a um conjunto de métodos, promovendo flexibilidade e reutilização de código. Ao separar a definição de comportamento da implementação concreta, interfaces simplificam a manutenção de sistemas complexos e permitem que novos tipos possam ser integrados com facilidade, melhorando a modularidade e a extensibilidade do código.

# Projeto

[Github](https://github.com/fabianoflorentino/poo/tree/main/abstracao)


# Referências

- [Wikipedia](https://pt.wikipedia.org/wiki/Abstração_(ciência_da_computação))
- [Stack Overflow](https://pt.stackoverflow.com/questions/23103/o-que-é-abstração)
- [Effective Go](https://go.dev/doc/effective_go#interfaces)
- [Go by Example](https://gobyexample.com/interfaces)
- [Aprenda Golang](https://aprendagolang.com.br/trabalhando-com-interfaces/)
```