lunes, 11 de abril de 2011

Proyecto Clase

Este es el proyecto de la clase finalizado.
En la esquina superior derecha de la pantalla principal hay un boton llamado cargar que sirve para cargar la informacion de usuarios
Descargar

domingo, 3 de abril de 2011

BOTONES Y CONTROLES PERSONALIZADOS

En este proyecto java se encuentra un paquete con 5 botones personalizados y otro con 2 controles personalizados(JTextField y JTextArea)
Descargar

martes, 29 de marzo de 2011

JTREE

El JTree nos permite mostrar información jerárquica, es excelente para mostrar datos como un árbol familiar o la estructura del sistema de archivos. Utilizar un JTree es algo sencillo, pero no siempre es muy claro cómo llenarlo para no gastar mucha memoria y para que no se gaste mucho tiempo al llenarlo. En este Trial vamos a hacer una aplicación guíada en la que utilizaremos un JTree para mostrar el sistema de archivos de la partición raíz de la computadora.
El archivo contiene una versión termianda del programa que vamos a crear en este Trial.r una aplicación guíada en la que utilizaremos un JTree para mostrar el sistema de archivos de la partición raíz de la computadora.
El archivo contiene una versión termianda del programa que vamos a crear en este Trial.

¿Cómo utilizar un JTree?

La aplicación que queremos crear es una aplicación similar al Explorador de Windows.
En la aplicación vamos a tener un JTree con los directorios que se encuentran en la
estructura de archivos, y en la otra parte vamos a tener los archivos que se encuentren
dentro del directorio seleccionado.
Además de utilizar el JTree vamos a utilizar extensivamente la clase File que nos
 permite muchas facilidades en el manejo de archivos.
Primero que nada crea una nueva aplicación de Java en que la clase principal se llame Main.
En la clase Main copia el siguiente código:






En este código estamos creando una nueva ventana. La ventana va a contener un 
JTree y un JList y cada uno va a tener su propio JScrollPane para permitir 
que tengan barras de desplazamiento.
En el constructor de la clase podemos ver que estamos creando un nuevo objeto 
de la clase File. La claseFile contiene muchos métodos que nos permiten 
manejar archivos, saber de que tipo son y algunos otros datos importantes sobre ellos.
Nuestro JTree es un conjunto de nodos que tienen un padre y cero o más hijos,
 así como un directorio tiene un directorio padre y puede contener cero o más directorios. 
En este caso, cada directorio va a ser un nuevo nodo de la claseDefaultMutableTreeNode.
 En el código podemos ver que creamos un nuevo objeto de esta clase con un constructor
 que recibe un objeto (en este caso el objeto File que creamos pero podría recibir 
cualquier otra cosa, incluyendo objetos creados por nosotros). Este nodo, 
al que estoy llamando top, va a ser la raíz de nuestro JTree y vamos a agregarle 
elementos más adelante para crear nuestro sistema de archivos.
Una vez que definimos nuestro nodo inicial (y que agregamos los componentes necesarios)
 vamos a crear un nuevo JTree que reciba como parámetro del constructor el nodo que
 acabamos de crear.
Después de definir el JTree le ponemos unJScrollPane para permitir que tenga barras
 de desplazamiento y después creamos todo el resto de la interfaz.
Esta clase utiliza el método pack(). Este método le pregunta a los componentes de la
 interfaz gráfica cuánto espacio necesitan y, dependiendo de esto, construye una ventana 
suficientemente grande para que todos los componentes puedan desplegarse de manera
 satisfactoria.
En el método main() únicamente creamos una instancia nueva de nuestro programa.


Al ejecutar el programa podemos ver que nuestra interfaz todavía es muy sencilla y no tiene 
ninguna funcionalidad. Nuestro siguiente paso es agregarle esta funcionalidad.


El arbol es por naturaleza una estructura recursiva. Lo que esto significa es que la mayoría 
de las veces vamos a tener que plantearnos soluciones recursivas para agregar y eliminar 
nodos. Por ejemplo, si tenemos un directorio (1), debemos encontrar sus hijos (1.1 y 1.2) y 
agregarlos, pero si estso hijos tienen hijos a su vez (1.1.1), también tenemos que agregar 
esos hijos. Es decir: Para un directorio cualquiera, debemos agregar sus subdirectorios y 
repetir el proceso con estos.
Para hacer esto con código debemos crear un método que agregue los hijos al padre y que
 por cada hijo se mande a llamar a si mismo, pero ahora con el hijo. Es decir, debemos crear
 un método recursivo. Agrega el siguiente código a tu aplicación:





Al correr el programa nos damos cuenta que faltan muchos directorios!
 Esto es comportamiento esperado porque al ir reduciendo la variable depth le indicamos
 al programa que no ponga todos los directorios sino únicamente los primeros dos niveles.
 Esto lo hacemos ya que tomaría muchísimo tiempo poner todos los directorios (un conteo 
rápido del número de archivos de mi disco duro indica que tengo más de cien mil archivos, 
imagina todo el tiempo que tomaría agregarlos todos). Este problema vamos a dejarlo volando
 un momento y antes vamos a resolver un punto un poco más importante.
Ya que tenemos un poco más de directorios en nuestro JTree podemos hacer que una vez
 que el usuario haga click sobre el directorio aparezcan los archivos que contiene en la lista 
de la izquierda. Para esto vamos a utilizar un TreeSelectionListener y el método 
valueChanged().
Primero que nada agrega el código:
 implements TreeSelectionListener
En el encabezado de la clase y utiliza la siguiente línea de código para agregar la capacidad
 de manejar eventos a nuestro JTree:
 treeDir.getSelectionModel().addTreeSelectionListener(this);
Después copia el siguiente código:
Al manejar eventos con un
JTree es muy importante saber
 qué nodo está seleccionado y qué objeto está guardado en ese nodo. Para poder obtener el nodo seleccionado vamos a utilizar el métodogetLastSelectedPathComponent() este método que parece trabalenguas nos devuelve unDefaultMutableTreeNode con el último nodo que fue seleccionado.
Para obtener el objeto que está guardado dentro del nodo podemos utilizar el método getUserObject()del nodo que acabamos de obtener. Como este método nos devuelve un objeto nosotros debemos hacer un cast al tipo de dato que está guardado.
En este método podemos ver que obtenemos el nodo y luego el objeto guardado, con este objeto obtenemos una lista de todos los archivos que están guardados en el directorio. Una vez más, el código que hace esto no es objetivo del Trial y no lo vamos a ver. Por último borramos la lista y agregamos todos los archivos, para saber cómo funciona el DefaultListModel y un JList puedes consultar el trial de Listas.
Al correr el programa podemos ver que ya aparecen los archivos que contiene el directorio seleccionado al hacer click sobre él. Por último vamos a resolver el problema que dejamos volando antes. Lo que queremos hacer ahora es que al expandir alguna carpeta se lean los directorios que contiene y que los agregue a esta carpeta para que los muestre de la misma manera que lo hace con el nodo raíz. Para resolver este problema podemos utilizar un TreeExpansionListener.
Agrega el TreeExpansionListener a la declaración de la clase y después agrega la siguiente línea de código para permitir que nuestro JTree responda a eventos de expansión y reducción de carpetas:
treeDir.addTreeExpansionListener(this);
Ahora agrega el siguiente código para manejar el evento de expansión:








Para obtener el nodo que se va a expandir en este método debemos hacer dos pasos, el primero es obtener un objeto TreePath mediante el métodogetPath() de event y el segundo es obtener elDefaultMutableTreeNode utilizando el métodogetLastPathComponent(). Una vez que conseguimos el nodo podemos utilizar el métodogetUserObject() de la misma manera que arriba para poder obtener el archivo.
Para agregar los subdirectorios al directorio seleccionado podemos utilizar el método populateNode() que ya habíamos creado.
Por último obtenemos el DefaultTreeModel que guarda todos los nodos de nuestro JTree (más o menos en la misma manera que elDefaultListModel guarda los objetos del JList) meidante el método getModel() y vamos a utilizar el método nodeStructureChanged() que recibe el nodo que ha cambiado como parámetro para avisarle alJTree que debe volverse a dibujar utilizando los valores nuevos.
En este método también podemos ver el métodosetCursor() que nos permite cambiar el cursor para avisarle al usuario que el método puede tardar.


Nuestro JTree ya nos permite ver archivos y nos permite navegar por todos los directorios de nuestro sistema de archivos, pero tiene muchas deficiencias.
La más notable es que los íconos no son consistentes y visualmente el programa es muy poco amigable. Para poder resolver este problema es necesario cambiar el DefaultCellRenderer que utiliza el JTree para dibujarse en pantalla, esto es un poco complicado por lo que no lo vamos a cubrir en el Trial, pero si quieres ver cómo se hace el código viene en el archivo de inicio.
Otra cosa que podríamos hacer es utilizar el método treeCollapsed para descargar los folders que no se están viendo, pero la memoria que podríamos recuperar es insignificante, por lo que no vale la pena descargar las carpetas de memoria y luego tener que perder en tiempo.

JTABLE

Las tablas nos permiten tener tabulados de información que se vean organizados y que sean de utilidad para los clientes. Las tablas son muy utilizadas en programas similares a excel, donde se deben tener rejillas de información; o en programas de administración donde pueden haber varios productos que tienen un conjunto de características, o en programas de ventas, donde pueden haber varios vendedores con número de ventas y con total vendido.
Para agregar una tabla en NetBeans selecciona el icono de tabla de la paleta (que regularmente se encuentra a la derecha) . Una vez que lo hayas seleccionado agrégalo a la ventana principal. El JTable utiliza un DataModel para representar sus datos, de la misma manera que varios otros componentes como JList.

Creando un modelo estático

El modelo nos permite indicarle a la tabla qué información va a contener. Si sólo queremos presentar información estática (que nunca cambia) al cliente entonces podemos usar un modelo estático, para hacer esto vamos a hacer click en el atributo model que se encuentra en las propiedades.

Una vez que hicimos click aparecerá una pantalla en la que podemos editar cómo queremos que se vea la tabla. En esta pantalla podemos seleccionar el núemro de columnas, el nombre de las columnas e incluso podemos agregar algunos datos.

En la pantalla anterior podemos ver cómo manejar el número de columnas (con los botones de Insert, Delete o con los botones de +, -) y también podemos ver una rejilla donde podemos poner el título que aparece en la columna, el tipo de dato que va a guardar y si se puede editar o no.
Con esto podemos crear una tabla estática que siempre va a iniciar con los mismos datos.

Creando un modelo dinámico

La mayoría de las veces un usuario no va a querer una tabla estática (en la que aunque pueda editar los valores no se muestren los valores que se habían guardado previamente). Es por esto que es necesario crear un modelo dinámico. Para poder crear un modelo dinámico es necesario implementar la interfaz TableModel que nos obliga a sobrecargar un gran número de métodos:
  • getColumnClass(): Es un método que nos permite saber qué clase tiene guardada cada columna, esto es para que sean más fáciles de pintar para java.
  • getColumnCount(): Es un método que nos permite saber cuántas columnas tiene la tabla.
  • getColumnName(): Es un método que nos permite saber el encabezado de la tabla para una cierta columna.
  • getRowCount(): Es un método que nos permite saber cuántas filas tiene la tabla.
  • getValueAt(): Es un método que nos devuelve el valor que se encuentra en la posición pasada como parámetro.
  • isCellEditable(): Es un método que nos devuelve verdadero si la celda puede ser modificada, o falso en caso contrario.
  • setValueAt(): Es un método que nos permite cambiar el valor que se encuentra en la posición pasada como parámetro mediante código (el usuario puede cambiar los datos dependiendo del método isCellEditable()).
  • getValueAt(): Es un método que nos devuelve el valor que está guardado en la celda pasada como parámetro, este valor va a ser de la clase que indica getColumnClass() para esa columna.
Además de todos los métodos anteriores, la interfaz TableModel tiene un par de métodos para manejar eventos (como por ejemplo, que el usuario haga click, que edite una celda). Estos métodos involucran agregar código a nuestra clase que cuando modifique algún valor o que agregue nuevos datos tenga que disparar eventos. Este código, aunque no es muy complicado, no tendría ninguna utilidad (a menos que vayamos a escribir una manera de deshacer acciones o algo similar), sin embargo como tenemos que implementar TableModel tendríamos que implementarlos. Por suerte Java cuenta con un modelo ya implementado (el que utilizan todas las tablas al ser creadas) que podemos utilizar para no implementar estos métodos, entonces, en lugar de implmentar la interfaz TableModel vamos a extender la clase DefaultTableModel que ya implementa la interfaz anterior.

Implementando el modelo dinámico

Normalmente las tablas sólo crecen en una dirección (hacia abajo, aumentando el número de filas). Por ejemplo, en el reporte de empleados, es probable que contratemos o despidamos empleados, por lo que vamos a tener que agregar más filas, sin embargo sería raro que apareciera un nuevo atributo que quisiéramos manejar del empleado (y más raro aún que el cliente pudiera modificar el programa de tal manera que lo agregue). Entonces, como la mayoría de las tablas crecen en una sola dimensión(sólo aumenta el número de filas) vamos a implementar un modelo en el que utilizando un ArrayList que contiene arreglos vamos a manejar el crecimiento de la tabla (el ArrayList puede crecer, pero los arreglos no).
El ArrayList va a representar las filas de la tabla, y va a contener arreglos, que representan las columnas.

Primero veamos a crear una clase nueva, que extienda DefaultTableModel.
public class EditableTableModel
extends DefaultTableModel
Nuestro modelo debe tener alguna manera de almacenar los datos (ya vimos cómo vamos a resolver este problema) y además debe contar con variables de control que nos faciliten la tarea de saber cuál es el nombre de las columnas, qué tipo de dato guarda cada columna (importante para poder guardar números o booleanos) y si la columna es editable (la mayoría de las veces este parámetro va a ser verdadero, pero podrían haber ocasiones en que necesitáramos que fuera falso).
    private ArrayList<Object[]> data;
 
    private int numColumns;
    private String columnNames[];
    private Class classes[];
    private boolean editable[];
El constructor que recibe todos los parámetros debe de crear un tabla de datos en blanco y debe de leer los parámetros que manda el usuario. Como vamos a tener varios constructores que reciban diferente número de parámetros debemos construir un método que nos permita iniciar el objeto y llamarlo desde todos los constructores, el método sería algo similar a:
    private void initComponents(String columnNames[], Class classes[], boolean editable[]) 
    throws IllegalArgumentException {
        if (columnNames.length != classes.length || classes.length != editable.length) 
            throw new IllegalArgumentException("The arrays passed as parameters must be of the same size");
 
        data = new ArrayList<Object[]>();
 
        this.numColumns = columnNames.length;
        this.columnNames = columnNames;
        this.classes = classes;
        this.editable = editable;
    }
La mayoría de los métodos son simples getters y setters (por ejemplo getRowCount() sólo debe regresar el tamaño de data con data.size()getValueAt() sólo debe obtener el valor de la celda con data.get(row)[col]), por lo que estos métodos no van a ser consultados con más detenimiento. Sin embargo, para permitir que la tabla pueda crecer debemos crear métodos que nos permitan agregar o quitar filas. Estos métodos deben agregar o quitar arreglos de objetos de la lista de datos. Es decir:
    public void addRow() {
        int numRows = data.size();
 
        Object[] row = new Object[numColumns];
        data.add(row);
 
        this.fireTableRowsInserted(numRows, numRows+1);
    }
Y para remover va a ser muy similar:
    @Override
    public void removeRow(int row) {
        data.remove(row);
        this.fireTableRowsDeleted(row, row);
    }
En los métodos anteriores no está sucediendo mucho que no sepamos, excepto por los métodos fireTableRowsInserted() y fireTableRowsDeleted(). Estos dos métodos le indican a la tabla (y la tabla se encarga de comunicarle a todos los componentes que dependan de ella) que se agregaron o quitaron filas. Si no hiciéramos esta llamada entonces no veríamos los cambios hasta que modifiquemos los datos en la lista, que sería cuando la tabla se daría cuenta de que el modelo cambió.
Otro método que quizás sería importante implementar sería uno que nos permitiera agregar filas con datos, ya que muchas veces vamos a leer los datos de un archivo y vamos a querer construir la tabla.
    public void addRow(Object[] row) {
        int numRows = data.size();
        data.add(row);
        this.fireTableRowsInserted(numRows, numRows+1);
    }
Quizás también sería prudente crear un constructor que reciba una matriz de datos y de ahí obtenga todos los datos para crear la tabla.

Usando el modelo

Construir el modelo es un proceso un poco abstracto y muchas veces no sabemos cómo están sucediendo las cosas sino hasta que lo comenzamos a usar, para poder usar nuestro modelo vamos a crear una clase de prueba que tenga una ventana con una tabla y dos botones de la siguiente manera:

Vamos a declarar el modelo en la parte de declaraciones globales, para que toda la interfaz gráfica pueda acceder a ella (esto es conveniente porque así los botones van a poder usarlo directamente, sin tener que sacarlo de la tabla pero podría considerarse una mala práctica de programación).
    private EditableTableModel model;
En el constructor de la ventana vamos a agregar el siguiente código:
    public EditableModelTest() {
        initComponents();
 
        String columnNames[] = { "Nombre",     "Edad",        "Telefono" };
        Class classes[] =      { String.class, Integer.class, String.class };
        boolean editable[] =   { true,         true,          true };
 
        model = new EditableTableModel(columnNames, classes, editable);
 
        tblEmployees.setModel(model);
    }
Como podemos ver, el código está creando tres arreglos, el primero tiene los nombres de las columnas (son tres columnas: nombre, edad y teléfono), el segundo arreglo es un arreglo de clases, que nos dice de qué tipo va a ser cada columna. Podemos utilizar cualquier clase de Java, pero regularmente queremos utilizar String, Integer, Double, Float o Boolean, que son las clases para las que ya está creado un renderer y por lo tanto no tenemos que preocuparnos por eso. Fíjate que después del nombre de la clase ponemos .class para que obtenga la clase. El último arreglo es un arreglo de boolean y nos dice si las columnas van a ser editables (en la mayoría de los casos sí).
Ahora vamos a implementar el botón para agregar filas:
    private void btnAddRowActionPerformed(java.awt.event.ActionEvent evt) {                                          
        model.addRow();
    }
Como nuestro modelo está bien implementado esto fue sencillísimo, ahora vamos a implementar el botón que borra las filas seleccionadas:
    private void btnRemoveRowActionPerformed(java.awt.event.ActionEvent evt) {                                             
        int rows[] = tblEmployees.getSelectedRows();
        model.removeRows(rows);
    }
Igual de sencillo. Una vez que hayamos hecho todo esto nuestro programa debe permitir agregar y quitar filas y poner los datos que querramos adentro de las filas.

Guardar datos

Una vez que los usuarios tengan la oportunidad de modificar la tabla van a agregar datos y van a querer guardar esos datos (imaginen que cada que abran excel tienen que volver a poner todos los datos que habían puesto la vez anterior). Para guardar los datos vamos a crear un método en el modelo que se encargue de poner los datos en una matriz (para que sea más fácil de manejar) y después, utilizando este método vamos a utilizar un par de ciclos para guardar los datos en un archivo.
En el modelo vamos a agregar el siguiente método:
    public Object[][] getDataMatrix() {
        int numRows = getRowCount();
        int numCols = getColumnCount();
        Object matrix[][] = new Object[numRows][numCols];
 
        for (int rowIndex = 0; rowIndex < data.size(); rowIndex++) {
            Object[] row = data.get(rowIndex);
            for (int colIndex = 0; colIndex < row.length; colIndex++) {
                Object object = row[colIndex];
                matrix[rowIndex][colIndex] = object;
            }
        }
 
        return matrix;
    }
Y dentro de la interfaz gráfica hay que crear un nuevo botón que sea el que guarda y debemos poner el siguiente código:
    private void btnSaveActionPerformed(java.awt.event.ActionEvent evt) {
        try {
            PrintWriter fileOut = new PrintWriter(new FileWriter("out.csv"));
 
            Object[][] data = model.getDataMatrix();
            for (int i = 0; i < data.length; i++) {
                fileOut.print(data[i][0]);
                for (int j = 1; j < data[i].length; j++) {
                    Object object = data[i][j];
                    if (object != null) 
                        fileOut.print("," + object.toString());
                    else
                        fileOut.print(",");
                }
                fileOut.println();
            }
            fileOut.close();
            JOptionPane.showMessageDialog(this, "Datos guardados");
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(this, "Error al guardar!");
        }
    }

jueves, 3 de febrero de 2011

PALABRAS RESERVADAS EN JAVA

Estas 48 palabras están defnidas en el lenguaje Java. Estas palabras reservadas, combinadaas con la sintaxis de los operadores y separadores, forman la definición del lenguaje Java. Estas palabras reservadas no se pueden utilizar como nombres en sus programas Java en variables, clases o métodos. true, false, y null no son palabras clave, pero tienen el significado de palabrasresevadas y ampoco se pueden utilizar como nombres en sus programas.

*abstract *double *int *strictfp ** *boolean *else *interface *super *break *extends *long *switch *byte *final *native *synchronized *case *finally *new *this *catch *float *package *throw *char *for *private *throws *class *goto * protected *transient *const * if *public* try *continue *implements *return *void *default *import *short *volatile *do *instanceof *static *while

**AGREGADO A JAVA2



Abstract:
Una clase abstracta es una clase que se introduce sólo para que se deriven nuevas clases de ella, no para que se creen objetos con su nombre. Del mismo modo, un método abstracto es un método que se introduce para que sea redefinido en una clase derivada.
double & int:
El tipo de dato real define un conjunto de números que pueden ser representados con la notación de coma flotante.Al igual que los números enteros, el tipo real está limitado superior e inferiormente según la cantidad de memoria que haya disponible para almacenarlo. Otro elemento importante a tener en cuenta en este tipo de datos es la precisión con que pueden representar número con decimales (cuantos decimales se pueden representar), esta característica también está directamente relacionada con la cantidad de memoria disponible para almacenar un valor real.
Strictfp:
La palabra clave "strictfp" fue una adición tardía a el lenguaje de programación Java. Se utiliza para controlar determinados aspectos de la aritmética de punto flotante. Puede ser un poco difícil de describir e ilustrar strictfp, por lo que este extremo lo hará en forma gradual. La punta comienza con unos pocos ejemplos de sintaxis y, a continuación, se presenta un ejemplo que muestra dónde strictfp podía ser importante. 
Strictfp puede usar como un modificador de la clase, interfaz, y el método de las declaraciones.
Boolean:
Hace referencia a una expresión o a una variable que puede tener solamente un valor: verdadero o falso. El leguaje Java dispone del tipo booleano y de los valores literales verdadero y falso.
if & else:
es una estructura de control utilizada para tomar decisiones. Es un condicional que realiza unas u otras operaciones en función de una expresión. Funciona de la siguiente manera, primero se evalúa una expresión, si da resultado positivo se realizan las acciones relacionadas con el caso positivo.
Goto:
en Java goto es una palabra reservada, pero no existe la instrucción
package:
Un paquete Java es un mecanismo para la organización de clases de Java en nombres similares a los módulos de Modula. Paquetes Java se pueden almacenar en archivos comprimidos llamados archivos JAR, permitiendo que las clases para descargar más rápido, como grupo, en lugar de uno en uno. Los programadores también se suelen utilizar para organizar clases de paquetes que pertenecen a la misma categoría o proporcionar una funcionalidad similar. 
* Un paquete proporciona un conjunto único de nombres para los tipos que contiene. 
* Cursos en el mismo paquete pueden acceder a los demás miembros protegidas.
switch:
Construcción sintáctica muy compacta para representar la ejecución de una entre varias sentencias dependiendo de un valorSólo funcionan sobre enteros, booleanos o caracteres 
Chequean que no hay duplicados 
las condiciones tienen que ser excluyentes 
Mejor legibilidad 
Sin “break”, el programa no saltaría al final 
El “default” es opcional; si no aparece, no se ejecuta nada
Throws:
Todos los métodos Java utilizan la sentencia throw para lanzar una excepción. Esta sentencia requiere un sólo argumento (un objeto Throwable1.3) Veamos el siguiente código de la función pop() cuyo propósito es sacar el elemento superior de la pila.
El método pop() comprueba si la pila no está vacía. Si lo está, crea un nuevo objeto de la clase EmptyStackException y lo lanza, aunque en el método no se genere alguna excepción debido a lo bien validado que se encuentra, nosotros somos quienes lo lanzamos. Además por lógica, la clase EmpyStackException es una subclase de Thowable, ya que en cualquier otro caso, no se podría lanzar dicha excepción. Algo que se debe considerar aquí, es que en la declaración del procedimiento añade el siguiente código throws EmptyStackException, throws es una palabra reservada de java, y EmpyStackException es una subclase de Throwable. El uso de throws permite evitarnos la molestia de capturar las excepciones del tipo de excepciones indicadas después de esta palabra (las clases van separadas por coma), esto debido a que deja al sistema de ejecución Java que decida cuál sería la mejor opción en caso de que ocurriera una excepción de los tipos indicados.
do:
ejecuta la expresión, pero no devuelve ningún resultado. Es una versión taquigráfica de una expresión SELECT, pero tiene la ventaja de que es un poco más rápida cuando el resultado no importa.
Transient:
la variable no es una parte persistente del estado del objeto. Por defecto, las variables miembro son una parte persistente del estado de un objeto, Las variables que forman parte persistente del estado del objeto deben guardarse cuando el objeto se archiva. Se puede utilizar la palabra clave transient para indicar a la máquina virtual Java que la variable indicada no es una parte persistente del objeto. 
Al igual que otros modificadors de variables en el sistema Java, se puede utilizar transient en una clase o declaración de variable de ejemplar como esta. 
Este ejemplo declara una variable entera llamada hobo que no es una parte persistente del estado de la claseTransientExample. 
while:
Se usa para repetir una instrucción durante todo el tiempo en queuna condición particular sea verdadera.
class:
La palabra reservada class sirve para señalar que se empieza a definir una clase, delimitada por llaves: {}

PROGRAMA CON ARREGLOS

Este es mi programa de un arreglo de 20 enteros identifica el mayor, el menor y los ordena
main.java
main.class

jueves, 27 de enero de 2011

SUBCLASES

Este es un ejemplo de subclases que realizan operaciones matematicas basicas.
todas las operaciones las realiza con el numero 2: 2+2, 2-2, 2*2, 2/2.

viernes, 21 de enero de 2011

JAVADOC

JAVADOC: nos sirve para realizar comentarios, indicar el autor,la versión de la clase, método o incluso paquetes.


 Los comentarios JavaDoc están destinados a describir, principalmente, clases y métodos. Como están pensados para que otro programador los lea y utilice la clase (o método) correspondiente, se decidió fijar al menos parcialmente un formato común, de forma que los comentarios escritos por un programador resultaran legibles por otro. Para ello los comentarios JavaDoc deben incluir unos indicadores especiales, que comienzan siempre por '@' y se suelen colocar al comienzo de línea. Por ejemplo esta es una clase para representar números círculos (reducida al mínimo):

package figuras;

/**
 * Una clase para representar círculos situados sobre el plano.
 * Cada círculo queda determinado por su radio junto con las 
 * coordenadas de su  centro.
 * @version 1.2, 24/12/04
 * @author Rafa Caballero
 */

INDICADORES MAS USUALES

  • @author nombreDelAutor descripción. 
Indica quién escribió el código al que se refiere el comentario. Si son varias personas se escriben los nombres separados por comas o se repite el indicador, según se prefiera. Es normal incluir este indicador en el comentario de la clase y no repetirlo para cada método, a no ser que algún método haya sido escrito por otra persona. 
  •  @version númeroVersión descripción.
Si se quiere indicar la versión. Normalmente se usa para clases, pero en ocasiones también para métodos. 
  •  @param nombreParámetro descripción.
Para describir un parámetro de un método. 
  •  @return descripción.
Describe el valor de salida de un método. 
  •  @see nombre descripción
Cuando el trozo de código comentado se encuentra relacionada con otra clase o método, cuyo nombre se indica en nombre. 
  •  @throws nombreClaseExcepción descripción
Cuando un método puede lanzar una excepción ("romperse" si se da alguna circunstancia) se indica así. 
  •  @deprecated descripción.
 Indica que el método (es más raro encontrarlos para una clase) ya no se usa y se ha sustituido por otro. 


HERRAMIENTA JAVADOC


 Aparte de obtenerse comentarios más fáciles de leer para otros programadores debido al formato impuesto por los indicadores, la principal utilidad de estos comentarios es que pueden utilizarse para generar la documentación de los programas. Para ello se utiliza la herramienta javadoc parte de JDSK. El formato más sencillo de esta herramienta, cuando se emplea desde línea de comandos es:
javadoc fichero.java
Por ejemplo:
javadoc Círculo.java
Lo que hace esta herramienta es extraer los comentarios JavaDoc contenidos en el programa Java indicado y construir con ellos ficheros .html que puede servir como documentación de la clase. Por ejemplo, esta es el fichero Círculo.html que genera javadoc (entre otros) al procesar el fichero Círculo.java (para distinguirlo de este documento muestro el fondo en color, aunque en realidad es blanco):