sábado, 5 de enero de 2019

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/
https://emanuelpeg.blogspot.com/2019/01/propiedades-y-campos-en-kotlin.html

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

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.



domingo, 7 de mayo de 2017

Construyendo proyectos con Gradle (instalación con SDKMAN!)

Gradle es una herramienta que nos permite construir proyectos Java, Groovy, Scala, etc. de una manera más sencilla que usando Maven.

¿Cómo instalar Gradle? 
La más sencilla es usando SDKMAN!, solo basta que escribas en la terminal:
$sdk install gradle

Así tendrás instalado la última versión, para comprobar que versión tienes instaladas tecleas:
$gradle --version o $gradle -v

Saldrá algo como esto:
------------------------------------------------------------
Gradle 3.5
------------------------------------------------------------

Build time:   2017-04-10 13:37:25 UTC
Revision:     b762622a185d59ce0cfc9cbc6ab5dd22469e18a6

Groovy:       2.4.10
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_131 (Oracle Corporation 25.131-b11)
OS:           Linux 4.4.0-75-generic amd64



Ahora nos ubicaremos en una carpeta y escribiremos un archivo llamado build.gradle. Dentro del archivo escribiremos lo siguiente:

task holaMundo << {
    println "Hola, mundo!"
}


Se trata de una simple tarea (task) denominada "holaMundo".

Para ejecutar el script escribiremos lo siguiente en la terminal:
$gradle -q build.gradle
$gradle -q holaMundo

Y obtendremos:
Hola, mundo!


Listo. Nuestro primer ejemplo esta hecho. En el siguiente post se verá la estructura de un proyecto Java usando Gradle .

Links:
https://gradle.org/
https://maven.apache.org/ 
http://codemonkeyjunior.blogspot.mx/search?q=maven
http://codemonkeyjunior.blogspot.mx/search?q=gradle

El lenguaje de programación C

El mítico lenguaje de programación C sigue siendo el lenguaje que definió todo. Y con todo nos referimos a todo lo referente a la inf...

Etiquetas

Archivo del blog