Artículos
Java

Calcular el área de un cubo en Java

14/Feb/2013

Para este ejercicio en el que vamos a calcular el área de un cubo en Java utilizaremos las siguientes fórmulas:

area_lateral= 4*Math.pow(a,2)

para obtener el área lateral y

area_total= 6*Math.pow(a,2)

para obtener el área total del cubo. Donde a es el valor de la arista del cubo.

Vamos a crear una clase abstracta llamada «Area» y definiremos dos métodos areaLateral() y areaTotal().

abstract class Area{
   public abstract double areaLateral();
   public abstract double areaTotal();
}

Las clases abstractas nos permiten crear una jerarquía de clases (clase base) que extienden su funcionalidad a otras clases denominadas derivadas.

Ahora creamos la clase derivada y la llamaremos «Cubo».

class Cubo extends Area{
private double arista;

@Override
public double areaLateral(){
//... aqui la fórmula para calcular el área lateral
}
   
@Override
public double areaTotal(){
...// aquí la fórmula para calcular  el área total
}

}

Con esto la clase base(Area) y la clase derivada(Cubo) tienen código y datos comunes. Finalmente creamos la clase principal «AreaCubo».

public class AreaCubo{
//creamos un miembro de tipo Area
   Area area; 
...

public AreaCubo(){}

   public AreaCubo(Area ar){
    this.area=ar;
   }
...
}

Para visualizar el resultado tendremos dos métodos.

   
   public void verAreaLateral(){
      System.out.println("area lateral obtenida: "+area.areaLateral());
  }
   public void verAreaTotal(){
    System.out.println("area total obtenida: "+area.areaTotal());
  }

El método main de la clase tiene el siguiente aspecto:

  public static void main(String[] args){
    //clase abstracta y la clase extendida
     Area area= new Cubo(10); //le asignamos el valor 10
   
     AreaCubo areaCubo=new AreaCubo(area);
     
     //visualizar área lateral 
     areaCubo.verAreaLateral();
    //visualizar área total
     areaCubo.verAreaTotal();
    
 }

Si a la arista le asignamos el valor de 10 obtendremos un área lateral de 400 y un área total de 600. Con estos pasos hemos podido, de forma sencilla, calcular el área de un cubo en Java.

Vídeos sobre Java

Disfruta también de nuestros artículos sobre Java en formato vídeo. Aprovecha y suscribete a nuestro canal.

Test Java

¿Te atreves a probar tus habilidades y conocimiento en Java con nuestro test?

Test Java
Artículos
Ceylon

Hola Mundo en Ceylon

12/Feb/2013

¿Qué es Ceylon?

Ceylon es un lenguaje de programación que al igual que Groovy pretenden darle una nueva visión al programador, tomar lo mejor de Java y olvidarse de lo malo. Una de las diferencias con respecto a Groovy (tipado dinámico) es que se trata de un lenguaje de tipado estático y es necesario tener más cuidado cuando se definen variables y funciones.

Su sintaxis es muy parecida a C.

doc "Definir la sintaxis"
by "Yo"
TipoDato nombreFuncion(Param param){ ... }

El lenguaje todavía esta en desarrollo por el equipo de Gavin King, pero se puede empezar a usar.

Hola Mundo con Ceylon

Escribir el famoso «Hola mundo» (los programas se guardan con la extensión *.ceylon):

Los pasos a seguir son:

  1. Crear un directorio llamado «Programas»
  2. Dentro crear una carpeta llamada «source»
  3. Ahora crear un archivo llamado «hola.ceylon»

Si no queda muy claro puedes guiarte por la imagen.

hola.ceylon

doc "Hola mundo en Ceylon"
by "Yo"

void run(){
  print("Hola mundo!!");
}

¿Cómo se compila y ejecuta Ceylon?

Debes teclear en la terminal de comandos:

ceylon compile source\hola.ceylon

Y para ejecutar:

ceylon run default

Listo, ya tienes tu primer programa escrito en este lenguaje.

Código Fuente

Descárgate el código fuente de Hola Mundo en Ceylon
Y si te ha gustado nuestro código fuente puedes regalarnos una estrella Star
Groovy

Crear un PDF con iText y Groovy

31/Ene/2013

En este ejemplo vamos a ver cómo podemos crear un documento PDF mediante la librería iText y el lenguaje Groovy. Es un código que ya vimos por encima en la carga dinámica de librerías con el uso de @Grapes en Groovy.

Así que podemos cargar dinámicamente nuestra librería iText mediante el uso de los @Grapes así no hace falta tenerla en el Classpath.

import groovy.grape.Grape

@GrabResolver(name='itextpdf', root='http://maven.itextpdf.com/')
@Grapes(@Grab(group='com.itextpdf', module='itextpdf', version='5.1.2'))

Ahora importamos las librerías necesarias para la creación del documento PDF en Groovy con iText.

import com.itextpdf.text.Document
import com.itextpdf.text.DocumentException
import com.itextpdf.text.Paragraph
import com.itextpdf.text.pdf.PdfWriter

Lo primero será crear el documento, para ello utilizamos la clase Document de iText

def documento="micodigo.pdf"
Document document = new Document();

Y obtener un PDFWriter que apunte a dicho documento.

PdfWriter.getInstance(document, new FileOutputStream(documento));

Una vez hecho esto, abrimos el documento y empezamos a escribir contenido sobre el documento PDF. Para ello utilizamos el método .add, el cual recibe como parámetro el texto que queremos insertar en el PDF.

document.open();
document.add(new Paragraph("Usando Grapes en Groovy"));
document.add(new Paragraph("https://lineadecodigo.com"));

Ya solo nos quedará realizar el cierre con el método .close()

document.close()

Vemos que de una forma muy sencilla mediant la librería iText y Groovy podemos generar un fichero PDF.

Groovy

Uso de @Grapes en Groovy

29/Ene/2013

Supongamos que tenemos la necesidad de conectar una aplicación a una base de datos, crear un documento PDF,etc. , pero no tenemos las librerías necesarias para ello entonces la solución sería usar Grapes.

¿Qué es Grapes?
Se trata de un gestor de dependencias que nos permite usar librerías sin la necesidad de agregarlas a nuestro CLASSPATH.

Ejemplo. Crear un documento PDF mediante la librería itext (itextpdf) usando Grapes.

Para usar esta herramienta es necesario importar lo siguiente:

import groovy.grape.Grape

Se deben cumplir estas convenciones:

  • group: grupo de módulos a usar, la libreía o librerías a usar
  • module: un módulo en específico de la librería
  • version: la versión a usar

Entonces quedaría así:

@Grapes(@Grab(group='com.itextpdf', module='itextpdf', version='5.1.2'))

Defino que librería se va usar, el módulo y la versión.

Por lo tando también debemos importar las librerías necesarias para crear el documento PDF:

//para crear el archivo
import java.io.FileOutputStream
import java.io.IOException

//librería itextpdf para crear el documento PDF
import com.itextpdf.text.Document
import com.itextpdf.text.DocumentException
import com.itextpdf.text.Paragraph
import com.itextpdf.text.pdf.PdfWriter

Ahora creamos una función «principal» del programa y le agregamos la anotación @Grapes y @Grab:

@Grapes(@Grab(group='com.itextpdf', module='itextpdf', version='5.1.2'))
def principal() throws DocumentException, IOException {
  //nombre del documento
  def documento="micodigo.pdf"
  Document document = new Document();
  PdfWriter.getInstance(document, new FileOutputStream(documento));
  document.open();
  //el contenido del PDF
  document.add(new Paragraph("Usando Grapes en Groovy"));
  document.add(new Paragraph("www.lineadecodigo.com"));
  document.close();
  println "Se ha creado el documento PDF"
}

Ahora solo falta invocar esa función:

//método principal del programa
principal()

Compilamos:
groovyc UsoGrapes.groovy

Listamos las dependencias:
grape list

Y finalmente ejecutamos el programa:
groovy UsoGrapes.groovy

Si todo salio bien obtendremos un documento PDF.

Artículos
Java

Calcular el índice de masa corporal con Java

18/Dic/2012

En este ejemplo vamos a calcular el índice de masa corporal con Java mediante la fórmula:

 imc= p/(t*t)

Donde:

  1. p= peso
  2. t= talla o estatura
  3. imc = el índice de masa corporal

Vamos a definir una clase Java llamada CalculoIMC.java y su método main e importamos la librería

javax.swing

,abajo de esta clase definimos otra más y la llamaremos Persona con cuatro atributos: nombre, edad, peso y estatura.

import javax.swing.JOptionPane;

class CalculoIMC{
  public static void main(String[] args) {
    //... falta más código por escribir
  }
}

//aqui esta la clase Persona
class Persona{
//atributos de la clase
  public String nombre;
  public int edad;
  public double peso,talla;
  //...
}

Ahora vamos a definir un método Java para asignar los atributos:

Persona asignar(String n,int e,double p,double t){
  nombre=n;
  edad=e;
  peso=p;
  talla=t;
  return this;
}

El operador this nos sirve para hacer referencia a los propios atributos de la clase Java. No es necesario declarar un tipo de dato.

Una vez hecho ya podemos escribir el método que calcula el índice de masa corporal con Java

public double imc(){
  return peso/(talla*talla);
}

Cuando se obtiene el resultado se puede hacer una comparativa de acuerdo a una clasificación:

String cad="";
if(imc()<16.00){
  cad="Infrapeso: Delgadez Severa";
}else if(imc()<=16.00 || imc()<=16.99){
  cad="Infrapeso: Delgadez moderada";
}else if(imc()<=17.00 ||imc()<=18.49){
  cad="Infrapeso: Delgadez aceptable";
}else if(imc()<=18.50 || imc()<=24.99){
  cad="Peso Normal";
}else if(imc()<=25.00 || imc()<=29.99){
  cad="Sobrepeso";
}else if(imc()<=30.00 || imc()<=34.99){
  cad="Obeso: Tipo I";
}else if(imc()<=35.00 || imc()=40.00){
  cad="Obeso: Tipo III";
}else{
  cad="no existe clasificacion";
}
  return cad;

Y para mostrar esos resultados usamos la clase Java

JOptionPane.showMessageDialog()

en un método llamado verDatos()

Persona verDatos(){
  String res="Datos\n";
  res+="\nnombre: "+nombre;
  res+="\nedad: "+edad;
  res+="\npeso: "+peso;
  res+="\ntalla: "+talla;
  res+="\nIMC obtenido es: "+imc();
  res+="\nClasificacion obtenida es: "+clasificacion();
  JOptionPane.showMessageDialog(null, res,"Resultado",JOptionPane.PLAIN_MESSAGE,new ImageIcon("ferd.jpg"));
  return this;
}
//nota: todo esto dentro de la clase Persona.java

Volvemos a la clase Java principal CalculoIMC:

public static void main(String[] args) {
  //instanciar clase 
  Persona persona= new Persona();

  //asignamos los datos de los atributos, para eso usamos JOptionPane.showInputDialog()
  persona.nombre=JOptionPane.showInputDialog("nombre: ");
  persona.edad=Integer.parseInt(JOptionPane.showInputDialog("edad: "));
  persona.peso=Double.parseDouble(JOptionPane.showInputDialog("peso: "));
  persona.talla=Double.parseDouble(JOptionPane.showInputDialog("talla: "));

  // y al final concatenamos los métodos
  persona.asignar(persona.nombre,persona.edad,persona.peso,persona.talla).verDatos();

Al final se visualiza nuestro ejemplo Java todo en una ventanita:

Vídeos sobre Java

Disfruta también de nuestros artículos sobre Java en formato vídeo. Aprovecha y suscribete a nuestro canal.

Test Java

¿Te atreves a probar tus habilidades y conocimiento en Java con nuestro test?

Test Java
Groovy

Paso de argumentos en Groovy

17/Dic/2012

Al igual que Java, en Groovy puedes introducir valores al ejecutar tu programa. Esto se conoce como paso de parámetros.

Vamos a ver en un ejemplo cómo pasar un único valor a un script. Tenemos el siguiente código:

if(args){
  println "Hola "+args[0]
} else{
  println "no introduciste nada"
}

Vemos que solo accedemos a la posición 0 del array de argumentos o args. Esto significa que solo recuperaremos el valor que se encuentre en dicha posición.

Compilamos:

groovyc miScript.groovy 

Ejecutamos:

groovy miScript.groovy Enrique

El parámetro que le enviamos («Enrique») por default es de tipo String.

Ahora si queremos enviar más de un parámetro necesitamos hacerlo mediante el uso del método each(). En each ejecutaremos un closure y el iterador del closure será el que contenga todos los valores que hayan venido como parámetros al programa.

if(args){
  args.each(){ it->
    println "Hola $it"
  }  
}else{
   println "no introduciste nada"
}
groovy miScript.groovy Enrique Magda Camila Juan

el resultado será:

Hola Enrique 
Hola Magda 
Hola Camila 
Hola Juan
Groovy

Conexión a base de datos Firebird desde Groovy

15/Oct/2012

Mediante este ejemplo vamos a explicar como realizar una sencilla conexión a una bases de datos Firebird desde un programa Groovy.

¿Qué necesitas para realizar este ejemplo?

Para poder codificar y probar el ejemplo es necesario lo siguiente:

  1. Tener instalado Firebird
  2. Descargar el driver JDBC del sitio oficial de Firebird.
  3. Usar la base de datos de ejemplo de Firebird (EMPLOYEE.FBD)

Al instalar Firebird se crea automáticamente una cuenta de usuario(sysdba) y un password(masterkey) que nos permitirá logearnos y acceder a la base de datos de ejemplo.

Codificando el ejemplo

Lo primero será importar la librería necesaria para la conexión:

import groovy.sql.Sql

Es increíble el ahorro de líneas de código, basta con usar el método Sql.newInstance(direccionBase,usuario,password,driverConexion) para la conectar la base de datos.

// Datos de la Conexión
def direccionBase="jdbc:firebirdsql://localhost/examples/empbuild/EMPLOYEE.FDB"
def usuario="sysdba"
def password="masterkey"
def driverConexion="org.firebirdsql.jdbc.FBDriver"

Ahora para ejecutar una consulta sql usamos el método sql.eachRow(consulta)

// Consulta
def consulta="select *from country"

Ahora solo falta recorrer los campos de la tabla para ello utilizamos el método sql.eachRow:

sql.eachRow(consulta){ fila ->
    println fila.country + "  "+ fila.currency
}

Ejecutar ejemplo

1. Desde terminal de comandos.

groovy ConexionFirebird.groovy

2. Puedes crear un archivo *.bat o *.cmd (en Windows).
ejecuta.cmd

@echo off
echo Teclea Enter para ejecutar programa...
pause >null
groovy ConexionFirebird.groovy

3. En Linux puedes crear un archivo *.sh
ejecuta.sh

 #!/bin/bash
read -p "Presiona Enter para ejecutar programa..."
groovy ConexionFirebird.groovy
Artículos
Java

Un juego sencillo con Java Swing

13/Oct/2012

Vamos a realizar un programa de escritorio usando Java Swing. Consiste en hacer un juego de adivinar la suma de dos números generados aleatoriamente.

Necesitamos los siguientes controles:

  1. 6 JTextField
  2. 6 JLabel
  3. 3 JButton

Un botón se encargará de generar y mostrar los dos números aleatorios, el siguiente botón activa una ventanita para introducir la suma de esos dos y comprobar si es correcta (acierto) o no (fallo) y mostrará el número de intentos realizados.

Y por último un botón para quitar la aplicación.

Como se trata de una aplicación gráfica es necesario importar las librerías javax.swing.* y java.awt.*.

import javax.swing.JTextField;
import javax.swing.JLabel;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import java.awt.event.*;
import javax.swing.JOptionPane;
import javax.swing.UIManager;

public class Aleatorio extends JFrame{

  public Aleatorio(){
  //..
 //..
 }
}

Los controles a usar para los que utilizaremos las clases JTextField y JButton:

final private JTextField txtNum1,txtNum2,txtResultado,txtIntentos,txtAciertos,txtFallas;
private JButton btnActiva,btnComprueba;
private JButton btnSalir;

También necesitamos definir las variables que controlarán los valores aleatorios y su suma, así como los aciertos, fallos e intentos:

//los dos números tomarán un valor aleatoriamete
private long num1,num2,valor;
//la suma
long suma_prog;
int intentos=0,aciertos=0,fallas=0;

Para generar los números aleatorios creamos una función:

public long obtenerAleatorio1(){
    return (long)(Math.random()*1000);
}

Puedes leer más información sobre como crear un número aleatorio con Java.

Ahora pasamos a codificar los botones Activar, Comprobar y Salir.

Activar
Este botón inicia el juego, para ello lo que hacemos es crear dos números aleatorios, con la clase creada anteriormente, y los ponemos dentro de los campos de texto sus valores.

btnActiva= new JButton("Activar");
btnActiva.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        Aleatorio aleatorio=new Aleatorio();				
        aleatorio.setNum1(aleatorio.obtenerAleatorio1());
        aleatorio.setNum2(aleatorio.obtenerAleatorio2());
				
        txtNum1.setText(String.valueOf(aleatorio.getNum1()));// no. 1
        txtNum2.setText(String.valueOf(aleatorio.getNum2()));// no.2
        txtResultado.setText("");
    }
});

Comprobar
Es el botón que lanza el juego, lo que hace es crear un dialogo, mediante una clase JOptionPane. Cogemos el valor insertado por el usuario y comprobamos si coincide con la suma de los números aleatorios. Si es así incrementamos los aciertos, si no coincide, incrementamos los fallos.

btnComprueba= new JButton("Comprobar");
btnComprueba.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        Aleatorio alea=new Aleatorio();				
        valor=Long.parseLong(JOptionPane.showInputDialog("Introduce valor"));
        alea.setValor(valor);
        txtResultado.setText(String.valueOf(alea.getValor()));//valor del usuario
        suma_prog=Long.parseLong(txtNum1.getText())+ Long.parseLong(txtNum2.getText());
				
        if(suma_prog==alea.getValor()){
            aciertos+=1;
            intentos+=1;
            txtIntentos.setText(String.valueOf(intentos));
            txtAciertos.setText(String.valueOf(aciertos));
        }else{
            fallas+=1;
            intentos+=1;
            txtIntentos.setText(String.valueOf(intentos));
            txtFallas.setText(String.valueOf(fallas));
        }
    }
});

Salir
En este caso, lo que hacemos es salir de la aplicación mediante el método System.exit.

btnSalir= new JButton("Salir");
btnSalir.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.exit(0);
    }
});

Espero les sea de utilidad.

Vídeos sobre Java

Disfruta también de nuestros artículos sobre Java en formato vídeo. Aprovecha y suscribete a nuestro canal.

Test Java

¿Te atreves a probar tus habilidades y conocimiento en Java con nuestro test?

Test Java
Artículos
Javascript

Programación Orientada a Objetos con Javascript: Un sencillo ejemplo

02/Ago/2012

Javascript es un lenguaje de programación que permite ampliar las posibilidades de las páginas HTML. El navegador se encarga por completo de interpretar el código escrito y no hay necesidad de compilación.

Para incluir código Javascript en páginas HTML es necesario hacer uso de la etiqueta

De esta forma insertaremos código Javascript de la siguiente forma:

También se pueden usar scripts externos:

Disfruta también de nuestros artículos sobre Javascript en formato vídeo. Aprovecha y suscribete a nuestro canal.

Test Javascript

¿Te atreves a probar tus habilidades y conocimiento en Javascript con nuestro test?

Test Javascript
Groovy

Groovy: un vistazo a los closures

12/Jul/2012

Inicio mis post en lineadecodigo con un pequeño vistazo a los closures.

Antes de empezar debemos de conocer dos conceptos. Por un lado Groovy, es un lenguaje de programación dinámico y fácil de aprender similar a Python y Ruby que va ganando terreno entre los desarrolladores Java.

Y un Closure, es la manera en como una función dentro de otra función contenedora puede hacer referencia a las variables después de que la función contenedora ha terminado de ejecutarse. Este término es algo dificil de entender, sin embargo pienso que con unos cuantos ejemplos entiendan el concepto.

Lo primero que haremos será crear un archivo (o fichero) y lo vamos a llamar «Closures.groovy». Veamos diferentes formas de codificar un clousure:

1. Creamos un closure muy simple.

//imprime el mensaje "Hola desde un closure"
def hola={
  println("Hola desde un closure")
}

//invocar closure "hola"
hola()

2. Ahora un closure con un parámetro.

// multiplica un número por 2
def doble={ n ->
  return n*2
}

//invocar closure "doble"
def numero=doble(5)
println("el doble de 5 es "+numero)
// también puede escribirse println "el doble de 5 es ${numero}"

3. Ahora un closure con dos parámetros.

def var="Bienvenido"
// imprime el valor de var y el parámetro que le envie el usuario
def msg1={it -> println "${var} ${it}"}
//invocamos el closure, debe salir el mensaje "Bienvenido mundo"
msg1("mundo")

4. Closure más complejo, recibe un método como parámetro.

//defino un closure con dos parámetros
def otro={metodo, parametro -> metodo(parametro)}
//ahora defino dos closure que reciben un solo parámetro
def inicio={it -> println "Hola ${it}"}
def fin={it -> println "Adios ${it}"}
//invoco el closure "otro"
otro(inicio,"Fernando")
otro(fin,"Fernando")

5. Mandamos una lista a un closure.

//defino una lista
def lista=["Andrea","Fernando","Antonio","Lucero","Veronica"]
//uso el closure "inicio"
println "\n"
lista.each inicio

6. Ejemplo con closures y diccionarios.

//defino el diccionario
def dicc=['Fernando':31,'Veronica':27,'María':43,'Yezmin':26,'Horacio':15]
def suma=0
//defino el closure
def edadTotal={ x ->
x.each{
suma+=it.value
// println("obtener valor: "+it.value+ " obtener llave o identificador: "+it.key)
}
println("Suma total de edades: "+suma)
}
//invoco el closure
edadTotal(dicc)

Para ejecutar este archivo pueden teclear desde la consola de comandos:

groovy Closures.groovy

También se puede probar el código mediante la consola groovy:

groovyconsole Closures.groovy

Si quieres puedes leer más información sobre los Closures de Groovy en http://groovy.codehaus.org/Closures