Imagen en JLabel, JButton

Algunas veces queremos colocar una imagen en un label o colocar imagenes en un boton aqui les dejo una solucion completamente sencialla solo basta de dos lineas utilizando la clase ImageIcon.

En la primera idicamos el path de la imagen, en la segunda le indicamos la escala que queremos utilizar y finalmente solo agregamos la imagen donde sea de nuestro agrado.

Espero les haya servido exitos.

ImageIcon fondo1 = new ImageIcon("fondo1.jpg"); //entre comillas "" //el path de la imagen Icon Fondo1 = new ImageIcon(fondo1.getImage().getScaledInstance(30,18, Image.SCALE_DEFAULT));//el 30,18 es el ancho y alto que //queremos definir a la imagen jButton1.setIcon(Fondo1);//agregamos la imagen al boton o label

Descargar Códio Fuente

JFileChooser para abrir y/o guardar archivos

JFileChooser es una clase java que nos permite mostrar fácilmente una ventana para la selección de un fichero. En esta oportunidad les dejare un ejemplo de una de las muchas formas de como Abrir y Guardar un archivo aplicando filtros también que al momento de guardar genere automáticamente la extensión y que evite abrir un archivo que ya se encuentra abierto.

Para abrir hacemos lo siguiente.
String path="";//creamos una variable global para guardar el path private void open() throws IOException { //empezamos implementando la clase JFileChooser para abrir archivos JFileChooser JFC = new JFileChooser(); //filtro que muestra solo los archivos con extension *.edu JFC.setFileFilter(new FileNameExtensionFilter("todos los archivos *.EDU", "edu","EDU")); //se comprueba si se ha dado al boton aceptar int abrir = JFC.showDialog(null, "Abrir"); if (abrir == JFileChooser.APPROVE_OPTION) { FileReader FR = null; BufferedReader BR = null; try { //abro el fichero y creo un BufferedReader para hacer //una lectura comoda (tener el metodo readLine();) File archivo = JFC.getSelectedFile();//abre un archivo .lengf //evitar abrir archivo con otra extension que no sea *.LFP String PATH = JFC.getSelectedFile().getAbsolutePath(); if(PATH.endsWith(".edu")||PATH.endsWith(".EDU")){ FR = new FileReader(archivo); BR = new BufferedReader(FR); //leyendo el archivo String linea;//variable para leer linea por linea el archivo de entrada if(path.compareTo(archivo.getAbsolutePath())==0){ JOptionPane.showMessageDialog(this, "Archivo Abierto","Oops! Error", JOptionPane.ERROR_MESSAGE); }else{ path = archivo.getAbsolutePath(); jTextArea.setText(null);//limpiamos el textArea antes de sobreescribir while((linea=BR.readLine())!=null){ //cuando termina el texto del archivo? jTextArea.append(linea+"\n");//utilizamos append para escribir en el textArea } } }else{ JOptionPane.showMessageDialog(this, "Archivo no soportado","Oops! Error", JOptionPane.ERROR_MESSAGE); open(); } } catch (FileNotFoundException ex) { ex.printStackTrace(); //Logger.getLogger(fileChooser.class.getName()).log(Level.SEVERE, null, ex); //cerramos el fichero, para asegurar que se cierra tanto // si todo va bien si salta una excepcion } finally { try { if(null!= FR){ FR.close(); } } catch (IOException ex) { ex.printStackTrace(); //Logger.getLogger(fileChooser.class.getName()).log(Level.SEVERE, null, ex); } } } }

Para guardar hacemos lo siguiente.
private void save(){ String texto = jTextArea.getText();//variable para comparacion if (texto.matches("[[ ]*[\n]*[\t]]*")) {//compara si en el JTextArea hay texto sino muestrtra un mensaje en pantalla JOptionPane.showMessageDialog(null,"No hay texto para guardar!", "Oops! Error", JOptionPane.ERROR_MESSAGE); }else{ JFileChooser fileChooser = new JFileChooser(); fileChooser.addChoosableFileFilter(new FileNameExtensionFilter("todos los archivos *.EDU", "edu","EDU"));//filtro para ver solo archivos .edu int seleccion = fileChooser.showSaveDialog(null); try{ if (seleccion == JFileChooser.APPROVE_OPTION){//comprueba si ha presionado el boton de aceptar File JFC = fileChooser.getSelectedFile(); String PATH = JFC.getAbsolutePath();//obtenemos el path del archivo a guardar PrintWriter printwriter = new PrintWriter(JFC); printwriter.print(jTextArea.getText());//escribe en el archivo todo lo que se encuentre en el JTextArea printwriter.close();//cierra el archivo //comprobamos si a la hora de guardar obtuvo la extension y si no se la asignamos if(!(PATH.endsWith(".edu"))){ File temp = new File(PATH+".edu"); JFC.renameTo(temp);//renombramos el archivo } JOptionPane.showMessageDialog(null,"Guardado exitoso!", "Guardado exitoso!", JOptionPane.INFORMATION_MESSAGE); } }catch (Exception e){//por alguna excepcion salta un mensaje de error JOptionPane.showMessageDialog(null,"Error al guardar el archivo!", "Oops! Error", JOptionPane.ERROR_MESSAGE); } } }
Descargar Código Fuente

JFrame/JDialog en pantalla

Cuándo usar JFrame y cuándo JDialog

En una aplicación java con ventanas debería haber un único JFrame, correspondiente a la ventana principal de la aplicación. El resto de ventanas secundarias deberían ser JDialog. 

¿Por qué es esto?

Un JFrame en una ventana que en Windows crea, en la barra de herramientas, donde está el menú de "inicio" y las aplicaciones que tenemos abiertas, un nuevo botón de aplicación abierta. En una aplcación lo normal es que sólo haya un botón ahí. Si creamos varios JFrame en nuestra aplicación, apareceran varios botones, uno por cada JFrame.

El JDialog no muestra este botón. Por ello, el resto de las ventanas de nuestra aplicación deberías ser JDialog.

Hay otro motivo más. Un JFrame no admite a ninguna otra ventana como padre. El JDialog sí admite como padres un JFrame u otros JDialog. Esto es importante porque una ventana hija siempre quedará por encima de su ventana padre. Si al crear los JDialog les pasamos el JFrame como padre, los JDialog siempre estarán visibles por encima del JFrame. No se podrán ir "detrás" de él.

Si además, en el constructor del JDialog ponemos a true el flag que indica que es modal, además de pasarle una ventana padre, entonces el JDialog impedirá el acceso a las otras ventanas hasta que se cierre. Esta seria una forma de crear el JFrame y el JPanel pueden también descargarse el código fuente el link lo deje mas abajo.

private void initComponents() { //Creando el JFrame final JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500);//asignamos el tamaño de la ventana frame.setLocationRelativeTo(null);//generar frame en el centro de nuestra pantalla frame.setResizable(false);//evita maximizar o cambiar el tamaño del JFrame frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);//terminar proceso al cerrar frame.setVisible(true);//visivilidad //Creando un JPanel JPanel panel = new JPanel(); panel.setLayout(null); panel.setBounds(0, 0, 500, 500);//indicamos posicion y tamaño al panel panel.setVisible(true); frame.add(panel);//agregar panel al frame //Creando un JButton JButton boton = new JButton("Abrir Dialogo"); boton.setBounds(175,225, 150, 50);//posicion y tamaño del boton boton.addActionListener(new ActionListener() {//evento del boton public void actionPerformed(ActionEvent e) { //Creando un JDialog la variable true indica que bloqueara //a la ventana padre la cual es el frame JDialog dialogo = new JDialog(frame, "Dialogo", true); dialogo.setSize(200, 100);//asignamos el tamaño del JDialog dialogo.setLocationRelativeTo(frame);//indicamos que se genere en el centro del JFrame dialogo.setResizable(false);//evita maximizar o cambiar el tamaño del JDialog dialogo.setVisible(true);//indicamos que sea visible dialogo.pack(); } }); panel.add(boton);//añadimos el boton al panel }
Descargar Código Fuente

Técnicas Básicas de Programación

La programación estructurada sigue tres reglas: la secuencia, la iteración y la decisión. La primera de ellas indica que las instrucciones del código se leerán de principio a fin; la segunda indica que, según cierta condición, un número de instrucciones podrían repetirse un numero determinado de veces, y la tercera indica que según unas ciertas condiciones se ejecutarán o no un conjunto de instrucciones. En el siguiente algoritmo para limpiar platos se aprecian estas tres características. La indentación de las instrucciones indican cuáles son englobadas y cuáles no por sus predecesoras.

  mientras haya platos
     coger plato
     mientras haya suciedad
        echar jabon
        pasar el estropajo por el plato
     si plato es azul
        ponerlo con los azules

En código no estructurado, quedaría algo más extraño, pero igualmente valido.

1 coger plato
2 echar jabón
3 pasar el estropajo por el plato
4 si hay suciedad ir a la instrucción 2
5 si el plato no es azul ir a la instrucción 7
6 ponerlo con los azules
7 si hay más platos ir a la instrucción 1

En programas más grandes, esto es muchísimo más complicado, pero puede aprender.

Ahora conocemos la ejecución de los algoritmos. Sin embargo, un programa se compone tanto de algoritmos como de una estructura de datos sobre la cual operar. Así que veamos primero algunas cosas importantes:

Antes de empezar un programa

Estructura de un programa

En la programación estructurada hay un inicio y un fin perfectamente bien definido de acuerdo al diagrama de flujo que se planteó al concebir la idea del programa.

Un programa bien estructurado debería tener algún subprograma que capture cualquier error dentro del programa principal o de cualquier subprograma dentro de la aplicación de tal modo que el subprograma que captura los errores genere un registro de datos que describa el error generado y/o en qué subprograma se generó el error para posteriormente corregirlo. Para facilitar la corrección de estos errores se hace uso de los comentarios agregados en el código fuente.

Variables y constantes

Como hemos visto, el ordenador sigue una serie de instrucciones. Pero esas instrucciones tienen que operar sobre una serie de datos. El ordenador típico sólo procesa una instrucción a la vez, por lo que necesita 'espacios de memoria' donde guardar o depositar, a modo de cajones, por usar un símil conocido, los diversos datos con los que trabaja. Aquí es donde entran en juego las variables y constantes.

En los inicios, con el ensamblador, se podía decir al ordenador, por ejemplo: 'Ejecuta la instrucción de esa posición de memoria' o también 'En esa posición de memoria está guardada mi edad, imprímela por pantalla'. Todo esto se deriva del hecho de que los programas también son datos. Esta ambigüedad presenta numerosos inconvenientes cuando se producen errores, como imaginarás fácilmente: de ahí que, a medida que los lenguajes promocionan hacia niveles superiores, se impida el tratamiento indistinto de los datos. A partir de entonces, un programa tiene que decirle al sistema operativo los cajones que necesita y éste se los proporciona independientemente de cuáles sean. Es decir, como quizá hallas leido en algún lado, se deben declarar las variables y/o constantes y su tipo.

Quizás suene más complicado de lo que es. Un ejemplo: Queremos sumar dos números. Nuestro programa tendrá que tener tres cajones: Uno para cada número y otro para el resultado. Cada cajón tiene un nombre en vez de una posición de memoria, de manera que sólo hay que nombrarlo:

Necesito cajones A, B y Resultado

Lee un número y guárdalo en A
Lee un número y guárdalo en B
Suma A y B y guárdalo en Resultado
Imprime el contenido de Resultado

He aquí nuestro programa. Como cabe pensar, un procesador no tiene la instrucción "Imprime por pantalla"; esto es una llamada a otra porción de código que, gracias a la abstracción, nosotros no hemos escrito, o hemos escrito una sola vez; a partir de lo cual podemos imprimir todo el texto que queramos en la pantalla.

Las posiciones de memoria A y B son Variables. Si queremos leerlas o escribirlas, podemos hacerlo. Típicamente, existirán datos que no pensamos modificar; no querremos que el usuario tenga que introducirlos cada vez, pues son de naturaleza más constante que otros (como puede ser el valor Pi para calcular el perímetro o área de un círculo). Para evitar modificarlos por error, podemos pedir al sistema variables especiales, que no puedan ser reescritas. Son las Constantes. Un ejemplo:

Comentario: Este programa calcula el área de un círculo

Constante PI = 3,14159265
Variable R
Variable Resultado

Leer número y guardar en R
Calcular PI * (R * R) y guardar en Resultado
Imprimir Resultado

El uso de variables y constantes se asemeja al uso que se les da en el álgebra o en otras ramas matemáticas.

Nótese también la clara separación entre estructuras de datos y algoritmos. Según los lenguajes, esto puede ser o no obligatorio, pero es recomendable en aras de una mayor claridad del trabajo.

Comentarios

El útil concepto del comentario: son líneas de texto que el compilador o el intérprete no consideran como parte del código, con lo cual no están sujetas a restricciones de sintaxis y sirven para aclarar partes de código en posteriores lecturas y, en general, para anotar cualquier cosa que el programador considere oportuno.

Uno como programador debe tener como prioridad documentar nuestro código fuente ya que al momento de depurar nos ahorrará mucho tiempo de analisis para su corrección o estudio.

Los programadores profesionales tienen la buena costumbre de documentar sus programas con encabezados de texto(encabezados de comentarios) en donde describen la función que va a realizar dicho programa, la fecha de creación, el nombre del autor y en algunos casos las fechas de revisión y el nombre del revisor.

Por lo general algunos programas requieren hacer uso de llamadas a subprogramas dentro de una misma aplicación por lo que cada subprograma debería estar documentado, describiendo la función que realizan cada uno de estos subprogramas dentro de la aplicación.

Estructuras de datos y de control

 

Estructuras de control

Las estructuras de control pueden dividirse en dos: Estructuras de control Condicional y Estructuras de control Repetitivo.

Las estructuras de control condicional son las que incluyen alternativas de selección en base al resultado de una operación booleana(El resultado de una operación booleana es siempre verdadero o falso), como por ejemplo, una comparación (A=B). Según la expresión sea cierta o falsa, se ejecutará un trozo de código u otro. Es el caso de la sentencia IF(Si) THEN(Entonces) ELSE(Sino) de Pascal o Basic:
IF A=0 THEN PRINT "A vale 0" ELSE PRINT "A no vale 0"
Otra sentencia de control son las de tipo SWITCH CASE. En este tipo de sentencias se especifica la variable a comparar y una lista de valores con lo que comparar. Aquel que sea el verdadero, se ejecutará:
SWITCH A CASE 0: PRINT "A vale 0" CASE 1: PRINT "A vale 1"
Otras herramientas imprescindibles del control de la ejecución de nuestro código son los BUCLES o CICLOS. Consisten en un método que permite repetir un trozo de código varias veces.

Hay básicamente dos tipos:

- Bucle FOR:

El bucle FOR (Para) consiste en una sentencia que engloba un grupo de instrucciones y tiene una variable(normalmente llamada i, de tipo entero) cuyo valor se va modificando en cada vuelta.
FOR i=0 TO 10 //Especificamos en este caso que i variará desde 0 hasta 10, con lo que repetiremos el bucle PRINT "Estamos en el bucle" //10 veces. NEXT i //Con esto cerramos el bucle e indicamos el final del bloque de instrucciones que se repiten

- Bucle WHILE:

El bucle WHILE (Mientras) consiste en un bucle en el que el código se repite hasta que se cumpla alguna condición booleana (es decir, una expresión que dé como resultado verdadero o falso). Hay variaciones, como el REPEAT...UNTIL, que se diferencia en el momento de comprobar si se hace verdadera o no la condición.

WHILE A<>(B*2) DO // Aquí especificamos la expresión que evaluamos y aquí se comprueba
        A=A+1 // Incrementamos el valor de A hasta que sea igual a B*2
DONE // Como en el FOR, necesitamos especificar donde acaba el bucle y el código.

Estructuras de datos

creo a como entero creo b como entero creo suma como entero a=2 b=1 suma = a + b imprimir suma  


Estructura de una aplicación

Cualquier programa que se realices debe de llevar una estructura para disminuir la tarea de depuración ya que esta labor lleva más tiempo del estimado.

Si eres principiante en el área de programación debes definir el programa a realizar, documentar cada uno de los pasos que realizas en tu programa, debes de considerar algún metodo de captura de errores, etc.

En esta subsección abarcaremos el cómo estructurar una aplicación para eficientar o disminuir el tiempo en depuración, así como localizar más rápidamente los errores.

Puedes buscar en Internet el concepto "pseudocódigo", que no es más que la escritura de un algoritmo en un lenguaje más cercano al natural. Es decir, la orden en lenguaje Javascript que repetiría el proceso de quitar suciedad añadiendo agua y jabón mientras se frota sería la siguiente:
function frotar(cuanto){ var veces = 0; for (veces = 0; suciedad = 0, veces = cuanto ; veces++){ suciedad = suciedad - (agua + jabón); } }
Mientras que el algoritmo o pseudocódigo quedaría así:
función frotar (cuantasveceslohago) variable vecesquellevo = 0 repetir (desde que vecesquellevo = 0 hasta que la suciedad = 0 ó vecesquellevo = cuantasveceslohago; aumentar vecesquellevo de una en una) suciedad = suciedad - (agua + jabón) fin repetir fin función
En primer lugar, es muy recomendable hacer un esquema sobre el papel con toda clase de datos que se vayan a utilizar. Por ejemplo, si queremos hacer un programa para controlar una empresa dedicada al alquiler de coches, podríamos necesitar:

* Matrícula del coche

 * Marca del coche

* Modelo del coche

* Color del coche

* Estado del coche (si está alquilado, en reparación o disponible)

* Situación del coche (en qué lugar del garaje o en qué localidad está)

* Kilometraje del coche

* Precio por hora del coche

por un lado, y:

* Nombre del cliente

* Apellidos del cliente

* Dirección del cliente

* DNI del cliente

* Permiso de conducir del cliente

* Número de cuenta del cliente

.... etc. por otro.

Ahora a programar.

“Primero resuelve el problema. Entonces, escribe el código.”
— John Johnson