Artículos
Java

Hola mundo con JavaFX

24/Feb/2014

En está ocasión vamos a usar la tecnología JavaFX para crear el ejemplo de Hola mundo con JavaFX, esta aplicación abrirá una ventana que muestra el clásico mensaje «Hola, mundo».

JavaFX es una tecnología que nos permite crear aplicaciones de escritorio RIA (Ritch Internet Applications)

Vamos a usar IntelliJ IDEA para crear el proyecto Hola Mundo con JavaFX.

Para ello elegimos New Project -> JavaFX Application:

IntelliJ

Lo primero será explicar los tres conceptos que tiene JavaFX:

  • El Escenario, que es representado por la clase Stage. El escenario es el representa al contenedor general de JavaFX.
  • La escena, es representada por la clase Scene y es la que tiene el contenido de lo que queremos representar. La escena, por lógica se monta sobre el escenario.
  • Los nodos de la escena, son los elementos que componen la escena. La clase superior que representa estos nodos es un Panel, en este caso vamos a utilizar un StackPane

Vamos a montar nuestro escenario del Hola Mundo con JavaFX, desde los nodos hasta la escena…

Crear un botón que nos salude

Lo primero que haremos será crear un botón que sea el que muestre el saludo. Para crear un botón escribiremos el siguiente código.

Button boton = new Button("Saludar");
boton.setVisible(true);
boton.setOnAction(new EventHandler() {
  public void handle(ActionEvent event) {
    System.out.println("Hola Mundo!!!");
  }
});

Como podemos ver es una simple clase Button, a la cual le hemos asociado un manejador mediante un EventHandler. Dicho EventHandler va a mostrar un saludo por consola.

El Panel Principal

Como hemos dicho hay que crear un nodo principal que será un Panel. En este caso es un StackPane.

panel = new StackPane();

Sobre el Panel vamos a añadir el botón:

panel.getChildren().add(boton);

Montando la escena

La escena es la que contiene a los nodos. Así que el montado de la Escena en JavaFX no deja de ser el añadirle los nodos.

Scene escena = new Scene(panel, 250, 150, Color.BLACK);

Subir la escena, al escenario

Si ya tenemos la escena, solo nos queda subir la escena al escenario y mostrar el escenario

primaryStage.setTitle("Iniciando con Java FX");
primaryStage.setScene(escena);
primaryStage.show();

Ahora veremos que el escenario es un atributo del método start, método básico en el desarrollo de aplicciones JavaFX.

Algunas cosas básicas más…

Antes de montar la aplicación Hola Mundo con JavaFX tiene que saber un par de cosas más sobre esta tecnología.

La primera es que la aplicación extiende de la clase Application

public class Main extends Application {...}

Y lo segundo es, que el método principal es start, el cual recibe como parámetro el escenario, es decir la clase Stage.

public class Main extends Application {
 @Override
    public void start(Stage primaryStage) throws Exception{
        ...
    }
}

Espero que os haya sido útil la explicación de como realizar un Hola Mundo con JavaFX.

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
Groovy

Crear una clase en Groovy

10/Feb/2014

En esta ocasión crearemos una clase en Groovy, al igual que en Java se debe usar la palabra class.

Clase en Groovy

class Computadora{
...
...
}

Nuestra clase en Groovy tendrá dos atributos:

String marca
String modelo

Por defecto estos atributos serán accesibles desde cualquier otra clase en Groovy. Si quiero crear otra clase en Groovy que acceda a esos atributos tengo que usar la palabra extends.

class Computadora_Portatil extends Computadora{
...
...
}

A esta nueva clase en Groovy le coloco otros dos atributos:

String memoria
String procesador

El código de ambas clases en Groovy quedaría de la siguiente forma:

//clase base
class Computadora{
	String marca
	String modelo
}

//clase hija
class Computadora_Portatil extends Computadora{
	String memoria
	String procesador
}

Constructor de una clase en Groovy

Podemos crear un constructor para cada clase en Groovy:

//clase base
class Computadora{
  //constructor
  Computadora(){}
}

//clase hija
class Computadora_Portatil extends Computadora{
  //constructor
  Computadora_Portatil(){}
}

Método main de una clase en Groovy

Ahora escribimos el «main» de nuestra clase en Groovy:

static main(args){
  //nota: no es necesario
}

Instancia de una clase en Groovy

static main(args){
  	def miPC=new Computadora() 
}

También podemos hacerlo de esta forma:

static main(args){
   def miPC= new Computadora(marca:"DELL",modelo:"1501")

  //mostramos los valores
  println "Mi PC:"
  println "marca >> ${miPC.marca} , modelo >> ${miPC.modelo}"

}

Existe también la alternativa de usar la palabra with para llenar los atributos de la clase en Groovy:

static main(args){
//en este caso usamos la clase hija
def miPortatil=new Computadora_Portatil()
miPortatil.with{
	memoria="1.7GiB"
	procesador="AMD V120 Processor"
}

//mostramos los valores
println "Mi PC portatil:"
println "memoria >> ${miPortatil.memoria} , procesador >> ${miPortatil.procesador}"

}

Espero que os haya gustado el artículo sobre cómo crear una clase en Groovy.

Artículos
Ceylon

Crear una clase en Ceylon

21/Nov/2013

Ya hemos visto en nuestro articulo anterior cómo se podía crear un programa Hola Mundo con Ceylon y cual era el procedimiento para compilarlo.

Ceylon es un lenguaje en desarrollo que corre sobre la JVM y pretende darle otro enfoque a la programación en Java.

Ahora vamos a crear una clase con Ceylon. Para ello vamos a ver cómo podemos crear la clase «Persona» en Java, Ceylon y Groovy, además un método que imprima un mensaje.

Clase Persona en Java

public class MainPersona{
        //método principal del programa
	public static void main(String[] args) {
		new MainPersona().ver(new Persona());
	}
	public void ver(Persona persona){
		persona.verMsg();
	}
}

class Persona{
	//imprimir un mensaje
        public void verMsg(){
	 	System.out.println("funcionando...desde Java");
	 }
}

Para compilar la clase Java escribiremos:

javac -g MainPersona.java

Y para ejecutar la clase Java:

java MainPersona

Clase Persona en Ceylon

doc "Ejemplo de clases"
by "Yo"

class Persona(){
  //imprimir un mensaje, la palabra reservada "shared" es algo parecido a la public de java
  shared void verMsg(){
    print("funcionando...desde Ceylon");
  }
}

//se pude considerar la función "main" del programa
void run(){
  verPersona(Persona());
}

void verPersona(Persona persona){
  persona.verMsg();
}

Para compilar la clase en Ceylon escribiremos:

ceylon compile source\Persona.ceylon

Y para ejecutar la clase en Ceylon:

ceylon run default

Clase Persona en Groovy

class Persona{
  //imprimir un mensaje
  def verMsg(){
    println "funcionando...desde Groovy"
  }
}

//método principal del programa
static main(args) {
  verPersona(new Persona())
}

def verPersona(Persona persona){
  persona.verMsg()
}

Para compilar la clase Groovy:

groovyc Persona.groovy

Y para ejecutar la clase Groovy:

groovy Persona.groovy

En los tres programas el resultado es el mismo (el mensaje en pantalla), además es de notarse que en Java se escribe más código.

Java, Ceylon y Groovy

La diferencia más importante a notar es que tanto Java como Ceylon son lenguajes de tipado estático, donde los tipos de datos son muy importantes a la hora de la compilación (esto puede evitar errores). Mientras que en Groovy al ser de tipado dinámico nos permite omitir el tipo de dato.

Espero que el ejemplo para crear una clase en Ceylon sirva para que alguien se interese en el lenguaje.

Groovy

Crear una ventana Swing en Groovy

19/Nov/2013

En este ejemplo se usarán las librerías javax.swing y java.awt para crear una ventana Swing en Groovy. El archivo se llamara Ventana.groovy.

Una de las ventajas de usar Groovy es que puedes utilizar las librerías de Java para crear aplicaciones de una manera más sencilla.

import javax.swing.JFrame
import javax.swing.JOptionPane
import javax.swing.ImageIcon
import javax.swing.*
import java.awt.event.*
import java.awt.*

Es importante importar estas librerías para Crear una ventana Swing en Groovy.

Creamos una función principal llamada ventana.

def ventana(){
  // aquí el código
}

Para invocarla solo es necesario poner el nombre:

//invocamos el método
ventana()

Dentro de la función ventana se va definir tres componentes:

  • Un JFrame, que servirá para contener los botones
  • Dos JButton, uno para mostrar un mensaje y otro para salir

Como funciona crear una ventana Swing en Groovy

Crea una ventana con dos botones, el botón «Activa» solicita el nombre de una persona y lo muestra en una ventanita (JOptionPane). El botón «Salir» finaliza la aplicación. Eso es todo, solo es un ejemplo de uso de Swing en Groovy.

Crear el JFrame, definimos su tamaño, título e indicamos que se puede cerrar.

frame=new JFrame(title: '::Ventana en Groovy::',size: [270,300],layout: new FlowLayout(),defaultCloseOperation: javax.swing.WindowConstants.EXIT_ON_CLOSE)

El botón que muestra un mensaje. Podemos asignarle un título, un tooltip, un estilo (color) y una imagen.

btnActiva=new JButton("Activa",new ImageIcon("pet01.png"))
  btnActiva.setBackground(Color.blue)
  btnActiva.setToolTipText("activar...")
  //...

Además definimos un evento con la interface ActionListener.

btnActiva.addActionListener({
    def cad=JOptionPane.showInputDialog("Tu nombre:")
    JOptionPane.showMessageDialog(null,"Hola "+cad,"Aviso del sistema",JOptionPane.PLAIN_MESSAGE,new ImageIcon("pet01.png"))

   } as ActionListener)

El botón para salir. El método exit finalizará el programita.

btnSalir=new JButton("Salir",new ImageIcon("pet01.png"))
  btnSalir.setBackground(Color.orange)
  btnSalir.setToolTipText("quitar...")
  btnSalir.addActionListener({
    System.exit(0)
  } as ActionListener)

Finalmente agregamos esos dos botones al JFrame. Además indicamos que el JFrame es visible (show).

frame.add btnActiva
frame.add btnSalir
frame.show()

Listo, compilamos

groovyc Ventana.groovy

y ejecutamos

groovy Ventana.groovy

Así se verá la ventana.
ventanagroovy

Existe un framework llamado Griffon que permite crear aplicaciones Swing usando el lenguaje Groovy.

Espero les sirva de algo.

Artículos
Java

Calcular el sector circular en Java

03/Sep/2013

Sector circular, es la relación que existe entre el arco, el radio y el ángulo central de una circunferencia.

¿Qué necesito para calcular el sector circular en Java?

  1. conocer el valor de radio de la circunferencia
  2. la longitud del arco
  3. el valor del ángulo central

Para obtener el valor del ángulo central se emplea la siguiente fórmula trigonométrica:

ang_central= arco / radio

Para obtener el valor del sector circular se emplea esta otra fórmula trigonométrica:

sector_circular= (radio*radio) * ang_central / 2

Creamos una clase Java llamada «Sector.java».

class Sector{
   private double radio;
   private double arco;
   //...
}

Podemos definir un constructor y los métodos GET.

class Sector{
   //...

   public Sector(double radio,double arco){
    this.radio=radio;
    this.arco=arco;
  }

  public double getRadio(){
    return radio;
  }

  public double getArco(){
    return arco;
  }

}

Definimos los métodos para obtener el ángulo central y el sector circular:

class Sector{
 //...

 public double calculaAngulo(){
    return arco/radio;
  }

 public double calculaSector(){
    return ((radio*radio)*calculaAngulo())/2;
  }

}

Lo que sigue es crear un método Java que sirva para mostrar los datos calculados:

class Sector{
 //...

 @Override
  public String toString(){
    return "Sector{radio: "+getRadio()+ ",arco:"+getArco()+", sector circular obtenido: "+calculaSector()+"}";
  }

 //este es el método que muestra los datos calculados
  public void ver(){
    System.out.print(toString());
  }

}

La clase Java principal tiene el siguiente aspecto:

public class Principal{
   public static void main(String[] args)throws Exception{
     
   }
}

Usaremos la clase Scanner para introducir los datos que se solicitan.

import java.util.Scanner;
public class Principal{
   public static void main(String[] args)throws Exception{
     Scanner in = new Scanner(System.in);
   }
}

Instanciamos la clase Sector.

import java.util.Scanner;

public class Ejemplos{
  public static void main(String[] args) {
    Scanner in=new Scanner(System.in);
    Sector sector=null;
      }
}

Definimos dos variables: radio y longitud del arco

//...
Scanner in=new Scanner(System.in);
Sector sector=null;
double r=0.0, l=0.0;

Solicitamos los datos al usuario.

System.out.print("Introduce el valor del radio: ");
r=in.nextDouble();
System.out.print("Introduce la longitud del arco: ");
l=in.nextDouble();

Invocamos el constructor de la clase Sector y mostramos el resultado.

sector=new Sector(r,l);
sector.ver();

Ejemplo. Si el valor del radio es de 5.5m y la longitud del arco es de 16.20m obtenemos un sector circular de 44.55m cuadrados:

Introduce el valor del radio: 5.5
Introduce la longitud del arco: 16.20
Sector{radio: 5.5,arco:16.2, sector circular obtenido: 44.55}

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

Ejecutar un proceso batch en Groovy

04/Ago/2013

Proceso batch en Groovy

En este ejemplo vamos a ver como ejecutar un proceso batch en Groovy. Para ello tenemos que saber que los archivos batch son útiles para la automatización de tareas,por ejemplo revisar el espacio en disco, ver el contenido de un directorio, ,etc. En este ejemplo vamos a crear un archivo BAT (MS-DOS).

Abrimos cualquier editor de texto (como notepad++, sublime text 2, etc.) y creamos un nuevo archivo, le llamaremos «miscomandos.bat» (también se puede cambiar la extensión por .cmd).

@echo off
echo Hola visitante de https://lineadecodigo.com/
@pause

Desde terminal de comando nos ubicamos en el directorio donde se creo el archivo y tecleamos su nombre, aparece el mensaje:

Hola visitante de https://lineadecodigo.com/

¿Groovy permite ejecutar comandos del sistema?

Asi es, basta que teclees desde terminal «groovysh»te abrirá el REPL. Escribe esto: printl «help».execute().text

Groovy Shell (2.1.5, JVM: 1.7.0_05)
Type 'help' or '\h' for help.
-----------------------------------------
groovy:000> printl "help".execute().text

Saldrá algo como esto:

-------------------------------------------------------------------------------
groovy:000> printl "help".execute().text
ERROR groovy.lang.MissingMethodException:
No signature of method: groovysh_evaluate.printl() is applicable for argument ty
pes: (java.lang.String) values: [Para obtener más información acerca de un coman
do específico, escriba HELP
seguido del nombre de comando
ASSOC          Muestra o modifica las asociaciones de las extensiones
               de archivos.
ATTRIB         Muestra o cambia los atributos del archivo.
BREAK          Establece o elimina la comprobación extendida de Ctrl+C.
BCDEDIT        Establece propiedades en la base de datos de arranque para
               controlar la carga del arranque.
CACLS          Muestra o modifica las listas de control de acceso (ACLs)
               de archivos.
CALL           Llama a un programa por lotes desde otro.
CD             Muestra el nombre del directorio actual o cambia a otro
               directorio.
CHCP           Muestra o establece el número de página de códigos activa.
//... más

Vamos a modificar el archivo «miscomandos.bat»

@echo off
@rem Programando en Batch
title Ejemplo de Batch 
cls
echo Hola usuario %USERNAME%
echo hora: %time%
echo fecha:  %date%
@pause

El siguiente paso es convertir este archivo en un *.exe, para ello usamos el programa battoexeconverter, nos generará el archivo ejecutable, lo guardamos en el ditrectorio C:\Windows\System32 (lo nombramos «miscomandos.exe»)

Creamos el archivo «ejecuta.groovy» con el siguiente código que ejecutará nuestro proceso batch en Groovy:

def programa="miscomandos.exe"
def sub="cmd /c start "+programa
Process p=sub.execute()
println p.text

Ejecutamos,la salida del proceso batch en Groovy es la siguiente:

Hola usuario Yo
hora: 19:10:47.86
fecha:  23/07/2013
Presione una tecla para continuar ...

Ya tenemos nuestro programa que permite ejecutar un proceso batch en Groovy.

Artículos
Java

Calcular el volumen de una esfera en Java

16/Jun/2013

Para el ejemplo que nos permite calcular el volumen de una esfera en Java vamos a crear cuatro archivos:

  1. Una interface «Servicio»
  2. Una clase abstracta «Figura»
  3. Una clase hija «Esfera»
  4. Una clase principal «VolumenEsfera»

Y es que aprovecharemos y utilizaremos conceptos de herencia para resolver nuestro problema.

La fórmula para calcular el volumen de una espfera en Java es la siguiente

volumen=(4/3)*Math.PI*(r*r*r)

Donde r es el radio de la esfera.

Interface Servicio

Definimos un método dentro de la interface «Servicio»

interface Servicio{
    public abstract void ver();
}

La Clase Abstracta

La clase abstracta implementara el método de la interface, además posee un método que nos servirá para obtener el volumen de la esfera:

abstract class Figura implements Servicio{
    private double radio;
    //este es el método que calcula el volumen de la esfera
    public abstract double volumen();
 
    public Figura(){}
 
    public Figura(double _radio){
        this.radio=_radio;
    }
 
    public double getRadio(){
        return this.radio;
    }
}

La Clase Concreta

Creamos la clase «Esfera» que hereda las propiedades y métodos de la clase abstracta:

class Esfera extends Figura{
    double r;
 
    public Esfera(){}
 
    public Esfera(double _r){
        super(_r);
        r=_r;
    }
 
    @Override
    public double volumen(){
        return ((4/3) * Math.PI*(r*r*r));
    }
 
    @Override
    public void ver(){
        System.out.println(String.format("radio: %f , volumen esfera: %f",getRadio(),volumen()));
    }
}

Como se puede notar la clase abstracta «Figura» no tiene la necesidad de hacer uso del método ver(), pero la clase hija «Esfera» si.

La clase principal tiene el siguiente aspecto:

public class VolumenEsfera{
   
    public static void main(String[] args) {
        Figura esfera=new Esfera(20);
        esfera.ver();
    }
}

Espero que os haya sido de utilidad la explicación de como calcular el volumen de una esfera en Java y algún concepto que otro de las herencias.

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
Java

Calcular el volumen de un cono en Java

14/Jun/2013

En este ejemplo vamos a calcular el volumen de un cono en Java. En el código vamos a utilizar la clase JOptionPane de la librería javax.swing para que la representación sea visual.

Lo primero será importar la clase JOptionPane:

import javax.swing.JOptionPane;

Definimos la estructura de la clase que va a cacular el volumen de un cono en Java y el método principal del programa será:

 
public class VolumenCono {
   public static void main(String[] args) {
     //aqui va el código
  }
  //aqui va el método
}

La fórmula para obtener el volumen del cono:

volumen=(Math.PI*(r*r)*h)/3

Donde r es el radio y h la altura del cono. La formula para calcular el volumen de un cono en Java quedará de la siguiente manera:

public static double volumen(double r,double h){
        return (Math.PI*(r*r)*h)/3;
    }

Para pedir los datos: radio y altura nos apoyamos en el método showInputDialog:

double radio=Double.parseDouble(JOptionPane.showInputDialog("Introduce radio:"));  
double altura=Double.parseDouble(JOptionPane.showInputDialog("Introduce altura:")); 

Y mostramos el resultado de calcular el volumen de un cono en Java. El código sería el siguiente

try{
  double radio=Double.parseDouble(JOptionPane.showInputDialog("Introduce radio:"));  
  double altura=Double.parseDouble(JOptionPane.showInputDialog("Introduce altura:"));
  JOptionPane.showMessageDialog(null,"Volumen obtenido\n"+String.valueOf(volumen(radio,altura)),"Aviso",JOptionPane.PLAIN_MESSAGE,new ImageIcon("imagen.jpg"));
  System.exit(0);
} catch(Exception ex) {
  JOptionPane.showMessageDialog(null,ex.getCause().toString(),"Aviso", JOptionPane.ERROR_MESSAGE,new ImageIcon("ferd.jpg"));
}

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
Java

Calcular el volumen de una pirámide en Java

14/Mar/2013

Para calcular el volumen de una pirámide en Java vamos a crear tres archivos:

  1. Una interface,que contenga el método para obtener el volumen de una pirámide en Java.
  2. Una clase que implemente la interface
  3. Una clase principal para visualizar el resultado

Dentro de la interface vamos a definir un método para el cálculo del volumen en Java.

interface Servicios{
  public static final int M=3; // se pude definir una constante
  public abstract double volumen(); //método para obtener el volumen de la pirámide
}

La fórmula del volumen de una pirámide es la siguiente:

volumen= (ab*h)/3;

La clase que implementa la interface requiere dos atributos: la base y la altura.

class Piramide implements Servicios{
    private double base;
    private double altura;
...
...
 }

Ahora definimos dos constructores, uno vacío y otro con parámetros.

    public Piramide(){}
 
    public Piramide(double b,double h){
        this.base=b;
        this.altura=h;
    }

Agregamos el método «volumen()».

    @Override
    public double volumen(){
        return (base*altura)/M;
    }

Finalmente la clase principal donde se visualiza el resultado de calcular el volumen de una pirámide en Java.

public class VolumenPiramide{
//definimos un atributo de tipo "Servicios"
    Servicios servicio;
 
    public Ejemplos(){}
 
    public Ejemplos(Servicios serv){
        this.servicio=serv;
    }
 // con este método visualizamos el resultado
    public void activa(){
        System.out.println("volumen obtenido: "+servicio.volumen());
    }
 
    public static void main(String[] args) {
        Servicios piramide=new Piramide(10,15);// base:10, altura:15
        new Ejemplos(piramide).activa();
    }
}

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
Java

Calcular el volumen de un cilindro en Java

09/Mar/2013

Para calcular el volumen de un cilindro en Java emplearemos la función Math.PI de la clase java.lang.Math en la siguiente fórmula:

volumen= Math.PI*(r*r)*h

Donde r es el radio del cilindro y h su altura. Vamos a crear un método que obtenga el volumen de un cilindro en Java y le llamaremos «volumen()», y otro que muestre el resultado que llamaremos «ver()» dentro de una interface.

interface Servicios{
  public abstract double volumen();
  public abstract void ver();
}

En las interfaces todos los métodos son abstractas y se puede omitir las palabras public y abstract.

Necesitamos ahora una clase que implemente esa interface.

class Cilindro{
   public Cilindro(){}
}

Es necesario agregarle dos miembros (radio y altura) y definir un constructor con parámetros.

class Cilindro implements Servicios{
 	private double radio;
 	private double altura;

 	public Cilindro(){}

 	public Cilindro(double _radio,double _altura){
 		this.radio=_radio;
 		this.altura=_altura;
 	}

  }

Una vez hecho esto le agregamos los métodos de la interface:

@Override
public void ver(){
 	System.out.println(toString());
}

public String toString(){
	return String.format("volumen obtenido : %f",volumen());
}

@Override
public double volumen(){
	return Math.PI*(radio*radio)*altura;
}

Es de notarse que el método «toString()» es propio de la clase Cilindro.

Para mostrar el resultado tenemos la clase principal «VolumenCilindro».

public class VolumenCilindro{
        //Interface nombreInstancia= new ClaseImpl();
        Servicios cilindro=new Cilindro(2,6);
 		cilindro.ver();
}

Ya tenemos nuestro programa que calcula el volumen de un cilindro 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