Un slideshow viene a significar visor de imágenes o diapositivas que van pasando una tras otra.
Estuve buscando para descargar slideshows para web. Encontré de todo tipo, muy elaborados y con muchos extras, unos de pago y otros gratis, pero no era lo que yo quería. Buscaba algo lo más sencillo posible para adaptarlo luego donde lo necesite y al final acabé programándolo a partir de jQuery.
Aquí va el código para el que lo necesite:
<html> <head> <!– Con ésto incluyes el jquery en tu web usando en CDN de Google –> <script src=»https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js»></script> </head> <body> <img id=»imagenslide» src=»imagenes/imagenInicial.jpg» alt=»Imagen de una mascota..» /> <script> cambiaSlideShow(); function cambiaSlideShow() { // variables para configurar var dirImagenes = ‘imagenes/’; // directorio donde estan // las imágenes, se deben nombrar de la forma // 1.jpg // 2.jpg // etcétera… var numImagenes = 3; // número de imágenes que hay // elige un número aleatorio para mostrar las imágenes // aleatoriamente var randomNum = Math.ceil(Math.random() * numImagenes); // con ésto la imagen desaparece y cuando ha desaparecido // cambia de imagen $(‘#imagenslide’).fadeOut(3000, function () {$(‘#imagenslide’).attr(‘src’, dirImagenes + randomNum + ‘.jpg’);} ); // con ésto otro la imagen aparece con un efecto fade de nuevo $(‘#imagenslide’).fadeIn(3000); setTimeout(function () {cambiaSlideShow(); }, 7000); } </script> </body> </html>
Y un archivo para descargar el ejemplo haciendo click aquí. Ten en cuenta que debes poner las imágenes en el directorio dirImagenes que tengas en dicha variable.
Ya le he puesto al blog un Favicon, y les dejo un nuevo post.
Cuando navegas por Internet, las páginas muestran un icono en tu navegador. Cuando agregas dicha web a Favoritos, Marcadores, o como se llame en el navegador que uses.. También verás dicho icono asociado a dicha página web. Ésto es lo que se llama ‘el Favicon’.
Favicon, viene de Favourites Icon, icono de favoritos en castellano. Nació para darle mejor estética al listado de páginas de nuestra lista de páginas web favoritas. Y si quieres que tu web tenga una imagen de éstas lo único que debes hacer es usar un código tal que así:
<html> <head> <title>Aquí va el título</title> <link href=»http://direcciondetuweb/favicon.ico» rel=»icon» type=»image/x-icon»> </head> <body> <p>Contenido de la página.</p> </body> </html>
La imagen debe ser de 16×16 pixeles tradicionalmente, también puede ser de 32×32, incluso se pueden usar en algunos navegadores imágenes en JPG, PNG y GIF. Pero éstas otras opciones no son totalmente estándar y puede que no funcionen en todos los navegadores.
En éste blog, gracias a Blogger, tengo disponible el gadget llamado tal cual Favicon, que automáticamente me genera el código de aquí arriba. Yo te lo he detallado por si acaso lo usas en otro sitio.
Así que, después de éste post ¿no merece que agregues ésta web a favoritos? agregame a favoritos y así me visitas de vez en cuando
Aquí dejo cómo crear una primera aplicación gráfica en Java usando Swing y Eclipse. El ejercicio clásico ¡Hola Mundo! usando una tecnología que nos brinda Java crear aplicaciones con entorno gráfico, Java Swing. Y para verlo, el entorno de desarrollo elegido ha sido Eclipse.
Curioseando qué tal van los desarrollos, con respecto a las interfaces gráficas de usuario (llamadas GUI para los amigos), veo que tengo otra nueva actualización del Window Builder. El Window Builder es un conjunto de plugins de Eclipse que nos van a permitir hacer GUIs en Java sin gastar casi tiempo.
A fecha de hoy tengo la versión Juno de Eclipse, y me acabo de instalar el plugin Swing Designer que está disponible dentro del propio Eclipse, en la famosa opción Help -> Install New Software. Instalada la versión 1.5.1 del Swing Designer, me he puesto manos a la obra.
En el Explorador de Proyectos, donde estés creando tu aplicación Java, le das con el botón derecho del ratón a New -> Other… Y verás una ventana como la siguiente donde puedes elegir todo el tipo de ficheros, clases, o lo que sea que quieras hacer:
Se parece a Visual Studio, NetBeans o IDEs similares ¿verdad? Personalmente no creo que Eclipse tenga nada que envidiar a ningún otro entorno de desarrollo de pago, o no de pago. ¿Qué más queremos teniendo Eclipse? Parezco un vendedor de Eclipse (jejejje es broma). Bromas aparte, depende de dónde te encuentres te irá mejor un entorno de desarrollo u otro…
Seguimos con lo que tenemos entre manos. He creado mi nueva Application Window que he llamado HolaMundoSwing y se me abre una ventana dentro de Eclipse tal que así:
Me ha generado 44 líneas de código, con las que ya tengo mi ventana con el programa básico. Tenemos disponible absolutamente todo el código necesario para crear aplicaciones con GUIs, es decir, que no se nos esconde nada del código fuente. Podríamos usar éste mismo código fuente en línea de comandos, y compilar nuestro programa Java con el javac.exe sin usar Eclipse. Lo que quiero explicar, es que Eclipse te genera y te da todo el código fuente, sin crear archivos secundarios en tu proyecto donde gestione la parte gráfica. No te atas a Eclipse. Es decir, en éste caso todo lo necesario está dentro del mismo fichero, te puedes llevar ésta recién creada aplicación de ventanas a otro sitio con sólo llevarte el fichero HolaMundoSwing.java y seguir programando.
Vamos ahora a lo que más nos va a interesar, el diseñador de formularios que nos va a ahorrar mucho tiempo en el diseño de la interfaz de usuario. Abajo tenemos una pestaña que pone ‘Design’, diseño en castellano. Le damos y nos sale una ventana como la siguiente. Aquí es donde podemos editar visualmente todo tipo de componentes visuales del estilo de botones, cajas de texto, grupos de selección, podemos poner imágenes, menús, y un largo etcétera…
Cómo se usa cada componente merece un post, así que éste lo voy a dejar así.
Lo lógico es que quieras juguetear poniendo componentes en tu nueva ventana. Para poder posicionarlos donde quieras hay que poner antes de nada en el formulario un ‘Absolute layer’ que tenemos en la sección ‘Layouts’. Después ya podrás poner los componentes donde quieras. En pocos segundos he puesto un botón, una etiqueta y una caja de selección, como podemos ver en la imagen de aquí arriba. Si volvemos a la pestaña de abajo donde pone ‘Source’, en nuestro Eclipse, veremos que automáticamente se ha generado todo el código correspondiente para dibujar los componentes en nuestro GUI. Queda después añadir el código para hacer funcionar cada cosa.
Puedes hacer doble click en el botón para ver la facilidad con que puedes empezar a programar. Se te pondrá delante el código fuente y la función donde puedes programar el click del botón. Verás un código tal que así:
JButton btnNewButton = new JButton(«Botu00F3n»); btnNewButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // AL HACER CLICK EJECUTA ÉSTO } }); btnNewButton.setBounds(10, 11, 89, 23); frmholaMundoSwing.getContentPane().add(btnNewButton);
Aquí queda ésta pequeña introducción a los Swings de Java. Si quieres hacer un fichero ejecutable de Java, un .JAR y distribuir el programa que acabas de hacer; en la ventana del explorador de proyectos, le das con el botón derecho del ratón al fichero HolaMundoSwing.java. Se despliega el menú y le haces click en Exportar. Luego eliges Java JAR file. Eliges destino. Y ya tienes un ejecutable .jar que puedes usar en cualquier ordenador con el JRE instalado.
Vamos a ver cómo se usan las clases de tipo interface. Se usan de igual manera que las clases abstractas, pero tienen unas características peculiares propias de ellas que las diferencian. Las interfaces establecen las variables y funciones que se van a tener, pero no se implementan las funciones dentro de ellas, sino que se implementan en las clases derivadas.
No podemos heredar de varias clases abstractas, pero sí que se puede hacer herencia múltiple usando interfaces.
Un ejemplo para explicarlo todo ésto es el siguiente:
package javaMedio; public class JavaMedio5Interfaz { public static void main(String[] args) { unaClase a; a = new unaClase(); a.nombre = «María»; a.escribir(); a.contar(); } } abstract class cBase { public String nombre; public void escribir() { System.out.println(nombre); } } interface iBase { public static int version = 2; public void contar(); } class unaClase extends cBase implements iBase { public void contar() { System.out.println(«versión: » + version + «rnvamos a contar: 0,1,10,11,100,101,110,111,1000…»); } }
Su salida es la siguiente:
María versión: 2 vamos a contar: 0,1,10,11,100,101,110,111,1000…
Vamos con la clase que hereda todo:
class unaClase extends cBase implements iBase { public void contar() { System.out.println(«versión: » + version + «rnvamos a contar: 0,1,10,11,100,101,110,111,1000…»); }
Observa que extiende cBase e implementa iBase, extends e implements son palabras clave. Dentro de ésta clase sólo se implementa la función contar(), y la función escribir ya está implementada.
No tiene más complicaciones, espero que haya servido de aclaración si eres nuevo o de recuerdo si ya eres veterano en ésto.
Algo raro pasa con static. Surge de la necesidad de compartir datos o código entre todas los objetos de una misma clase.
Por ello, los atributos declarados como static dentro de una clase, existen incluso sin tener ningún objeto de la clase, y se puede acceder a ellos con sólo haber cargado la clase en la JVM. Es decir, por ejemplo, si tenemos una clase como la siguiente:
package javaMedio; public class Persona { public String nombre = new String(); public static String nombreDeLaClase = new String(«Persona»); private static String version = new String(«1.0.0»); public void escribir() { System.out.println(«Ésta persona se llama » + nombre); System.out.println(«…» + nombreDeLaClase); System.out.println(«…» + version); } }
Y en otro fichero tenemos algo tal que así:
package javaMedio; public class JavaMedio4Static { public static void main(String[] args) { System.out.println(Persona.nombreDeLaClase); // no podemos hacer ésto // System.out.println(Persona.version); Persona p1 = new Persona(); Persona p2 = new Persona(); p1.nombre = «Pepito»; p2.nombre = «Juanito»; // no debemos, pero podemos hacer ésto p1.nombreDeLaClase = «Clase de nombre Persona»; // deberíamos hacer así Persona.nombreDeLaClase = «Clase de nombre Persona»; // para evitar confusiones // porque todas las Personas // van a tener la misma variable // nombreDeLaClase p1.escribir(); p2.escribir(); } }
Observa que al principio del main accedemos directamante a la variable Persona.nombreDeLaClase sin haber declarado tan siquiera un objeto de tipo Persona. Sólo porque están en el mismo package las dos clases entonces ya podemos acceder a la variable. Y se puede acceder a ésta variable porque ya está cargada en la máquina virtual de Java y es accesible.
Luego más abajo tenemos cómo cambiar una variable static pública. Para terminar observa que no se puede acceder desde fuera a una variable static privada. Si declaramos más objetos de tipo Persona, todos van a tener el mismo valor de las variables static.
La salida del programa es la siguiente:
Persona Ésta persona se llama Pepito …Clase de nombre Persona …1.0.0 Ésta persona se llama Juanito …Clase de nombre Persona …1.0.0
Retomando el ejemplo. Viendo la salida del programa, tenemos la variable nombre, que cada objeto tiene un valor distinto (Pepito y Juanito). Y por otro lado el nombreDeLaClase y versión, que tienen el mismo valor tanto para p1 como para p2, es decir, comparten éstas dos mismas variables. Éste es un ejemplo sencillo pero da mucho más juego el uso de static.
Continuando con la herencia y polimorfismo de las clases vamos a ver qué son los métodos y clases abstractas. Cuando una clase va a ser la base para otras, pero no van a codificarse las funciones que tiene, sino que se van a hacer en las clases que la extienden, entonces declaramos la clase como abstract.
Vamos a ver con un ejemplo cómo se usa, es muy sencillo:
package javaMedio; public class JavaMedio3Abstract { public static void main(String[] args) { claseBase objeto1, objeto2; // ésto no lo podemos hacer porque es abstract // objeto1 = new claseBase(); objeto1 = new claseA(); objeto2 = new claseB(); objeto1.cadena = «cadena del objeto1»; objeto2.cadena = «cadena del objeto2»; objeto1.escribir(); objeto2.escribir(); } } abstract class claseBase { public byte x, y; public String cadena; public abstract void escribir(); }
class claseA extends claseBase { public void escribir() { System.out.println(«Esto es un objeto de la claseA: » + cadena); } } class claseB extends claseBase { public void escribir() { System.out.println(«Esto es un objeto de la claseB: » + cadena); } }
Como vemos, no podemos reservar memoria para un objeto de tipo claseBase, porque éste tipo de objeto es base de otros, es decir, que al ser abstract sólo se puede usar para construir a partir de ellos otros.
¿Sencillo verdad? No tiene más complicaciones el tipo abstract.
Queda decir que la salida del programa anterior es:
Esto es un objeto de la claseA: cadena del objeto1 Esto es un objeto de la claseB: cadena del objeto2
Sábado sabadete, aquí va otro tutorialete… xD para los que esten siguiendo estos minitutoriales para aprender a programar en Java, vamos a continuar con los conocimientos indispensables antes de empezar a hacer programas más o menos grandes. O si ya te has enfrascado con alguno y necesitas saber ésto de los extends espero que aclare las cosas.
Ésta vez voy a explicar cómo reutilizar código, para no tener que hacer una y otra vez lo mismo o para mantener el código bien organizado utilizando la herencia y polimorfismo.
Vamos a ver cómo crear clases reutilizando el código de clases ya creadas, de manera que podremos ampliar su uso añadiendo nuevas funciones o miembros de la clase, o podremos modificar los existentes. Todo ésto se hace con la palabra reservada extends.
A saber, al utilizar extends, la clase que extiende a otra hereda todas las variables y funciones de la otra. A ésto se le llama herencia. Y por otro lado, en la clase que ha heredado, por ejemplo una función, podemos volver a declararla en la clase que extiende, de manera que haga otra cosa. A ésto otro se le llama polimorfismo.
Ésto es todo lo que hay que saber, ahora lo vamos a ver todo de una vez con un ejemplo sencillo que incluya todo ésto que hemos visto. Al grano:
package javaMedio; public class JavaMedio2Extends { public static void main(String[] args) { Circulo ci = new Circulo(); ci.coordenadaX = 0; ci.coordenadaY = 1; ci.color = «verde»; ci.radio = 2; Cuadrado cu = new Cuadrado(); cu.coordenadaX = 2; cu.coordenadaY = 3; cu.color = «rojo»; cu.lado = 2; ci.escribir(); cu.escribir(); } } class Objeto { byte coordenadaX, coordenadaY; String color; public void escribir() { System.out.println(«(» + coordenadaX + «, » + coordenadaY + «) « + color); } } class Circulo extends Objeto { int radio; } class Cuadrado extends Objeto { int lado; public void escribir() { System.out.println(«Esto es un cuadrado de color » + color); } }
Éste programilla nos va a dar de resultado:
(0, 1) verde Esto es un cuadrado de color rojo
Vamos a ver ahora el porqué por ejemplo podemos escribir ci.escribir(); si la clase Circulo no tiene una función escribir(). En el main hemos declarado la variable ci de tipo Circulo: Circulo ci = new Circulo();
… y en la clase Circulo tenemos:
class Circulo extends Objeto { int radio; }
… notad que sólo hay una variable llamada radio, y en el main estamos utilizando la siguiente instrucción:
ci.escribir();
… y no nos da error. Esto es porque Circulo extiende la clase Objeto y la clase Objeto SÍ que tiene la función escribir():
Podemos ver que la clase Circulo ha heredado la función escribir(), de igual manera del resto de variables coordenadaX, coordenadaY y color. Estan declaradas en la clase Objeto pero se usan con la variable ci que es de tipo Circulo:
Círculo ha heredado todo de la clase Objeto y le ha añadido la variable radio. Sin embargo Cuadrado he heredado también pero en vez de tener radio, lo que tienes es lado.
Ahora vamos con el polimorfismo, que en ejemplo lo tenemos con el Cuadrado. Ya tenemos una función escribir() en la clase Objeto, al declarar Cuadrado que hereda de Objeto tendrá la función escribir() ya de por sí, pero al haberla declarado dentro de Cuadrado y haber hecho que haga algo diferente entonces está ocurriendo el llamado polimorfismo. Poli-morfismo, que significa varias formas, viene a decir que el Cuadrado y Circulo, aunque los dos sean Objetos tienen distinta forma porque la función escribir funciona de diferente manera. Por ésto cuando en el main pusimos:
ci.escribir(); cu.escribir();
Nos escribe cosas diferentes, porque el Circulo utiliza la función escribir() de Objeto, mientras que Cuadrado utiliza la suya propia que se ha reprogramado:
(0, 1) verde <- resultado de ci.escribir(); Esto es un cuadrado de color rojo <- resultado de cu.escribir();
Ya a partir de aquí hay que seguir con las interfaces, las clases abstractas y otras cosas más, pero no es objetivo de éste post. Tal vez más adelante en otro.
Espero que sirva para aprender si eres nuevo, o te haya aclarado algo si estas refrescando la memoria.
Vamos a ver cómo organizar los programas Java, en clases u objetos como prefiramos llamarlos. Cómo dividir los códigos fuentes en distintos ficheros o cómo plantearse la creación de un programa bien grande estructurándolo para poder hacerlo poco a poco, repartiendo el trabajo o haciéndolo en partes más simples.
Todo son clases en Java, y estas clases se organizan packetes, llamados packages en inglés. Podemos crear clases a partir de otras clases utilizando el extends. Y cada clase la podemos separar individualmente en cada fichero. Por otro lado los paquetes de clases los podemos importar para usarlos en una clase mediante la instrucción import. Resumiendo ésto es todo, a continuación lo veremos explicado.
Cada fichero se debe nombrar con el nombre de la clase principal. Un ejemplo que nos va a servir para comprender varios conceptos es el siguiente:
package javaMedio; import java.util.Date; public class JavaMedio1ClasesPaquetes { public static void main(String[] args) { Persona p = new Persona(); p.nombre = «Pepito»; p.escribir(); } } class Persona { String nombre = new String(); Date fechaCreacion = new Date(); public void escribir() { String aux = new String(); aux = «Objeto de tipo Persona con nombre: » + nombre + «n» + «Creado en fecha: » + fechaCreacion; System.out.println(aux); } }
Éste programa de aquí arriba debemos guardarlo en un fichero llamado JavaMedio1ClasesPaquetes.java para que funcione y no nos de error. Para empezar escribimos el paquete al que pertenece una clase mediante una línea como la que sigue: package JavaMedio; Podemos tener muchas clases dentro del paquete JavaMedio, y si queremos usar todas las clases del paquete en una nueva clase deberemos importar el paquete mediante la instrucción import. En el ejemplo, a continuación, vemos que se ha importado la clase fecha (Date en inglés), que está dentro del paquete de utilidades que proporciona Java de la siguiente manera: import java.util.Date;
Si queremos importar todas las utilidades de Java, lo haríamos de la forma siguiente:
import java.util.*; A continuación se declara la clase principal con la función main principal, porque es una aplicación de consola, es decir, se ejecuta en línea de comandos:
public class JavaMedio1ClasesPaquetes { public static void main(String[] args) { Persona p = new Persona(); p.nombre = «Pepito»; p.escribir(); } }
Podemos leer la clase JavaMedio1ClasesPaquetes es una clase pública, es así porque tiene el main. Y dentro del main tenemos que se declara la variable p de tipo Persona, se reserva memoria, se le pone el nombre Pepito y a continuación se llama a la función escribir() de la clase Persona. Hay varios tipos de clases que son: abstract, final, public y synchronizable. Abstract son clases que se usan para hacer otras con ellas. Final son clases con las que no se pueden hacer otras a partir de ellas. Las public son las normales. Y las synchronizable son clases que no se pueden usar en paralelo desde dos hilos de ejecución distintos. Para más información sobre las clases de tipo synchronizable acudir a la programación multihilos de Java. En la declaración de la clase Persona podemos ver que no es una clase pública, esto se hace así porque la he puesto dentro del mismo fichero, y no debe haber más que una clase pública en cada fichero. Vamos a analizar el código de la clase:
class Persona { String nombre = new String(); Date fechaCreacion = new Date(); public void escribir() { String aux = new String(); aux = «Objeto de tipo Persona con nombre: » + nombre + «n» + «Creado en fecha: » + fechaCreacion; System.out.println(aux); } }
Vemos que la clase Persona tiene dos variables: nombre y fechaCreacion. Y tiene una función pública: escribir(). La función lo que hace es escribir las variables internas de Persona. La variable nombre podemos acceder a ella desde fuera, es decir, es pública, como podemos observar en el main: p.nombre = «Pepito»; Ésta instrucción nos lo permite. Siempre que una variable no se le ponga el tipo de control de acceso permitido, se supone pública. Podríamos haber escrito mejor en la clase Persona:
class Persona { public String nombre = new String(); public Date fechaCreacion = new Date(); …
Así estaría más claro el nivel de acceso desde fuera de la clase. El control de acceso dentro de una clase se especifica mediante las palabras public, protected y private. Public indica que la variable o función se puede usar desde fuera. Private es lo contrario que public, protected indica que sólo acceder si la clase que accede es del mismo paquete.
Si queremos usar la clase Persona desde otras clases o ficheros deberíamos separar en un fichero la clase, quedaría un fichero llamado Persona.java que tendría lo siguiente:
package javaMedio; import java.util.Date; public class Persona { public String nombre = new String(); public Date fechaCreacion = new Date(); public void escribir() { String aux = new String(); aux = «Objeto de tipo Persona con nombre: » + nombre + «n» + «Creado en fecha: » + fechaCreacion; System.out.println(aux); } }
Entonces el primer fichero llamado JavaMedio1ClasesPaquetes.java quedaría:
package javaMedio;
public class JavaMedio1ClasesPaquetes {
public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}
}
Podemos ver que tanto la clase JavaMedio1ClasesPaquetes como Persona están en el mismo paquete, entonces para usar Persona en el fichero JavaMedio1ClasesPaquetes.java no hace falta usar el import.
Para terminar, saber que algunos de los paquetes principales que proporciona Java son los siguientes para el que quiera continuar investigando:
java.appletPara la creación de Applets. java.io Para manejo de la entrada y salida. java.lang Paquete de clases variadas. java.netAquí tenemos clases que usan TCP/IP. java.utilUtilidades variadas. java.awt Para hacer interfaces de usuario con botones, ventanas, etcétera. java.swingMás compatible con los distintos Sistemas Operativos que la AWT, yo usaría ésta en vez de la AWT porque te aseguras de que tu programa va a funcionar en más plataformas.
Por ahora queda terminado este minitutorial sobre clases y paquetes. Saludos;}
Ya estamos a domingo de nuevo, parece que va siendo costumbre los domingos de nuevo escribir un post. Vamos a empezar con un tipo de variables que vamos a usar para almacenar muchos datos de igual naturaleza, es decir, los llamados vectores y matrices. Algunos llaman a los vectores matrices también porque son matrices de una sola fila.
Imaginemos pues que queremos guardar 3 elementos de tipo entero. Para ello usaremos lo siguiente:
package javaBasico; public class JavaBasico6Matrix { public static void main(String[] args) { // declaración de la variable ‘vector’ int vector[]; // se reserva memoria para guardar los // valores, es decir, guardamos 3 posiciones // de memoria de tipo entero vector = new int[3]; // guardamos en la posición 0 el número 2 vector[0] = 2; // guardamos… vector[1] = 3; // guardamos… vector[2] = 4; // escribimos en el out (pantalla) el vector System.out.println(vector[0] + «, » + vector[1] + «, » + vector[2]); } }
En Java siempre los vectores y matrices, también las clases que hagamos primero hay que declararlas y luego se les reserva memoria para poder usarlas. Es decir, la primera parte es decirle al programa que vamos a usar una variable, que le llamamos ‘vector’, y que va a ser un vector de enteros. Lo siguiente es realmente reservar una parte de la memoria del ordenador para guardar esos números enteros. Internamente el Sistema Operativo se encarga de la reserva de memoria, generalmente es en memoria principal (la RAM o caché). Hay que acordarse, siempre se declara, luego se reserva memoria. La memoria se libera automáticamente porque Java tiene un sistema por el que todas las variables usadas en una clase se borran en memoria cuando la vida de la clase ha terminado. Los tipos de datos primitivos sólo se declaran y directamente se utilizan sin tener que reservar memoria, ésta es una diferencia básica. Vamos ahora con las matrices. Si queremos por ejemplo almacenar valores como hacemos en una hoja de Excel, ordenando por filas y columnas, podemos usar una variable ‘matriz’ de la forma siguiente:
package javaBasico; public class JavaBasico6Matrix { public static void main(String[] args) { // declaración de la variable int matriz[][]; // se reserva memoria matriz = new int[2][2]; // guardamos… matriz[0][0] = 2; // guardamos… matriz[0][1] = 3; // guardamos… matriz[1][0] = 4; // guardamos… matriz[1][1] = 5; // escribimos en el out System.out.println(matriz[0][0] + «, » + matriz[0][1]); System.out.println(matriz[1][0] + «, » + matriz[1][1]); } }
Es igual que un vector pero ahora tenemos dos coordenadas, donde pone: matriz[a][b] a y b son las coordenadas.
Hay que fijarse en que en la reserva de memoria se le dice el tamaño o número de posiciones, pero a la hora de usar la variable, comenzamos por la posición 0 como primera posición. Ésto puede llevar a confusión porque la última posición de la matriz por ejemplo, no es matriz[2][2], sino es matriz[1][1], porque hemos empezado por matriz[0][0].
Falta decir que en un vector o en una matriz podemos poner enteros, decimales, o incluso objetos de la clase que queramos, por ejemplo:
package javaBasico; class Persona { // ésta es una clase que // de momento son String nombre; int edad; } public class JavaBasico6Matrix { public static void main(String[] args) { // declaración de la variable Persona personas[]; // se reserva memoria personas = new Persona[20]; } }
Podemos ver que con éste código hemos hecho un vector para guardar nombre y edad para 20 personas.
¡Hola de nuevo! Estoy cogiendo carrerilla con ésto de los tutoriales, me siento fresco, será el buen tiempo, que es fin de semana, los pájaros cantan, el indice Ibex sube, la prima de riesgo baja aquí en España. La cosa no está para echar cohetes pero bueno, si necesitas hacer cosas en Java, que ya están hechas, sólo tendrás que usarlas y entonces sí que vas a hechar cohetes. Vamos a ver unas clases de Java que nos facilitan la vida mucho, sobre todo si estas siguiendo el tutorial desde cero.
Para empezar, si vamos a utilizar cadenas de caracteres, Java nos proporciona la clase String. Podemos declarar variables de tipo String de la forma:
String cadena; cadena = «Aquí va la cadena de caracteres que queramos»; cadena = cadena + cadena; System.out.println(cadena);
Ésto anterior nos va a imprimir:
Aquí va la cadena de caracteres que queramosAquí va la cadena de caracteres que queramos
Lo que hemos visto aquí arriba es que la variable cadena le hemos dicho que almacene «Aquí va la cadena de caracteres que queramos», luego al hacer la suma lo que le hemos dicho que haga es que ahora cadena vale cadena + cadena, es decir, pon dos veces el valor de cadena.
Ahora vamos a leer una cadena desde el teclado, usando las clases BufferedReader, IOException e InputStreamReader: package javaBasico; import java.io.BufferedReader;
import java.io.IOException; import java.io.InputStreamReader; public class JavaBasico5ClasesComunes { public static void main(String[] args) throws IOException { String cadena; // ésto es un lector de buffer BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // daclarado de forma que br apunta al System.in // el System.in es la entrada del sistema, // que es el teclado System.out.print(«Escribe una cadena y pulsa enter: «); cadena = br.readLine(); // con el readLine lo que hace el programa es // esperar a que // escribas algo y aprietes enter, y lo // guarda en la variable // cadena System.out.println(«Has escrito: » + cadena); } }
El código fuente anterior habla por sí sólo, es la manera de leer una cadena desde el teclado, aunque es un poco confuso si eres nuevo en Java pero no te preocupes. Tenemos formas más fáciles de leer datos desde el teclado. Las clases System.in, System.out, y System.err son muy comunes. Por ejemplo el siguiente programa lee valores desde el teclado: package javaBasico; import java.io.IOException; public class JavaBasico5ClasesComunes {
public static void main(String[] args) throws IOException { char b; System.out.println(«Escribe una letra y pulsa enter: «); b = (char) System.in.read(); System.out.println(b); } }
Queda saber que el System.err es la salida del sistema para los errores. Normalmente lo que escribamos en el System.err se muestra en la pantalla. Es útil usar la salida de errores porque de ésta manera, más adelante podremos diferenciar entre lo que hemos escrito como error y lo hemos escrito en el out normal. Se supone que los errores a lo mejor queremos guardarlos en un fichero y sólo queremos que se vea en la pantalla lo que escribimos en el out. Un ejemplo de uso de out y del err, aunque ya hemos usado el out varias veces, es muy parecido:
System.out.println(«Ésto es salida normal, para el out»); System.err.println(«Ésto es un error, para el err»);
Más adelante podremos decirle al programa que haga algo concreto con lo que se escribe en la salida o en error, es lo que se llama redireccionar las salidas estándar o de errores.
No me voy a extender demasiado en éste post, así que como última clase de uso común de Java vamos a ver la clase Math. Si algo que tiene Java, es que es muy muy grande, y seguro que hay algo para lo que quieras. Me remito a la documentación de Java oficial a fecha de hoy:
… por si deseas entrar más en detalle sobre las clases disponibles.
Podemos observar lo rico que es Java en utilidades que tenemos disponibles, mire la siguiente imagen de mi Eclipse funcionando, programando para éste minitutorial con la clase Math, al escribir el punto se me despliega lo siguiente:
Puedes ver la cantidad de funciones matemáticas que tienes disponibles, ahora es cuando tienes que hechar cohetes no tienes que reinventar la rueda volviendo a programar cosas que ya tengas hechas. Recomiendo que antes de sentarse a programar funciones nuevas mire a ver si ya lo tenemos disponible listo para usarlo.
Un ejemplo sencillo de uso de la clase Math es:
package javaBasico; public class JavaBasico5ClasesComunes { public static void main(String[] args) { System.out.println(Math.abs(-23)); } }
Su resultado va a ser que va a escribir en la pantalla 23, que es el valor absoluto de -23.
Bueno con esto ya tienen para hacer unas pruebas o para seguir investigando por otro lado. Hay gran cantidad de funciones dentro de la clase Math: para hacer raices cuadradas, senos, cosenos, tangentes, logaritmos, máximos, mínimos, redondear… y también una gran cantidad de clases de uso común.
Si hay algo que no exista y necesites, puedes hacer tu propia clase de utilidades con las funciones quieras.
Ya lo veremos a lo mejor en otro tutorial.
Hola! hoy es domingo, tengo un rato libre, y he pensado avanzar un poco este curso de programación rápido con las funciones. Vamos a ver en líneas generales cómo dividir el código de nuestro programa para que sea más fácil luego leerlo, para desarrollarlo en partes o poco a poco, en fin, es de buena costumbre usar funciones cuando hacemos tareas que usan mas de unas 20 líneas de código.
Es decir, comenzamos escribiendo código en el ‘main’, y llegado el momento de que nuestro ‘main’ ocupa muchas líneas entonces se convierte en un mamotreto de código que es bien complicado de leer. Para evitar ésto lo dividimos con funciones como por ejemplo puede ser el código siguiente:
public class JavaBasico4Funciones { public static void main(String[] args) { PrincipioDelPrograma(); HacerCosa1(); HacerCosa2(); HacerCosa3(); FinalDelPrograma(); } static void PrincipioDelPrograma(){ } static void HacerCosa1(){ } static void HacerCosa2(){ } static void HacerCosa3(){ } static void FinalDelPrograma(){ } } De ésta manera queda más claro todo y podemos centrarnos en hacer los subprogramas declarados en las funciones. Éste es un ejemplo claro de la técnica de programación ‘Divide y vencerás’. También puede ocurrir que estamos escribiendo un programa y llegamos a un momento en que nos bloqueamos. Por ejemplo: … // un montón de líneas de código.. // llegamos al momento en que imprimimos el resultado System.out.println(«El resultado es:»); System.out.println(…
Ahora aquí deberíamos de imprimir el resultado del programa pero no sabemos cómo calcularlo, nos estan saltando chispas del cerebro, entonces ponemos:
System.out.println(ResultadoDelPrograma());
Y ya más adelante cuando tengamos la mente más fresca lo resolvemos programando la función que acabamos de poner aquí arriba:
static String ResultadoDelPrograma() { // aquí dentro va el subprograma que calcula el resultado }
Las funciones pueden recibir variables, y también pueden devolver resultados o escribir en dichas variables. Para crear una función que recibe parámetros podemos verlo claro en el siguiente ejemplo:
static void Sumar(int a, int b) { int resultado; resultado = a + b; System.out.println(a + » + » + b + » = » + resultado); }
La forma de usar ésta función en el main podría ser:
Sumar(1,2);
Lo que escribirá por pantalla: 1 + 2 = 3
Si queremos devolver un valor con una función podríamos modificar la anterior de la forma:
static int Sumar2(int a, int b) { int resultado; resultado = a + b; return resultado; }
Lo que escribirá por pantalla: El resultado vale 3
Debemos fijarnos en la declaración de la función, el tipo de dato primitivo ‘int’ es lo que nos dice qué va a devolver la función.
En líneas generales ésto es lo que necesitamos saber para empezar a programar con funciones. Tenemos muchas formas de usar las funciones, dentro de una clase, también se pueden usar desde fuera si las declaramos como public en vez de static. Se puede extender mucho éste y los otros tutoriales de Java Básico que estoy escribiéndoles pero en un principio creo que es suficiente.
Si eres avanzado en el tema, hay algo mal o te gustaría que ampliara la información déjame un mensaje. También son bien recibidas las sugerencias.
Si aún sigues aquí leyendo es que no te he aburrido, me alegro, yo humildemente espero que te haya servido el post xDD. Un saludo
Sábado por la mañana, hace buena temperatura ahora en otoño, ni frio ni calor en Alicante. Así da gusto. Pues hoy voy a darle vueltas a los bucles y a controlar qué se ejecuta en un pequeño programa en Java.
Vamos a ver los bucles y las estructuras principales que se usan. Éstos son los if, else, switch, while, do while, for, break, continue y el try-catch para control de errores de ejecución.
Vamos al grano, si usamos el siguiente código:
// Paquete donde se organiza ésta clase de Java package javaBasico;
// Declaración de la clase con su nombre public class JavaBasico3BuclesEstructuras { // Entrada principal al programa, el main para los amigos public static void main(String[] args) { // Aquí va el código que empieza nada más // arrancar el programa System.out.println(«¡Hola Mundo!»); // declaro la variable a y le doy valor byte a = 1; // el if sirve para comprobar si ocurre // una cosa… if (a == 2) { // si a vale 2 entonces hace ésto System.out.println(«a sí vale 2»); } else { // si a no vale 2 muestra éste mensaje System.out.println(«a no vale 2»); } // switch sirve para hacer una lista de // casos posibles switch (a) { case 1: // caso de que a valga 1 System.out.println(«a vale 1»); break; case 2: // .. System.out.println(«a vale 2»); break; case 3: // .. System.out.println(«a vale 3»); break; default: break; } a = 0; // el while repite lo que tenemos entre // llaves mientras se cumpla la // condición while (a != 10) { a++; System.out.println(«a = » + a); } // éste bucle es parecido al anterior // pero comprueba si a > 5 después de ejecutar // una vez lo que hay entre llaves do { System.out.println(«a ahora vale » + a); a–; } while (a > 5); short b; // ésta parte del código intenta ejecutarse // try significa ejecutar try { b = 0; a = (byte) ((byte) 1 / b); } catch (Exception e) { // si ocurre algún error en el try // ejecuta // lo siguiente System.out.println(«ERROR: «+ e.getMessage()); } // mensaje de fin de programa… System.out.println(«Ha terminado el programa…»); } }
Nos tiene que dar la siguiente salida:
¡Hola Mundo!
a no vale 2
a vale 1
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10
a ahora vale 10
a ahora vale 9
a ahora vale 8
a ahora vale 7
a ahora vale 6
ERROR: / by zero
Ha terminado el programa…
El código está comentado, espero que no sea demasiado de golpe, si estas empezando con ésto de la programación y te complicas mucho no dudes en comentar el post y gustoso lo aclaro.
Éstas son las formas sencillas de estructurar los programas para que hagan tareas cuando se cumplan ciertas condiciones de algunas variables. También se utilizan para tareas repetitivas los bucles. Con ésto y las funciones podremos estructurar nuestros programas de manera dividamos el problema en subproblemas más sencillos de solucionar.
Divide y vencerás
Ésta forma de afrontar los problemas de programación se utiliza mucho.
El try-catch necesita de una especial mención porque es una estructura para controlar los posibles que pueden suceder en un programa y evitar así que se queden colgados, terminen inesperadamente y en definitiva la tarea no se termine. El try-catch tiene muchas opciones pero necesitaría de otro post para ello así que tal vez en un futuro.
Espero que sirva para aclarar algo a los nuevos, o para repasar a los veteranos. Un saludo