Cómo implementar conceptos de programación orientada a objetos en Go

La Programación Orientada a Objetos (POO) es un paradigma de programación basado en objetos como concepto central. En OOP, el código se formatea en función de la funcionalidad, lo que permite el mantenimiento del código, la abstracción, la reutilización, la eficiencia y numerosas funcionalidades en el objeto.

El objeto tiene atributos (variables) que definen sus características, propiedades y métodos (funciones) que definen las acciones (procedimientos) y comportamientos del objeto.

La programación orientada a objetos en Go es diferente de otros lenguajes. Los conceptos orientados a objetos se implementan en Go mediante estructuras, interfaces y tipos personalizados.

Personalización de tipos en Go

Los tipos personalizados facilitan la agrupación e identificación de códigos similares para su reutilización.

El código para declarar tipos personalizados es:

tipo tipoNombre tipo de datos 

Al crear un tipo personalizado y asignar una variable, puede verificar el tipo usando reflejar. Tipo de() que toma una variable y devuelve el tipo de la variable.

importar( "fmt"
 "reflejar")
tipo dos En t// crea el tipo "dos"
variable número dos // variable de tipo "dos"
fmt. Imprimir (reflejar. TipoDe (número))

​​​

Él número variable es un tipo de dos que es un número entero. Puede ir más allá para crear más del tipo personalizado.

Creación de estructuras en Go

Las estructuras (estructuras) son los planos para la programación orientada a objetos en Go. Las estructuras son colecciones de campos definidas por el usuario.

Una estructura puede contener una variedad de tipos de datos, incluidos tipos y métodos compuestos.

Puede crear una estructura usando esta sintaxis:

tipo NombreEstructura estructura {
// algún código
}

Convencionalmente, los nombres de las estructuras suelen estar en mayúsculas y en mayúsculas para facilitar la lectura.

El tipo de estructura toma nombres de campo y tipos de datos. Las estructuras pueden admitir cualquier tipo de datos de Go, incluidos los tipos personalizados.

tipo Usuario estructura {
 campo1 cuerda
 campo2 En t
 mapa de campo mapa[cuerda]En t
}

Puede crear instancias de un tipo de estructura asignando la estructura como una variable.

instancia := Usuario{
// algún código
}

La instancia de estructura se puede completar con campos en la creación de instancias como se define en la inicialización o se puede establecer en nulo.

instancia := Usuario{
 campo1: "un cuerda campo",
 campo2: 10,
 mapa de campo: mapa[cuerda]En t{},
 }

Acceso a elementos de estructura

Puede acceder a los campos de una instancia de estructura utilizando una notación de puntos para el campo.

fmt. Println("Accediendo a un campo de valor", instancia.campo2)

Esto genera el campo2 de la instancia de estructura instanciada.

Asignación de métodos a estructuras

Las funciones (métodos) se asignan a los tipos de estructuras especificando un nombre de receptor y el nombre de la estructura antes del nombre de la función, como se muestra en la siguiente sintaxis.

función(nombre de estructura del receptor)nombre de la función() {
// algún código
}

El método nombre de la función solo se puede usar en el tipo de estructura especificado.

Implementando herencia en Go

La herencia es la capacidad de los objetos y tipos para acceder y utilizar métodos y atributos de otros objetos. Go no tiene Herencia como característica, pero puede usar composiciones. En Go, la composición implica hacer referencia a una superestructura (la estructura que se heredará) en una subestructura proporcionando el nombre de la superestructura a la subestructura.

Usando el ejemplo de estructura anterior:

tipo Usuario estructura {
 campo1 cuerda
 campo2 En t
 mapa de campo mapa[cuerda]En t
}
tipo Usuario2 estructura {
 Usuario
}

Al pasar el Usuario nombre de estructura en el Usuario2 estructura, la Usuario2 struct puede acceder a todos los métodos y atributos del Usuario estructura en la creación de instancias, excepto que se emplean técnicas de abstracción.

hijo := Usuario2{
 Usuario{
 campo1: "bebé",
 campo2: 0,
 mapa de campo: nulo,
 },
 }
fmt. Println (hijo.field2)

Él hijo La variable anterior es una instanciación de la Usuario2 estructura Como se ve en el ejemplo, el hijo variable puede acceder e instanciar valores del tipo Usuario y usarlos.

Encapsular campos de tipo en Go

La encapsulación, también conocida como “ocultación de información”, es una técnica de agrupar los métodos y atributos de un objeto en unidades para restringir el uso y acceso excepto especificado (habilitando privilegios de lectura/escritura).

La encapsulación se implementa en Go usando identificadores exportados y no exportados en paquetes.

Identificadores exportados (lectura y escritura)

Los identificadores exportados se exportan desde sus paquetes definidos y acceden a otros programas. Poner en mayúscula un identificador de campo exporta el campo fo.

tipo Usuario estructura {
 Campo1 cuerda
 Campo2 En t
 Mapa de campo mapa[cuerda]En t
}
tipo Usuario2 estructura {
 Usuario
}

Identificadores no exportados (solo lectura)

Los identificadores no exportados no se exportan del paquete definido y normalmente se escriben en minúsculas.

tipo Usuario estructura {
 campo1 cuerda
 campo2 En t
 mapa de campo mapa[cuerda]En t
}
tipo Usuario2 estructura {
 Usuario
}

El concepto de identificadores exportados y no exportados también se aplica a los métodos de un objeto.

Polimorfismo en Go

El polimorfismo es una técnica utilizada para dar diferentes formas a un objeto para la flexibilidad.

Go implementa polimorfismo usando interfaces. Las interfaces son tipos personalizados que se utilizan para definir firmas de métodos.

Declaración de interfaces

Declarar interfaces es similar a declarar estructuras. Sin embargo, las interfaces se declaran utilizando el interfaz palabra clave.

tipo Nombre de la interfaz interfaz{
// algunos métodos
}

Las declaraciones de interfaz contienen métodos que deben implementarse mediante tipos de estructuras.

Implementación de interfaces en estructuras

Los tipos que implementan la interfaz deben declararse, después de lo cual los métodos del tipo implementan la interfaz.

// La interfaz
tipo Color interfaz{
 Pintura() cuerda
}
// Declarando las estructuras
tipo Verde estructura {
// algún código específico de estructura
}
tipo Azul estructura {
// algun codigo especifico
}

El fragmento de código anterior tiene un Color interfaz declarada con un Pintura método que implementará el Verde y Azul tipos de estructuras.

Las interfaces se implementan asignando métodos a tipos de estructura y luego nombrando el método por el método de interfaz que se implementará.

función(g verde)Pintura()cuerda {
devolver "pintado de verde"
}
función(b Azul)Pintura()cuerda {
devolver "pintado de azul"
}

El método Paint está implementado por los tipos Green y Blue que ahora pueden llamar y usar el Pintura método.

pincel := Verde{}
fmt. Imprimir (pincel. Pintura())

Se imprime "Pintado de verde" en la consola que valida que la interfaz se implementó con éxito.

Abstracción de campos en Go

La abstracción es el proceso de ocultar métodos y atributos sin importancia de un tipo, lo que facilita la protección de partes del programa contra un uso anormal o no intencionado.

Go no tiene la abstracción implementada desde el principio; sin embargo, puede trabajar implementando la abstracción usando interfaces.

// los humanos pueden correr
tipo Humano interfaz {
 correr() cuerda
}
// El niño es un humano con piernas.
tipo Chico estructura {
 Piernas cuerda
}
// un método en boy implementa el método run de la interfaz Human
función(niño)correr()cuerda {
devolver H. Piernas
}

El código anterior crea un Humano interfaz con un correr interfaz que devuelve una cadena. Él Chico tipo implementa el correr metodo de la Humano interfaz y devuelve una cadena en la creación de instancias.

Una de las formas de implementar la abstracción es hacer que una estructura herede la interfaz cuyos métodos se van a abstraer. Hay muchos otros enfoques, pero este es el más fácil.

tipo Persona estructura {
 Nombre cuerda
 Edad En t
 Estado Humano 
}
funciónprincipal() {
 persona1 := &Niño{Piernas: "dos piernas"}
 persona2 := &Persona{ // instancia de una persona
 Nombre: "amina",
 Edad: 19,
 Estado: persona1,
 }
 fmt. Println (persona. Estado.ejecutar()) 
}

Él Persona struct hereda el Humano interfaz y puede acceder a todos sus métodos usando la variable Estado heredar la interfaz.

En la instanciación por referencia (usando un puntero), la instancia del Persona estructura Persona2 hace referencia a una instancia de la Chico estructura Persona1 y obtiene acceso a los métodos.

De esta manera, puede especificar métodos específicos para ser implementados por el tipo.

OOP vs Programación Funcional

La programación orientada a objetos es un paradigma importante, ya que le brinda más control de su programa y fomenta la reutilización del código de una manera que no lo hace la programación funcional.

Esto no hace que la programación funcional sea una mala elección, ya que la programación funcional puede ser útil y mejor para algunos casos de uso.

¿Qué es la programación orientada a objetos? Los conceptos básicos explicados en términos sencillos

Leer siguiente

Sobre el Autor