Programación - 04 Programación Orientada a Objetos. 1DAM. Curso 2022-2023

Overview

Programación - 04 Programación Orientada a Objetos

Tema 04 Programación Orientada a Objetos. 1DAM. Curso 2022/2023.

imagen

Contenidos

  1. Programación Orientada a Objetos
  2. Objetos
  3. Clases
  4. Instanciación de objetos
  5. Propiedades y métodos
  6. Constructores
  7. Referencia this
  8. Getters y Setters
  9. Igualdad e identidad
  10. POJOS y POKOS. Data classes
  11. Atributos y métodos de clase
  12. Composición de objetos
  13. Enums Class

Programación Orientada a Objetos

La programación orientada a objetos es un paradigma de programación que se basa en el concepto de objetos, los cuales contienen información en forma de campos (a veces también referidos como atributos o propiedades) y código en forma de métodos.

Los objetos son capaces de interactuar y modificar los valores contenidos en sus campos o atributos (estado) a través de sus métodos (comportamiento) y siempre tienen una identidad.

Algunas características clave de la programación orientada a objetos son herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.

Objetos

Un objeto es una entidad que tiene un estado y un comportamiento. El estado de un objeto es almacenado en campos (atributos) y el comportamiento es mostrado por métodos (funciones) y tienen una identidad. En lenguajes tipados, un objeto es una instancia de una clase (nos sirve para tipar).

  • Objetos: unidad que engloba dentro de sí un conjunto de datos y módulos necesarios para el tratamiento de esos datos. Cada objeto contiene datos y funciones.
  • Atributos: Son los datos incluidos en el objeto. Parecidas a las variables de C clásico pero incluidas en los objetos.
  • Métodos: Son módulos que pertenecen a los objetos y que manejarán los atributos.
  • Identidad: Cada objeto tiene una identidad única que lo distingue de los demás objetos. La identidad de un objeto no puede ser cambiada durante la ejecución del programa.
  • Mensajes: El modo mediante el que se comunican los objetos. Consiste en llamar a un método de un objeto.
  • Interfaz: Las clases (y, por lo tanto, los objetos) tienen partes públicas y partes privadas. La parte pública es visible para todos los objetos, mientras que la parte privada es sólo visible para el propio objeto. A la parte pública de un objeto se le denomina interfaz.
// Llamando a un objeto
val persona = Persona()
persona.nombre = "José Luis"
persona.apellidos = "González Sánchez"
persona.programar(lenguaje= "Kotlin")

Clases

Una clase es un modelo o plantilla para crear objetos. Una clase define los campos y los métodos de un objeto. Un objeto es una instancia de una clase. La clase nos va a servir para tipar los objetos.

// Definiendo una clase
class Persona {
    // Estado del objeto
    var nombre: String = ""
    var apellidos: String = ""

    // Comportamiento del objeto
    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }
}

Instanciación de Objetos

La instanciación de objetos es el proceso de crear un objeto a partir de una clase. La instanciación de objetos se realiza mediante la palabra reservada new (Java), o llamando a su constructor (Kotlin).

A los miembros de un objeto se accede a través de su referencia. La sintaxis es: nombre_referencia.miembro

// Instanciando un objeto
val persona = Persona()
persona.nombre = "José Luis"
persona.programar(lenguaje= "Kotlin")

Propiedades y métodos

Los atributos definen el estado de un objeto. Las propiedades se definen en la clase y representan los atributos del estado y se acceden a través de la referencia del objeto.

Los métodos definen el comportamiento de un objeto. Los métodos se definen en la clase y representan las acciones del comportamiento y se acceden a través de la referencia del objeto.

Podemos tener propiedades y métodos públicos, privados y protegidos. Por defecto, las propiedades y métodos son públicos. Si son privados, sólo pueden ser accedidos desde la propia clase. Si son protegidos, sólo pueden ser accedidos desde la propia clase y sus subclases. De esta manera podemos encapsular y ocultar la información y acciones que deseemos.

// Definiendo una clase
class Persona {
    var nombre: String = ""
    var apellidos: String = ""
    private var experiencia: Int = 99

    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }
    private fun dormir() {
        println("Durmiendo...")
    }
}

// Instanciando un objeto
val persona = Persona()
persona.nombre = "José Luis"
persona.programar(lenguaje= "Kotlin")
// No puedo acceder a lo privados de la clase

Constructores

Los constructores son métodos especiales que se utilizan para inicializar los objetos. Los constructores se definen en la clase y se ejecutan al instanciar un objeto. Los constructores pueden tener parámetros y pueden ser sobrecargados.

En Kotlin existe un constructor primario y uno secundario. El constructor primario se define en la cabecera de la clase y el secundario se define en el cuerpo de la clase. El constructor primario no puede tener código, pero el secundario sí. Si no se define ningún constructor, se crea un constructor primario vacío.

Inicializador de instancia: es un bloque de código que se ejecuta al instanciar un objeto. Se define en el cuerpo de la clase y se ejecuta antes del constructor secundario.

// Definiendo una clase con constructor primario
class Persona(nombre: String, apellidos: String, experiencia: Int = 0) {
    var nombre: String = ""
    var apellidos: String = ""

    private val experiencia: Int = 99
    private val nivel: Int = 0

    // Constructor secuendario 
    constructor(nombre: String, apellidos: String, experiencia: Int = 0, nivel: Int = 0) : this(nombre, apellidos, experiencia) {
        this.nivel = nivel
    }
    init {
        println("Inicializando instancia")
    }
    
    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }

    private fun dormir() {
        println("Durmiendo...")
    }
}

Referencia this

La referencia this es una referencia al objeto actual. Se utiliza para acceder a los miembros de la clase. Si no se utiliza la referencia this, se accede a los miembros de la clase.

// Definiendo una clase con constructor primario
class Persona(nombre: String, apellidos: String, experiencia: Int = 0) {
    var nombre: String = ""
    var apellidos: String = ""

    private val experiencia: Int = 99
    private val nivel: Int = 0

    // Constructor secuendario, utilizando la referencia this para llamar al constructor primario
    // y acceder a los miembros de la clase y no a los parámetros del constructor
    constructor(nombre: String, apellidos: String, experiencia: Int = 0, nivel: Int = 0) : this(nombre, apellidos, experiencia) {
        this.nivel = nivel
    }
    init {
        println("Inicializando instancia")
    }
    
    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }

    private fun dormir() {
        println("Durmiendo...")
    }
    
    // usamos la referencia this para acceder a los miembros de la clase y no a los parámetros
    fun setExperiencia(experiencia: Int) {
        this.experiencia = experiencia
    }
}

Getters y Setters

Los getters y setters son métodos especiales que se utilizan para acceder/cambiar a los atributos de un objeto. Los getters y setters se definen en la clase y se acceden a través de la referencia del objeto.

// Definiendo una clase con getters y setters
class Persona {
    var nombre: String = ""
    var apellidos: String = ""
    private var experiencia: Int = 99

    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }
    private fun dormir() {
        println("Durmiendo...")
    }
    
    // Getter
    fun getExperiencia(): Int {
        return experiencia
    }
    // Setter
    fun setExperiencia(experiencia: Int) {
        this.experiencia = experiencia
    }
}

En Kotlin podemos definir getters y setters de forma automática. Para ello, debemos definir los atributos con la palabra reservada var. Si definimos los atributos con la palabra reservada val, sólo se creará el getter.

Podemos crear campos calculados, es decir, campos que no se almacenan en memoria, sino que se calculan a partir de otros campos. Para ello, debemos definir el campo con la palabra reservada val y no con var.

También podemos cambiar como se almacenan los atributos en memoria. Por ejemplo, podemos almacenarlos en minúsculas o en mayúsculas. Para ello, debemos definir el getter y el setter de forma manual.

// Clase con getters y setters automáticos
class Persona {
    var nombre: String = ""
    var apellidos: String = ""
    private var experiencia: Int = 99

    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }
    private fun dormir() {
        println("Durmiendo...")
    }
    
    // Campos calculados
    val nombreCompleto: String
        get() = "$nombre $apellidos"

    // Campos con almacenamiento personalizado
    var experiencia: Int = 99
        get() = field
        set(value) {
            if (value > 0) {
                field = value
            } else {
                field = 0
            }
        }
}

Igualdad e identidad

En Kotlin, para comparar objetos, debemos utilizar el operador ==. Este operador compara el contenido de los objetos (estado). Realmente ejecuta el método equals. Si queremos comparar la identidad de los objetos, debemos utilizar el operador ===. Este operador compara la referencia de los objetos (identidad).

En Java el operador == compara la identidad de los objetos. Para comparar el contenido de los objetos, debemos utilizar el método equals.

// Clase Persona
class Persona {
    var nombre: String = ""
    var apellidos: String = ""
    private var experiencia: Int = 99

    fun programar(lenguaje: String) {
        println("Programando en $lenguaje")
    }
    private fun dormir() {
        println("Durmiendo...")
    }
    
    // Campos calculados
    val nombreCompleto: String
        get() = "$nombre $apellidos"

    // Campos con almacenamiento personalizado
    var experiencia: Int = 99
        get() = field
        set(value) {
            if (value > 0) {
                field = value
            } else {
                field = 0
            }
        }

        // Sobreescribimos el método equals, solo serán iguales si tienen el mismo nombre y apellidos
        override fun equals(other: Any?): Boolean {
            if (other == null || other !is Persona) {
                return false
            }
            return nombre == other.nombre && apellidos == other.apellidos
        }
}

// Comparar con equals
val persona1 = Persona()
persona1.nombre = "Juan"
persona1.apellidos = "Pérez"

val persona2 = Persona()
persona2.nombre = "Juan"
persona2.apellidos = "Pérez"

println(persona1 == persona2) // true
println(persona1.equals(persona2)) // true
println(persona1 === persona2) // false

// Comparar con ===
val persona3 = persona1
println(persona1 === persona3) // true

POJOS y POKOS. Data classes

Los POJOS (Plain Old Java Objects) son objetos simples que no tienen lógica de negocio en Java. Los POKOS (Plain Old Kotlin Objects) son objetos simples que no tienen lógica de negocio en Kotlin. En Kotlin, los POJOS y POKOS se definen como clases de datos. Para definir una clase de datos, debemos utilizar la palabra reservada data en Kotlin, en Java podremos usar los records.

Las data classes tienen los siguientes miembros:

  • Constructor primario con los parámetros que se pasan al constructor.
  • Propiedades deberían ser inmutables para cada parámetro del constructor primario.
  • Método equals: compara el contenido de los objetos.
  • Método hashCode: calcula el hash del objeto. Se utiliza para comparar objetos, pues dos objetos con el mismo hash son iguales.
  • Método toString: devuelve una cadena con el nombre de la clase y los valores de los atributos.

Si las propiedades de la data class son inmutables, se creará un getter para cada propiedad. Si las propiedades de la data class son mutables, se creará un getter y un setter para cada propiedad. Podemos hacer uso de copy para crear una copia de la data class variando las propiedades que nos interesen.

// Definiendo una clase de persona como data class
data class Persona(val nombre: String, val apellidos: String, var experiencia: Int)

val persona1 = Persona("Juan", "Pérez", 99)
println(persona1) // Persona(nombre=Juan, apellidos=Pérez, experiencia=99)
println(persona1.nombre) // Juan

val persona2 = persona1.copy(nombre = "Pepe")
println(persona2) // Persona(nombre=Pepe, apellidos=Pérez, experiencia=99)

val persona3 = persona1.copy()
println(persona3) // Persona(nombre=Juan, apellidos=Pérez, experiencia=99)

println(persona1 == persona2) // false
println(persona1 == persona3) // true
println(persona1 === persona2) // false
println(persona1 === persona3) // false
println(persona1.hashCode() == persona2.hasCode()) // false
println(persona1.hashCode() == persona3.hasCode()) // true

Los métodos equals, hashCode y toString se generan automáticamente. Si queremos sobreescribirlos, debemos hacerlo manualmente. Esto nos permite poder usarlos en cualquier clase, no solo en las data classes.

// Clase Persona, equivalente a la data class Persona
class Persona(val nombre: String, val apellidos: String, var experiencia: Int) {
    // Sobreescribimos el método equals, solo serán iguales si tienen el mismo nombre y apellidos
    override fun equals(other: Any?): Boolean {
        if (other == null || other !is Persona) {
            return false
        }
        return nombre == other.nombre && apellidos == other.apellidos
    }

    // Sobreescribimos el método hashCode, solo serán iguales si tienen el mismo nombre y apellidos
    override fun hashCode(): Int {
        return nombre.hashCode() + apellidos.hashCode()
    }

    // Sobreescribimos el método toString, solo serán iguales si tienen el mismo nombre y apellidos
    override fun toString(): String {
        return "Persona(nombre=$nombre, apellidos=$apellidos, experiencia=$experiencia)"
    }
}

Atributos y métodos de clase

Un atributo de clase es una variable miembro que no se asocia a un objeto (instancia) de una clase, sino que se asocia a la clase misma; no hay una copia del dato para cada objeto sino una sola copia que es compartida por todos los objetos de la clase. El acceso a las variables estáticas desde fuera de la clase donde se definen se realiza a través del nombre de la clase y no del nombre del objeto como sucede con las variables miembro normales (no estática).

Para los métodos, la idea es la misma que para los datos: los métodos de clase se asocian a una clase, no a una instancia. Los métodos de clase se pueden invocar sin necesidad de crear una instancia de la clase.

En Java podemos definir atributos y métodos estáticos con la palabra reservada static. En Kotlin, no existe la palabra reservada static, pero podemos definir atributos y métodos estáticos con la palabra reservada companion object. Los atributos y métodos de companion object se pueden acceder sin necesidad de crear una instancia de la clase.

class Persona(val nombre: String, val apellidos: String, var experiencia: Int) {
    val id = Persona.nextId()

    override toString(): String {
        return "Persona(id=$id, nombre=$nombre, apellidos=$apellidos, experiencia=$experiencia)"
    }

    // Definimos un companion object, es decir los atributos y metodos de clase
    companion object {
        var contador = 0
        private fun nextId() {
            return contador++
        }

        fun gritar() {
            println("¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡")
        }
    }
}

val persona1 = Persona("Juan", "Pérez", 99)
println(persona1) // Persona(id=1, nombre=Juan, apellidos=Pérez, experiencia=99)
val persona2 = Persona("Pepe", "García", 99)
println(persona2) // Persona(id=2, nombre=Pepe, apellidos=García, experiencia=99)
val persona3 = Persona("Ana", "García", 99)
println(persona3) // Persona(id=3, nombre=Ana, apellidos=García, experiencia=99)

Persona.gritar() // ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡

Composición de objetos

La composición de objetos es una forma de reutilizar código. Consiste en crear una clase que contenga como atributos objetos de otras clases. De esta forma, podemos reutilizar los métodos de las clases que componen la clase que estamos creando.

Si es una relación 1-1 asignamos el objeto como atributo de la clase. Si es una relación 1-N asignamos una colección de objetos como atributo de la clase.

// una persona tiene un coche
data class Coche(val marca: String, val modelo: String, val color: String)
data class Persona(val nombre: String, val apellidos: String, val coche: Coche)

// una persona tiene varios coches
data class Persona(val nombre: String, val apellidos: String, val coches: Array<Coche>)

Enums class

Los tipos enumerados son una forma de definir un conjunto de constantes. En Kotlin, los tipos enumerados se definen con la palabra reservada enum class. Los valores de un tipo enumerado se pueden acceder con el nombre de la clase y el nombre del valor separados por un punto. A veces es necesario acceder al valor de un tipo enumerado como un objeto, en ese caso podemos usar la función valueOf(). Por otro lado, podemos almacenar un valor en base a su constructor si lo definimos (solo en Kotlin).

// Enums colores
enum class Color {
    ROJO, VERDE, AZUL
}

// Accedemos a los valores del enum
println(Color.ROJO) // ROJO
println(Color.VERDE) // VERDE
println(Color.AZUL) // AZUL

// Accedemos a los valores del enum como objetos
println(Color.valueOf("ROJO")) // ROJO
println(Color.valueOf("VERDE")) // VERDE
println(Color.valueOf("AZUL")) // AZUL

// saber el orden de los valores del enum
println(Color.ROJO.ordinal) // 0
println(Color.VERDE.ordinal) // 1

// Obtener values del enum
val colores = Color.values()
println(colores) // [ROJO, VERDE, AZUL]

// Enums con constructor, solo en Kotlin
enum class Color(val rgb: Int) {
    ROJO(0xFF0000),
    VERDE(0x00FF00),
    AZUL(0x0000FF)
}

// Accedemos a los valores del enum
println(Color.ROJO) // ROJO
// Obtenemos el valor rgb
println(Color.ROJO.rgb) // 0xFF0000

Recursos

Autor

Codificado con 💖 por José Luis González Sánchez

Twitter GitHub

Contacto

Cualquier cosa que necesites házmelo saber por si puedo ayudarte 💬 .

              

¿Un café?

joseluisgs




Licencia de uso

Este repositorio y todo su contenido está licenciado bajo licencia Creative Commons, si desea saber más, vea la LICENSE. Por favor si compartes, usas o modificas este proyecto cita a su autor, y usa las mismas condiciones para su uso docente, formativo o educativo y no comercial.

Licencia de Creative Commons
JoseLuisGS by José Luis González Sánchez is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
Creado a partir de la obra en https://github.com/joseluisgs.

You might also like...
OO Boot Camp reference implementation for Jordanian client in Kotlin in January 2022

oo_boot_camp_2022-01-24_kotlin Copyright (c) 2022 by Fred George May be used fre

Clean Android multi-module offline-first scalable app in 2022. Including Jetpack Compose, MVI, Kotlin coroutines/Flow, Kotlin serialization, Hilt and Room.

Android Kotlin starter project - 2022 edition Android starter project, described precisely in this article. Purpose To show good practices using Kotli

A project to show the best way to build an Android app on 2022 (by me).
A project to show the best way to build an Android app on 2022 (by me).

Hello Architecture I create this project to show what's for me the best way to build an Android app on 2022. Architecture I use this diagram as and id

Programación - 02 Programación Estructurada y Modular. 1DAM. Curso 2022-2023
Programación - 02 Programación Estructurada y Modular. 1DAM. Curso 2022-2023

Programación - 02 Programación Estructurada y Modular Tema 02 Programación Estructurada y Modular. 1DAM. Curso 2022/2023. Programación - 02 Programaci

Prácticas en la cursada de programación orientada a objetos 2
Prácticas en la cursada de programación orientada a objetos 2

Países impostores Antes de empezar: algunos consejos El enunciado tiene mucha información, van a necesitar leerlo varias veces. La sugerencia es que l

Guía de supervivencia de Kotlin para 2º DAM. Curso 2022/2023
Guía de supervivencia de Kotlin para 2º DAM. Curso 2022/2023

Kotlin Supervivencia para 2º DAM Ejemplos de la supervivencia en Kotlin para 2º DAM. Curso 2022/2023. Kotlin Supervivencia para 2º DAM 1. Programación

Curso com conteúdo de algoritmos voltado a linguagem de programação Kotlin criado pela comunidade Kotlinautas

Curso de Algoritmos Kotlinautas Olá! Seja bem vindes ao curso de algoritmos da comunidade Kotlinautas. O objetivo desse curso é de oferecer um materia

Curso microservices kotlin micronaut
Curso microservices kotlin micronaut

Arquitetura de Microserviços Instruções Criando rede no docker: docker network create micronaut-net Criando imagem Postgresql no Docker: docker run -

Este é um projeto desenvolvido durante o curso de Desenvolvimento Android do professor Jamilton Damasceno na Udemy.

Pedra_Papel_Tesoura_App 📋 Índice Sobre Tecnologias utilizadas Preview 🖥 Preview 2021-10-16-18-42-09.mp4 📖 Sobre Este é um projeto desenvolvido dura

O projeto Calling-Therapies é um aplicativo em desenvolvimento para o Trabalho de Conclusão de Curso da faculdade.

Calling-Therapies 📔 Informações sobre o projeto O projeto Calling-Therapies é um aplicativo em desenvolvimento para o Trabalho de Conclusão de Curso

Primeiro aplicativo desenvolvido na linguagem kotlin, durante o Hackathon no curso de Android Kotlin da Cel.Lep em parceria com Estação Hack from Facebook
Primeiro aplicativo desenvolvido na linguagem kotlin, durante o Hackathon no curso de Android Kotlin da Cel.Lep em parceria com Estação Hack from Facebook

Tela Splash: Nome do aplicativo e uma imagem: Tela Main, principal tela do aplicativo: Um campo para o usuário informar a medida; Um spinner com os ti

Repositorio para el curso de Desarrollo Móvil 2021-15
Repositorio para el curso de Desarrollo Móvil 2021-15

Repositorio para el curso de Desarrollo Móvil 2021-15 Construir e instalar la aplicación Vinilos de forma local Clonar el repositorio Puede clonarlo a

Aqui você encontra os projetos Kotlin atualizados do curso do Professor Marco Maddo.

Fundamentos-da-Programacao-Kotlin-para-Leigos-IntelliJ Aqui você encontra os projetos Kotlin atualizados do curso do Professor Marco Maddo. Visite a p

Curso dos fundamentos da linguagem Kotlin disponibilizado pela TreinaWeb

💻 Kotlin Fundamentos 💻 Curso dos fundamentos da linguagem Kotlin disponibilizado pela TreinaWeb Tecnologias Usadas Kotlin Executando Clone o projeto

DogglersApp - Criação de um App para estudo de RecyclerView no Android Studio. Parte do curso Android Basics in Kotlin

Dogglers - Starter Code Starter code for the second independent project for Android Basics in Kotlin. Introduction This is the starter code for the Do

Repositorio com a finalidade de por em pratica todo o conhecimento das aulas do curso Kotlin e Spring do Zero ao avançado da udemy

kotlin-spring Repositorio com a finalidade de por em pratica todo o conhecimento das aulas do curso Kotlin e Spring do Zero ao avançado da udemy. Obse

Jugando con un Parking realizado como prueba de examen en JetBrains Academy, curso Kotlin Developer
Jugando con un Parking realizado como prueba de examen en JetBrains Academy, curso Kotlin Developer

Kotlin Parking Lot Proyecto de evaluación para el título de Kotlin Developer en Jetbrains Academy. Consiste en realizar un parking con las especificac

Projeto das aulas da disciplina de Programação Móvel da turma do 06˚ Periodo do curso de Sistemas de Informação - IFAL - campus Arapiraca.

Programação Móvel - Sistemas de Informação Projeto das aulas da disciplina de Programação Móvel da turma do 06˚ periodo de SI - IFAL - campus Arapirac

🗺 Android Developer Roadmap 2022 suggests learning paths to understanding Android development.
🗺 Android Developer Roadmap 2022 suggests learning paths to understanding Android development.

Android Developer Roadmap 2022 English | 한국어 Android Developer Roadmap 2022 suggests learning paths to understanding Android development. You can read

Owner
José Luis González Sánchez
PhD Software Development Profe de DAM/DAW/ASIR @IESLuisVives Kotlin Certified Trainer by @JetBrains @GitHub Campus Advisor @GitKraken Ambassador 💻🎾🎸🍻
José Luis González Sánchez
Prácticas en la cursada de programación orientada a objetos 2

Países impostores Antes de empezar: algunos consejos El enunciado tiene mucha información, van a necesitar leerlo varias veces. La sugerencia es que l

Esteban Barreto 0 Dec 7, 2021
Guía de supervivencia de Kotlin para 2º DAM. Curso 2022/2023

Kotlin Supervivencia para 2º DAM Ejemplos de la supervivencia en Kotlin para 2º DAM. Curso 2022/2023. Kotlin Supervivencia para 2º DAM 1. Programación

José Luis González Sánchez 27 Dec 28, 2022
Curso microservices kotlin micronaut

Arquitetura de Microserviços Instruções Criando rede no docker: docker network create micronaut-net Criando imagem Postgresql no Docker: docker run -

null 0 Oct 20, 2021
O projeto Calling-Therapies é um aplicativo em desenvolvimento para o Trabalho de Conclusão de Curso da faculdade.

Calling-Therapies ?? Informações sobre o projeto O projeto Calling-Therapies é um aplicativo em desenvolvimento para o Trabalho de Conclusão de Curso

Diego Silva 12 Mar 10, 2022
Repositorio para el curso de Desarrollo Móvil 2021-15

Repositorio para el curso de Desarrollo Móvil 2021-15 Construir e instalar la aplicación Vinilos de forma local Clonar el repositorio Puede clonarlo a

null 3 Dec 6, 2021
Curso dos fundamentos da linguagem Kotlin disponibilizado pela TreinaWeb

?? Kotlin Fundamentos ?? Curso dos fundamentos da linguagem Kotlin disponibilizado pela TreinaWeb Tecnologias Usadas Kotlin Executando Clone o projeto

Aryosvalldo Cleef de Souza 0 Dec 11, 2021
DogglersApp - Criação de um App para estudo de RecyclerView no Android Studio. Parte do curso Android Basics in Kotlin

Dogglers - Starter Code Starter code for the second independent project for Android Basics in Kotlin. Introduction This is the starter code for the Do

Gustavo Zanardi dos Reis 0 Jan 20, 2022
Repositorio com a finalidade de por em pratica todo o conhecimento das aulas do curso Kotlin e Spring do Zero ao avançado da udemy

kotlin-spring Repositorio com a finalidade de por em pratica todo o conhecimento das aulas do curso Kotlin e Spring do Zero ao avançado da udemy. Obse

Lucas Bastos Nascimento 2 Nov 29, 2022
Jugando con un Parking realizado como prueba de examen en JetBrains Academy, curso Kotlin Developer

Kotlin Parking Lot Proyecto de evaluación para el título de Kotlin Developer en Jetbrains Academy. Consiste en realizar un parking con las especificac

José Luis González Sánchez 1 Jan 10, 2022
Projeto das aulas da disciplina de Programação Móvel da turma do 06˚ Periodo do curso de Sistemas de Informação - IFAL - campus Arapiraca.

Programação Móvel - Sistemas de Informação Projeto das aulas da disciplina de Programação Móvel da turma do 06˚ periodo de SI - IFAL - campus Arapirac

tarsisms 2 Oct 14, 2022