feed twitter facebook LinkedIn facebook

Java » Hola mundo con JavaFX

febrero 24, 2014 por ARIEL 5 Comentarios Imprimir Imprimir

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.

  1. Button boton = new Button("Saludar");
  2. boton.setVisible(true);
  3. boton.setOnAction(new EventHandler<ActionEvent>() {
  4. public void handle(ActionEvent event) {
  5. System.out.println("Hola Mundo!!!");
  6. }
  7. });

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.

  1. panel = new StackPane();

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

  1. 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.

  1. 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

  1. primaryStage.setTitle("Iniciando con Java FX");
  2. primaryStage.setScene(escena);
  3. 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

  1. 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.

  1. public class Main extends Application {
  2. @Override
  3. public void start(Stage primaryStage) throws Exception{
  4. ...
  5. }
  6. }

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

Java » Convertir una Lista en un Array

enero 31, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya vimos en su momento como podíamos convertir, de una forma sencilla, un array en una lista en Java. En este caso vamos a ver la operación contraria que será convertir una lista en un array con Java.

Lo primero será definir una Lista. Para ello utilizamos el interface List implementado mediante una clase ArrayList. Hay que recordar que cuando utilicemos colecciones tenemos que indicar el tipo de colección que estamos utilizando. En nuestro caso vamos a crear una lista de cadenas o String.

  1. List<String> milista = new ArrayList<String>();

Para insertar cada uno de los elementos en la lista utilizamos el método .add().

  1. milista.add("Elemento 1");
  2. milista.add("Elemento 2");

Lo siguiente será crear el array sobre el que vamos volcar el contenido de la lista. A la hora de crear el array deberemos de asignarle el tamaño que tenga la lista. Para saber el tamaño de una lista en java utilizamos el método .size()

  1. String[] miarray = new String[milista.size()];

El interface List tiene un método .toArray() este es el método clave que nos va a convertir una lista en un array con Java. Así que simplemente invocamos el método indicando como parámetro el array sobre el que queremos volcar el contenido.

  1. miarray = milista.toArray(miarray);

Ahora, para comprobar que hemos realizado bien el proceso de convertir una lista en un array con Java vamos a recorrer el contenido del array y ver que es el mismo que insertamos en la lista.

  1. for(String s : miarray)
  2. System.out.println(s);

Y hasta aquí nuestro ejemplo de como convertir una lista en un array con Java. Esperamos que os haya ayudado.

Java » Números repetidos en un array Java

enero 30, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Los ejercicios de manipulación de arrays son muy recomendables para aprender la lógica de programación Java, así como sus estructuras. De esta forma tenemos algunos ejemplos como encontrar el primer número repetido, encontrar el número mayor y su posición,...

En este caso vamos a ver como podemos encontrar los números repetidos en un array Java. Es decir, la idea es partir de un primer array que contenga los números a buscar.

  1. int numeros[] = {1,2,3,4};

Y tener un segundo array que contenga la lista sobre la que buscamos.

  1. int lista[]= {2,4,5,2,4,4,4,3,4,2,3};

Una solución rápida sería realizar dos bucles for, el primero que recorra el primer array Java y el segundo que recorra el segundo array Java.

  1. for (int x=0;x<numeros.length;x++) {
  2. for (int y=0;y<lista.length;y++) {
  3. if (numeros[x]==lista[y])
  4. System.out.println("El número "+numeros[x]+" está repetido");
  5. }
  6. }

La verdad que este código funcionaría ya que al recorrer los dos arrays Java chequearíamos todos los números. Si bien vamos a intentar que sea un poco más óptimo en la búsqueda. Y es que la idea es en primer lugar ir recorriendo el array de números (igual que hacíamos antes).

  1. for (int x=0;x<numeros.length;x++) {
  2. ....
  3. }

Pero en la búsqueda sobre la lista vamos a utilizar un bucle while de Java. Este bucle contendrá dos condiciones, por un lado la del límite del array y por otro un flag que nos diga si hemos encontrado el número, ya que en este caso no hace falta buscar más y podremos parar la búsqueda.

El código sería el siguiente:

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {...}
  6. }

Vemos que hemos utilizado un flag encontrado que estará a "false" mientras no encuentre el número, será en este momento cuando cambiemos su valor para salir del bucle.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10. }

Ya solo nos quedará preguntar por la variable encontrado para ver si se ha encontrado el número.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10.  
  11. if (encontrado)
  12. System.out.println (numeros[x] + " es un número repetido. Encontrado en " + iter + " búsquedas");
  13. else
  14. System.out.println (numeros[x] + " no está en la lista. No encontrado en " + iter + " búsquedas");
  15. }

Adicionalmente vemos que en la variable iter tenemos el número de búsquedas que hemos realizado en el segundo array Java. Con esto ya tenemos resuelto como buscar números repetidos en un array Java.

Java » Calcular el sector circular en Java

septiembre 3, 2013 por ARIEL 1 Comentario Imprimir Imprimir

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".

  1. class Sector{
  2. private double radio;
  3. private double arco;
  4. //...
  5. }

Podemos definir un constructor y los métodos GET.

  1. class Sector{
  2. //...
  3.  
  4. public Sector(double radio,double arco){
  5. this.radio=radio;
  6. this.arco=arco;
  7. }
  8.  
  9. public double getRadio(){
  10. return radio;
  11. }
  12.  
  13. public double getArco(){
  14. return arco;
  15. }
  16.  
  17. }

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

  1. class Sector{
  2. //...
  3.  
  4. public double calculaAngulo(){
  5. return arco/radio;
  6. }
  7.  
  8. public double calculaSector(){
  9. return ((radio*radio)*calculaAngulo())/2;
  10. }
  11.  
  12. }

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

  1. class Sector{
  2. //...
  3.  
  4. @Override
  5. public String toString(){
  6. return "Sector{radio: "+getRadio()+ ",arco:"+getArco()+", sector circular obtenido: "+calculaSector()+"}";
  7. }
  8.  
  9. //este es el método que muestra los datos calculados
  10. public void ver(){
  11. System.out.print(toString());
  12. }
  13.  
  14. }

La clase Java principal tiene el siguiente aspecto:

  1. public class Principal{
  2. public static void main(String[] args)throws Exception{
  3.  
  4. }
  5. }

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

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

Instanciamos la clase Sector.

  1. import java.util.Scanner;
  2.  
  3. public class Ejemplos{
  4. public static void main(String[] args) {
  5. Scanner in=new Scanner(System.in);
  6. Sector sector=null;
  7. }
  8. }

Definimos dos variables: radio y longitud del arco

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

Solicitamos los datos al usuario.

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

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

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

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}

Java » Usar una Hashtable Java

agosto 2, 2013 por Francisco Meza 3 Comentarios Imprimir Imprimir

Una Hashtable Java es una estructura de datos que utiliza una función hash para identificar datos mediante una llave o clave (ej. Nombre de una persona). La función hash transforma una llave a un valor índice de un arreglo de elementos. En este caso a una índice de nuestra Hashtable Java.

Una Hashtable Java más específica del funcionamiento es la siguiente:

Identificador Dato
101 Harry
102 Potter
103 IRONMAN
104 IRONMAN
105 HALLO

Vea que el identificador será el que hace referencia a los datos en este caso solo será un nombre, para este caso haremos un pequeño ejemplo en java donde solo manejaremos una clase la cual tendrá las siguientes propiedades: un objeto de tipo hash con sus respectivos métodos, los elementos de la tabla y finalmente el main dentro de la misma clase

Lo primero será definir una variable contenedor para instanciar la clase Hashtable Java:

  1. Hashtable<String,String> contenedor=new Hashtable<String,String>();

Nos vamos a ayudar del método .put() para insertar elementos dentro de la Hashtable Java:

  1. contenedor.put("101", "Harry");
  2. contenedor.put("102", "Potter");
  3. contenedor.put("103", "IRONMAN");
  4. contenedor.put("104", "IRONMAN");
  5. contenedor.put("105", "HALLO");

El primer elemento será la clave y el segundo será el valor a almacenar.

Si queremos obtener un valor de la Hashtable Java tendremos que pasarle al método .get() la clave que queremos recuperar:

  1. System.out.println(contenedor.get("105"));
  2. System.out.println(contenedor.get("101"));

Mediante un Enumeration vamos a recorrer el contenido de nuestra Hashtable Java:

  1. Enumeration<String> enumeration = contenedor.elements();
  2. while (enumeration.hasMoreElements()) {
  3. System.out.println(""+"hashtable valores: " + enumeration.nextElement());
  4. }

Si queremos saber cuales son las claves de la Hashtable Java usamos el método .keys().

  1. Enumeration<String> llaves = contenedor.keys();
  2. while (llaves.hasMoreElements()) {
  3. System.out.println(""+"hashtable llaves: " + llaves.nextElement());
  4. }

También se puede obtener la enumeración de todas las claves mediante el uso del método .keys().

  1. System.out.println("Claves: " +contenedor.keys());

En unas pocas líneas de código hemos visto como poder usar una Hashtable Java.

Java » Calcular el volumen de una esfera en Java

junio 16, 2013 por ARIEL 1 Comentario Imprimir Imprimir

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"

  1. interface Servicio{
  2. public abstract void ver();
  3. }

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:

  1. abstract class Figura implements Servicio{
  2. private double radio;
  3. //este es el método que calcula el volumen de la esfera
  4. public abstract double volumen();
  5.  
  6. public Figura(){}
  7.  
  8. public Figura(double _radio){
  9. this.radio=_radio;
  10. }
  11.  
  12. public double getRadio(){
  13. return this.radio;
  14. }
  15. }

La Clase Concreta

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

  1. class Esfera extends Figura{
  2. double r;
  3.  
  4. public Esfera(){}
  5.  
  6. public Esfera(double _r){
  7. super(_r);
  8. r=_r;
  9. }
  10.  
  11. @Override
  12. public double volumen(){
  13. return ((4/3) * Math.PI*(r*r*r));
  14. }
  15.  
  16. @Override
  17. public void ver(){
  18. System.out.println(String.format("radio: %f , volumen esfera: %f",getRadio(),volumen()));
  19. }
  20. }

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:

  1. public class VolumenEsfera{
  2.  
  3. public static void main(String[] args) {
  4. Figura esfera=new Esfera(20);
  5. esfera.ver();
  6. }
  7. }

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.

Java » Calcular el volumen de un cono en Java

junio 14, 2013 por ARIEL 4 Comentarios Imprimir Imprimir

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:

  1. 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á:

  1.  
  2. public class VolumenCono {
  3. public static void main(String[] args) {
  4. //aqui va el código
  5. }
  6. //aqui va el método
  7. }

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:

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

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

  1. double radio=Double.parseDouble(JOptionPane.showInputDialog("Introduce radio:"));
  2. 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

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

Java » 5 Ejemplos de Arrays en Java

junio 12, 2013 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Una buena de empezar a programar con arrays en Java es aprenderte los 5 ejemplos de arrays en Java:

5 Ejemplos de Arrays en Java

Si quieres incluir la imagen en tu web puedes utilizar el siguiente código:

  1. <!-- BEGIN Infografia Linea de Codigo -->
  2. <a href="http://lineadecodigo.com/java/5-ejemplos-de-arrays-en-java/">
  3. <img alt="5 Ejemplos de Arrays en Java en Linea de Codigo" src="http://lineadecodigo.com/wp-content/uploads/2013/06/LDC_ArraysEnJava-795x1024.jpg" width="477" height="614" />
  4. </a>
  5. Originalmente en <a href="http://lineadecodigo.com/java/5-ejemplos-de-arrays-en-java/">Linea de Codigo</a>
  6. <!-- END Infografia Linea de Codigo -->

Java » Calcular el volumen de una pirámide en Java

marzo 14, 2013 por ARIEL 3 Comentarios Imprimir Imprimir

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.

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

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.

  1. class Piramide implements Servicios{
  2. private double base;
  3. private double altura;
  4. ...
  5. ...
  6. }

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

  1.  
  2. public Piramide(){}
  3.  
  4. public Piramide(double b,double h){
  5. this.base=b;
  6. this.altura=h;
  7. }
  8.  

Agregamos el método "volumen()".

  1.  
  2. @Override
  3. public double volumen(){
  4. return (base*altura)/M;
  5. }
  6.  

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

  1.  
  2. public class VolumenPiramide{
  3. //definimos un atributo de tipo "Servicios"
  4. Servicios servicio;
  5.  
  6. public Ejemplos(){}
  7.  
  8. public Ejemplos(Servicios serv){
  9. this.servicio=serv;
  10. }
  11. // con este método visualizamos el resultado
  12. public void activa(){
  13. System.out.println("volumen obtenido: "+servicio.volumen());
  14. }
  15.  
  16. public static void main(String[] args) {
  17. Servicios piramide=new Piramide(10,15);// base:10, altura:15
  18. new Ejemplos(piramide).activa();
  19. }
  20. }
  21.  

Java » Calcular el volumen de un cilindro en Java

marzo 9, 2013 por ARIEL Sin Comentarios Imprimir Imprimir

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.

  1. interface Servicios{
  2. public abstract double volumen();
  3. public abstract void ver();
  4. }

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.

  1. class Cilindro{
  2. public Cilindro(){}
  3. }

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

  1. class Cilindro implements Servicios{
  2. private double radio;
  3. private double altura;
  4.  
  5. public Cilindro(){}
  6.  
  7. public Cilindro(double _radio,double _altura){
  8. this.radio=_radio;
  9. this.altura=_altura;
  10. }
  11.  
  12. }

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

  1.  
  2. @Override
  3. public void ver(){
  4. System.out.println(toString());
  5. }
  6.  
  7. public String toString(){
  8. return String.format("volumen obtenido : %f",volumen());
  9. }
  10.  
  11. @Override
  12. public double volumen(){
  13. return Math.PI*(radio*radio)*altura;
  14. }

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

Para mostrar el resultado tenemos la clase principal "VolumenCilindro".

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

Ya tenemos nuestro programa que calcula el volumen de un cilindro en Java.