Manual Tecnicas de Programación Orientado A Objetos - A - Java - V0510

TcnicadeProgramacinOrientadaaObjetos 2
Presentacin..3
Modulo A
Semana 1: Arreglos Lineales y Matrices ...4
Semana 2: Ordenamiento de datos y Bsqueda de Datos..28
Semana 3: Programacin Orientada a Objetos 38
Semana 4: Manejo de la Clase String 65
Semana 5: Manejo de Archivos .....74
Semana 6: Clases Primitivas .92
Semana 7: Mtodos propios 109
Semana 8: Ejercicios de Aplicacin115
Semana 9: Manejo de Capas en una aplicacin en escritorio121

Bibliografa:


PRESENTACIN
Esta gua didctica es un material de ayuda institucional, perteneciente a las
especialidades de computacin, Ingeniera de Software e Ingeniera de Redes y
Comunicaciones tiene por finalidad proporcionar los conocimientos de la
programacin orientada a Objetos a los estudiantes del segundo ciclo de estudios.
La Organizacin SISE, lder en la enseanza tecnolgica a nivel superior, promueve
la elaboracin de materiales educativos, en concordancia a las exigencias de las
tecnologas de estos tiempos, que permiten la creacin de nuevas herramientas de
aprendizaje con el objetivo de facilitar el acceso de los estudiantes a la educacin en
el marco del desarrollo tecnolgico de la informtica u de las telecomunicaciones.
Esta gua se divide en 2 mdulos y cada una de ellas en 9 semanas. Permite conocer
las herramientas indispensables para la elaboracin de aplicaciones con el uso de la
tcnica O.O. Se inicia con el uso de tcnica en manejo de datos en memoria y en el
manejo de capas donde estas tcnicas bsicas se necesitan para dar solucin a una
determinada proposicin o problema.
En este proceso el alumno aprender instrucciones que le permitirn evaluar
expresiones para luego procesar un conjunto de sentencias. Tambin aprender el
manejo de una aplicacin a nivel de contenedores, de la misma forma el manejo del
lenguaje de programacin orientada a objetos.
La implementacin y uso de Capas dentro de la aplicacin en escritorio permitirn que
el alumno aplique la programacin Orientada a objetos.
Todas estas herramientas darn un soporte solido al alumno para aprender a
programar en cualquier lenguaje de programacin Orientada a Objetos(J AVA, .NET,
Visual C,etc).
Este material en su primera edicin, servir para ayudar a nuestros estudiantes
SISESINOS a tener una formacin solida para resolver problemas.

Tcni

Arre
Cont
-
-
-
-
-
-
-
-
_____

Un a
conse
eleme
cual e

icadeProgra
eglos
tenidos
Concepto d
Acceso Se
Arreglos co
Uso del J L
Definicin d
Operacione
Uso de
getSelected

___________
arreglo es u
ecutivas de
ento de un a
especifica la
Los arr
Unidimen
Bidimens
Multidime
amacinOrie
de Arreglos :
cuencial y A
on uso de Es
ist (defaultLis
de matrices:
es con Matriz
el J Table
dColum(), ch
___________
una colecci
memoria y
arreglo se d
posicin rel
reglos pue
nsionales (ve
sionales (mat
ensionales (t
entadaaObj
Declaracin
Aleatorio. Agr
structuras Co
stModel)
Acceso a el
z
e(DefatultTab
hangeSelect
___________
n de datos
y reciben un
eber utiliza
ativa en que
eden ser:
ectores).
trices, tablas
tres dimensio
jetos
, asignacin
regar Datos d
ondicionales:
ementos de
bleModel),
ion(), addRo
___________
del mismo
n nombre c
ar el nombre
se encuentr
s).
ones o ms).
e inicializac
de Arreglo.
: Uso de Con
una matriz:
(setEleme
ow(),etc).
___________
ARRE
tipo, que s
omn. Para
e del arreglo
ra el element
.
in de memo
ntadores y A
Asignacin d
entAt(), g
___________
EGLOS
se almacena
a referirse a
acompaad
to.
oria a un arre
Acumuladores
de Datos:
getSelectedR
___________
LINEAL
an en posic
a un determ
do de un nd
4

eglo
s.
Row(),
_____
LES
ciones
minado
dice el
Declarar de un arreglo:

Con esto diremos que se est definiendo un atributo de tipo arreglo y estamos
determinando el tipo de dato y el tamao de registros.

Ejemplos:
Entero: Numeros[10]
Decimal: talla [5]
Carcter nombres [8]
Asignacin de datos hacia a un arreglo:

Esta instruccin asigna el valor asociado de la expresin a la posicin ndice del
arreglo nombre_variable. El ndice debe ser una expresin del tipo entero en el rango
[0, longitud-1].

Ejemplos: Estableciendo Datos a los Arreglos

Numero[2]=152 talla[4]=170.5 nombre[6]=Vernica
Numero[5]=115 talla[0]=168.52 nombre[3]=William
Numero[10]=652 talla[2]=102.62 nombre[1]=Angie
Numero[0]=52 talla[1]=85.62 nombre[8]=Sebastian
Los datos establecidos en Memoria serian as:
ArregloNumero
ndice 0 1 2 3 4 5 6 7 8 9 10
Valores 52 0 152 0 0 115 0 0 0 0 652

ArregloTalla
ndice 0 1 2 3 4 5
Valores
168.52 85.62 102.6 0 170.5 0
Arreglo
Nombres
ndice 0 1 2 3 4 5 6 7 8
Valores null Angie null William null null Vernica null Sebastin

<tipo de dato>: nombre_variable [Tamao]

nombre_variable[ndice] =<expresin del tipo>

Nota: las posiciones que no se le asignaron datos quedaran vacios (0) en el
caso de ser numero y null en el caso de carcter.

Acceso al contenido de un arreglo:
Para poder acceder al contenido:

a. Mostrar: Obtener el dato de acuerdo al ndice establecido, para ello se deber mostrar
dicho dato, lo cual se podr utilizar una variable o mostrarlo directamente.Aqu tambin
vale la aclaracin de que el ndice debe estar dentro del rango de definicin del arreglo.

Variable=nombre_Arreglo[ndice]
Mostar(Variable) o Mostar(nombre_Arrgelo[indice)
Ejemplo:
X=nombre[1]
Mostrar(X) el resultado ser Angie
_________________________________________________________
Mostrar(nombre[8]) el resultado ser Sebastin

b. Lectura: se podr ingresar datos al arreglo en forma contigua de acuerdo al ndice. Es
por ello que se usara a una estructura iterativa que puede ser Mientras(while), Desde
(do) o Repetir(do..while).
Leer(Arreglo[indice])
Nota Para que esta lectura se repita hasta el total de tamao del arreglo se deber de
usar a una estructura Iterativa.

Un Ejemplo con l Desde
desde(x=0 hasta 10-1)
leer(Arreglo[x])
mostrar(Arreglo[x)
fin_desde

Los pasos para la utilizar de un vector son

1. Declarar el vector: Consiste en establecer el nombre, el tamao y el tipo de los datos
que se van a almacenar en el arreglo ejemplo:
Hay que diferenciar dos trminos:
tamao del vector (T): es el nmero mximo de elementos que puede contener el
vector.
Numero de elementos(N): que indica cuantos elementos hay almacenados en el
arreglo en determinado momento. Nota N<=T.

T =10;
decimal: notas[T]
2. Llenar el vector con los datos: Se puede hacer en el momento de la declaracin
asignando al vector los valores que necesitamos almacenar.
Ejemplo.
decimal : notas[10] ={2.3 , 3.5 , 4.2 , 3.3 , 3.0 , 4.9 , 4.2 , 3.0 , 2.0 , 1.5 };

recorriendo el arreglo as dndole nuevos valores:
desde(i =0 hasta N-1)
leer( notas[i] )
fin_desde
3. Manipular la informacin guardada en el vector. Para esto es necesario recorrer dicha
estructura y se puede hacer de la siguiente manera.
mostrar ( notas[i] )
fin_desde
Tambien se puede leer y a la vez escribir los datos ingresados al arreglo

leer( notas[i] )
mostrar ( notas[i] )
fin_desde

Operaciones que se pueden realizar con los arreglos
Son las siguientes:
Lectura (llenar el vector)
Escritura (mostrar el vector)
Asignacin (dar valor a una posicin especfica)
Actualizacin (insercin , eliminacin, modificacin )
Ordenacin . (burbuja, insercin directa, seleccin directa, selle y quicksort).
Bsqueda. (secuencial, binaria, hash( por claves) ).
Ejemplos:
1. Crear un Arreglo que permita ingresar 10 Apellidos.

Carcter: Apellidos[10]
desde(i =0 hasta 10-1)
leer(Apellidos[i] )
mostrar (Apellidos [i] )
fin_desde

2. Crear un Arreglo que permita ingresar 15 promedios del aula 307 del curso de
fundamentos de programacin

decimal: Promedios[15]
desde(i =0 hasta 15-1)
leer(Promedios[i] )
mostrar (Promedios [i] )
fin_desde

3. Crear un Arreglo que permita ingresar 20 Nombres de Institutos y Zona de
ubicacin.
Constante N=20
Carcter: Institutos[N]
Carcter: Zonas[N]

leer(Institutos[i] )
leer(Zonas[i] )
mostrar(Institutos[i])
mostrar (Zonas[i] )
fin_desde

4. Crear un Arreglo que ingrese 50 datos numricos enteros.
Constante N=50
entero: Numeros[N]
leer(Numeros[i] )
mostrar(Numeros[i])
fin_desde

5. Crear un Arreglo que ingrese 10 promedios y mostrar cuantos estn aprobados y
cuantos desaprobados.
Constante N=10
decimal: Promedios[N]
leer(Promedios[i] )
mostrar (Promedios [i] )
si(Promedios[i]>=10.5)
ca=ca+1
sino
cd=cd+1
fin_si
fin_desde
mostrar(Total de Aprobados: +ca)
mostrar(Total de Desaprobados: +cd)


6. Crear un Arreglo que ingrese 15 reas y sus respectitos Sueldos y mostrar cuantos
estn son del rea Sistemas, Contabilidad, y cuantos sueldos superan al sueldo
mnimo y cuntos de ellos ganan entre 1000 y 2500.
Constante N=15
entero:Sueldo[N]
Carcter:Area[N]
leer(Sueldo[i] , Area[i] )
mostrar (Sueldo[i] , Area[i] )
si(Area[i]=Sistema)
cs=cs+1
fin_si
si(Area[i]=Contabilidad)
cc=cc+1
fin_si
si(Sueldo[i]>650)
csum=csum+1
fin_si
si(Sueldo[i]>=1000 y Sueldo[i]<=2500)
cr=cr+1
fin_si
fin_desde
mostrar(Total del rea de Sistemas: +cs)
mostrar(Total del rea de Contabilidad: +cc)
mostrar(Total de Empleados que ganan ms que el sueldo mnimo: +csum)
mostrar(Total de Empleados que ganan entre 1000 y 2500: +cr)

USO DE ARREGLOS EN JAVA

Una matriz es una estructura que contiene mltiples valores del mismo tipo. La longitud de un
array se establece cuando se crea un arreglo (en tiempo de ejecucin).
Se pueden declarar en J ava Arreglos de cualquier tipo:

Para definir un Arreglo se establecer con el operador new.
Lapalabraclavenewseusaparacrearunainstanciadelaclase.
Antesdeserinstanciadaconnewnoconsumememoria,simplementeesunadeclaracinde
tipo.Porejemplo:
// Solo definir a un identificador como tipo arreglo.
char nombreJ ugadores [];
int edades[];

// Definir el arreglos con su tamao especifico
String [ ] nombreJ ugadores =new String [10];
int [ ] edades =new int [99];
int[] a_Nac=new int[5];
int[] codigo =new int[4];

O se puede crear ya el arreglo con sus valores inciales:

String nombres[] ={"Veronica","William","Angie","Sebastian"};

Esto que es equivalente a:
String nombres[]=new String[4];
nombres[0] =new String( "Veronica );
nombres[1] =new String( "William" );
nombres[2] =new String( "Angie" );
nombres[3] =new String( "Sebastin" );

Otro Ejemplo:
String [ ] Coordinadores={Vernica Escobar, Vctor Snchez,Rogelio Tello,Carlos Monge};
O Tambin:
Coordinadores [0] =" Vernica Escobar ";
Coordinadores [1] =" Vctor Snchez ";
Coordinadores [2] =" Rogelio Tello ";
Coordinadores [3] ="Carlos Monge";

Casos Prcticos
1. Ejemplo ingresando valores aleatorios al arreglo:
private void btnAgregar_actionPerformed(ActionEvent e) {
modLstf.clear();
int Numeros[]=new int[10];
for( int i=0; i <10; i++){
Numeros[i] =(int)(Math.random()*100)+1;
modLstf.addElement((i+1)+".- "+Numeros[i] );
}
}

Seusaraelrandompara
poderestablecernmeros
aleatoriosenestecaso
serdesde1al100.

2. Almacenar los votos obtenidos por los 20 candidatos. Estos son ingresados por el usuario.
int votos[]=new int[20]; //Declara el Arreglo en forma Local
modLstf.clear(); //Limpia todo el contenido de la lista
for( int i=0; i <20; i++){
votos[i] =Integer.parseInt(J OptionPane.showInputDialog("Ingresar Cantidad de
Votos - "+(i+1)));
modLstf.addElement((i+1)+".- "+votos[i] );
}
}

3. Se tiene una lista llamado Amigos donde son Vernica E., Gelnda D., Victor S., Rogelio T.,
Waldir C., Eduardo A., Carlos M., Henrry Q., Miguel F., Manue T, J uan C.. Se necesita
almacenarlo en un Arreglo y mostrarlo.

String Amigos[]={"Vernica E.","Glenda D.","Victor S.","Waldir C.","Rogelio R.",
"Eduardo A.","Carlos M.","Henrry Q.","Miguel F.","Manuel T.","J uan C."};

for( int i=0; i <Amigos.length; i++){
modLstf.addElement((i+1)+".- "+Amigos[i] );
}
}

4. Se pide crear una lista que almacene 10 registros: estos datos sern Apellidos, edades y
distritos del aula 307.
final int t=10;
int edades[]=new int[t];
String apellidos[]=new String[t];
String distritos[]=new String[t];
for( int i=0; i < t; i++ ){
apellidos[i] =J OptionPane.showInputDialog("Registro nro. "+(i+1)+"\n"+"Ingresar Apellidos:");
Estemtodolength
devuelveunvalor
numricoentero
Ellengthseusaparavereltotalde
elementosquetieneelarreglo.
edades[i] =Integer.parseInt(J OptionPane.showInputDialog("Ingresar Edades"));

distritos[i] =J OptionPane.showInputDialog("Ingresar Distrito:");
modLstf.addElement((i+1)+".- "+apellidos[i] );
modLstE.addElement(edades[i]);
ModLstD.addElement(distritos[i]);
}

5. Modificando el programa anterior, tambin deber de visualizar cuantos son mayores a 31
o menores e iguales que 31. Cuntos son del distrito de Surco o Chorrillos.

public class FrmCAso01 extends JFrame {

final int t=5;
int edades[]=new int[t];
String apellidos[]=new String[t];
String distritos[]=new String[t];

Estosarreglosdebenser
variableGlobalesdebidoa
queesllamadoenbotones
diferentes.
Elatributotesuna
constantedondeindicael
tamaodelosArreglos.

for( int i=0; i <t; i++){
apellidos[i] =J OptionPane.showInputDialog("Registro nro. "+(i+1)+"\n"+"Ingresar Apellidos:");
edades[i] =Integer.parseInt(J OptionPane.showInputDialog("Ingresar Edades"));
distritos[i] =J OptionPane.showInputDialog("Ingresar Distrito:");
modLstf.addElement((i+1)+".- "+apellidos[i] );
modLstE.addElement(edades[i]);
ModLstD.addElement(distritos[i]);
}

private void btnReporte_actionPerformed(ActionEvent e) {
int cc=0,cmay=0,cme=0;
for( int i=0; i <t; i++){
if(distritos[i].equalsIgnoreCase("Surco") | distritos[i].equalsIgnoreCase("Chorrillos"))
cc=cc+1;
if(edades[i]>31)
cmay=cmay+1;
else
cme=cme+1;
}
txtsalida.append("* Total del Distrito de "+"\n"+"Surco o de Chorrillos son: "+cc+"\n");
txtsalida.append("* Total de Mayores de 31 Aos son: "+cmay+"\n");
txtsalida.append("* Total de Menores o iguales a 31 Aos son: "+cme+"\n");
}
0 1 2
0
1
2
3
0 1 2
0
1
2
3
4
0 1 2 3 4
0
1
ARREGLOS BIDIMENSIONALES
MATRICES

La utilizacin de matrices constituye actualmente una parte esencial de los lenguajes de
programacin, ya que la mayora de los datos se introducen en los ordenadores como tablas
organizadas en filas y columnas: hojas de clculo, bases de datos, Archivos, etc.

Se llama matriz de orden mn a todo conjunto rectangular de elementos Matriz(m)(n)
dispuestos en m lneas horizontales (filas) y n verticales (columnas) de la forma:

Definir una matriz

<tipo de dato>: nombre_variable[Filas][Columnas]

Ejemplo:
a) Entero: Numeros[5][3]
Cuando se define este espacio en memoria para las matrices establece este espacio.

b) Caracter: Letras[2][5]

Filas
Columnas
Recordemosquelos
ArreglosoMatrices
empiezandesdela
posicincerotantopara
lasfilasycolumnas.
Asignacin de datos hacia una Matriz:

nombre_variable[ndiceFila] [ndiceColumna] =<expresin del tipo>

Ejemplos: Estableciendo Datos a una Matriz
Asignar aos de nacimiento a la Matriz Numeros.
Numeros[0][1]=1975
Numeros[1][2]=1972
Numeros[3][1]=1999
Numeros[4][2]=2004
Asignar Letras a la Matriz Letras
Letras[0][0]= V
Letras[0][1]= E
Letras[0][2]= R
Letras[0][3]= O
Letras[0][4]= N
Letras[1][0]= I
Letras[1][1]= C
Letras[1][2]= A
Acceso al contenido de una Matriz:
Para poder acceder al contenido:

a. Mostrar: Obtener el dato de acuerdo al ndice establecido, para ello se deber mostrar
utilizando una variable o mostrndolo directamente.

Variable=Matriz[ndiceFila] [ndiceColumna]

Mostrar(Variable) o Mostar(Matriz[ndiceFila] [ndiceColumna])

Ejemplo:
X=Letras[0][3]
Mostrar(X) el resultado ser O
_________________________________________________________
Mostrar(Letras[0][0]) el resultado ser V

b. Lectura: se podr ingresar datos al arreglo en forma contigua de acuerdo al ndice. Es
por ello que se usara a una estructura iterativa anidad que puede ser Mientras(while),
Desde (do) o Repetir(do..while).
Leer(Matriz[ndiceFila] [ndiceColumna])
Nota: Para que esta lectura se repita hasta el total de tamao del arreglo se deber de
usar a una estructura Iterativa anidada que permitir realizar el recorrido de filas y de las
columnas o viceversa(Columnas o Filas).

Llenar datos a la matriz:

Ejemplo. Recorriendo la Matriz dndole nuevos valores:
desde(f=0 hasta Filas-1)
desde(c =0 hasta Columnas-1)
leer( numeros[f][c] )
fin_desde
fin_desde

4. Manipular la informacin guardada en la Matriz. Para esto es necesario recorrer dicha
estructura y se puede hacer de la siguiente manera.
desde(f =0 hasta Filas-1)
mostrar( numeros[f][c] )
fin_desde
fin_desde

Tambin se puede leer y a la vez escribir los datos ingresados al arreglo
desde(f =0 hasta Filas-1)
leer( numeros[f][c] )
mostrar( numeros[f][c] )
fin_desde
fin_desde

Operaciones que se pueden realizar con los arreglos

Lectura (llenar datos de la matriz)
Escritura (mostrar datos de la matriz)
Asignacin (dar valor a una posicin especfica)
Actualizacin (insercin , eliminacin, modificacin )

Ejemplos:
En una matriz de dimensiones 5x4 hallar el mayor valor y el menor valor.
Variables
Fi=5
Co=4
Entero: Datos[Fi][Co]
Inicio
mayor=0; menor=1000;
desde(x=0 hasta Fi-1)
desde (y=0 hasta Co-1)
leer(Datos [x] [y])
si (Datos [x] [y]>mayor)
mayor=matriz [x] [y]
si (Datos [x] [y]<menor)
menor=matriz [x] [y]
fin_desde
fin_desde
escribir(mayor, menor)
fin_programa

USO DE MATRICES con el control JTABLE

J ava posee la capacidad de definir un conjunto de variables del mismo tipo agrupadas todas
ellas bajo un mismo nombre, y distinguindolas mediante un ndice numrico.
Para definir un arreglo o Matriz en java es como definir una variable o atributo, pero al
especificar el tipo lo que hacemos es colocar un par de corchetes [] para indicar que lo que
estamos definiendo es un arreglo o Matriz.
Para definir una Matriz se realiza de la siguiente manera:
Tipo_de_Dato variables[ ] [ ] =new Tipo_de_Dato [fila] [columna];
Por ejemplo definicin de Matrices:
int numero[][]=new int[5][3];
double sueldos[][]=new double[10][2];
String apellidos[][]=new String[5][4];
boolean estado [][]=new boolean[6][4];
Asignar datos:
numero[0][0]=123;
numero[0][1]=456
Leer datos:
//solo indica el ingreso para esa posicin de la matriz
nmeros[0][2]=Integer.parseInt(J OptionPane.showInputDialog(Ingresar Numero));
En el caso que se desee realizar para toda la matriz debers de usar a una estructura
anidada para el ingreso. Por ejemplo:
//Definimos el total de filas y columnas
final int filas=5;
final int columnas=3;
int numero[][]=new int[filas][columnas];
for(int y=0;y<filas;++y){
for(int x=0;x<columnas;++x){
numero[y][x]=Integer.parseInt(J OptionPane.showInputDialog(Ingresar
Numero));
}
}
Uso del JTable

J table es una clase que me permite organizar una determinada informacin en tabla, esta
difiere de una base de datos normal porque al utilizar J table t puedes visualizar esta tabla,
brindndole al usuario organizacin de informacin, oportunidades de editar y cambiar el
tamao de las columna entre otras.
J table le da al programador muchas facilidades, pues este posee varias caractersticas que
permiten hacer desde tablas con informacin compleja y muy estructurada hasta tablas con
informacin sencilla y "bsica".
TABLE MODEL
La clase J table controla como se presentan los datos, para crear una J table habr pues que
crear un DefaultTableModel antes, normalmente. DefaultTableModel lo que hace es
predeterminar ciertas caractersticas para el J table es decir que tu puedes poner ciertos
parmetros dentro de un DefaultTableModel y as no tener que determinarlos siempre.
DefaulTableModel guarda los datos de la tabla para s mismo, es decir, puede tener la
informacin de la tabla pero estos datos son los visualizados por el computador, es decir, para
visualizar una tabla el DEFAULTTABLEMODEL puede tener la informacin pero sin el J table
no se puede visualizar para el usuario.
EDITABLE O NO?
J table tiene una caracterstica muy llamativa, este permite que el programador pueda decidir
que se edita y que no, sin embargo si el programador dentro de su programa o de su
DEFAULTTABLEMODEL no tiene determinado este aspecto, J table automticamente hace
editable las celdas dentro de la tabla.
LA INFORMACIN, Y LAS COLUMNAS?.
J table te brinda muchas facilidades para poder crear una tabla, y as mismo de llenarla con la
informacin que desees ( nmeros, letras etc...) por lo que sencillamente dentro de una tabla
esta automticamente esta a travs de la informacin debidamente separada - por ""(comillas)
o por , (coma) - es capaz de contabilizarlas y al mismo tiempo llenarla con la informacin que
se le dio; es decir el programador solo se debe encargar de poner los ttulos de las tablas y as
mismo de escribir la informacin en el mismo orden en que desee que salga de acuerdo con
los ttulos y J table se encargara automticamente de colocar la informacin donde se le indico.
UN CHECK BOX?
Para un CellRendered con un DefaultTableModel sencillo, tal vez identificar clases pueda ser
algo ms complejo que no pueda hacer, pero para uno un poco ms avanzado, esto sera muy
fcil, y para esto cito el caso de un CHECK BOX(casilla de verificacin) el cual es un
componente grafico generado por J table despus de que identifica una informacin tipo
boolean, dndole as la apariencia de un cuadro rellenable, un check box no es ms que eso,
una opcin - que puede ser editable o no.
UN LIST BOX?
En algunas oportunidades, para cierto tipo de informacin que deseamos que el usuario
complete, necesitamos darle a el usuario, cierto tipo de opciones cosa que a travs de un List
Box tu puedes ofrecer al usuario el tipo de respuestas que tu desees que selecciones, este tipo
de organizacin de informacin ya no es tan sencillo como declarar una informacin tipo
boolean, toca crear la lista.
Creacin y enlace de un JTable

Insertar el J Table y definir la clase DefaultTableModel en el public class por
ejemplo:

En el mtodo jbInit establecer el enlace del modal y el total de filas y columnas.

Ejemplo 01:
Crear una Matriz de 5 X 3 y llenar datos numricos enteros.
Realizar el procedimiento de creacin y enlace del J table.

final int filas=5;
final int columnas=3;
int numero[][]=new int[filas][columnas];
for(int y=0;y<filas;++y){
for(int x=0;x<columnas;++x){
numero[y][x]=Integer.parseInt(J OptionPane.showInputDialog("IngresarNumero"));
modTbDatos.setValueAt(numero[y][x],y,x);
}
}
}
DefaultTableModel modTbDatos=new DefaultTableModel();
jTable1.setModel(modTbDatos);
modTbDatos.setColumnCount(3);
modTbDatos.setRowCount(5);
Ejemplo 02:
Mostrar los resultados de las tablas de multiplicar hasta el 10.
Realizar el procedimiento de creacin y enlace del J table.
final int MAXT =11;
int [] [] tabla =new int [MAXT][MAXT];
//Se inicializan los valores de tabla
for (int i =0; i <MAXT; i++)
for (int j =0; j <MAXT; j++)
tabla [i][j] =i*j;
//Se imprime tabla
//se muestran los resultados que tenga la matriz
for (int i =0; i <MAXT; i++) {
for (int j =0; j <MAXT; j++)
modTbDatos.setValueAt(tabla [i][j],i,j);
}
}

Ejemplo 03:
Crear 2 vectores Apellidos y Edades que almacenen 15 registros y debern ser
presentados en el J Table por columnas.

final int filas=15;
int Edad[]=new int[filas];
String apellidos[]=new String[filas];
for (int i =0; i <filas; i++){
apellidos[i]=J OptionPane.showInputDialog("Ingresar Apellidos");
Edad[i]=Integer.parseInt(J OptionPane.showInputDialog("Ingresar Edad"));
modTbDatos.setValueAt(apellidos[i],i,0);
modTbDatos.setValueAt(Edad[i],i,1);
}
}

BALOTARIO DE EJERCICIOS USANDO VECTORES Y MATRICES

1. Dado un vector de nmeros reales:
a) Escriba un mtodo max que nos devuelva el mximo de los valores incluidos en el
vector.
b) Escriba un mtodo min que nos devuelva el mnimo de los valores incluidos en el
vector.
c) Escriba un mtodo media Aritmtica que nos devuelva la media de los valores
incluidos en el vector.
d) Dado un vector de nmeros reales, escriba un mtodo que nos devuelva el mximo
y el mnimo de los valores incluidos en el vector.
e) Dado un vector, implemente un mtodo que inserte un elemento en una posicin
dada del vector.
f) Realizar programas que definan un vector de 10 elementos inicializado con valores
enteros cualesquiera, tanto negativos como positivos y hagan lo siguiente:
Mostrar por pantalla el contenido del vector
Mostrar por pantalla el contenido del vector en orden inverso.
Mostrar la suma de los valores del vector
Indicar el mximo y el mnimo de los valores del vector.
Hallar la media aritmtica de aquellos valores que sean mayores que 20 y
menores que 80.
Indicar cuantos hay pares y si hay alguno primo.
2. Realizar un programa al que se le vayan introduciendo por teclado nmeros enteros. El
programa dispone de dos vectores, uno llamado positivos y otro negativo, ambos de 8
posiciones. Se trata de meter los nmeros introducidos en uno u otro segn su signo
hasta que se llenen los dos. El programa avisar si se intenta meter un nmero
(positivo o negativo) cuando el vector correspondiente est lleno. Finalmente el
programa nos
a) informar de la suma de todos los elementos guardados en los vectores.
b) El promedio de lo positivos
c) Cuantos nmeros +fueron mayores a 100.

3. Realizar un subprograma llamado llenar_vector_sin_repet igual que
llenar_vector_10_elem pero que no introduzca repetidos. Realizar un programa que lo
utilice y muestre por pantalla el contenido del vector.

4. Dada una matriz de 10 x 10, mostrar la suma de las filas y columnas
a) Que fila obtuvo la suma mayor
b) Que columna obtuvo la suma menor.
c) El numero mayor
d) El promedio de la suma
e) El promedio de la columna.


Contenidos
- Definir Ordenamientos de Datos: Mtodo de Burbuja, Mtodo Shell.
- Definicin de Bsqueda: Tipos Bsqueda de Datos dentro de un Arreglo.
- Tipos de Bsquedas: Bsqueda Lineal - Bsqueda Binaria.

____________________________________________________________________________

Algoritmos de Ordenamiento
Ordenar es simplemente colocar informacin de una manera especial basndonos en un
criterio de ordenamiento.

Mtodos de ordenamientos.
Existen diferentes mtodos de ordenamiento entre ellas tenemos por Seleccin, Insercin,
Quick Sort, Burbuja, Shell, etc. Dentro de las cuales hablaremos de los mtodos:
El hecho de que la informacin est ordenada, nos sirve para poder encontrarla y accesarla de
manera ms eficiente ya que de lo contrario se tendra que hacer de manera secuencial.
A continuacin se describirn 4 grupos de algoritmos para ordenar informacin:

Algoritmos de insercin:
En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a la
vez. Cada elemento es INSERTADO en la posicin apropiada con respecto al resto de los
elementos ya ordenados.
Entre estos algoritmos se encuentran el de INSERCION DIRECTA, SHELL SORT, INSERCION
BINARIA y HASHING.

Algoritmos de intercambio:
En este tipo de algoritmos se toman los elementos de dos en dos, se comparan y se
INTERCAMBIAN si no estn en el orden adecuado. Este proceso se repite hasta que se ha
analizado todo el conjunto de elementos y ya no hay intercambios.
Entre estos algoritmos se encuentran el BURBUJ A y QUICK SORT.
Algoritmos de seleccin:

En este tipo de algoritmos se SELECCIONA o se busca el elemento ms pequeo (o ms

grande) de todo el conjunto de elementos y se coloca en su posicin adecuada. Este proceso
se repite para el resto de los elementos hasta que todos son analizados.
Entre estos algoritmos se encuentra el de SELECCION DIRECTA.

Algoritmos de enumeracin:
En este tipo de algoritmos cada elemento es comparado contra los dems. En la comparacin
se cuenta cuntos elementos son ms pequeos que el elemento que se est analizando,
generando as una ENUMERACION. El nmero generado para cada elemento indicar su
posicin.
Los mtodos simples son: Insercin (o por insercin directa), seleccin, burbuja y shell, en
dnde el ltimo es una extensin al mtodo de insercin, siendo ms rpido. Los mtodos ms
complejos son el quick-sort (ordenacin rpida) y el heap sort.
A continuacin se mostrarn los mtodos de ordenamiento ms simples.

Mtodo Burbuja.
El bubble sort, tambin conocido como ordenamiento burbuja, consiste en comparar un valor
con el siguiente valor y de acuerdo a la condicin se realizara el intercambio entre los datos, y
este recorrido se va ir haciendo hasta culminar todos los elementos N-1 del arreglo.

Algoritmo:

Mtodo de Shell.
Nombrado as debido a su inventor Donald Shell. Ordenamiento de disminucin incremental,
Ordena subgrupos de elementos separados K unidades (respecto de su posicin en el arreglo)
del arreglo original. El valor K es llamado incremento.
Despus de que los primeros K subgrupos han sido ordenados (generalmente utilizando
INSERCION DIRECTA), se escoge un nuevo valor de K ms pequeo, y el arreglo es de nuevo
partido entre el nuevo conjunto de subgrupos. Cada uno de los subgrupos mayores es
ordenado y el proceso se repite de nuevo con un valor ms pequeo de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste de todo el
arreglo ya casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el ltimo
valor debe ser 1. "Es como hacer un ordenamiento de burbuja pero comparando e
intercambiando elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte del
subgrupo y se aplica insercin directa.
Desde(g=0 hasta N-1) // recorrido del vector
Desde (i=0 hasta N-1) //posiciones de comparacin
si(vector[i] > vector[i+1])
aux=vector[i]
vector[i]=vector[i+1]
vector[i+1]=aux
fin_si
fin_desde
fin_desde
El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos) y luego se va
reduciendo a la mitad en cada repeticin hasta que el salto o distancia vale 1.

Procedimiento Shell Sort;

Ejemplo:
Para el arreglo a =[6, 1, 5, 2, 3, 4, 0]
Tenemos el siguiente recorrido:
Recorrido Salto Lista Ordenada Intercambio
1 3 2,1,4,0,3,5,6 (6,2), (5,4), (6,0)
2 3 0,1,4,2,3,5,6 (2,0)
3 3 0,1,4,2,3,5,6 Ninguno
4 1 0,1,2,3,4,5,6 (4,2), (4,3)
5 1 0,1,2,3,4,5,6 Ninguno

Procedimiento SHELL(variables Vector:A; entero:n)
variables
entero: aux,i,int
logico: band
Incio
int=n+1;
Mientras (int>1)
int=1mod(int div 2)
band=true
Mientras (band=true )
band=false
i=1
Mientras ((i+int)<=n)
si(a[i] > a[i+int]) entonces
aux=a[i]
a[i]=a[i+int]
a[i+int]=aux
band=true
fin_si
i=i+1
Fin_Mientras
Fin_Mientras
Fin_Mientras
Fin
Ejemplos en cdigo JAVA:

.

void shell_sort(int A[], int size){
int i, j, incrmnt, temp;
incrmnt =size/2;
while (incrmnt >0) {
for (i=incrmnt; i <size; i++) {
j =i;
temp =A[i];
while ((j >=incrmnt) && (A[j-incrmnt] >temp)) {
A[j] =A[j - incrmnt];
j =j - incrmnt;
}
A[j] =temp;
}
incrmnt /=2;
}
}

void ordenamientoBurbuja(int v[], int util_v) {
int temp;
for (int i =0; i <=util_v - 2; i++) {
for (int j =i +1; j <=util_v - 1; j++) {
if (v[i] >v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
}
}
Bsqueda
Un algoritmo de bsqueda es aquel que est diseado para localizar un elemento concreto
dentro de una estructura de datos. Consiste en solucionar un problema de existencia o no de
un elemento determinado en un conjunto finito de elementos, es decir, si el elemento en
cuestin pertenece o no a dicho conjunto, adems de su localizacin dentro de ste.
Este problema puede reducirse a devolver la existencia de un nmero en un vector.

Bsqueda secuencial
Permite localizar el dato dentro del arreglo desde la posicin inicial hasta la posicin final, la
existencia se puede asegurar desde el momento que el elemento es localizado (pero no
podemos asegurar la no existencia hasta no haber analizado todos los elementos del arreglo).

Bsqueda binaria
Se utiliza cuando el vector en el que queremos determinar la existencia o no de un elemento
est ordenado, o puede estarlo, este algoritmo reduce el tiempo de bsqueda
considerablemente, ya que disminuye exponencialmente con el nmero de iteraciones.

Datos de Entrada:
vec: nombre de la coleccin de todos los datos
tam: tamao del vector
dato: elemento que se quiere buscar.

Variables
entero: pos
Inicio
leer(dato)
pos =0
Mientras(pos <tam)
Si (vec[pos]=dato) entonces
Devolver=verdadero
sino
pos =pos +1
fin_si
fin_Mientras

Ejemplos

Caso 01
Dentro de una lista de 10 nombres, verifique si el nombre ingresado existe o no.

Caso 02

Dentro de una lista de 25 distritos muestre si existe o no el distrito de Villa el Salvador.

Caso 03

Crear una Aplicacin donde permita llenar datos a los vectores Nombres, Apellidos Ao de
Nacimiento y edad. Permitir hasta 20 registros.
La edad se calcula de acuerdo al Ao de Nacimiento
El programa permitir :
o Ordenar por Apellido
o Buscar Datos por Nombres y decir cuntos Nombres son iguales.

public class FrmEjem01 extends JFrame {
final int filas=20;
String nom[]=new String[filas];
String ape[]=new String[filas];
int edad[]=new int[filas];
int anac[]=new int[filas];

Sedefineladimensiny
losnombresdelos
Arreglos
int Reg;

private void jbInit() throws Exception {
------------------------------------------------------
//llenando el combo con las fechas
for(int g=1970;g<=2010;++g)
cboAnac.addItem(g);

void LeerDatos(){
if(Reg<filas){
nom[Reg]=txtNom.getText();
ape[Reg]=txtApe.getText();
}
else
J OptionPane.showMessageDialog(null,"Ya no puede ingresar mas registros");

}
void llenarRegistros(){
modTbDatos.setValueAt((Reg+1),Reg,0);
modTbDatos.setValueAt(nom[Reg],Reg,1);
modTbDatos.setValueAt(ape[Reg],Reg,2);
modTbDatos.setValueAt(anac[Reg],Reg,3);
modTbDatos.setValueAt(edad[Reg],Reg,4);
++Reg;
}
private void btnAceptar_actionPerformed(ActionEvent e) {
LeerDatos();
llenarRegistros();
}

private void cboAnac_actionPerformed(ActionEvent e) {
anac[Reg]=Integer.parseInt(cboAnac.getSelectedItem().toString());
edad[Reg]=2010-anac[Reg];
lbledad.setText(""+edad[Reg]);

}
void OrdenarB(){
String tempA,tempN;
int tempAn,tempE;
for (int i =0; i <Reg - 1; i++) {
for (int j =0; j <Reg - 1; j++) {
if ((ape[j].compareTo(ape[j+1]))>0) {
tempA =ape[j];
ape[j] =ape[j+1];
ape[j+1] =tempA;

SedefineelContador
delRegistro
SeEstablecevalores
alCombo
PreguntandosielRegistroes
menoraltotaldeFilas.
LlenalosdatosalosArreglos
Muestralosdatosquetieneel
Arreglo
IncrementoelRegistropara
controlareltotaldedatos
ingresados.
Calculalaedadsegnelao
seleccionado.
OrdenamientoBurbuja.
PormediodelApellido

//
tempN =nom[j];
nom[j] =nom[j+1];
nom[j+1] =tempN;

//
tempAn =anac[j];
anac[j] =anac[j+1];
anac[j+1] =tempAn;

//
tempE =edad[j];
edad[j] =edad[j+1];
edad[j+1] =tempE;
}
}
}

// visualizar datos ordenados
for(int g=0;g<Reg;++g){
modTbDatos.setValueAt((g+1),g,0);
modTbDatos.setValueAt(nom[g],g,1);
modTbDatos.setValueAt(ape[g],g,2);
modTbDatos.setValueAt(anac[g],g,3);
modTbDatos.setValueAt(edad[g],g,4);
}

}
private void BtnOrdenart_actionPerformed(ActionEvent e) {
OrdenarB();
}

Elrestodelosvectorestambien
debenderealizarsoloel
intercambioparaseguirelorden.
Establecereltotaldefilas
segnaltotalderegistros.
MostrarlosDatosOrdenados.
Eliminartodoslasfilasdela
tabla.
LlamaralOrdenamientoy
volveramostrarlosdatos.Y
seVisualizaraenlatabla
ordenadoporApellido.
Para la Busqueda. Deber de aparecer la ventana para buscar el nombre y visualizar si se

encontro y cuantas veces.

Por lo tanto agrega el metodo busqueda_Nom() y lo llamaremos en el boton Busqueda.

void busqueda_Nom(){
int f=0,c=0;
String Vb=J OptionPane.showInputDialog("Ingresar Nombres a Buscar");
while(f<Reg){
if(Vb.equalsIgnoreCase(nom[f])){
c=c+1;
}
++f;
}
if(c>0)
J OptionPane.showMessageDialog(null,"Nombre Encontrado"+"\n"+"y se Repite
:"+(c)+"Veces");
else
J OptionPane.showMessageDialog(null,"No se Encontrado el Nombre");
}

private void btnBusqueda_actionPerformed(ActionEvent e) {

busqueda_Nom();
}

Insertar el Botn Eliminar Registro Intenta estableciendo el siguiente cdigo

private void btnEliminar_actionPerformed(ActionEvent e) {
//Fila seleccionada de la Tabla
int FilSelec=jTable1.getSelectedRow();
modTbDatos.removeRow(FilSelec);
nom[FilSelec]="";
ape[FilSelec]="";
edad[FilSelec]=0;
anac[FilSelec]=0;
}


Contenidos
- Introduccin a la programacin Orientada a Objetos POO.
- Caracteristicas de la programacin orientada a objetos.
- Definicin de Clases
- Constructores, Estructura de una clase
- Nivel de acceso(public, private, protected)
- Uso de atributo static.
- Interfaces, definicin.
- Paquete, distribucin, mencionar la razn de trabajar en capas, manejo de capas
(Lgica y Presentacin )
- Encapsulacin (get y set de los atributos)
- Herencia: extends, Polimorfismo
- Sobrecarga de Mtodos
____________________________________________________________________________

Programacin Orientada a Objetos
Es un paradigma de programacin que usa objetos y sus interacciones, para disear
aplicaciones y programas de ordenador. Est basado en varias tcnicas, incluyendo herencia,
modularidad, polimorfismo y encapsulamiento. Su uso se populariz a principios de la dcada
de 1990. En la actualidad, existe variedad de lenguajes de programacin que soportan la
orientacin a objetos.
Un objeto es en realidad un conjunto de funciones y procedimientos, todos ellos relacionados
con un determinado concepto del mundo real. Los objetos son entidades que combinan estado
(atributo), comportamiento (mtodo) e identidad:
El estado est compuesto de datos, ser uno o varios atributos a los que se habrn
asignado unos valores concretos (datos).
El comportamiento est definido por los procedimientos o mtodos con que puede
operar dicho objeto, es decir, qu operaciones se pueden realizar con l.
La identidad es una propiedad de un objeto que lo diferencia del resto, dicho con otras
palabras, es su identificador (concepto anlogo al de identificador de una variable o
una constante).

La programacin orientada a objetos, expresa un programa como un conjunto de estos objetos,

que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y mdulos
ms fciles de escribir, mantener, y reutilizar.
Un objeto contiene toda la informacin que permite definirlo e identificarlo frente a otros objetos
pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener
valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de
interaccin llamados mtodos, que favorecen la comunicacin entre ellos. Esta comunicacin
favorece a su vez el cambio de estado en los propios objetos. Esta caracterstica lleva a
tratarlos como unidades indivisibles, en las que no se separa el estado y el comportamiento.
Los mtodos (comportamiento) y atributos (estado) estn estrechamente relacionados por la
propiedad de conjunto. Esta propiedad destaca que una clase requiere de mtodos para poder
tratar los atributos con los que cuenta. El programador debe pensar indistintamente en ambos
conceptos, sin separar ni darle mayor importancia a alguno de ellos. Hacerlo podra producir el
hbito errneo de crear clases contenedoras de informacin por un lado y clases con mtodos
que manejen a las primeras por el otro. De esta manera se estara realizando una
programacin estructurada camuflada en un lenguaje de programacin orientado a objetos.
La POO difiere de la programacin estructurada tradicional, en la que los datos y los
procedimientos estn separados y sin relacin, ya que lo nico que se busca es el
procesamiento de unos datos de entrada para obtener otros de salida. La programacin
estructurada anima al programador a pensar sobre todo en trminos de procedimientos o
funciones, y en segundo lugar en las estructuras de datos que esos procedimientos manejan.
En la programacin estructurada slo se escriben funciones que procesan datos. Los
programadores que emplean POO, en cambio, primero definen objetos para luego enviarles
mensajes solicitndoles que realicen sus mtodos por s mismos.
Caractersticas de la POO
Existe un acuerdo acerca de qu caractersticas contempla la "orientacin a objetos", las
caractersticas siguientes son las ms importantes:
Abstraccin: Denota las caractersticas esenciales de un objeto, donde se capturan
sus comportamientos.Cada objeto en el sistema sirve como modelo de un "agente"
abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse"
con otros objetos en el sistema sin revelar cmo se implementan estas caractersticas.
Los procesos, las funciones o los mtodos pueden tambin ser abstrados y cuando lo
estn, una variedad de tcnicas son requeridas para ampliar una abstraccin.

Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse
pertenecientes a una misma entidad, al mismo nivel de abstraccin. Esto permite
aumentar la cohesin de los componentes del sistema. Algunos autores confunden
este concepto con el principio de ocultacin, principalmente porque se suelen emplear
conjuntamente.

Principio de ocultacin: Cada objeto est aislado del exterior, es un mdulo
natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cmo
pueden interactuar con los objetos de la clase. El aislamiento protege a las
propiedades de un objeto contra su modificacin por quien no tenga derecho a acceder
a ellas, solamente los propios mtodos internos del objeto pueden acceder a su estado.
Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de
maneras inesperadas, eliminando efectos secundarios e interacciones inesperadas.
Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del
objeto de una manera controlada y limitando el grado de abstraccin. La aplicacin
entera se reduce a un agregado o rompecabezas de objetos.

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden

compartir el mismo nombre, al llamarlos por ese nombre se utilizar el comportamiento
correspondiente al objeto que se est usando. O dicho de otro modo, las referencias y
las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocacin
de un comportamiento en una referencia producir el comportamiento correcto para el
tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecucin", esta
ltima caracterstica se llama asignacin tarda o asignacin dinmica. Algunos
lenguajes proporcionan medios ms estticos (en "tiempo de compilacin") de
polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.

Herencia: las clases no estn aisladas, sino que se relacionan entre s, formando una
jerarqua de clasificacin. Los objetos heredan las propiedades y el comportamiento de
todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y
el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos
especializados de objetos preexistentes. Estos pueden compartir (y extender) su
comportamiento sin tener que volver a implementarlo. Esto suele hacerse
habitualmente agrupando los objetos en clases y estas en rboles o enrejados que
reflejan un comportamiento comn. Cuando un objeto hereda de ms de una clase se
dice que hay herencia mltiple.

Recoleccin de basura: la Recoleccin de basura o Garbage Collector es la tcnica
por la cual el ambiente de Objetos se encarga de destruir automticamente, y por tanto
desasignar de la memoria, los Objetos que hayan quedado sin ninguna referencia a
ellos. Esto significa que el programador no debe preocuparse por la asignacin o
liberacin de memoria, ya que el entorno la asignar al crear un nuevo Objeto y la
liberar cuando nadie lo est usando. En la mayora de los lenguajes hbridos que se
extendieron para soportar el Paradigma de Programacin Orientada a Objetos como
C++u Object Pascal, esta caracterstica no existe y la memoria debe desasignarse
manualmente.

Clases en POO
Las clases son declaraciones de objetos, tambin se podran definir como abstracciones de
objetos(quiere decir que la definicin de un objeto es la clase). Cuando programamos un objeto
y definimos sus caractersticas y funcionalidades en realidad lo que estamos haciendo es
programar una clase.

Propiedades en clases
Las propiedades o atributos son las caractersticas de los objetos. Cuando definimos una
propiedad normalmente especificamos su nombre y su tipo. Nos podemos hacer a la idea de
que las propiedades son algo as como variables donde almacenamos datos relacionados con
los objetos.

Mtodos en las clases
Son las funcionalidades asociadas a los objetos. Cuando estamos programando las clases las
llamamos mtodos. Los mtodos son como funciones que estn asociadas a un objeto.

Objetos en POO
Los objetos son ejemplares de una clase cualquiera. Cuando creamos un ejemplar tenemos
que especificar la clase a partir de la cual se crear. Esta accin de crear un objeto a partir de
una clase se llama instanciar (que viene de una mala traduccin de la palabra instace que en
ingls significa ejemplar). Por ejemplo, un objeto de la clase fraccin es por ejemplo 3/5. El
concepto o definicin de fraccin sera la clase, pero cuando ya estamos hablando de una
fraccin en concreto 4/7, 8/1000 o cualquier otra, la llamamos objeto.
Para crear un objeto se tiene que escribir una instruccin especial que puede ser distinta
dependiendo el lenguaje de programacin que se emplee, pero ser algo parecido a esto.
miCoche =new Coche()
Con la palabra new especificamos que se tiene que crear una instancia de la clase que sigue a
continuacin. Dentro de los parntesis podramos colocar parmetros con los que inicializar el
objeto de la clase coche.

Estados en objetos
Cuando tenemos un objeto sus propiedades toman valores. Por ejemplo, cuando tenemos un
coche la propiedad color tomar un valor en concreto, como por ejemplo rojo o gris metalizado.
El valor concreto de una propiedad de un objeto se llama estado.
Para acceder a un estado de un objeto para ver su valor o cambiarlo se utiliza el operador
punto.
miCoche.color =rojo
El objeto es miCoche, luego colocamos el operador punto y por ltimo el nombre e la propiedad
a la que deseamos acceder. En este ejemplo estamos cambiando el valor del estado de la
propiedad del objeto a rojo con una simple asignacin.

Mensajes en objetos
Un mensaje en un objeto es la accin de efectuar una llamada a un mtodo. Por ejemplo,
cuando le decimos a un objeto coche que se ponga en marcha estamos pasndole el mensaje
ponte en marcha.
Para mandar mensajes a los objetos utilizamos el operador punto, seguido del mtodo que
deseamos invocar.
miCoche.ponerseEnMarcha()
En este ejemplo pasamos el mensaje ponerseEnMarcha(). Hay que colocar parntesis igual
que cualquier llamada a una funcin, dentro iran los parmetros.

Otras cosas
Hay mucho todava que conocer de la POO ya que slo hemos hecho referencia a las cosas
ms bsicas. Tambin existen mecanismos como la herencia y el polimorfismo que son unas
de las posibilidades ms potentes de la POO.
La herencia sirve para crear objetos que incorporen propiedades y mtodos de otros objetos.
As podremos construir unos objetos a partir de otros sin tener que reescribirlo todo.
El polimorfismo sirve para que no tengamos que preocuparnos sobre lo que estamos
trabajando, y abstraernos para definir un cdigo que sea compatible con objetos de varios
tipos.
Son conceptos avanzados que cuesta explicar en las lneas de ese informe. No hay que olvidar
que existen libros enteros dedicados a la POO y aqu solo pretendemos dar un repaso a
algunas cosas para que os suenen cuando tengis que poneros delante de ellas en los
lenguajes de programacin que debe conocer un desarrollador del web.

Creacin de Clases en JAVA

Crear la aplicacin con su proyecto, luego elegir crea la Class y saldr esta ventana.

Para crear una sub clase (hija), deber de seleccionar
la opcin public estars. Y su estructura quedara as.

Para crear una clase main (principal), deber de seleccionar la opcin public y generate
Main Method. Y su estructura quedara as.

Ejemplo 01: mostrar mis datos personales desde una clase Main.

public class ClassEjecutar1 {
public static void main(String[] args) {
//referencia de la clase
ClassEjecutar1 Ejecutar =new ClassEjecutar1();
String nombres="Veronica Ysabel";
String ape="Escobar Runco";
String espe="Computacion e Informatica";
System.out.println("Nombres: "+nombres);
System.out.println("Apellidos: "+ape);
System.out.println("Especialidad: "+espe);
}
}

public class SubClaseHija1 {

//Cuerpo de la Clase Hija

}
publicclassClassEjecutar{
//AtributosGlobales
//Metdos
publicstaticvoidmain(String[]args){
//referenciadelaclase
ClassEjecutarEjecutar=newClassEjecutar();
//atributosLocales

Ejemplo 02: mostrar datos personales ingresado por el usuario desde una clase
Main.

ClassEjecutar2 Ejecutar =new ClassEjecutar2();
String nombres=J OptionPane.showInputDialog("Ingresar Nombre");
String ape=J OptionPane.showInputDialog("Ingresar Apellido");
String espe=J OptionPane.showInputDialog("Ingresar Especialidad");
JOptionPane.showMessageDialog(null,"Nombres: "+nombres+"\n"+"Apellidos:"+ape
+"\n" +"Especialidad: "+espe,"Datos Personales",1);
}
}

Ejemplo 03: ingresar 2 nmeros y mostrar las 4 operaciones bsicas.

int num1, num2, sum,res,mul;
double divi;
num1=Integer.parseInt(J OptionPane.showInputDialog("Ingrece el #1"));
sum=num1+num2;
res=num1-num2;
mul=num1*num2;
divi=num1/num2;
J OptionPane.showMessageDialog(null,"La suma de\t"+num1+"+"+num2+"="+
sum,"Operacin de Suma",2);
J OptionPane.showMessageDialog(null,"La resta de\t"+num1+"-"+num2+"="+
res,"Operacin de Resta",2);
J OptionPane.showMessageDialog(null,"La multiplicacion de\t"+num1+"*"+num2+"="+
mul,"Operacin de Multiplicacin",2);
J OptionPane.showMessageDialog(null,"La Divisin de\t"+num1+"/"+num2+"="+
Usandoconsola
UsandoMessage
divi,"Operacin de Divisin",2);

}
}

Aplicando Herencia entre Clases

Ejemplo 01: ingresar 2 nmeros y mostrar las 4 operaciones bsicas usando
herencia.

//Metodos
public int Suma(int a,int b){
return(a+b);
}
public int Resta(int a,int b){
return(a-b);
}
public int Multiplica(int a,int b){
return(a*b);
}
public int divi(int a,int b){
return(a/b);
}
}

package prjcaso1;

import javax.swing.JOptionPane;

public class ClassEjecutar extends SubClaseHija1 {
//Atributos Globales
ClassEjecutar Ejecutar =new ClassEjecutar();
//atributos Locales
int num1, num2;

J OptionPane.showMessageDialog(null,"La suma de\t"+num1+"+"+num2+"="+
Ejecutar.Suma(num1,num2),"Operacion de Suma",2);
J OptionPane.showMessageDialog(null,"La resta de\t"+num1+"-"+num2+"="+

Ejecutar.Resta(num1,num2),"Operacion de Resta",2);
J OptionPane.showMessageDialog(null,"La multiplicacion de\t"+num1+"*"+num2+"="+
Ejecutar.Multiplica(num1,num2),"Operacion de Multiplicacin",2);
J OptionPane.showMessageDialog(null,"La Divisin de\t"+num1+"/"+num2+"="+
Ejecutar.divi(num1,num2),"Operacion de Divisin",2);

}
}

Usando Referencias

//Metodos
public int Suma(int a,int b){
return(a+b);
}
public int Resta(int a,int b){
return(a-b);
}
public int Multiplica(int a,int b){
return(a*b);
}
public int divi(int a,int b){
return(a/b);
}
}

// La clase Main
public class ClassEjecutar {
//Atributis Globales
//referencia del Frame
FrmOperaciones llamar=new FrmOperaciones();
llamar.setVisible(true);
//atributos Locales

}
}

//Diseo de Frame
public class FrmOperaciones extends JFrame {
//Referencia de la SubClase
SubClaseHija1 Ejecutar = new SubClaseHija1();

.
private void btnCalcular_actionPerformed(ActionEvent e) {
int num1, num2;
num1=Integer.parseInt(txta.getText());
num2=Integer.parseInt(txtb.getText());
txtSalida.append("La suma de\t"+num1+"+"+num2+"="+Ejecutar.Suma(num1,num2)+"\n");

txtSalida.append("La resta de\t"+num1+"-"+num2+"="+Ejecutar.Resta(num1,num2)+"\n");
txtSalida.append("La multiplicacion de:
"+num1+"*"+num2+"="+Ejecutar.Multiplica(num1,num2)+"\n");
txtSalida.append("La Divisin de\t"+num1+"/"+num2+"="+Ejecutar.divi(num1,num2)+"\n");

}
}

Los constructores
Un objeto de una clase se crea llamando a una funcin especial denominada constructor de la
clase. El constructor se llama de forma automtica cuando se crea un objeto, para situarlo en
memoria e inicializar los miembros datos declarados en la clase. El constructor tiene el mismo
nombre que la clase. Lo especfico del constructor es que no tiene tipo de retorno.
public class ClassConstructor {
public ClassConstructor() {
System.out.println("Alumno SISE");
}
public ClassConstructor(String Esp) {
System.out.println("Su Especialidad " +Esp);
}
public ClassConstructor(int Costo) {
System.out.println("El Costo " +Costo +" Soles");
}
public ClassConstructor(int Costo,String Esp) {
double de=0,neto;
if(Esp.equalsIgnoreCase("Sistemas"))
de=0.15*Costo;
if(Esp.equalsIgnoreCase("Contabilidad"))
de=0.10*Costo;
neto=Costo-de;
System.out.println("Descuento " +de);
System.out.println("Neto " +neto );
}

Llamando al constructor desde una clase Main
public static void main(String args[]) {
ClassConstructor Alum1 =new ClassConstructor();
String espe=J OptionPane.showInputDialog("Ingresar Especialidad");
int costo=Integer.parseInt(J OptionPane.showInputDialog("Ingresar Costo"));
ClassConstructor Alum2 =new ClassConstructor(espe);
ClassConstructor Alum3 =new ClassConstructor(costo,espe);
}
}
Calificadores: Public, Private, Protected, Static y Final.

El uso de calificadores de acceso en J ava tiene sus bases en el uso de libreras
("packages"), al ser diseado un programa existen diversas funciones/mtodos y variables
dentro de ste, algunas de estas requerirn ser modificadas conforme incrementen las
necesidades del programa, mientras otras permanecern inmviles, la importancia de estos
cambios requiere que sean utilizados calificadores para permitir/negar el acceso a ciertos
segmentos del programa, analicemos el siguiente caso:
Usted ya diseo 300 clases que estn siendo re-utilizadas por otros programas, sin
embargo, se le ha solicitado una modificacin radical a estos objetos base, cuales
mtodos/campos de estas 300 Clases puede modificar sin quebrantar los otros programas
que hacen uso de estas ? Aqu puede surgir un serio problema sino han sido utilizados los
calificadores de acceso acordemente.
Ahora bien, adems de los calificadores de acceso que permiten restringir el uso de
mtodos/campos a determinadas situaciones, tambin existen otros calificadores que
afectan directamente la creacin y uso de instancias por clase estos calificadores son static
yfinal.
public : Acceso libre .
El uso del calificador public significa que toda definicin ser accesible de cualquier punto,
ya sea un mtodo, campo o clase. Su uso implica un acceso global, desde luego el uso de
este calificativo en Clases que sern modificadas constantmente es fuertemente
desalentado, ya que puede quebrantar dependencias forjadas en versiones previas.
private : Solo en la misma Clase .
El calificador private indica que dicho componente ser accesible nicamente dentro de la
Clase en cuestin, si se intenta accesar cualquier elemento de este tipo dentro de otra
Clase ser generado un error de compilacin.
El calificador private suele utilizarse en Clases que sern modificadas continuamente, esto
permite evitar futuros quebrantos en otras Clases como fue mencionado al inicio.
protected : Clases Heredadas y misma Clase.
El uso de protected es utilizado bajo los conceptos de Herencias ("Inheritance"), aunque
este tema ser descrito en otra seccin, mediante protected es posible accesar elementos
de la Clase Hereditaria ("Inherited"), aunque no aquellos que utilicen el calificador private.
En otras palabras, si determinada Clase hijo hereda ("inherit") el comportamiento de una
Clase padre, la Clase hijo tendr acceso a todos aquellos campos/mtodos definidos como
protected en padre, pero no aquellos declarados como private en padre.
Ningn Calificador : Clase en Librera y misma Clase .

Finalmente, cuando no es empleado ninguno de los calificadores de acceso mencionados
anteriormente los elementos son considerados amigables, esto implica que todo
campo/mtodo carente de calificador ser accesible dentro de todas Clases pertenecientes
a su misma librera("package").
static : Una sola instancia .
El uso del vocablo static ha venido siendo utilizado en los mtodos principales (main) de los
programas escritos anteriormente, su uso esta relacionado directamente al uso de
instancias en Clases; en ocasiones es necesario o conveniente generar elementos que
tomen un mismo valor para cualquier nmero de instancias generadas o bien
invocar/llamar mtodos sin la necesidad de generar instancias, y es bajo estas dos
circunstancias que es empleado el calificador static.
El primer uso de static puede ser poco evidente, pero tomemos el caso de la Clase
mencionada al inicio de este curso de una Lampara, en caso de requerirse un elemento
como un apagador pudiera resultar sobrado generar una instancia para cada Lampara, en
este caso pudiera ser restringido un apagador a una sola instancia mediante el calificador
static permitiendo que dicho elemento sea utilizado por todas las instancias de Lampara ah
generadas; desde luego la descripcin anterior esta trivializada, sin embargo, conforme se
avance en el presente curso sern ilustrados otros ejemplos con este mecanismo.
La segunda situacin para el uso de static puede ser ejemplificada perfectamente a travs
del mtodo main J ava, el mtodo main puede ser llamado automticamente al invocarse la
respectiva Clase debido a que no se encuentra asociado con ningn tipo de instancia, esto
implica que su comportamiento siempre ser el mismo independientemente de la instancia
que realza su llamada.
Dos aspectos caractersticos de utilizar el calificador static en un elemento J ava son los
siguientes :
No puede ser generada ninguna instancia (Uso de new) de un elemento static puesto que
solo existe una instancia.
Todos los elementos definidos dentro de una estructura static deben ser static ellos mismos
, o bien, poseer una instancia ya definida para poder ser invocados.
NOTA: Lo anterior no implica que no puedan ser generadas instancias dentro de un
elemento static; no es lo mismo llamar/invocar que crear/generar.
La teora del concepto static puede ser un poco difcil de digerir, sin embargo, como fue
mencionado anteriormente, conforme avance el curso sern descritos diversos fragmentos
de cdigo para dejar en claro su uso.
final : Una sola instancia y definitiva.

El calificador final estrechamente relacionado con el uso de static implica una asignacin
nica y definitiva al elemento de una clase. A diferencia de static que implica una sola
instancia, el termino final lleva dicha instancia a una definicin nica y como su nombre lo
implica final.
Generalmente final es utilizado en aquellos elementos que no sern modificados al
momento de ejecutarse ("Run-Time") un programa o clase , a travs de final se asigna un
valor que no podr ser modificado bajo ninguna circunstancia al momento de ejecucin
("Run-Time), en efecto logrando un nivel de eficiencia en ejecucin.
De igual manera que la utilizacin de static el uso de final ser ilustrado conforme se
avanze en este curso.

Atributo Static
El atributo static, que se puede utilizar con propiedades declaradas con las palabras clave var,
const o function, permite asociar una propiedad a la clase en lugar de asociarla a instancias de
la clase. El cdigo externo a la clase debe llamar a propiedades estticas utilizando el nombre
de la clase en lugar de un nombre de instancia. Las subclases no heredan las propiedades
estticas, pero las propiedades forman parte de una cadena de mbitos de subclase. Esto
significa que en el cuerpo de una subclase se puede utilizar una variable o un mtodo esttico
sin hacer referencia a la clase en la que se defini.

Interfaces
El concepto de Interface lleva un paso ms adelante la idea de las clases abstractas. En J ava
una interface es una clase abstracta pura, es decir una clase donde todos los mtodos son
abstractos (no se implementa ninguno). Permite al diseador de clases establecer la forma de
una clase (nombres de mtodos, listas de argumentos y tipos de retorno, pero no bloques de
cdigo). Una interface puede tambin contener datos miembro, pero estos son siempre static y
final. Una interface sirve para establecer un 'protocolo' entre clases.
Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface
puede definirse public o sin modificador de acceso, y tiene el mismo significado que para las
clases. Todos los mtodos que declara una interface son siempre public.
Para indicar que una clase implementa los mtodos de una interface se utiliza la palabra clave
implements. El compilador se encargar de verificar que la clase efectivamente declare e
implemente todos los mtodos de la interface. Una clase puede implementar ms de una
interface.
Declaracin y uso
Una interface se declara:
interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
. . .
}
Por ejemplo:
interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}
Y una clase que implementa la interface:
class InstrumentoViento extends Object implements InstrumentoMusical {
void tocar() {. . . };
void afinar() {. . .};
String tipoInstrumento() {}
}
class Guitarra extends InstrumentoViento {
String tipoInstrumento() {
return "Guitarra";
}
}
La clase InstrumentoViento implementa la interface, declarando los mtodos y escribiendo el
cdigo correspondiente. Una clase derivada puede tambin redefinir si es necesario alguno de
los mtodos de la interface.

Referencias a Interfaces
Es posible crear referencias a interfaces, pero las interfaces no pueden ser instanciadas. Una
referencia a una interface puede ser asignada a cualquier objeto que implemente la interface.
Por ejemplo:
InstrumentoMusical instrumento =new Guitarra();
instrumento.play();
System.out.prinln(instrumento.tipoInstrumento());

InstrumentoMusical i2 =new InstrumentoMusical(); //error.No se puede instanciar
Extensin de interfaces
Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface
puede extender ms de una interface. La sintaxis es:
interface nombre_interface extends nombre_interface , . . . {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
. . .
}
Agrupaciones de constantes
Dado que, por definicin, todos los datos miembros que se definen en una interface son static y
final, y dado que las interfaces no pueden instanciarse resultan una buena herramienta para
implantar grupos de constantes. Por ejemplo:
public interface Meses {
int ENERO =1 , FEBRERO =2 . . . ;
String [] NOMBRES_MESES ={" " , "Enero" , "Febrero" , . . . };
}
Esto puede usarse simplemente:
System.out.println(Meses.NOMBRES_MESES[ENERO]);

Un ejemplo casi real


Los paquetes

Los paquetes son una forma de organizar grupos de clases. Un paquete contiene un
conjunto de clases relacionadas bien por finalidad, por mbito o por herencia.
Los paquetes resuelven el problema del conflicto entre los nombres de las clases. Al
crecer el nmero de clases crece la probabilidad de designar con el mismo nombre a
dos clases diferentes.
Las clases tienen ciertos privilegios de acceso a los miembros dato y a las funciones
miembro de otras clases dentro de un mismo paquete.
En el Entorno Integrado de Desarrollo (IDE) J Builder de Borland, un proyecto nuevo se crea en
un subdirectorio que tiene el nombre del proyecto. A continuacin, se crea la aplicacin, un
archivo .java que contiene el cdigo de una clase cuyo nombre es el mismo que el del archivo.
Se pueden agregar nuevas clases al proyecto, todas ellas contenidas en archivos .java
situadas en el mismo subdirectorio. La primera sentencia que encontramos en el cdigo fuente
de las distintas clases que forman el proyecto es package o del nombre del paquete.
La palabra reservada import
Para importar clases de un paquete se usa el comando import. Se puede importar una clase
individual
import java.awt.Font;
o bien, se puede importar las clases declaradas pblicas de un paquete completo, utilizando un
arterisco (*) para reemplazar los nombres de clase individuales.
import java.awt.*;
Para crear un objeto fuente de la clase Font podemos seguir dos alternativas
import java.awt.Font;
Font fuente=new Font("Monospaced", Font.BOLD, 36);
O bien, sin poner la sentencia import
java.awt.Font fuente=new java.awt.Font("Monospaced", Font.BOLD, 36);
Normalmente, usaremos la primera alternativa, ya que es la ms econmica en cdigo, si
tenemos que crear varias fuentes de texto.
Se pueden combinar ambas formas, por ejemplo, en la definicin de la clase BarTexto
import java.awt.*;
public class BarTexto extends Panel implements java.io.Serializable{
//...
}
Panel es una clase que est en el paquete java.awt, y Serializable es un interface que est en
el paquete java.io

Los paquetes estndar
Paquete Descripcin
java.applet
Contiene las clases necesarias para crear applets que se ejecutan en
la ventana del navegador
java.awt
Contiene clases para crear una aplicacin GUI independiente de la
plataforma
java.io Entrada/Salida. Clases que definen distintos flujos de datos
java.lang
Contiene clases esenciales, se importa impcitamente sin necesidad de
una sentencia import.
java.net
Se usa en combinacin con las clases del paquete java.io para leer y
escribir datos en la red.
java.util Contiene otras clases tiles que ayudan al programador

Herencia
La herencia es uno de los conceptos ms cruciales en la POO. La herencia bsicamente
consiste en que una clase puede heredar sus variables y mtodos a varias subclases (la clase
que hereda es llamada superclase o clase padre). Esto significa que una subclase, aparte de
los atributos y mtodos propios, tiene incorporados los atributos y mtodos heredados de la
superclase. De esta manera se crea una jerarqua de herencia.
Por ejemplo, imaginemos que estamos haciendo el anlisis de un Sistema para una tienda que
vende y repara equipos celulares.

Tcni
En el
Esas
utiliza
En ge
grfic

E

El en
gene
los de
Los t
enca
Una v

icadeProgra
l grfico vem
2 Clases n
amos el com
eneral, pode
co:
ENCAPSU
ncapsulamien
rar compone
etalles de la
rminos md
psulado de s
vez encapsu
amacinOrie

mos 2 Clases
nuevas se c
portamiento
mos tener un
LAMIENT
nto es la cara
entes autno
implementac
dulo, compon
software.
ulada, una en
entadaaObj
s ms que p
construirn a
de la Super
na gran jerar
O
acterstica de
omos de softw
cin al mund
nente o bean
ntidad de sof
jetos
osiblemente
a partir de la
Clase.
rqua de Clas
e autonoma
ware tomand
do exterior.
n se suelen u
ftware se pue
necesitemo
a Clase Cel
ses tal y com
de la OO. E
do una parte
utilizan en lug
ede visualiza
os para crear
lular existen
mo vemos en
Esta caracter
de funciona
gar de comp
ar como una
r nuestro Sis
te. De esa
n el siguiente
stica permi
lidad y oculta
ponente
caja negra.
55
stema.
forma
e
te
ando


Sobrecarga
En programacin orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos o
ms funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o ms
funciones con el mismo nombre realizan acciones diferentes. El compilador usar una u otra
dependiendo de los parmetros usados. A esto se llama tambin sobrecarga de funciones.
Tambin existe la sobrecarga de operadores que al igual que con la sobrecarga de funciones
se le da ms de una implementacin a un operador.
Sobrecarga es la capacidad de un lenguaje de programacin, que permite nombrar con el
mismo identificador diferentes variables u operaciones
El mismo mtodo dentro de una clase permite hacer cosas distintas en funcin de los
parmetros
J ava no permite al programador implementar sus propios operadores sobrecargados, pero s
utilizar los predefinidos como el + del ejemplo anterior. C++, por el contrario si permite
hacerlo.
Sobrecarga de Mtodos y de Constructores

La firma de un mtodo es la combinacin del tipo de dato que regresa, su nombre y su lista de
argumentos.

La sobrecarga de mtodos es la creacin de varios mtodos con el mismo nombre pero con
diferentes firmas y definiciones. J ava utiliza el nmero y tipo de argumentos para seleccionar
cul definicin de mtodo ejecutar.

J ava diferencia los mtodos sobrecargados con base en el nmero y tipo de argumentos que
tiene el mtodo y no por el tipo que devuelve.

Tambin existe la sobrecarga de constructores: Cuando en una clase existen constructores
mltiples, se dice que hay sobrecarga de constructores.
Algunos mtodos en una clase pueden tener el mismo nombre. Estos mtodos deben contar
con diferentes argumentos. El compilador decide qu mtodo invocar comparando los
argumentos. Se generara un error si los mtodos slo varan en el tipo de retorno.

Ejemplos

Caso 01
Crear una sobrecarga que permita sumar 2 nmeros y ser llamado de acuerdo al tipo
de dato que se le envie.

public class ClassSobreCalculos {
public int Totales(int a,int b){
return(a+b);
}

public double Totales(double a, double b){
return(a+b);
}

public long Totales(long a, long b){
return(a+b);
}
}

Caso 02
Crear una sobrecarga de mtodos donde permita hallar el sueldo, descuento y el neto.
El sueldo depender del costo y cantidad de horas
El descuento segn el estado de Honorarios o Planilla
Neto segn el sueldo y el descuento.

package pckLogico;
public class ClassSobre {
public double Calcular(int ch,int costo){
return(ch*costo);
}

public double Calcular(int sueld, String estado){
double de=0;
if(estado.equalsIgnoreCase("Planilla"))
de=0.12*sueld;
if(estado.equalsIgnoreCase("Honorarios"))
de=0.07*sueld;
return(de);
}
public double Calcular(int sueld,double de){
return(sueld-de);
}
}

Package pckLogico;

public class ClassEncapsular {
int sueldo,costo,ch;
double desc,neto;
String estado;
public int getSueldo() { return sueldo; }
public void setSueldo(int sueldo) { this.sueldo =sueldo; }
public int getCosto() { return costo; }
public void setCosto(int costo) { this.costo =costo; }
public int getCh() { return ch; }
public void setCh(int ch) { this.ch =ch; }
public double getDesc() { return desc; }
public void setDesc(double desc) { this.desc =desc; }
public double getNeto() { return neto; }
public void setNeto(double neto) { this.neto =neto; }
public String getEstado() { return estado; }
public void setEstado(String estado) { this.estado =estado; }
}

Llamando las clases Encapsulada y sobrecarga en el JFRAME

package pclPrincipal;
public class FrmDatos extends JFrame {
ClassSobre metodos=new ClassSobre();
ClassEncapsular atri=new ClassEncapsular();

atri.setCh(Integer.parseInt(txtch.getText()));
atri.setCosto(Integer.parseInt(txtcosto.getText()));
atri.setSueldo(metodos.Calcular(atri.getCh(),atri.getCosto()));
lblSuel.setText(""+atri.getSueldo());
atri.setDesc(metodos.Calcular(atri.getSueldo(),atri.getEstado()));
atri.setNeto(metodos.Calcular(atri.getSueldo(),atri.getDesc())) ;
lblDes.setText(""+atri.getDesc());
lblN.setText(""+atri.getNeto());
Object valores[]={c,atri.getCh(),atri.getCosto(),atri.getSueldo(),atri.getDesc(),atri.getEstado(),
atri.getNeto()};
ModDatos.addRow(valores);
++c; // contador de registros
}

private void rbtPla_actionPerformed(ActionEvent e) {
atri.setEstado("Planilla");
}

private void rbtHo_actionPerformed(ActionEvent e) {
atri.setEstado("Honorarios");
}

}

Caso 03
Crear una sobrecarga de mtodos donde permita hallar el sueldo, descuento y el neto.
El sueldo depender del costo y cantidad de horas
El descuento ser del 10% si el sueldo supera a los 1500
Neto segn el sueldo y el descuento.

public class ClassMetodos extends ClassEncapsular{
public int pago(int ch,int cst){
return(ch*cst);
}
public double pago(int sueldo){
double d=0;
if(sueldo>1500)
d=0.10*sueldo;

return(d);
}
public double pago(int sueldo,double dsct){
return(sueldo-dsct);
}
}
//Campos encapsulado
int c,cs,suel;
double np,des;
public int getC() {
return c;
}
public void setC(int c) {
this.c =c;
}
public int getCs() {
return cs;
}
public void setCs(int cs) {
this.cs =cs;
}
public int getSuel() {
return suel;
}
public void setSuel(int suel) {
this.suel =suel;
}
public double getNp() {
return np;
}
public void setNp(double np) {
this.np =np;
}
public double getDes() {
return des;
}
public void setDes(double des) {
this.des =des;
}
}

// Frame:
public class FrmVentana extends JFrame {
Class1 x = new Class1();
*****

public FrmVentana() {
try {
jbInit();
}catch (Exception e) {
e.printStackTrace();
}
}

*******
******
******
}

private void btnCalcular_actionPerformed(ActionEvent e) {
x.setC(Integer.parseInt(txtch.getText()));
x.setCs(Integer.parseInt(txtcst.getText()));
x.setSuel(x.pago(x.getC(),x.getCs()));
x.setDes(x.pago(x.getSuel()));
x.setNp(x.pago(x.getSuel(),x.getDes()));
lblSueldo.setText(""+x.getSuel());
lblDesc.setText(""+x.getDes());
lblnp.setText(""+x.getNp());
}

private void btnLlamar_actionPerformed(ActionEvent e) {
FrmResultados j=new FrmResultados();
j.setVisible(true);
j.lblr.setText(""+x.getNp());
}
}

// Clase Main
public class Class1 extends ClassMetodos{

FrmVentana ven=new FrmVentana();
ven.setVisible(true);
}
}

Caso 04
Crear una sobrecarga de mtodos donde permita hallar el precio, total, igv y el neto.
Segn el articulo saldr el precio. El total ser deacuerdo a la cantidad y precio y el neto ser
deacuero al total y a la seleccin del Igv.

// Clase encapsulada
package pckLogico;

int precio,cantidad;
double total,igv;
String articulo;

public int getPrecio() {
return precio;
}

public void setPrecio(int precio) {
this.precio =precio;
}

public int getCantidad() {
return cantidad;
}

public void setCantidad(int cantidad) {
this.cantidad =cantidad;
}

public String getArticulo() {
return articulo;
}

public void setArticulo(String articulo) {
this.articulo =articulo;
}

public double getTotal() {
return total;
}

public void setTotal(double total) {
this.total =total;
}

public double getIgv() {
return igv;
}

public void setIgv(double igv) {
this.igv =igv;
}
}

// clase sobrecarga
package pckLogico;
public class ClassSobreCarga {
public int Calcular(String articulo){
int pre =0;
if(articulo.equalsIgnoreCase("Monitor"))
pre=259;
if(articulo.equalsIgnoreCase("Teclado"))
pre=15;
if(articulo.equalsIgnoreCase("Memorias"))
pre=175;
if(articulo.equalsIgnoreCase("Case"))
pre=550;
if(articulo.equalsIgnoreCase("Lectora"))
pre=25;
return(pre);
}
public double Calcular(int cantidad, int precio){
return(cantidad*precio);
}
public double calcular(double total){
return(total*0.19);
}
public double calcular(double total,double igv){
return(total+igv);
}
}

//Frame
ClassEncapsular atributo =new ClassEncapsular();
ClassSobreCarga metodos =new ClassSobreCarga();
String Titulos[]={"registro","articulo","precio","cantidad","total"};
String valores[][]={};
int c=1;
*************
***************
*********************
*********************
*********************
cboArticulo.addItem("Seleccionar");
cboArticulo.addItem("Monitor");
cboArticulo.addItem("Teclado");
cboArticulo.addItem("Memorias");
cboArticulo.addItem("Case");
cboArticulo.addItem("Lectora");
}

private void cboArticulo_actionPerformed(ActionEvent e) {
lblTotal.setText("");
txtCantidad.setText("");

atributo.setArticulo(cboArticulo.getSelectedItem().toString());
lblPrecio.setText(""+metodos.Calcular(atributo.getArticulo()));
atributo.setPrecio(metodos.Calcular(atributo.getArticulo()));
lblPrecio.setText(""+atributo.getPrecio());
}

atributo.setCantidad(Integer.parseInt(txtCantidad.getText()));
atributo.setPrecio(atributo.getPrecio());
atributo.setTotal(metodos.Calcular(atributo.getCantidad(),atributo.getPrecio()));
lblTotal.setText(""+atributo.getTotal());
if(chkIGV.isSelected())
atributo.setIgv(metodos.calcular(atributo.getTotal()));
else
atributo.setIgv(0);
lblIGV.setText(""+atributo.getIgv());
lblneto.setText(""+metodos.calcular(atributo.getTotal(),atributo.getIgv()));
Object
valores[]={c,atributo.getArticulo(),atributo.getPrecio(),atributo.getCantidad(),atributo.getTotal()};
ModDatos.addRow(valores);
++c;
}

private void btnLimpiar_actionPerformed(ActionEvent e) {
txtCantidad.setText("");
cboArticulo.setSelectedIndex(0);
lblIGV.setText("");
lblneto.setText("");
lblPrecio.setText("");
lblTotal.setText("");

}
}


Contenidos
- Manejo de Paneles(J Panel)
- Clase GregorianCalendar
- Clase String: Uso de la Clase String String.valueOf(), length(), charAt(), toString(),
substring(), indexOf(), lastIndexOf(), equalsIgnoreCase(), compareTo(),
- Uso de la Clase String: concat(), replace(), toLowerCase(), toUperCase().
____________________________________________________________________________

PANEL
Construir directamente programas o aplicaciones directamente en un FRAME, produce
rpidamente un amontonamiento de controles o componentes en la propia forma.
Es ms conveniente usar componentes de agrupamiento visuales que faciliten la separacin
fsica y lgica de las diversas partes que componen un programa o aplicacin.
Estos controles de agrupamiento son conocidos como paneles, aunque en visual basic se
conocen como frames (no confundirlos con frame de java).
J ava tiene los siguientes tipos de paneles, PANEL, SPLITPANE, SCROLLPANE,
TABBEDPANE, TOOLBAR.
Recordar adems que los panels pueden y deben usar su propio layout para acomodar los
componentes visuales que contendr.
En particular frame usando su layout acomoda sus paneles y panel usando su layout acomoda
los componentes.

El panel es un rea de J ava Desktop System en la que se pueden ejecutar aplicaciones y
realizar otras tareas.
La clase Panel es el ms simple de los Contenedores de Componentes grficos. En realidad,
se trataba de crear una clase no-abstracta (Container s lo es) que sirviera de base a los
applet y a otras pequeas aplicaciones. La clase Panel consta de dos mtodos propios: el
constructor, cuyo fin es crear un nuevo Panel con un LayoutManager de tipo FlowLayout (el de
defecto), y el mtodo addNotify() que, sobrecargando la funcin del mismo nombre en la clase
Container, llama al mtodo createPanel() del Toolkit adecuado, creando as un PanelPeer. El
AWT enviar as al Panel (y por tanto al applet) todos los eventos que sobre l ocurran. Esto
que puede parecer un poco rebuscado, obedece al esquema arquitectnico del AWT; se trata
del bien conocido esquema de separacin interface/implementacin que establece por un lado

una clase de interface y por otras distintas clases de implementacin para cada una de las
plataformas elegidas.

GregorianCalendar
Segn la documentacin del API de java, la clase Calendar es una clase abstracta base para
convertir entre un objeto de tipo Date (java.util.Date) y un conjunto de campos enteros como
YEAR (ao), MONTH (mes), DAY (da), HOUR (hora), etc.
Una subclase de Calendar representa una fecha de acuerdo a las reglas de un calendario
especfico. La plataforma provee una subclase concreta de Calendar: GregorianCalendar.
Futuras subclases podran representar varios tipos de calendarios lunares usados en diferentes
lugares del mundo.
La clase Calendar tiene mucho del comportamiento que esperaramos de la clase
java.util.Date, es decir, cuando obtenemos una instancia de la clase Calendar obtenemos un
instante de tiempo especfico con gran precisin similar a lo que obtenemos con la clase date.
S es cierto, podemos decir aqu que los milisegundos juegan un papel fundamental en esta
clase; pero el verdadero sentido de la clase Calendar no es obtener un instante de tiempo sino
extraerle datos.
Recordemos que la clase java.util.Date tiene mtodos que permiten obtener el ao, mes y da,
pero estos mtodos estn obsoletos precisamente por que para eso existe Calendar y de
hecho cuando usamos el mtodo getYear() de la clase java.util.Date esta recurre a las
funcionalidades que posee la clase Calendar.

Hay que mencionar tambin que obtener un instante de tiempo especfico y diferente del actual
es supremamente sencillo con esta clase, indicndole simplemente el da, mes y ao con que
se desea trabajar, o se puede especificar an ms dando hora, minuto y segundo deseado.
Veamos:
El mtodo getInstance() de la clase nos devuelve una subclase de Calendar con el tiempo
ajustado a la hora actual, y usamos el mtodo set(args) para forzarlo a tomar la fecha
deseada:
Calendar ahoraCal =Calendar.getInstance();
System.out.println(ahoraCal.getClass());
ahoraCal.set(2004,1,7);
System.out.println(ahoraCal.getTime());
ahoraCal.set(2004,1,7,7,0,0);
System.out.println(ahoraCal.getTime());

Extraer los datos
La clase Calendar tiene un nico mtodo get para obtener todos sus datos para lo cual se
ayuda de una serie de atributos constantes que permiten obtener o ajustar un atributo
determinado de la fecha; los ms importantes son (al lado los valores que representan):

YEAR: Ao.
MONTH: Mes.
DATE, DAY_OF_MONTH: Da del mes.
DAY_OF_WEEK: Da de la semana entre 1 (MONDAY) y 7 (SATURDAY).
HOUR: Hora antes o despus del medio da (en intervalos de 12 horas).
HOUR_OF_DAY: Lo hora absoluta del da (en intervalos de 24 horas).
MINUTE: El minuto dentro de la hora.
SECOND: El segundo dentro del minuto.

Estn tambin los atributos que representan los meses, como: J ANUARY, MARCH, J UNE,
DECEMBER, etc. que van desde 0 (J ANUARY) hasta 11 (DECEMBER).

Tambin hay atributos que representan los das: SUNDAY, TUESDAY, SATURDAY, etc. estos
empiezan con 1 (SUNDAY) y van hasta 7 (SATURDAY).

Hay ms atributos pero con estos es suficiente para los objetivos de este artculo, si deseas
conocerlos todos recurre a la documentacin del lenguaje.

Para extraer algn atributo se usa el mtodo get pasndole como parmetro alguna de las
constantes que vimos anteriormente y el mtodo devuelve siempre un dato de tipo int; as para
obtener el ao, mes, da y hora, usaramos el siguiente cdigo:
System.out.println("ANYO: "+ahoraCal.get(Calendar.YEAR));
System.out.println("MES: "+ahoraCal.get(Calendar.MONTH));
System.out.println("DIA: "+ahoraCal.get(Calendar.DATE));
System.out.println("HORA: "+ahoraCal.get(Calendar.HOUR));
if (ahoraCal.get(Calendar.MONTH) ==Calendar.J UNE){
System.out.println("ES J UNIO");
}else{
System.out.println("NO ES J UNIO");
}
Si el objeto tiene la fecha equivalente a 5:30 p.m. del 22 de junio de 2004 se ve la siguiente
salida:
AO:2010
MES:Mayo
DIA:02
HORA:5
ES J UNIO
Modificar Un Atributo
Modificar un atributo de Calendar es tan sencillo como obtenerlo, solamente es necesario usar
el mtodo set(int atributo, int valor), en donde atributo es una de las constante mencionadas
anteriormente y valor es la cantidad que se le quiere asignar. Por ejemplo:
ahoraCal.set(Calendar.MONTH,Calendar.J ANUARY) o ahoraCal.set(Calendar.YEAR, 1980)
ajustaran la fecha almacenada en el objeto ahoraCal a enero o al ao 1980 sin modificar
ninguno de los otros atributos.

Aclaremos esto con un ejemplo. Mi cumpleaos es en octubre 27 :-), y deseo saber qu da lo
celebrar en el 2010; para eso obtengo una instancia de Calendar (que siempre devuelve un
objeto del tipo GregorianCalendar) y la ajusto hasta el 27 de octubre de 2010, luego obtengo el
nombre del da, veamos:
Calendar cumpleCal =Calendar.getInstance();
cumpleCal.set(2010,9,27); //La hora no me interesa y recuerda que los meses van de 0 a 11
int dia =cumpleCal.get(Calendar.DAY_OF_WEEK);
System.out.println(dia); //Da 4 =WEDNESDAY =MIRCOLES
La salida es: 4, lo que quiere decir que en el 2010 el 27 de octubre ser un da mircoles (as
que probablemente lo celebre el viernes 29 :-));

Clase GregorianCalendar y operaciones

Realizar operaciones como sumar o restar das no es algo que dependa directamente de
Calendar sino ms bien de una subclase de esta que implemente algn tipo de calendario
usado, pues no todos los calendarios tienen 12 meses ni aos de 365 das como el que
nosotros (en casi todo occidente) usamos.

Este calendario usado en occidente, llamado gregoriano fue adoptado por primera vez en 1582
por el imperio romano (o aproximadamente) y posteriormente se fue adoptando en muchos
otros pases, por ejemplo 1752 en Gran Bretaa y 1918 en Rusia.
A grandes rasgos sabemos que el calendario gregoriano consta de aos que son definidos por
cada traslacin (vuelta de la tierra alrededor del sol), cada ao tiene doce meses de los cuales
7 tienen 31 das, 4 tienen 30 das y 1 tiene 28 das excepto en aos bisiestos que tiene 29.
Estos aos bisiestos se implantaron para corregir el desfase que tenemos cada cuatro aos (un
ao real dura 365 das y 6 horas aproximadamente), regla completa para los aos bisiestos
segn el calendario gregoriano es la siguiente:

"Un ao es bisiesto si es divisible por 4, a menos que sea divisible por 100 y no por 400".

Todo esto quiz suene un poco tonto, pero es absolutamente necesario tenerlo claro para
entender el funcionamiento de la clase GregorianCalendar.

GregorianCalendar es una subclase de Calendar y es la implementacin directa del calendario
gregoriano (de hecho es la nica implementacin de un calendario en jdk1.4) tal y como lo
conocemos hoy da. Es con esta clase con la que podemos sumar 2 3 das a una fecha sin
preocuparnos por desbordamientos o recalcular meses o aos, pues ella lo hace
automticamente tomando en cuenta las reglas en los prrafos anteriores.
De igual forma podemos obtener informacin como el da de la semana o la semana del ao
que fue una fecha determinada.
Los mtodos roll() y add()
Anteriormente vimos los mtodos set() y get() de la clase Calendar para obtener fechas y los
datos de esas fechas, ahora veremos los mtodos add() y roll() que nos permiten avanzar un
tiempo exacto sobre los datos obtenidos anteriormente.

El mtodo add(CONSTATE, valor) suma algebraicamente valor a una fecha; el valor a sumar
asume el significado dado por CONSTANTE, que es una de las definidas para la clase y que se
mencionaron en la seccin anterior (MONTH, YEAR, SECOND, etc).

Por ejemplo agreguemos 3 das y 2 meses a la fecha actual:
Calendar hoy =Calendar.getInstance();
hoy.add(Calendar.DATE, 3);
hoy.add(Calendar.MONTH, 2);
System.out.println(hoy.getTime());
Ahora restemos 5 aos y 50 das (Prebalo en tu PC):
Calendar hoy =Calendar.getInstance();
hoy.add(Calendar.YEAR, -5);
hoy.add(Calendar.DATE, -50);
System.out.println(hoy.getTime());


Clase String
J ava posee gran capacidad para el manejo de cadenas dentro de sus clases String y
StringBuffer. Un objeto String representa una cadena alfanumrica de un valor constante que
no puede ser cambiada despus de haber sido creada. Un objeto StringBuffer representa una
cadena cuyo tamao puede variar.
Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayora de
las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven
valores String.
Hay que tener en cuenta que las funciones estticas no consumen memoria del objeto, con lo
cual es ms conveniente usar Character que char. No obstante, char se usa, por ejemplo, para
leer ficheros que estn escritos desde otro lenguaje.

MTODOS PRINCIPALES:
Para poder aplicar estos mtodos es necesario crear un objeto String. Adems de estos
mtodos, la clase String cuenta con otros muchos.
int length(): devuelve la longitud de la String, incluyendo espacios en blanco.
La longitud siempre es una unidad mayor que el ndice asociado al ltimo
carcter de la String.
Ejemplo:

int indexOf(String str, int indice): devuelve el ndice en el que aparece por
primera vez la String del primer argumento en la que se aplica el mtodo, a
partir del ndice especificado en el segundo argumento. Recordar que una
String est indexada. Si el ndice a partir del que se inicia la bsqueda no
existe o la String no aparece, devuelve -1. MUY USADO.
Ejemplo:

int indexOf(char ch): devuelve el ndice en el que aparece por primera vez el
carcter que se le pasa al argumento. Si no se encuentra el carcter devuelve -
1. Se observa que el nombre de este mtodo es igual al anterior aunque su
nmero de argumentos es distinto adems de su tipo. A esto, en J ava, se le
llama sobrecarga de mtodos: mismo nombre pero distinto n de
String s= SISE tiene 27 aos..! ;
int longitud=str.length();
String s= Sebastian Aquino ;
Cad=s.indexOf( t ,s.length());
argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para

comprobar que hay ms con este mismo nombre. Este concepto se tratar ms
en profundidad en temas posteriores.

String replace (char viejoChar, char nuevoChar): cambia el carcter
asociado al primer argumento por el que se le pasa al segundo, de la String
sobre la que se aplica el mtodo generando una nueva. La String sobre la que
se aplica el mtodo no cambia, simplemente se crea otra nueva en base a la
String sobre la que se aplica el mtodo.
Ejemplo:

String toLowerCase(): devuelve una nueva String convirtiendo todos los caracteres
de la String sobre la que se aplica el mtodo, en minsculas.

String toUpperCase(): devuelve una nueva String convirtiendo todos los caracteres
de la String sobre la que se aplica el mtodo, en maysculas.

boolean equals(String str): investiga si dos String tienen los mismos caracteres y en
el mismo orden. Si es as devuelve true y si no false. MUY USADO
boolean equalsIgnoreCase(String str): investiga si dos String tienen los mismos
caracteres y en el mismo orden sin tener en cuenta las maysculas. Si es as devuelve
true y si no false. MUY USADO
boolean startsWith(String str): devuelve true si la String sobre la que se aplica
comienza por la del argumento; false si esto no ocurre.
boolean startsWith(String str, int indice): devuelve true si la String sobre la que se
aplica comienza por la del argumento a partir de un determinado ndice asociado al
segundo argumento; false si esto no ocurre.
String s1= Angie ;
Cad=s.replace(e,E);
String s=william;
JOptionPane.showMessageDialog(null,s.toUpperCase());
String s= Laboratorios SIse ;
Cad=s.indexOf(S);
String s=SEBASTIAN;
JOptionPane.showMessageDialog(null,s.toLowerCase());
boolean endsWith(String str): devuelve true si la String sobre la que se aplica acaba
en la del argumento; false si esto no ocurre.
String trim(): devuelve una String en base a la que se le pasa al argumento, pero sin
espacios en blanco al principio ni al final. No elimina los espacios en blanco situados
entre las palabras.
Ejemplo:

String substring(int indiceIni, int indiceFin): devuelve una String obtenida a partir
del ndice inicial incluido y del ndice final excluido; es decir, se comporta como un
intervalo semiabierto [indiceIni, indiceFin). Si el ndice final sobrepasa la longitud de la
String, lanza una IndexOutOfBoundsException. MUY USADO.
Ejemplo:

char charAt (int indice): devuelve el carcter asociado al ndice que se le pasa como
argumento de la String sobre la que se aplica el mtodo. Si el ndice no existe se lanza
una StringIndexOutOfBoundsException que hereda de IndexOutOfBoundsException.
MUY USADO.

String s= Hola William ;
//primero visualicemos la longitud
Int l=s.length();
J OptionPane.showMessageDialog(null,I)
//quitemos el espacio en blanco
Cad=s.trim();
//vuelve a mostrar la longitud
Int l=s.length();
J OptionPane.showMessageDialog(null,I)
String s=Docentes de Programacion;
Cad=s.substring(4,9);

Contenidos
- Clase String: Definicin de Archivos
- Archivos de Textos: Lectura / Escritura.
- Aplicar la capa de Datos con Manejo de Archivos.
- Manejo de Excepciones y try catch,
- Manejo de las clases BufferedReader, BufferedWriter, PrintWriter, FileReader,
readLine, StringTokenizer, nextToken.
- Apertura de Archivos, Grabar Datos a un archivo.
____________________________________________________________________________

Definicin de ARCHIVOS.
Los archivos tambin denominados ficheros (file); es una coleccin de informacin (datos
relacionados entre s), localizada o almacenada como una unidad en alguna parte de la
computadora.
Los archivos son el conjunto organizado de informaciones del mismo tipo, que pueden
utilizarse en un mismo tratamiento; como soporte material de estas informaciones.

Introduccin a los archivos.
Los archivos como coleccin de datos sirve para la entrada y salida a la computadora y son
manejados con programas.
Los archivos pueden ser contrastados con Arrays y registros; Lo que resulta dinmico y por
esto en un registro se deben especificar los campos, l nmero de elementos de un arrays (o
arreglo), el nmero de caracteres en una cadena; por esto se denotan como "Estructuras
Estticas".
En los archivos no se requiere de un tamao predeterminado; esto significa que se pueden
hacer archivos de datos ms grandes o pequeos, segn se necesiten.
Cada archivo es referenciado por su identificador (su nombre).

Caractersticas de los Archivos

Independencia de las informaciones respecto de los programas
La informacin almacenada es permanente
Un archivo puede ser accedido por distintos programas en distintos momentos
Gran capacidad de almacenamiento.

Clasificacin de los Archivos
Los archivos se clasifican segn su uso en tres grupos:
Permanentes o Maestros:
Estos contienen informacin que varia poco. En algunos casos es preciso
actualizarlos peridicamente.
De Movimientos
Se cercan para actualizar los archivos maestros. Sus registros son de tres
tipos: alta, bajas y modificaciones.
De Maniobra o Trabajo.
Tienen una vida limitada, normalmente menor que la duracin de la ejecucin de un programa.
Su utilizan como auxiliares de los anteriores.
Tipos De Archivos
Los elementos de un archivo pueden ser de cualquier tipo, simples o estructurados o segn su
funcin.
Segn su funcin.
Se define por:
a.- Archivos Permanentes: Son aquellos cuyos registros sufren pocas o ninguna variacin a
lo largo del tiempo, se dividen en:
Constantes: Estn formados por registros que contienen campos fijos y campos de baja
frecuencia de variacin en el tiempo.
De Situacin: Son los que en cada momento contienen informacin actualizada.
Histricos: Contienen informacin acumulada a lo largo del tiempo de archivos que han
sufridos procesos de actualizacin o bien acumulan datos de variacin peridica en el tiempo.
b.- Archivos de Movimiento: Son aquellos que se utilizan conjuntamente con los maestros
(constantes), y contienen algn campo comn en sus registros con aquellos, para el
procesamiento de las modificaciones experimentados por los mismos.
c.- Archivo de Maniobra o Transitorio: Son los archivos creados auxiliares creados durante
la ejecucin del programa y borrados habitualmente al terminar el mismo.

Segn sus elementos.
Archivo de Entrada: Una coleccin de datos localizados en un dispositivo de entrada.
Archivo de Salida: Una coleccin de informacin visualizada por la computadora.
Constantes: estn formados por registros que contienen campos fijos y campos de baja
frecuencia de variacin en el tiempo.
De Situacin: son los que en cada momento contienen informacin actualizada.
Histricos: Contienen informacin acumulada a lo largo del tiempo de archivos que han sufrido
procesos de actualizacin, o bien acumulan datos de variacin peridica en el tiempo.
Archivos de Movimiento o Transacciones: Son aquellos que se utilizan
conjuntamente con los maestros (constantes), y contienen algn campo comn en sus
registros con aquellos, para el procesamiento de las modificaciones experimentados
por los mismos.
Archivos de Maniobra o Transitorios: Son los archivos auxiliares creados durante la
ejecucin del programa y borrados habitualmente al terminar el mismo.

Acceso a los Archivos
Se refiere al mtodo utilizado para acceder a los registros de un archivo prescindiendo de su
organizacin. Existen distintas formas de acceder a los datos:
Secuenciales; los registros se leen desde el principio hasta el final del archivo, de tal forma
que para leer un registro se leen todos los que preceden.
Directo; cada registro puede leerse / escribirse de forma directa solo con expresar su direccin
en el fichero por l numero relativo del registro o por transformaciones de la clave de registro
en l numero relativo del registro a acceder.
Por ndice; se accede indirectamente a los registros por su clave, mediante consulta
secuenciales a una tabla que contiene la clave y la direccin relativa de cada registro, y
posterior acceso directo al registro.
Dinmico; es cuando se accede a los archivos en cualquier de los modos anteriormente
citados.
La eleccin del mtodo est directamente relacionada con la estructura de los registros del
archivo y del soporte utilizado.

Tipos de accesos
Acceso Secuencial. Exige el tratamiento de elemento, para esto es necesario una exploracin
secuencial comenzando desde el primer momento (Pascal permite este acceso)
Secuenciales: archivo de texto que debe ser ledo del principio hasta el final.
Acceso Directo. Permite procesar o acceder a un elemento determinado y referencia
directamente por su posicin en el soporte de almacenamiento (Turbo Pascal permite este
acceso.
Aleatorios: Es un archivo con registros de un mismo largo. Un programa puede accesar
directamente cualquier registro sin tener que leer los registros previos.
Binarios: Es un archivo que lee byte por byte sin asumir ninguna estructura.
Los archivos Binarios no son un nuevo tipo de archivo, pero si una nueva forma de manipular
cualquier tipo de archivo. Las tcnicas de archivo binarios permiten leer o cambiar cualquier
byte de un archivo. Son herramientas extremadamente potentes, pero como toda herramienta
potente debe manejarse con cuidado

Operaciones generales que se realizan sobre un archivo.
Las operaciones generales que se realizan son:
Creacin. Escritura de todos sus registros.
Consulta. Lectura de todos sus registros.
Actualizacin. Insercin supresin o modificacin de algunos de sus registros
Clasificacin. Reubicacin de los registros de tal forma que queden ordenados segn
determinados criterios.
Borrado. Eliminando total del archivo, dejando libre el espacio del soporte que ocupaba.

Excepciones
Excepcion es, o sencillamente problemas. En la programacin siempre se producen errores,
ms o menos graves, pero que hay que gestionar y tratar correctamente. Por ello en java
disponemos de un mecanismo consistente en el uso de bloques try/catch/finally . La tcnica
bsica consiste en colocar las instrucciones que podran provocar problemas dentro de un
bloque try, y colocar a continuacin uno o ms bloques catch, de tal forma que si se provoca un
error de un determinado tipo, lo que haremos ser saltar al bloque catch capaz de gestionar
ese tipo de error especfico. El bloque catch contendr el codigo necesario para gestionar ese
tipo especfico de error. Suponiendo que no se hubiesen provocado errores en el bloque try,
nunca se ejecutaran los bloques catch.
Veamos ahora la estructura del bloque try/catch/finally:
try {
//Cdigo que puede provocar errores
}catch(Tipo1 var1) {
//Gestin del error var1, de tipo Tipo1
}
[ ...
catch(TipoN varN) {
//Gestin del error varN, de tipo TipoN
}]
[
finally {
//Cdigo de finally
}

Como podemos ver es obligatorio que exista la zona try, o zona de pruebas, donde pondremos
las instrucciones problemticas. Despus vienen una o ms zonas catch, cada una
especializada en un tipo de error o excepcin. Por ltimo est la zona finally, encargada de
tener un cdigo que se ejecutar siempre, independientemente de si se produjeron o no
errores.
Se puede apreciar que cada catch se parece a una funcin en la cul slo recibimos un objeto
de un determinado tipo, precisamente el tipo del error. Es decir slo se llamar al catch cuyo
argumento sea coincidente en tipo con el tipo del error generado

Archivos de Texto

Archivos necesarios:
Los archivos nos permiten guardar nuestro trabajo para que no perdamos datos una vez que
cerremos la aplicacin. Existen dos tipos de archivos en J ava, en este trial veremos los
primeros. Los archivos de texto en J ava se manejan mediante la clase BufferedReader y la
clase PrintWriter. Estas dos clases nos permiten manejar los archivos de texto como podemos
ver en la presentacin a continuacin:

Archivos de Texto
Adems de los ejemplos y ejercicios de la presentacin puedes basarte en el siguiente archivo
para aprender a manejar archivos de texto:

Cmo guardar en archivos de texto?
En la computadora, los archivos son un bitstream o "flujo de bits". Esto es para que se puedan
construir fcilmente programas que puedan escribir a cualquier tipo de flujo, ya sean archivos,
la pantalla, la impresora o una red. La clase que nos srive para imprimir bits a un bitstream es
PrintWriter. En la imagen de la izquierda podemos ver que el constructor del PrintWriter recibe
un FileWriter, esto se debe a que el PrintWriter sabe escribir a un flujo, pero no sabe a cul, la
clase FileWriter le permite escribir a un flujo de archivos.
El constructor de FileWriter es muy importante, puede recibir uno o dos parmetros, el primer
parmetro es el nombre del archivo o un objeto de la clase File que represente el archivo que
queremos abrir, el segundo (que es opcional) es un boolean que indica si se debe sobreescribir
el archivo o escribir al final.

Hay dos maneras de escribir a un archivo una vez que ya tenemos el PrintWriter, pero primeor
tenemos que entender una cosa de esta clase. El PrintWriter es un buffer, como una caja en la
que se guarda lo que se va a escribir al archivo y una vez que ya est todo listo se manda al
archivo.

Para mandar un String a un archivo de texto podemos utilizar dos mtodos, el primero es
println() que recibe una lnea de texto y la imprime en el archivo con un cambio de lnea ("\n") al
final, el segundo mtodo que se utiliza frecuentemente es el mtodo print que funciona
bsicamente de la misma manera, pero no pone un salto de lnea al final y no imprime los
datos al archivo sino nicamente los deja en el buffer, por lo que tenemos que utilizar el mtodo
flush() para que lo imprima al archivo.

Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya que en
caso contrario no estamos seguros de que todos los cambios se guarden en el archivo. Para
poder cerrar el archivo utilizamos el mtodo close() del PrintWriter.

Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya que en
caso contrario no estamos seguros de que todos los cambios se guarden en el archivo. Para
poder cerrar el archivo utilizamos el mtodo close() del PrintWriter.

Cmo leer de archivos de texto?
El bitstream que creamos al guardar un archivo podemos leerlo mediante la clase
BufferedReader. Pero al igual que la clase PrintWriter esta clase no sabe qu tipo de archivo
est leyendo por lo que hay que especificarle queobtenga el bitstream desde un archivo
utilizando la clase FileReader.

Para construir un FileReader lo nico que tenemos que hacer es utilizar el constructor que
recibe el nombre de archivo o un objeto de la clase File representando el archivo que queremos
leer. Una vez que ya tenemos el FileReader debemos utilizarlo para construir un
BufferedReader, de la manera que se ve a la izquierda.

Una vez que tengamos el BufferedReader podemos utilizar varios mtodos que nos permiten
escribir a archivos de texto. El primero que vamos a ver es el mtodo read(), que nos devuelve
un int con el cdigo Unicode del carcter ledo, para poder convertir este cdigo en un carcter
debemos utilizar un cast a char. Para hacer un cast de un tipo de dato a otro tenemos que
poner la variable que queremos que reciba el valor, un smbolo de igual, el tipo de dato al que
queremos convertir y el valor que queremos convertir, como se ve en la imagen de la izquierda.

El otro mtodo del BufferedReader que nos va a ser muy til es el mtodo readLine(), este
mtodo nos permite leer todo un archivo mucho ms rpido y nos es muy til cuando queremos
obtener datos de un archivo de inicio ya que podemos leer una lnea cada vez y utilizarla de la
manera que nos convenga.

Al igual que cuando utilizamos el PrintWriter debemos cerrar el archivo al terminarlo de utilizar
utilizando el mtodo close() del BufferedReader ya que aunque en este caso no se pierden
datos, otros programas no van a poder utilizar el archivo hasta que lo cerremos.

Por ltimo vamos a darle un rpido vistazo a la clase File que nos es muy til siempre que
trabajamos con archivos.

El constructor de File recibe un String con la ruta del archivo, una vez que creamos el
objeto tipo File podemos utilizar los siguientes mtodos:

f.canRead(): Devuelve un boolean verdadero en caso de que se pueda leer el archivo,
falso en caso de que no se pueda leer.
f.canWrite(): Devuelve un boolean verdadero en caso de que se pueda escribir el
archivo, falso en caso de que no se pueda escribir.
f.delete(): Intenta borrar el archivo, devuelve true si pudo hacerlo, false en caso de que
no lo haya borrado.
f.deleteOnExit(): Borra el archivo al terminar el programa, muy til cuando
necesitamos un lugar para guardar muchos datos y no queremos saturar la memoria
porque nos permite crear un archivo temporal en el que se guarden los datos.


Para poder leer archivos de texto en J ava debemos crear un objeto de tipo
BufferedReader. BufferedReader es una clase que contiene mtodos predefinidos para
poder leer de una secuencia de bits.
Para poder guardar archivos de texto en J ava debemos crear un objeto de tipo
PrintWriter. PrintWriter es una clase que contiene mtodos predefinidos para meter
datos a una secuencia de bits.
Puedes hacer click en los nombres para ver el API que contiene muchos mtodos
tiles.

BufferedReader
El constructor que vamos a utilizar para crear un BufferedReader es:
BufferedReader fileIn =new BufferedReader(new
FileReader(fileName);
Ya que tenemos el objeto tipo BufferedReader podemos utilizar varios mtodos para
leer, l ms comn es: fileIn.readLine();
Este mtodo lee una lnea y la devuelve o devuelve null si llegamos al final del archivo
y no hay nada que leer.

Es importante recordar cuando trabajamos con archivos que cada que leemos o
escribimos a un archivo debemos hacerlo dentro de un try.
Un try es un manejador de excepciones, cuando sucede un error en la ejecucin de
nuestro programa ejecuta ciertas instrucciones dependiendo del tipo de error que
sucedi.
Otro mtodo muy importante es el mtodo: fileIn.read();

Este mtodo nos permite leer un solo carcter del flujo de datos. El mtodo regresa un
nmero (int) del 1 al 65535 si puede leer del archivo o regresa -1 si no.

try {
BufferedReader fileIn =new BufferedReader(
new FileReader(fileName));
int i =fileIn.read(); //Iniciamos una variable a la que
//vamos a leer
char c =(char) i; //Como lo que leimos es un int debemos
// hacer un cast a char
}catch (IOException ioe) {
}catch (FileNotFoundException fnfe) {
}

PrintWriter

El constructor que vamos a utilizar para crear un PrintWriter es:
PrintWriter fileOut =new PrintWriter(new FileWriter(fileName);
Ya que tenemos el objeto PrintWriter podemos utilizar varios mtodos para escribir, los
ms comunes son:
fileOut.print(String);
fileOut.println(String);
Estos dos mtodos reciben un String y lo imprimen en el archivo, el segundo mtodo le
pone un carcter de fin de lnea al final.

Al igual que al leer debemos recordar utilizar un try. Cuando utilizamos el PrintWriter
todo entra a un buffer y una vez que terminemos de escribir los datos debemos
recordar utilizar el mtodo flush() del PrintWriter para escribir todo al archivo.
Al terminar de usar el archivo tambin debemos recordar que debemos cerrarlo
mediante el mtodo close() del PrintWriter.

String fileName ="Texto.txt";
PrintWriter fileOut =null;
try {
fileOut =new PrintWriter(new FileWriter(fileName));
String s ="Una linea de texto";
fileOut.println(s);
fileOut.flush();
System.out("Error, disco protegido contra lectura");
}catch (FileNotFoundException fnfe) {
System.out("Error, no se encuentra el archivo");
}finally {
if (fileIn !=null) {
try {
fileIn.close();
}
}
}

Ejemplos:
Caso 01

package prjarchivos;

import java.io.FileReader;
import java.io.IOException;

import javax.swing.J Frame;

public class ArchivoApp2{
FileReader entrada=null;
StringBuffer str=new StringBuffer();
try {
entrada=new FileReader("VERARCHI01.txt");
int c;
while((c=entrada.read())!=-1){
str.append((char)c);
}
System.out.println(str);
System.out.println("--------------------------------------");
}
catch (IOException ex) {
System.out.println("El archivo no existe");
}
finally{
//cerrar los flujos de datos
if(entrada!=null){
try{
entrada.close();
}
catch(IOException ex){}
}
System.out.println("el bloque finally siempre se ejecuta");
}
}
}

Caso 02
package prjrarchivos2;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import javax.swing.J OptionPane;
import pckPrincipal.FrmLlamar;


public class Class1 extends FrmLlamar{
public Class1() {
String nombre=" VERARCHI02.txt";
BufferedReader entrada;
try {
entrada =new BufferedReader(new FileReader(nombre));
String texto="";
while(true){
texto =entrada.readLine();
//J OptionPane.showMessageDialog(null,texto);
if(texto==null) break;
System.out.println(texto);
this.txt.append(texto+"\n");
}
entrada.close();
this.setVisible(true);

}catch(FileNotFoundException f){

}catch (IOException e) {
// TODO
}
}

}

Caso 03

package pckClase;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.util.Vector;
import javax.swing.J Frame;
import javax.swing.J OptionPane;
import pckAplica.FrmArchivo3;

public class ClassAr3 {
public String datos[]=new String[50];
public int i,pos,tam;
public ClassAr3() {
}
public void llamar(){
String subStr="";
String nombre="ArchivoApp2.txt";
BufferedReader entrada;
try {
entrada =new BufferedReader(new FileReader(nombre));
String texto="";
while(true){
texto =entrada.readLine();
/* tam=texto.length();
for(int g=0;g<tam;++g){
String j=String.valueOf(texto.charAt(g));
//J OptionPane.showMessageDialog(null,j);
if(j.equals(",")){
datos[i]=subStr;
++i;
}
else
subStr=subStr+j;
} */
if(texto==null) break;
System.out.println(texto);
}
entrada.close();
}catch(FileNotFoundException f){

}catch (IOException e) {
// TODO
}
}
}

Caso Prctico: Usando la Tcnica P.O.O:

Guarda registro, cdigo, Nombre, Apellido, Carrera y pago dentro de un Archivo. Para ello cree
la siguiente estructura de trabajo.

Desarrollo:
En el paquete Paneles se usaran: Contenido(tendr los controles para el ingreso de
datos) y pie(presentara la fecha y hora del sistema, utilizaremos el GregorianCalendar).
En la capa lgica 2 subclases: ClassEncapsulada(se crearan los get y set por cada
atributo que se tenga) y ClassMetodos(se creara los mtodos para generar el cdigo y
hallar el pago de acuerdo a la especialidad)
Los Frame son los objetos visualizadores de los paneles

Empecemos a codificar

package pckLogico;

public class ClassEncapsulada {
String nom,ape,cod;
int p,reg;

public String getNom() {
return nom;
}

public void setNom(String nom) {
this.nom =nom;
}

public String getApe() {
return ape;
}

public void setApe(String ape) {
this.ape =ape;
}

public int getP() {
return p;
}

public void setP(int p) {
this.p =p;
}

public int getReg() {
return reg;
}

public void setReg(int reg) {
this.reg =reg;
}
public String getCod() {
return cod;
}

public void setCod(String cod) {
this.cod =cod;
}
}// fin de la clase encapsulada

package pckLogico;
public class ClassMetodos {
int x=11,dv,pag;
GregorianCalendar formato=new GregorianCalendar();
int devNV(char letra){

switch(letra){
case 'a':case 'A':dv=1;break;
case 'e':case 'E':dv=2;break;
case 'i':case 'I':dv=3;break;
case 'o':case 'O':dv=4;break;
case 'u':case 'U':dv=5;break;
default : dv=x;
++x;
}
return(dv);
}
public String genera(String cadN,String cadA){

int ao=formato.get(formato.YEAR);
int mes=formato.get(formato.MONTH)+1;
//Datos del Nombre
char n1=cadN.charAt(0);
int largoN=cadN.length();
char n2=cadN.charAt(largoN-1);
//datos del Apellido
char a1=cadA.charAt(0);
int largoA=cadA.length();
char a2=cadA.charAt(largoA-1);

String cad=(""+ao+devNV(n1)+devNV(n2)+devNV(a1)+devNV(a2)+mes);
return(cad);

}
public int pago(int index){
switch(index){
case 1: pag=850;break;
}
return(pag);
}
}// fin de la clase Metodos

Uso de los paneles: disee todo este formato

package pckPaneles;
public class pnlContenido extends JPanel {
ClassMetodos llamar=new ClassMetodos();
ClassEncapsulada atri=new ClassEncapsulada();
ClassArchivo datos=new ClassArchivo();
int dv,c=1,x=11;
String titulos[]={"Registro","Codigo","Nombres","Apellidos","Categoria","Pago"};
String contenido[][]={};
private J TextField TXTNOM =new J TextField();
private J TextField TXTAPE =new J TextField();
private J ComboBox cboespe =new J ComboBox();
private J Label lblp =new J Label();
private J Separator jSeparator1 =new J Separator();
private J Separator jSeparator2 =new J Separator();
private J Button btnaadir =new J Button();
private J Button btnsalir =new J Button();
private J ScrollPane jScrollPane1 =new J ScrollPane();
private J Table jTable1 =new J Table();
private DefaultTableModel modtbdatos =new DefaultTableModel(contenido,titulos);
private J Button btnLsitaAr =new J Button();

*******************

************************
modtbdatos.setColumnCount(6);
***************************
jTable1.setModel(modtbdatos);
cboespe.addItem("Seleccionar cat");
cboespe.addItem("Sistemas");
cboespe.addItem("Redes");
cboespe.addItem("Diseo Grafico");
cboespe.addItem("Contabilidad");
cboespe.addItem("Administracion");
cboespe.addItem("Otros");
}

private void btnaadir_actionPerformed(ActionEvent e) {
atri.setReg(c);
x=11;
atri.setNom(TXTNOM.getText());
atri.setApe(TXTAPE.getText());
atri.setCod(llamar.genera(atri.getNom(),atri.getApe()));
Object
valores[]={atri.getReg(),atri.getCod(),atri.getNom(),atri.getApe(),cboespe.getSelectedItem(),atri.
getP()};
modtbdatos.addRow(valores);

datos.Grabar(atri.getReg(),atri.getCod(),atri.getNom(),atri.getApe(),atri.getCod(),atri.getP());
++c;
}

private void cboespe_actionPerformed(ActionEvent e) {
atri.setCod(cboespe.getSelectedItem().toString());
lblp.setText(""+atri.getP());
atri.setP(llamar.pago(cboespe.getSelectedIndex()));
}

private void btnListaAr_actionPerformed(ActionEvent e) {
Frmlectura x=new Frmlectura();
x.setVisible(true);
}
}//fin del panel contenido


// Panel Pie
package pckPaneles;
public class pnlPie extends JPanel {
************************

privatevoidjbInit()throwsException{
********************************
int dia=formato.get(formato.DAY_OF_MONTH);
int mes=formato.get(formato.MONTH)+1;
int ao=formato.get(formato.YEAR);
lblf.setText(""+dia+"/"+mes+"/"+ao);
lblf.setFont(new Font("Dialog", 1, 11));
int hora=formato.get(formato.HOUR_OF_DAY);
int min=formato.get(formato.MINUTE);
int seg=formato.get(formato.SECOND);
lblh.setFont(new Font("Dialog", 1, 11));
lblh.setText(""+hora+":"+min+":"+seg);
}
}//fin del panel pie

// estableciendo los paneles al Frame
package pckPresentacion;
public class FrmPresenta extends JFrame {
int dv=0;
ClassEncapsulada atri=new ClassEncapsulada();
private pnlPie pnlPie1 =new pnlPie();
private pnlContenido pnlEncabezado1 =new pnlContenido();

public FrmPresenta() {
try {
jbInit();
}
}

this.getContentPane().setLayout( null );
this.setSize(new Dimension(400, 408));
this.setResizable(false);
this.setTitle("Usando Archivos");
pnlPie1.setBounds(new Rectangle(0, 345, 395, 40));

pnlEncabezado1.setBounds(new Rectangle(0, 0, 395, 345));
this.getContentPane().add(pnlEncabezado1, null);
this.getContentPane().add(pnlPie1, null);
}
}


Contenidos
- Definicin de la Clase Vector.
- Definicin de la Clase ArrayList.
- Diferencias entre ellas
- Mtodos de la clase Vector y ArrayList
- Aplicando atributos encapsulados usando estas clases
- Definicin de la la Clase Hashtable.
- Mtodos get y put
____________________________________________________________________________

Vector
Es una clase que permite crear matrices dinmicas, es decir matrices que varan en cantidad
de elementos durante la ejecucin del programa, lo cual no se puede hacer en java con la clase
Array que es la clase que generalmente se utiliza para crear matrices.

En un Vector, puedo agregar cualquier cosa, incluso puedo agregar diferentes tipos de objetos
a un mismo vector, esto se debe a que Vector almacena objetos de tipo Object que es la clase
base de J ava. Esto no puedo hacerlo con un Array ya que todos sus elementos deben ser del
mismo tipo.

Por este motivo, cuando accedo a un elemento de un Vector, debo moldearlo a su tipo
especfico de datos, de lo contrario obtendr un objeto de tipo Object.

La clase Enumeration se utiliza con un vector o mejor dicho, se crea a partir de la cantidad de
elementos de un vector, ya que lo nico que hace Enumeration es enumerar los elementos de
un vector. Enumeration lo nico que hace es recorrer los elementos de un vector hacia
adelante mediante el mtodo nextElement (), asegurando que nunca se pasar del ndice del
vector, esto lo hace mediante el mtodo hasMoreElements().
Solo para eso sirve Enumeration, pero asegura que no habr error por salirse del ndice del
vector. Este es un ejemplo de cmo utilizar ambas clases juntas:

Crear un vector
Para usar la clase Vector hemos de poner al principio del archivo del cdigo fuente la siguiente
sentencia import
import java.util.*;

Cuando creamos un vector u objeto de la clase Vector, podemos especificar su dimensin
inicial, y cuanto crecer si rebasamos dicha dimensin.

Tenemos un vector con una dimensin inicial de 20 elementos. Si rebasamos dicha
dimensin y guardamos 21 elementos la dimensin del vector crece a 25.
Al segundo constructor, solamente se le pasa la dimensin inicial.

Si se rebasa la dimensin inicial guardando 21 elementos, la dimensin del vector se
duplica.
El programador ha de tener cuidado con este constructor, ya que si se pretende
guardar un nmero grande de elementos se tiene que especificar el incremento de la
capacidad del vector, si no se quiere desperdiciar intilmente la memoria el ordenador.
Con el tercer constructor, se crea un vector cuya dimensin inicial es 10.

La dimensin del vector se duplica si se rebasa la dimensin inicial, por ejemplo,
cuando se pretende guardar once elementos.

Aadir elementos al vector
Hay dos formas de aadir elementos a un vector. Podemos aadir un elemento a continuacin
del ltimo elemento del vector, mediante la funcin miembro addElement.

Podemos tambin insertar un elemento en una determinada posicin, mediante
insertElementAt. El segundo parmetro o ndice, indica el lugar que ocupar el nuevo objeto.
Si tratamos de insertar un elemento en una posicin que no existe todava obtenemos una
excepcin del tipo ArrayIndexOutOfBounds. Por ejemplo, si tratamos de insertar un elemento
en la posicin 9 cuando el vector solamente tiene cinco elementos.
Vector VecDatos=new Vector(20, 5);
Vector VecDatos =new Vector(20);

Vector VecDatos =new Vector();

VecDatos.addElement(" uno" );
Ejemplo: Para insertar el string "tres" en la tercera posicin del vector v, escribimos

En la siguiente porcin de cdigo, se crea un vector con una capacidad inicial de 10 elementos,
valor por defecto, y se le aaden o insertan objetos de la clase String.

Vector vecDatos =new Vector();
vecDatos.addElement("Veronica");
vecDatos.addElement("William");
vecDatos.addElement("Sebastian");
vecDatos.addElement("Angie");
vecDatos.addElement("Victor");
vecDatos.addElement("Carlos");
vecDatos.addElement("Henrry");
vecDatos.addElement("Eduardo");
//vecDatos.insertElementAt("Tres", 2);
//se crea una enumeracion de acuerdo a los elementos del vector
Enumeration enume =vecDatos.elements();
//mientras queden elementos en la enumeracion
while(enume.hasMoreElements())
modLstDatos.addElement(enume.nextElement());
}

VecDatos.insertElementAt("tres", 2);
Para saber cuntos elementos guarda un vector, se llama a la funcin miembro size. Para
saber la dimensin actual de un vector se llama a la funcin miembro capacity.
Agregue esta 2 lneas al cdigo anterior.

Podemos eliminar todos los elementos de un vector, llamando a la funcin miembro
removeAllElements. O bien, podemos eliminar un elemento concreto, por ejemplo el que
guarda el string "tres".

Podemos eliminar dicho elemento, si especificamos su ndice.

Acceso a los elementos de un vector
El acceso a los elementos de un vector no es tan sencillo como el acceso a los elementos de
un array. En vez de dar un ndice, usamos la funcin miembro elementAt. Por ejemplo,
vecDatos.elementAt(4) sera equivalente a vecDatos [4], si vecDatos fuese un array.
Para acceder a todos los elementos del vector, escribimos un cdigo semejante al empleado
para acceder a todos los elementos de un array.
for(int i=0; i<v.size(); i++){
System.out.print(vecDatos.elementAt(i)+"\t");
}
Existe otra alternativa, que es la de usar las funciones del interface Enumeration. Este
interface declara dos funciones pero no implementa ninguna de ellas. Una Enumeration nos
permite acceder a los elementos de una estructura de datos de forma secuencial, como ya lo
hemos mostrado en el ejemplo anterior.
lblT.setText(" " +vecDatos.size());

lblD.setText(" " +vecDatos.capacity());
vecDatos.removeElement(" Angie" );
vecDatos.removeElementAt(2);

public interface Enumeration {
boolean hasMoreElements();
Object nextElement();
}
La funcin miembro elements de la clase Vector devuelve un objeto de la clase
VectorEnumerator que implementa el interface Enumeration y tiene que definir las dos
funciones hasMoreElements y nextElement.
final class VectorEnumerator implements Enumeration {
Vector vector;
int count;
VectorEnumerator(Vector vecDatos) {
vector =vecDatos;
count =0;
}
public boolean hasMoreElements() {
//...
}
public Object nextElement() {
//...
}
}
El objeto enum devuelto por la funcin miembro elements es de la clase VectorEnumerator, sin
embargo no podemos escribir
VectorEnumerator enum=vecDatos.elements();
porque VectorEnumerator no es una clase pblica. Como podemos ver en su definicin, no
tiene la palabra reservada public delante de class. Sin embargo, podemos guardar un objeto
de la clase VectorEnumerator en una variable enum del tipo Enumeration, por que la clase
implementa dicho interface.

Enumeration enum=vecDatos.elements();
while(enum.hasMoreElements()){
System.out.print(enum.nextElement()+"\t");
}
Desde el objeto enum devuelto por la funcin miembro elements de la clase Vector llamamos a
las funciones miembro hasMoreElements y nextElement de la clase VectorEnumerator. La
funcin hasMoreElements devuelve true mientras haya todava ms elementos que se
puedan acceder en el vector v. Cuando se ha llegado al ltimo elemento del vector, devuelve
false. La funcin nextElement devuelve una referencia al prximo elemento en la estructura de
datos. Esta funcin devuelve una referencia a un objeto de la clase base Object, que el
programador precisar en ciertos casos, como veremos ms abajo, promocionar (casting) a la
clase adecuada.
Para buscar objetos en un vector se puede usar una Enumeration y hacer una comparacin
elemento por elemento mediante equals, tal como vemos en la siguiente porcin de cdigo

Algunos de los mtodos de la clase Vector se muestran a continuacin:
Vector ( )
Constructor: crea un vector inicialmente vaco
void addElement (Objet obj)
Inserta el objeto especificado al final del vector
void setElementAt (Object obj, int indce)
Inserta el objeto especficado en el vector en la posicin especficada
Object remove (int indce)
Elimina el objeto que se encuentra en la posicin especficada y lo regresa
boolean removeElement (Object obj)
Elimina la primera occurencia del objeto especficado en el vector
void removeElementAt (int indce)
Elimina el objeto especficado en el ndice del vector
void clear ( )
Elimina todos los objetos del vector
boolean contains (Object obj)
Enumeration enum=vecDatos.elements();
while(enum.hasMoreElements()){
String elemento=(String)enum.nextElement();
if(elemento.equals("William")){
lblEnc.setText("Encontrado William");
break;
}
}
Regresa verdadero si el objeto dado pertenece al vector

int indexOf (Object obj)
Regresa el ndice del objeto especficado. Regresa -1 si no fue encontrado
el objeto
Object elementAt (int indce)
Regresa el componente en el ndice especficado
boolean isEmpty ( )
Regresa verdadero si el vector no contiene elementos
int size ( )
Regresa el nmero de elementos en el vector

Ejemplo 01:
public class VerCasoVector{

public static void main () {
Vector DocentesSta =new Vector ();
DocentesSta.addElement ("Veronica");
DocentesSta.addElement ("William");
DocentesSta.addElement ("Victor");
DocentesSta.addElement ("Rogelio");
DocentesSta.addElement ("Carlos");

ModLstDatos.addElement(DocentesSta);
//Quita el elemento
DocentesSta.removeElement ("Rogelio");

ModLstDatos.setText(DocentesSta);
lblP.setText("En la posicin 1 est: " +DocentesSta.elementAt (1));
DocentesSta.insertElementAt ("Angie", 2);

lblT.setTexr("Tamao de la banda: " +DocentesSta.size ());
for (int i =0; i <DocentesSta.size (); i++)
ModLstDatos.addElement(DocentesSta);
}
}

Si se necesitan aadir valores de datos primitivos a un Vector se pueden utilizar las clases
conocidas como envoltorios que son: Integer, Long, Double y Float. Sus mtodos de
conversin respectivos son: intValue ( ), longValue ( ), doubleValue ( ) y floatValue ( ).
Ejercicio:

Complemente la siguiente clase, escribiendo las instrucciones necesarias donde se muestran
los subguiones(__), guate del ejemplo anterior:

import java.util.*;
/**
* Uso de las clases Vector e Integer
*/
public class EjercicioVector
{

public static void main ()
{
Vector vecDatos =new Vector ();
vecDatos.add (new Integer (1));

for (int i =0; i <v.size (); i++) {
Integer iI =(Integer) v.get (i);
ModLstDatos.addElement(iI.______________() +" ");
}

// Insertar un nuevo Objeto de tipo Integer cuyo valor sea 10
______________________
//El nuevo vector es
__________________
____________________
// Insertar un nuevo Objeto de tipo Integer cuyo valor sea 6 en la pos.3
System.out.println ("Se inserta un nuevo objeto cuyo valor es 6 en la posicin 3");
___________________________
_______________________________________
// Eliminar el objeto que contiene al Integer cuyo valor es 3
____________________
_______________________________
// Escribir el valor del segundo objeto
txtArea.append("El valor del segundo objeto es: " +_____________+ \n );

// Determinar el nmero de objetos del vector
txtArea.append ("El tamao del vector es: " +_____________+ \n );

// Eliminar el tercer objeto y escribir su valor
txtArea.append ("En la tercera posicin haba un: " +_____________+ \n );

_____________________________

}
}

Ejemplo 02:

package pckLogico;
import java.util.Enumeration;
public class ClassVector1 {
Vector Numeros =new Vector();//se crea un vector
public ClassVector1() {
for (int a =0; a <100; a++){
Numeros.addElement(a);//se agrega elementos al vector
}

Enumeration enume =Numeros.elements();//se crea una enumeracion de acuerdo a los
elementos del vector
while(enume.hasMoreElements())//mientras queden elementos en la enumeracion
System.out.println((Integer)enume.nextElement()); //se moldea el objeto del vector para
poder imprimirlo

}

}

package pckEjecutar;

import pckLogico.ClassVector1;

public class ClassPrincipal {

ClassVector1 x;
x=new ClassVector1();
}
}

La clase ArrayList
Las aplicaciones frecuentemente necesitan almacenar un grupo de datos en un slo objeto.
Los arrays sirven bien para este propsito, pero algunas veces necesitamos incrementar o
reducir dinmicamente el nmero de elementos del array, o hacer que contenga distintos tipos
de datos
Esto es comn entre las aplicaciones como las tiendas online. Un cliente aade una mercanca
a su carro de la compra, y detrs de la escena, los tems son almacenados y eliminados
automticamente.
Para esta clase de grupos de datos crecientes y menguantes, podemos usar la clase Vector , o
la reciente clase ArrayList del paquete java.util .
Un ArrayList contiene tantos objetos como necesitemos.
ArrayList tiene varios constructores, dependiendo de cmo necesitemos construir el ArrayList
Los siguientes dos constructores nos ayudarn a empezar:

Un objeto ArrayList slo contiene referencias a objetos. Para almacenar tipos primitivos como
double long o float ,
Si necesitamos circular a travs de los elementos del ArrayList , usamos la clase
Iterator y sus mtodos hasNext y next :

ArrayList es una de las muchas clases del Collection Framework , que proporciona un
conjunto de interfaces y clases bien-diseados para almacenar y manipular grupos de datos
como una sola unidad, una coleccin.
Es una Lista volcada en un Array. Se debe utilizar en lugar de Vector como almacenamiento
de objetos de propsito general. Permite un acceso aleatorio muy rpido a los elementos, pero
realiza con bastante lentitud las operaciones de insertado y borrado de elementos en medio de
la Lista. Se puede utilizar un ListIterator para moverse hacia atrs y hacia delante en la Lista,
pero no para insertar y eliminar elementos.
Ventajas
Un ArrayList es un array dinmico. No tiene restricciones de capacidad. Su tamao se ajusta
de forma dinmica.
ArrayList() construye un ArrayList con capacidad cero
por defecto, pero crecer segn le vayamos
aadiendo:
ArrayList al =new ArrayList();
ArrayList(int initialCapacity) construye un ArrayList
vaco con una capacidad inicial especificada:
ArrayList al2 =new ArrayList(5);
Iterator alIt =al.iterator();
while (alIt.hasNext()){
ModLstDatos(alIt.next() +" ");
}
Constructor por defecto: new ArrayList(). Inicialmente, la capacidad de un ArrayList creado as

es 0.
Los elementos dentro de un ArrayList son Objetos. No pueden ser de tipo bsico, pero
pueden ser de cualquier tipo de objeto.
La clase ArrayList forma parte del paquete java.util Para poner un elemento dentro de esta
estructura, usamos el mtodo add y para recoger un elemento usamos el mtodo get.

Ejemplo 01: ArrayListEjem01
import java.util.*;
public class ArrayListEjem01 {
public static void main(String[ ] args) {
ArrayList Saludo =new ArrayList();
Saludo.add("Sise");
Saludo.add("te");
Saludo.add("da la");
Saludo.add("Bienvenidaa");
Saludo.add("..");
for (int i=0;i<Saludo.size();i++)
ModLstSaludos(Saludos.get(i)+" ");
}
}

Mtodos de ArrayList
int size().- El tamao actual (puede ser 0)
void add(obj).- Aade un objeto al final del ArrayList, incrementando su tamao de
obj es un objeto.
Object get(N).- Devuelve el elemento almacenado a la posicin N en el ArrayList.
N tiene que ser un entero entre 0 y size()-1.

Nota:
En ArrrayListInteger.java, se convierte el objeto devuelto por get() a un Integer con
casting.
En ArrayListString.java, se convierte el objeto devuelto por get() a un String llamando al
mtodo toString() de Object.

Ejemplo 01: Usando el ArrayList
import java.util.ArrayList;
public class ArrayListEntero {
ArrayList numeros =new ArrayList();
Integer num1 =new Integer(10);
numeros.add(num1);
numeros.add(num2);
numeros.add(num3);
numeros.add(num4);
int suma=0;
for (int i=0;i<numeros.size();i++) {
Integer vanum =(Integer)numeros.get(i);
suma =suma +vanum.intValue();
txtArea.append(vanum);
if (i<numeros.size()-1)
txtArea.append ("+");
else
txtArea.append ("=");
}
txtArea.append(\n+suma);
}
}

import java.util.*;
public class ArrayListString {
ArrayList Saludo =new ArrayList();
Saludo.add("Sise");
Saludo.add("te");
Saludo.add("da la");
Saludo.add("Bienvenidaa");
Saludo.add("..");
for (int i=0;i<Saludo.size();i++)
Object objecto =Saludo.get(i);
String cadena =objecto.toString();
cadena =cadena.toUpperCase();
txtSalida.append(cadena+" ");
}
}

Ms Mtodos de ArrayList
void set(index, obj): Sustituye el elemento en la posicin index por el objeto obj.
(index tiene que ser entre 0 y size()-1) dentro del ArrayList, sustituyendo el elemento
previamente almacenado a la posicin N. Es equivalente a A[N] =obj para un array A.

Object remove(index) -- Elimina el elemento a la posicin index (index entre 0 y size()-1).

ArrayList remplaza a Vector y Iterator remplaza a Enumeration:
Se puede crear un objeto ArrayList y moldearlo a una Collection. Al utilizar mtodos de
Collection, cualquier objeto de una clase derivada de Collection debera funcionar, pero se crea
un ArrayList porque es el caballo de batalla de las colecciones y viene a tomar el relevo al
Vector.

El mtodo add(), como su nombre sugiere, coloca un nuevo elemento en la coleccin. Sin
embargo, la documentacin indica claramente que add() "asegura que la coleccin contiene el
elemento indicado". Esto es para que un Set tenga significado, ya que solamente aadir el
elemento si no se encuentra en la coleccin. Para un ArrayList, o cualquier otra lista ordenada,
add() significa siempre "colocarlo dentro".

Todas las colecciones pueden producir un Iterator invocando al mtodo iterator(). Un Iterator
viene a ser equivalente a una Enumeration, a la cual reemplaza, excepto en los siguientes
puntos:

Utiliza un nombre que est histricamente aceptado y es conocido en toda la literatura de
programacin orientada a objetos
Utiliza nombres de mtodos ms cortos que la Enumeration: hasNext() en vez de
hasMoreElements(), o next() en lugar de nextElement().


Crear el siguiente Caso utilizando la clase primita ArrayList.

// Clase Encapsulada
package PckLogico;

public class ClassEncapsulada {
String nombre,apellido,condicion;
int reg,nota1,nota2,nota3,nota4;
double promedio;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre =nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido =apellido;
}
public int getNota1() {
return nota1;
}
public void setNota1(int nota1) {
this.nota1 =nota1;
}
return nota2;
}
this.nota2 =nota2;
}


return nota3;
}
this.nota3 =nota3;
}
return nota4;
}
this.nota4 =nota4;
}
public String getCondicion() {
return condicion;
}
public void setCondicion(String condicion) {
this.condicion =condicion;
}
public int getReg() {
return reg;
}
public void setReg(int reg) {
this.reg =reg;
}
public double getPromedio() {
return promedio;
}
public void setPromedio(double promedio) {
this.promedio =promedio;
}
}//fin de la clase encapsulada

// ClassMetodos
package PckLogico;

import java.util.ArrayList;
public class ClassMetodo{
static ArrayList Registros;
public ClassMetodo(){
Registros=new ArrayList();
}
public void AddRegistro(ClassEncapsulada Datos){
Registros.add(Datos);
}
public ClassEncapsulada getEncapsulada(int i){
return((ClassEncapsulada)Registros.get(i));
}
public int tamao(){
return(Registros.size());
}
}

//ClassEjecutar
package PckPrincipal;

import PckPresentacion.FrmAcceso;
import PckPresentacion.FrmDatos;

public class ClassEjecutar {
FrmAcceso prin=new FrmAcceso();
prin.setVisible(true);

// Cerrar una ventana
}
}

// uso del FRAME
//inicializacion
ClassEncapsulada atri;
ClassMetodo metodos;
String valores[][]={};
Stringnombres[]={"Reg","Nombre","Apellido","Nota 1","Nota 2","Nota 3","Nota 4",
"Promedio","Condicion"};
int R=1;
**********************************
**********************************
**********************************
**********************************
**********************************
**********************************
lblreg.setText(""+R);
atri=new ClassEncapsulada();
metodos=new ClassMetodo();
}
void datos(){
atri.setNombre(txtnom.getText());
atri.setApellido(txtape.getText());
atri.setNota1(Integer.parseInt(txtN1.getText()));
atri.setPromedio((atri.getNota1()+atri.getNota2()+atri.getNota3()+atri.getNota4())/4.0);
lblPromedio.setText(""+atri.getPromedio());
if(atri.getPromedio()>=10.5) atri.setCondicion("Aprobado");
else atri.setCondicion("Desaprobado");
lblCondicion.setText(atri.getCondicion());
}


void Eliminar(){
int fila=tbl_d.getSelectedRow();
modTDatos.removeRow(fila);
}
datos();
Object valores[]={R,atri.getNombre(),atri.getApellido(),atri.getNota1(),atri.getNota2(),
atri. getNota3(),atri.getNota4(),atri.getPromedio(),atri.getCondicion()};
modTDatos.addRow(valores);
++R;
}
private void jButton1_actionPerformed(ActionEvent e) {
//Ir al Inicio del registro de la Tabla
tbl_d.setRowSelectionInterval (0,0);
}

//Ir al Siguiente Registro de la Tabla
if ( tbl_d.getSelectedRow() !=0 ) {
tbl_d.setRowSelectionInterval (tbl_d.getSelectedRow()+1, tbl_d.getSelectedRow() +1);
}

}

//Ir al Anterio de la Tabla
if ( tbl_d.getSelectedRow() !=0 ) {
tbl_d.setRowSelectionInterval (tbl_d.getSelectedRow()-1, tbl_d.getSelectedRow() -1);
}
}
//Implementa para ir al final del registro de la tabla

}

private void btnSalir_actionPerformed(ActionEvent e) {
System.exit(0);
}

private void btnEliminar_actionPerformed(ActionEvent e) {
Eliminar();
}

private void btnBuscar_actionPerformed(ActionEvent e) {
/* Implementa Este boton
}
}// fin del Frame


//Frame Acceso

String Nombre, clave;

Nombre=txtNombre.getText();
clave=txtClave.getText();

if(Nombre.equalsIgnoreCase("SISE")&&clave.equalsIgnoreCase("2010")){
FrmDatos prin=new FrmDatos();
prin.setVisible(true);
this.dispose();
}
}


Contenidos
- Uso de mens(J Menu)
- J ProgressBar,
- J ColorChooser, J FileChooser,
- InternalFrame
- Implementacin de Libreras
- Creacin de Archivos J ar Ejecutables
____________________________________________________________________________

Mens
Un men en una aplicacin no es ms que un MenuBar en el que hay varios mens.
Pensemos en un programa cualquiera con las voces de men File Edit y Help. Estas tres voces
en J ava son unos objetos de la clase Men y se tienen que aadir a un objeto de la clase
MenuBar que se une a la ventana. Cada men tiene varias voces. Por ejemplo, el men
Archivo tendr las voces: Abrir, Cerrar, Guarda y Salir. stos en J ava son unos objetos de la
clase MenuItem (o tambin Men si incluyen otros submens).

Por lo tanto, si a una aplicacin le quisieramos aadir un men tendramos hacer las siguientes
cosas siguiendo un rden cualquiera:
Crear los objetos MenuItem
Crear los objetos men y pegarles los MenuItem
Crear una MenuBar y pegarles los Mens

Adems, como siempre, tenemos que escribir unos gestores para los sucesos de los mens y
asociarlos a los mens.

Los sucesos de los MenuItem son los que tenemos que gestionar nosotros a diferencia de los
sucesos de los mens que los gestiona el sistema. Mientras los segundos sirven para que
aparezcan y desaparezcan las voces del men, los primeros son los clicks sobre la orden
correspondiente al Item.

Por lo tanto, para stos tendremos que escribir unos ActionListener, como para los botones.
Realmente no son otra cosa que unos botones especiales. Los constructores son tres:

MenuItem() , que construye un MenuItem sin etiqueta.

MenuItem(String label), que construye MenuItem con etiqueta label.
MenuItem(String label, MenuShortcut s), que construye un MenuItem con etiqueta label
y acelerador (tecla de opcin rpida) definido en MenuShortcut s.

Algunos mtodos son:
addActionListener(ActionListener l), asocia un ActionListener al MenuItem para
escuchar los sucesos de tipo ActionEvent (el clic).
void deleteShortcut(), borra la tecla de opcin rpida para el menuitem.
String getActionCommand(), da la accin asociada al MenuItem. La accin es la
que pasa al actionListener del botn para identificar el botn mismo. As varios item
pueden tener el mismo gestor de sucesos que podr distinguir el botn clicado
basndose en la rden que le llega.
String getLabel(), devuelve la etiqueta del MenuItem
EventListener[]getListeners(Class listenerType) , devuelve todos los oyentes de
sucesos asociados al MenuItem, del tipo listenerType.
MenuShortcut getShortcut(), devuelve la definicin del acelerador para el
MenuItem.
boolean isEnabled(), dice si el men esta disponible o no. Si no lo est se
visualizar en gris.
void removeActionListener(ActionListener l), elimina el oyente asociado.
void setActionCommand(String command), ajusta la orden asociada al
MenuItem. Si no est especificado, la rden es la etiqueta del MenuItem.
void setEnabled(boolean b), habilita y deshabilita el MenuItem.
void setLabel(String label), ajusta la etiqueta para el MenuItem.
void setShortcut(MenuShortcut s), define el acelerador para el men.

Por lo tanto, para crear los Item del men Archivo descrito antes tendremos que escribir:

MenuItem abrir=new MenuItem("Abrir");
MenuItem cerrar=new MenuItem("Cerrar");
MenuItem guardar=new MenuItem("Guardar");
MenuItem salir=new MenuItem("Salir");

Por tanto creamos el objeto Menu para pegar los MenuItem.
Dos constructores del objeto son:

Menu(), construye un Men sin etiqueta
Menu(String label), construye un men con etiqueta label.

Cmo Usar MonitoProgress?

Una tarea ejecutndose en un programa puede tardar un poco en completarse. Un programa
amigable proporciona alguna indicacin al usuario sobre lo que puede tardar la tarea y lo que
ya lleva realizado.
El paquete Swing proporciona tres clases para ayudar a crear GUIs que monitoricen y
muestren el progreso de tareas de larga duracin.
JProgressBar
Una barra de progreso que muestra grficamente qu cantitad total de la tarea se ha
terminado. Puedes ver Cmo usar Progress Bars para ms informacin.
ProgressMonitor
Un ejemplar de esta clase monitoriza el progreso de una tarea. Si el tiempo enlapsado
de la tarea excede un valor especificado en el programa, el monitor trae un dilogo con
una descripcin de la tarea, una nota de estado, una barra de progreso, un botn Ok, y
un botn Cancel. Puedes ver Cmo usar Progress Monitors para ms detalles.
ProgressMonitorInputStream
Un stream de entrada con un monitor de progreso aadido, que monitoriza la lectura
desde el stream. Se utiliza un ejemplar de este stream como cualquier otro stream. Se
puede obtener el monitor de progreso del stream llamando a getProgressMonitor y
configurndolo como se describe en Cmo usar Progress Monitors.
Despus de ver una barra de progreso y un monitor de progreso en accin, Decidir si utilizar
una Barra o un Monitor de Progreso puede ayudarnos a decidir cul es el apropiado para
nuestra aplicacin.

J FileChooser
JFileChooser es una clase java que nos permite mostrar fcilmente una ventana para la
seleccin de un fichero.
Si queremos abrirlo para leer el fichero, podemos llamarlo as

A la vuelta, en seleccion tendremos
JFileChooser.CANCEL_OPTION Si el usuario le ha dado al botn cancelar.
JFileChooser.APPROVE_OPTION Si el usuario le ha dado al botn aceptar
JFileCHooser.ERROR_OPTION Si ha ocurrido algn error.

Comprobando que se ha dado al botn aceptar, podemos obtener el fichero seleccionado por
el usuario as

Para seleccionar un fichero para guardar datos, el mecanismo es igual, pero se llama al
mtodo showSaveDialog()

La nica diferencia entre uno y otro es la etiqueta del dilogo y de los botones. Uno pondr
"Abrir" y otro "Guardar"

Filtrar los ficheros visibles
Si no queremos que el JFileChooser muestre todos los ficheros del directorio, podemos
aadirle un filtro. Bsicamente hay que hacer una clase que herede de FileFilter y definir el
mtodo accept(). Este mtodo recibe un parmetro File y nosotros debemos decidir si pasa o
no el filtro, devolviendo true o false. Por ejemplo, si slo queremos ver fichero .jpg, podemos
hacer este filtro.

J FileChooser fileChooser =new J FileChooser();
int seleccion =fileChooser.showOpenDialog(areaTexto);
if (seleccion ==J FileChooser.APROVE_OPTION){
File fichero =fileChooser.getSelectedFile();
// Aqu debemos abrir y leer el fichero.
...
}
J FileChooser fileChooser =new J FileChooser();
int seleccion =fileChooser.showSaveDialog(areaTexto);
if (seleccion ==J FileChooser.APPROVE_OPTION){
File fichero =fileChooser.getSelectedFile();
// Aqu debemos abrir el fichero para escritura
// y salvar nuestros datos.
...
}

Debemos definir ambos mtodos. La descripcin puede ser cualquier cadena de texto que nos
sirva como descripcin del filtro. Finalmente, debemos pasar este filtro al J FileChooser
fileChooser.setFilter(new FiltroDeJ PG());

Sin embargo, una de las bondades ofrecidas por el J DK 1.6, es el ahorro en la codificacin de
una clase filtro, pues este, ya viene con una incluida a la cual solo necesitamos invocarla, la
sintaxis es la siguiente:

Tenes definir un FileFilter , es decir, creas una clase que herede de FileFilter y le das las
propiedades que deseas. Por ejemplo:

Import javax.swing.filechooser.FileFilter;
...
public class FiltroDeJ PG extends FileFilter{
public boolean accept (File fichero) {
if (tieneExtensionJ PG (fichero))
return true;
else
return false;
}
public String getDescription() {
return ("Filtro J PGs");
}
}
J FileChooser jf =new J FileChooser();
FileNameExtensionFilter filter =new
FileNameExtensionFilter("J PG & GIF", "jpg", "gif");
jf.setFilter(filter);

J FileChooser chooser =new J FileChooser();

ExampleFileFilter filter =new ExampleFileFilter();

File fichero =null;

filter.addExtension("txt");
filter.addExtension("bat");
filter.setDescription("Ficheros de texto");

chooser.setFileFilter(filter);
int returnVal =chooser.showOpenDialog(this);

if(returnVal ==J FileChooser.APPROVE_OPTION)

fichero =chooser.getSelectedFile();

Si queres trabajar con directorios tenes que cambiar el modo de seleccin usando la constante
J FileChooser.DIRECTORIES_ONLY. El modo de seleccin tambin puede ser cambiado para
permitir elegir mas de un fichero o directorio a la vez:

chooser.setFileSelectionMode(J FileChooser.DIRECTOR IES_ONLY);

Contenidos
Threads

____________________________________________________________________________

Una thread es un nico flujo de contrrol dentro de un programa. Algunnaas veces es llammado
contexto de ejecucin porque cada thread debe tenner sus propios recurssos, como el
prrogram counter y el stack de ejecucin, como el contexto dee ejecucin. Sin embargo, toda
thread en un programa aun comparte muchos recursos, tales como espacio de memoria y
archivvos abiertos. Threads tambien son llamadas procesos livianos (lightweight prrocess).
Comparticin de datos
Todos los hilos de proceso que pertenecen a un mismo proceso comparten un rea comn de
datos que sirve para intercambiar informacin entre ellos. No es necesario acudir a tcnicas de
comunicacin entre procesos tales como paso de mensajes, ya que todos los hilos son
capaces de acceder directamente a los datos compartidos.
Por otro lado, la conmutacin entre hilos de un mismo proceso es muy rpida, puesto que la
cantidad de informacin que ha de ser salvada y/o restaurada por el sistema es mucho menor.
Por eso, cuando se trata con hilos siempre se habla de cambios de contexto ligeros, en
contraposicin a los cambios de contexto pesados, que implican el manejo de procesos.

Ejemplo 01

Crear una Aplicacin que presente la hora del sistema usando hilos.

public class PanelReloj extends JPanel{
J Label reloj;

public PanelReloj(){
reloj=new J Label("", J Label.CENTER);
reloj.setForeground(Color.blue);
reloj.setFont(new Font("Arial", Font.BOLD, 30));
add(reloj, BorderLayout.CENTER);
MiReloj hilo=new MiReloj(reloj);
hilo.start();
try {
jbInit();
}
}

}

public class MiReloj extends Thread{
J Label lblReloj;

// constructor
public MiReloj(J Label lblReloj){
this.lblReloj=lblReloj;
}

// puesta en marcha del hilo
public void run() {
while(true) {
Date hoy=new Date();

SimpleDateFormat sdf=new SimpleDateFormat("hh:mm:ss");

lblReloj.setText(sdf.format(hoy));

try {sleep(1000); }catch (Exception ex) {}
}
}

}

public class CFrmP extends JFrame{

public static void main(String[] arg){
CFrmP ver = new CFrmP ();
PanelReloj panel =new PanelReloj();
ver.setContentPane(panel);
ver.setSize(250,100);
ver.setLocationRelativeTo(null);
ver.setVisible(true);
}

}

Ejemplo 02

crear el Panel por medio de Codigo: Solo inserte el panel y digite los siguiente, crea una
clase main y una subclase.

public class PanelCarrera extends JPanel implements ActionListener{
public J Label lblJ 1 =new J Label("1",J Label.CENTER);
public J Label lblJ 2 =new J Label("2",J Label.CENTER);
J Label barrera=new J Label();
J Button b=new J Button("Inicia carrera");

//Constructor
public PanelCarrera(){
setLayout(new BorderLayout());
J Panel p=new J Panel();
p.setLayout(null);
lblJ 1.setBounds(0,25, 20,20);
lblJ 1.setBackground(Color.blue);
lblJ 1.setOpaque(true);
lblJ 1.setForeground(Color.white);

lblJ 2.setBounds(0,50, 20, 20);
lblJ 2.setBackground(Color.red);
lblJ 2.setOpaque(true);
lblJ 2.setForeground(Color.white);

barrera.setBounds(310,0, 2,400);
barrera.setBackground(Color.green);
barrera.setOpaque(true);
b.addActionListener(this);

p.add(lblJ 1);
p.add(lblJ 2);
p.add(barrera);

add(p, BorderLayout.CENTER);
add(b, BorderLayout.SOUTH);
}

public void actionPerformed(ActionEvent e){
lblJ 1.setLocation(0, lblJ 1.getLocation().y);
lblJ 2.setLocation(0, lblJ 2.getLocation().y);
ClassCarreraHilo st1=new ClassCarreraHilo(lblJ 1, this);
ClassCarreraHilo st2=new ClassCarreraHilo(lblJ 2, this);
st1.start();
st2.start();
}
}

// creacin de la clase Hilo

class ClassCarreraHilo extends Thread{
J Label eti;
PanelCarrera p;

//contructor de la clase
public ClassCarreraHilo(JLabel eti, PanelCarrera p){
this.eti=eti;
this.p=p;
}

// meto de inicializacion de la clase Threads
public void run() {
int c1, c2;
while(true){
//usando un un Try
try {
//usando sleep de la clase threads
sleep((int)(Math.random() * 1000));
c1=p.lblJ 1.getLocation().x;
c2=p.lblJ 2.getLocation().x;

if(c1<290 && c2<290){
eti.setLocation(eti.getLocation().x +10, eti.getLocation().y);
//usando el panel
p.repaint();
}
else break;
}catch (InterruptedException e) {}
}

// determina el ganador si alguien lleg a la meta

if (eti.getLocation().x>=290)
if (c1>c2)
J OptionPane.showMessageDialog(null,"Gano 1");
else if (c2>c1)
J OptionPane.showMessageDialog(null,"Gano 2");
else
J OptionPane.showMessageDialog(null,"Empate");

}
}

// Usando el Jframe dentro de una clase con herencia de las propiedades del Frame
public class ClassFrmHiloJuego extends JFrame{
public static void main(String[] arg){
ClassFrmHiloJ uego Carrera = new ClassFrmHiloJ uego();
PanelCarrera panel =new PanelCarrera();
Carrera.setContentPane(panel);
Carrera.setSize(350,200);
Carrera.setTitle("J uego de 2 - Ganador Aleatorio - VER");
Carrera.setLocationRelativeTo(null);
Carrera.setVisible(true);

}

}

Ejemplo 03
Muestre la palabra SISEpuede cada cierto tiempo

public class ClassBlink implements Runnable {
Thread Blink=new Thread(this);
J Label tiempo=new J Label();
public ClassBlink() {
J Frame ventana =new J Frame("Visualizar Palabra");
ventana.setSize(250,100);
ventana.setVisible(true);
ventana.add(tiempo);

//Blink=new Thread(this);
Blink.start();
try {
jbInit();
}
}
public void run(){
try {
while(true){
tiempo.setText("Sise puede..");
Blink.sleep(1000);
tiempo.setText(" ");
Blink.sleep(1000);
}
}catch (InterruptedException ex) {
System.out.println("Error...");
}

}

new ClassBlink();
}

tiempo.setBackground(new Color(0, 0, 165));
tiempo.setForeground(new Color(247, 255, 214));
tiempo.setOpaque(true);
tiempo.setFont(new Font("Dialog", 1, 21));
}
}


Proyecto Final: Caso Practico.

Crear un Proyecto final donde aplique la Tecnica de programacin orientada a Objetos
(herencias, sobrecarga de mtodos, encapsulamiento), uso de mtodos, paneles establecer
archivos, uso de imgenes, hilo para el reloj activo, etc.
Todos los datos estarn guardados dentro de un Archivo llama Datos.txt
La estructura a trabajar seria:

Agregue al Proyecto una Interface llamada intImpleMetodoso en el Paquete pckInterface
donde defina todos los metodos a utilizar por el proyecto


Ademas Agregue 2 Frame en la capa Presentacion:
Para el Acceso de Usuario: Que estarn registrados dentro un Archivo.
Para el reporte de Datos: donde mostrara, el total de sueldos desembolsados por la
empresa, total de descuentos, aumentos y netos, cuantos tuvieron aumentos y cuantos
descuentos

Presentacin Final

Panel Encabezado

Panel Pie: use la Clase GregorianCalendar y Hilos

Panel Listado: usara el JFileChooiser para jalar la foto

El botn agregar solo almacenara datos al ArrayList, lo botones modificar, eliminar, depender
de la seleccin del J Table y buscar pedir el numero para mostrar todos los elementos en el
panel contenido.

Panel Contenido
Todos permitir mostrar todos los datos dentro del arrayList asi como aquellos que ya estaban
en el archivo.
X apellido: segn a las letras o palabra completa se realizar el filtro por apellidos en el J table.

Manual Tecnicas de Programación Orientado A Objetos - A - Java - V0510

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual Tecnicas de Programación Orientado A Objetos - A - Java - V0510

Uploaded by

Copyright:

Available Formats

TcnicadeProgramacinOrientadaaObjetos 2

Los pasos para la utilizar de un vector son

USO DE ARREGLOS EN JAVA

edades[i] =Integer.parseInt(J OptionPane.showInputDialog("Ingresar Edades"));

Asignacin de datos hacia una Matriz:

Operaciones que se pueden realizar con los arreglos

USO DE MATRICES con el control JTABLE

Uso del JTable

Creacin y enlace de un JTable

BALOTARIO DE EJERCICIOS USANDO VECTORES Y MATRICES

En este tipo de algoritmos se SELECCIONA o se busca el elemento ms pequeo (o ms

Ejemplos en cdigo JAVA:

Para la Busqueda. Deber de aparecer la ventana para buscar el nombre y visualizar si se

private void btnBusqueda_actionPerformed(ActionEvent e) {

La programacin orientada a objetos, expresa un programa como un conjunto de estos objetos,

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden

Creacin de Clases en JAVA

J OptionPane.showMessageDialog(null,"La resta de\t"+num1+"-"+num2+"="+

txtSalida.append("La suma de\t"+num1+"+"+num2+"="+Ejecutar.Suma(num1,num2)+"\n");

Calificadores: Public, Private, Protected, Static y Final.

Ningn Calificador : Clase en Librera y misma Clase .

final : Una sola instancia y definitiva.

Clase GregorianCalendar y operaciones

argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para

Caractersticas de los Archivos

Caso Prctico: Usando la Tcnica P.O.O:

pnlPie1.setBounds(new Rectangle(0, 345, 395, 40));

Regresa verdadero si el objeto dado pertenece al vector

//El nuevo vector es

Constructor por defecto: new ArrayList(). Inicialmente, la capacidad de un ArrayList creado as

MenuItem() , que construye un MenuItem sin etiqueta.

Cmo Usar MonitoProgress?

public class CFrmP extends JFrame{

// determina el ganador si alguien lleg a la meta

Panel Listado: usara el JFileChooiser para jalar la foto

You might also like