sábado, 5 de enero de 2019

Herencia en Kotlin

Herencia en Kotlin
En este ejemplo veremos herencia, un concepto base en el paradigma orientado a objetos. En Herencia una clase Base (clase padre o superclase) puede heredar atributos (variables de instancia) y su comportamiento (métodos).

¿Cómo creamos herencia en Kotlin?

open class Electronico{}

data class Computadora: Electronico(){}

Esto parece sencillo, pero ¿qué pasa cuando las clases tienen atributos? Enseguida veremos un ejemplo.

Crearemos dos clases:
  • Una clase Padre (Padre.kt) y
  • Una clase hija (Estudiante.kt)

Persona.kt
package com.codemonkey.clases;

open class Persona(open val nombre:String, open val apellidos:String, open val edad:Byte){
    init{
        println("objeto Persona creado e inicializado");
    }

    var Color:String = "Blanco";

    constructor(nombre:String, apellidos:String, edad:Byte, color:String): this(nombre,apellidos,edad){
        Color = color;
    }
}

Persona (Superclase) posee tres atributos en el constructor principal: nombre,apellidos y edad. Enel segundo constructor añadimos un nuevo atributo: color.

Estudiante.kt

package com.codemonkey.clases;

data class Estudiante(override val nombre:String,override val apellidos:String,override val edad:Byte, val id:Long):Persona(nombre,apellidos,edad){
    init{
        println("objeto Estudiante creado e inicializado");
    }

    init{
        println("Estudiante ${nombre} ${apellidos}");
    }
}

Como se puede observar no solo hereda sus atributos sino que podemos añadir uno propio. En esta caso es el id del Estudiante. También es importante notar el bloque de código que empieza con init. Este se ejecutará al inicio (parecido al constructor).

main.kt

package com.codemonkey;

import com.codemonkey.clases.*

object Main {
   @JvmStatic
   fun main(args:Array<String>){
var id=10000L
     var nombre = "Carolina"
     var apellidos = "Contreras Lopez"
     var edad:Byte = 10
     var estudiante:Estudiante = Estudiante(nombre,apellidos,edad,id);
     println(estudiante)

     nombre = "Juan"
     apellidos = "Estevez"
     var tuEdad:Byte=33;
     var color = "Castaño"
     var persona = Persona(nombre,apellidos,tuEdad,color);
     println("Nombre compledo ${persona.nombre} ${persona.apellidos}");
     println("Edad ${persona.edad} años, color de cabello: ${persona.Color}");
}
}

Post anteriores:
http://codemonkeyjunior.blogspot.com/2019/01/arreglos-listas-funciones-y-clases-en.html
http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html

Arreglos, listas, funciones y clases en Kotlin

En casi cualquier lenguaje de programación debemos trabajar con estructuras de datos como listas, arreglos, mapas, etc. Kotlin no se queda atrás y nos permite definir estas estructuras con algunas peculiaridades.
Si queremos definir un array (no olvidar que debemos poner de qué tipo) :

var arreglo: Array<Double> = arrayOf<Double>(10.7,20.55,31.90,49.99,53.33,66.666,70.70);

Si queremos definir una lista, por ejemplo de un tipo específico (un tipo Clase) podríamos definir primero la clase:


data class Circulo(val radio:Double)

¿Sólo eso? Sí, sólo eso. Kotlin nos ahorra mucho trabajo.

Ahora definamos una lista de tipo Circulo:

val listaCirculo: List<Circulo> =listOf(Circulo(34.55), Circulo(7.8),Circulo(12.00));

 ¿Cómo los recorremos?

//for en arreglo
     for(arr:Double in arreglo){
       println("Hola ${arr}");
     }
println();
     //for en lista Circulo
     for(circulo:Circulo in listaCirculo){
       println(circulo);
       println("Radio = ${circulo.radio}")
     }

¿Y qué pasa con las funciones?
Aquí unos ejemplos:


//Una función sin parámetros de entrada y salida
fun nombreFuncion(){
  println("Hola, desde Kotlin!!!");

}

nombreFuncion();

//Una función con parámetros de entrada:
fun getValor(numero:Int): Int{
  return numero*2;
}

var valor = getValor(2);
println("Valor: ${valor}");

//Una función de tipo Boolean
fun String.esMayorACinco():Boolean{
    return this.length > 5;
}
 println("CINCO".esMayorACinco());//false


Post anterior: http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html


Links:
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a


Conociendo Kotlin

Kotlin es un lenguaje dependiente de la Máquina Virtual Java (JVM); empresas como Google han adoptado este lenguaje porque promete ofrecer compatibilidad e interoperabilidad con proyectos hechos con le lenguaje Java. Kotlin es muy similar a otros lenguajes de programación como Scala y Go (e incluso Typescript). Al igual que Java posee tipos clase (Byte, Short, Int, Float, Double, Boolean, Char). Además podemos importar librerías de Java sin ningún problema. Para declarar una variable modificable usamos var, para declarar una variable no modificable usamos val (similar a Scala).

¿Tipado estático?
El tipado estático puede parecer engorroso a algunos programadores, pero tener que definir el tipo de variables a usar tiene la ventaja de que a la hora de la compilación verificará si existe algún problema. (Supongamos que en un lenguaje dinámico donde no es necesario declarar el tipo de variable a usar necesitamos listar, en una llamada a un método especial, cadenas de texto ("strings") y le pasamos una lista con datos tipo Boolean, etc. y nos provoca un error).


Un programa escrito en Kotlin debe llevar la extensión *.kt

 main.kt
package com.codemonkey

fun main() {
    println("Programando en Kotlin!!!")
}

 Tipos de variables main.kt
//Enteros:
var byte:Byte = 0;
var short:Short = 120;
var int:Int = 40;
var long:Long = 12000000;

//Reales
var float:Float = 2.30f;
var double:Double = 12.654;

//Booleano
var verdadero:Boolean = true;

//Caracter
var character:Char = '\u0000';

//Cadenas
var cadenaStr:String = "Codemonkey Junior";


//Array
var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);

//Lista
var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 
Imprimimos los datos a pantalla:
//Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");
Compilamos y creamos el jar:
$ kotlinc main.kt -include-runtime -d main.jar
Ejecutamos:
$ java -jar main.jar

También existe la manera de crear y compilar proyectos Kotlin usando Gradle. Para eso debemos definir nuestro archivo gradle.build

gradle.build

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}


Modificamos nuestro código:

package com.codemonkey
  
object Main {
   @JvmStatic
   fun main(args:Array<String>){
       //Enteros:
     var byte:Byte = 0;
     var short:Short = 120;
     var int:Int = 40;
     var long:Long = 12000000;
     
     //Reales
     var float:Float = 2.30f;
     var double:Double = 12.654;
     
     //Booleano
     var verdadero:Boolean = true;
     
     //Caracter
     var character:Char = '\u0000';
     
     //Cadenas
     var cadenaStr:String = "Codemonkey Junior";
     
     //Arrays
     var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);
     //Lista
     var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

     //Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

   }
}


Listar Arrays


  println();
     for(numero in numeros){
       println(" "+numero);
     }
     println();
     for(elemento in miLista){
       println("${elemento}")
     }

Para compilar, construir nuestro proyecto tecleamos:
$ gradle build

Para listar las tareas disponibles usamos:
$ gradle -q task
 
Usaremos run para correr el proyecto:

$ gradle run

Links de interés
https://codemonkeyjunior.wordpress.com/2018/11/18/gradle-kotlin/
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a
https://rubentejera.com/por-que-usar-kotlin/

Poner código en blogger
http://hilite.me/ 

sábado, 10 de noviembre de 2018

Programando en Ruby ... no. 6

En esta serie de programación en Ruby hemos visto muchos ejemplos, desde simples códigos para imprimir un valor y programación orientada a objetos.

En este post escribiremos un archivo llamado models.rb dentro de un directorio denominado clases.
models.rb

#clase padre
class Animal 
  attr_accessor :no_patas
   def initialize(no_patas)
       @no_patas=no_patas
        puts "objeto Animal creado"
  end
end

#clase hija
class Aracnido  < Animal
  attr_accessor :especie
   def initialize(no_patas, especie)
       super(no_patas)
       @especie=especie
        puts "objeto Aracnido creado"
  end
end

#clase hija
class Ave   <  Animal
  attr_accessor :color
   def initialize(no_patas, color)
        super(no_patas)
       @color=color
        puts "objeto Ave creado"
  end
end 
 
Este archivo nos servirá para escribir nuestras clases (Animal, Aracnido y Ave). Donde Animal es la clase padre y las demás son las clases hijo.

Ahora debemos crear un archivo llamado main.rb donde importaremos este archivo.


require_relative 'clases/models'

def main
 begin
  animal = Animal.new(4)
  ave = Ave.new(2,'Verde')
  aracnido = Aracnido.new(8,'Delatore Riebelle')
 rescue Exception => e
  puts "Ha ocurrido una excepcion: #{e}"
 end
end

#main
main

Usamos require_relative para indicar la ruta donde se encuentran las clases con las que queremos trabajar.

Para correr el archivo abrimos una terminal y escribimos:
ruby main.rb


viernes, 9 de junio de 2017

Simple texto (Cómo deberíamos escribir nuestro código)

Recuerda que mudamos el blog:CodeMonkey Junior

¿Cómo deberíamos escribir nuestro código? en el siguiente vídeo se comparten algunas ideas que pueden servirnos a la hora de escribir nuestro código:

Recuerda, también puedes consultar el nuevo blog de Codemonkeyjunior

sábado, 27 de mayo de 2017

Nuevo blog de codemonkey junior

He aquí el nuevo blog:
https://codemonkeyjunior.wordpress.com/

He decidido trasladar el blog a otro sitio. Seguiré escribiendo algunos post.
Gracias.

miércoles, 10 de mayo de 2017

Construyendo proyectos con Gradle (estructura de directorios)

La estructura de todo proyecto en Gradle debe tener la siguiente forma:

Proyecto
     |
     src
        |
          main
                | java
                | resources

        | test
               | java
               | resources

Una parte de desarrollo:
src/main/java
src/main/resources

Y una de testing (pruebas):
src/test/java
src/test/resources

Dentro de  la carpeta src/main/java debe estar nuestra clase principal.
Ejemplo:
src/main/java/Main.java

Además de la estructura debemos contar con el archivo build.gradle:
Proyecto
      |
     src
        |
          main
                | java
                | resources

        | test
               | java
               | resources
    |
build.gradle

Es decir:
Proyecto
src/main/java/Main.java
src/main/resources
src/test/java/Main.java
src/test/resources
build.gradle

Dentro del archivo build.gradle escribiremos:


apply plugin: 'java'
apply plugin: 'application'

sourceCompatibility = 1.8

targetCompatibility = 1.8
mainClassName = "org.codemonkey.Main"
version = "1.0"


repositories {
    mavenLocal()
    mavenCenter()
}

dependencies {

    compile group: 'junit', name: 'junit', version: '4.12'

}

Ahora la clase Main.java

package org.codemonkey;

public class Main{
   
    public static void main(String[] args) throws IOException {
        System.out.println("Hola mundo!");
    }   
} 


Dentro de la terminal teclearemos:
$gradle build

Con esto construiremos nuestro proyecto. Ahora listemos las tareas disponibles con:
$gradle task

Al desplegar las tareas debe haber una llamada run, esta nos permitira correr nuestro programa:
$gradle run

Salida:
Hola, mundo!

Con esto tendremos nuestro primer ejemplo. En el siguiente post veremos un ejemplo con Spring y Gradle.