Você está na página 1de 123

 Presentación…………………………………………………………………………………………..

 Modulo A

 Semana 1: Arreglos Lineales y Matrices …………………………………………………...4

 Semana 2: Ordenamiento de datos y Búsqueda de Datos…….……………….28

 Semana 3: Programación 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: Métodos propios …………………………………………………………………109

 Semana 8: Ejercicios de Aplicación………………………………………………………115

 Semana 9: Manejo de Capas en una aplicación en escritorio……………………121

 Bibliografía: ……………………………………………………………………………………………

Técnica de Programación Orientada a Objetos 2


PRESENTACIÓN
Esta guía didáctica es un material de ayuda institucional, perteneciente a las
especialidades de computación, Ingeniería de Software e Ingeniería de Redes y
Comunicaciones tiene por finalidad proporcionar los conocimientos de la
programación orientada a Objetos a los estudiantes del segundo ciclo de estudios.

La Organización SISE, líder en la enseñanza tecnológica a nivel superior, promueve


la elaboración de materiales educativos, en concordancia a las exigencias de las
tecnologías de estos tiempos, que permiten la creación de nuevas herramientas de
aprendizaje con el objetivo de facilitar el acceso de los estudiantes a la educación en
el marco del desarrollo tecnológico de la informática u de las telecomunicaciones.

Esta guía se divide en 2 módulos y cada una de ellas en 9 semanas. Permite conocer
las herramientas indispensables para la elaboración de aplicaciones con el uso de la
técnica O.O. Se inicia con el uso de técnica en manejo de datos en memoria y en el
manejo de capas donde estas técnicas básicas se necesitan para dar solución a una
determinada proposición o problema.

En este proceso el alumno aprenderá instrucciones que le permitirán evaluar


expresiones para luego procesar un conjunto de sentencias. También aprenderá el
manejo de una aplicación a nivel de contenedores, de la misma forma el manejo del
lenguaje de programación orientada a objetos.

La implementación y uso de Capas dentro de la aplicación en escritorio permitirán que


el alumno aplique la programación Orientada a objetos.

Todas estas herramientas darán un soporte solido al alumno para aprender a


programar en cualquier lenguaje de programación Orientada a Objetos(JAVA, .NET,
Visual C,etc).

Este material en su primera edición, servirá para ayudar a nuestros estudiantes


SISESINOS a tener una formación solida para resolver problemas.

Técnica de Programación Orientada a Objetos 3


Arreglos

Contenidos

- Concepto de Arreglos :Declaración, asignación e inicialización de memoria a un arreglo


- Acceso Secuencial y Aleatorio. Agregar Datos de Arreglo.
- Arreglos con uso de Estructuras Condicionales: Uso de Contadores y Acumuladores.
- Uso del JList (defaultListModel)
- Definición de matrices: Acceso a elementos de una matriz: Asignación de Datos:
- Operaciones con Matriz
- Uso del JTable(DefatultTableModel), (setElementAt(), getSelectedRow(),
getSelectedColum(), changeSelection(), addRow(),etc).
-

ARREGLOS LINEALES
Un arreglo es una colección de datos del mismo tipo, que se almacenan en posi iones
consecutivas de memoria y reciben un nombre común. Para referirse a un determinado
elemento de un arreglo se deberá utilizar el nombre del arreglo acompañado de un índice el
cual especifica la posición relativa en que se encuentra el elemento.

 Los arreglos pueden ser:


 Unidimensionales (vectores).

 Bidimensionales (matrices, tablas).

 Multidimensionales (tres dimensiones o más)

Técnica de Programación Orientada a Objetos 4


 Declarar de un arreglo:

<tipo de dato>: nombre_variable [Tamaño]

 Con esto diremos que se está definiendo un atributo de tipo arreglo y estamos
determinando el tipo de dato y el tamaño de registros.

Ejemplos:
Entero: Numeros[10]
Decimal: talla [5]
Carácter nombres [8]

 Asignación de datos hacia a un arreglo:

nombre_variable[índice] = <expresión del tipo>

 Esta instrucción asigna el valor asociado de la expresión a la posición índice del


arreglo nombre_variable. El índice debe ser una expresión del tipo entero en el rango
[0, longitud-1].

Ejemplos: Estableciendo Datos a los Arreglos

Numero[2]=152 talla[4]=170.5 nombre[6]=”Verónica”


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í:


Arreglo Numero
Índice 0 1 2 3 4 5 6 7 8 9 10
Valores 52 0 152 0 0 115 0 0 0 0 652

Arreglo Talla
Í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 Verónica null Sebastián

Técnica de Programación Orientada a Objetos 5


Nota: las posiciones que no se le asignaron datos quedarían vacios (0) en el
caso de ser numero y null en el caso de carácter.

 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í también
vale la aclaración de que el índice debe estar dentro del rango de definición 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á Sebastián

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 tamaño 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

Técnica de Programación Orientada a Objetos 6


 Los pasos para la utilizar de un vector son
1. Declarar el vector: Consiste en establecer el nombre, el tamaño y el tipo de los datos
que se van a almacenar en el arreglo ejemplo:
 Hay que diferenciar dos términos:
tamaño del vector (T): es el número máximo 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 declaración


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í dándole nuevos valores:

desde(i = 0 hasta N-1)


leer( notas[i] )

fin_desde

3. Manipular la información guardada en el vector. Para esto es necesario recorrer dicha


estructura y se puede hacer de la siguiente manera.

desde(i = 0 hasta N-1)


mostrar ( notas[i] )
fin_desde

Tambien se puede leer y a la vez escribir los datos ingresados al arreglo

desde(i = 1 hasta N-1)


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)
 Asignación (dar valor a una posición específica)
 Actualización (inserción , eliminación, modificación )
 Ordenación . (burbuja, inserción directa, selección directa, selle y quicksort).
 Búsqueda. (secuencial, binaria, hash( por claves) ).

Técnica de Programación Orientada a Objetos 7


Ejemplos:

1. Crear un Arreglo que permita ingresar 10 Apellidos.

Carácter: 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 programación

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


ubicación.

Constante N=20

Carácter: Institutos[N]

Carácter: Zonas[N]

desde(i = 0 hasta N-1)


leer(Institutos[i] )

leer(Zonas[i] )

mostrar(Institutos[i])

mostrar (Zonas[i] )

fin_desde

Técnica de Programación Orientada a Objetos 8


4. Crear un Arreglo que ingrese 50 datos numéricos enteros.

Constante N=50

entero: Numeros[N]

desde(i = 0 hasta N-1)


leer(Numeros[i] )

mostrar(Numeros[i])

fin_desde

5. Crear un Arreglo que ingrese 10 promedios y mostrar cuantos están aprobados y


cuantos desaprobados.

Constante N=10

decimal: Promedios[N]

desde(i = 0 hasta N-1)


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)

Técnica de Programación Orientada a Objetos 9


6. Crear un Arreglo que ingrese 15 Áreas y sus respectitos Sueldos y mostrar cuantos
están son del área “Sistemas”,” Contabilidad”, y cuantos sueldos superan al sueldo
mínimo y cuántos de ellos ganan entre 1000 y 2500.

Constante N=15

entero:Sueldo[N]

Carácter:Area[N]

desde(i = 0 hasta N-1)


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 más que el sueldo mínimo: “+csum)

mostrar(“Total de Empleados que ganan entre 1000 y 2500: “+cr)

Técnica de Programación Orientada a Objetos 1


0
 USO DE ARREGLOS EN JAVA

Una matriz es una estructura que contiene múltiples valores del mismo tipo. La longitud de un
array se establece cuando se crea un arreglo (en tiempo de ejecución).

Se pueden declarar en Java Arreglos de cualquier tipo:

Para definir un Arreglo se establecerá con el operador new.

La palabra clave new se usa para crear una instancia de la clase.

Antes de ser instanciada con new no consume memoria, simplemente es una declaración de
tipo. Por ejemplo:

// Solo definir a un identificador como tipo arreglo.

char nombreJugadores [];

int edades[];

// Definir el arreglos con su tamaño especifico


String [ ] nombreJugadores = 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 iníciales:

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( "Sebastián" );

Técnica de Programación Orientada a Objetos 1


1
Otro Ejemplo:

String [ ] Coordinadores={“Verónica Escobar”, “Víctor Sánchez”,“Rogelio Tello”,”Carlos Monge”};

O También:

Coordinadores [0] = " Verónica Escobar ";


Coordinadores [1] = " Víctor Sánchez ";
Coordinadores [2] = " Rogelio Tello ";
Coordinadores [3] = "Carlos Monge";

Casos Prácticos

1. Ejemplo ingresando valores aleatorios al arreglo:

private void btnAgregar_actionPerformed(ActionEvent e) {

modLstf.clear();
Se usara el random para
int Numeros[]=new int[10];
poder establecer números
for( int i=0; i < 10; i++ ){ aleatorios en este caso
será desde 1 al 100.
Numeros[i] = (int)(Math.random()*100)+1;

modLstf.addElement((i+1)+".- "+Numeros[i] );

Técnica de Programación Orientada a Objetos 1


2
2. Almacenar los votos obtenidos por los 20 candidatos. Estos son ingresados por el usuario.
private void btnAgregar_actionPerformed(ActionEvent e) {
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(JOptionPane.showInputDialog("Ingresar Cantidad de
Votos - "+(i+1)));
modLstf.addElement((i+1)+".- "+votos[i] );
}
}

Técnica de Programación Orientada a Objetos 1


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

private void btnAgregar_actionPerformed(ActionEvent e) {


String Amigos[]={"Verónica E.","Glenda D.","Victor S.","Waldir C.","Rogelio R.",

"Eduardo A.","Carlos M.","Henrry Q.","Miguel F.","Manuel T.","Juan C."};

El length se usa para ver el total de


elementos que tiene el arreglo.

for( int i=0; i < Amigos.length; i++ ){

modLstf.addElement((i+1)+".- "+Amigos[i] );

Este método length


devuelve un valor
numérico entero

4. Se pide crear una lista que almacene 10 registros: estos datos serán Apellidos, edades y
distritos del aula 307.
private void btnAgregar_actionPerformed(ActionEvent e) {

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] = JOptionPane.showInputDialog("Registro nro. "+(i+1)+"\n"+"Ingresar Apellidos:");

Técnica de Programación Orientada a Objetos 1


4
edades[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingresar Edades"));

distritos[i] =JOptionPane.showInputDialog("Ingresar Distrito:");

modLstf.addElement((i+1)+".- "+apellidos[i] );

modLstE.addElement(edades[i]);

ModLstD.addElement(distritos[i]);

5. Modificando el programa anterior, también deberá de visualizar cuantos son mayores a 31


o menores e iguales que 31. Cuántos son del distrito de Surco o Chorrillos.

public class FrmCAso01 extends JFrame {

Estos arreglos deben ser


variable Globales debido a
final int t=5;
que es llamado en botones
int edades[]=new int[t]; diferentes.

String apellidos[]=new String[t]; El atributo t es una


String distritos[]=new String[t]; constante donde indica el
tamaño de los Arreglos.

Técnica de Programación Orientada a Objetos 1


5
private void btnAgregar_actionPerformed(ActionEvent e) {

for( int i=0; i < t; i++ ){

apellidos[i] = JOptionPane.showInputDialog("Registro nro. "+(i+1)+"\n"+"Ingresar Apellidos:");

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

distritos[i] =JOptionPane.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 Años son: "+cmay+"\n");

txtsalida.append("* Total de Menores o iguales a 31 Años son: "+cme+"\n");

Técnica de Programación Orientada a Objetos 1


6
Técnica de Programación Orientada a Objetos 17
 ARREGLOS BIDIMENSIONALES
 MATRICES

La utilización de matrices constituye actualmente una parte esencial de los lenguajes de


programación, ya que la mayoría de los datos se introducen en los ordenadores como tablas
organizadas en filas y columnas: hojas de cálculo, bases de datos, Archivos, etc.

Se llama matriz de orden m×n a todo conjunto rectangular de elementos Matriz(m)(n)


dispuestos en m líneas horizontales (filas) y n verticales (columnas) de la forma:

Columnas

0 1 2
Recordemos que los
0
Arreglos o Matrices
Filas 1 empiezan desde la
2
posición cero tanto para
3
las filas y columnas.

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

0 1 2
0
1
2
3
4

b) Caracter: Letras[2][5]

0 1 2 3 4
0
1

Técnica de Programación Orientada a Objetos 18


 Asignación de datos hacia una Matriz:

nombre_variable[índiceFila] [índiceColumna] = <expresión del tipo>

Ejemplos: Estableciendo Datos a una Matriz

 Asignar años 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 mostrándolo 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

Técnica de Programación Orientada a Objetos 19


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 tamaño 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 dándole 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 información 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)
desde(c = 0 hasta Columnas-1)
mostrar( numeros[f][c] )
fin_desde
fin_desde

También se puede leer y a la vez escribir los datos ingresados al arreglo

desde(f = 0 hasta Filas-1)


desde(c = 0 hasta Columnas-1)
leer( numeros[f][c] )
mostrar( numeros[f][c] )
fin_desde
fin_desde

Técnica de Programación Orientada a Objetos 20


 Operaciones que se pueden realizar con los arreglos
 Lectura (llenar datos de la matriz)
 Escritura (mostrar datos de la matriz)
 Asignación (dar valor a una posición específica)
 Actualización (inserción , eliminación, modificación )

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

Técnica de Programación Orientada a Objetos 21


 USO DE MATRICES con el control JTABLE

Java posee la capacidad de definir un conjunto de variables del mismo tipo agrupadas todas
ellas bajo un mismo nombre, y distinguiéndolas mediante un índice numérico.

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 definición 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 posición de la matriz

números[0][2]=Integer.parseInt(JOptionPane.showInputDialog(“Ingresar Numero));

 En el caso que se desee realizar para toda la matriz deberás 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(JOptionPane.showInputDialog(“Ingresar

Numero));

Técnica de Programación Orientada a Objetos 22


 Uso del JTable

Jtable es una clase que me permite organizar una determinada información en tabla, esta
difiere de una base de datos normal porque al utilizar Jtable tú puedes visualizar esta tabla,
brindándole al usuario organización de información, oportunidades de editar y cambiar el
tamaño de las columna entre otras.

Jtable le da al programador muchas facilidades, pues este posee varias características que
permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con
información sencilla y "básica".

TABLE MODEL

La clase Jtable controla como se presentan los datos, para crear una Jtable habrá pues que
crear un DefaultTableModel antes, normalmente. DefaultTableModel lo que hace es
predeterminar ciertas características para el Jtable es decir que tu puedes poner ciertos
parámetros 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
información de la tabla pero estos datos son los visualizados por el computador, es decir, para
visualizar una tabla el DEFAULTTABLEMODEL puede tener la información pero sin el Jtable
no se puede visualizar para el usuario.

EDITABLE O NO?

Jtable tiene una característica 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, Jtable automáticamente hace
editable las celdas dentro de la tabla.

LA INFORMACIÓN, Y LAS COLUMNAS?.

Jtable te brinda muchas facilidades para poder crear una tabla, y así mismo de llenarla con la
información que desees ( números, letras etc...) por lo que sencillamente dentro de una tabla
esta automáticamente esta a través de la información debidamente separada - por ""(comillas)
o por , (coma) - es capaz de contabilizarlas y al mismo tiempo llenarla con la información que
se le dio; es decir el programador solo se debe encargar de poner los títulos de las tablas y así
mismo de escribir la información en el mismo orden en que desee que salga de acuerdo con
los títulos y Jtable se encargara automáticamente de colocar la información donde se le indico.

UN CHECK BOX?

Para un CellRendered con un DefaultTableModel sencillo, tal vez identificar clases pueda ser
algo más complejo que no pueda hacer, pero para uno un poco más avanzado, esto sería muy
fácil, y para esto cito el caso de un CHECK BOX(casilla de verificación) el cual es un
componente grafico generado por Jtable después de que identifica una información tipo
boolean, dándole así la apariencia de un cuadro rellenable, un check box no es más que eso,
una opción - que puede ser editable o no.

UN LIST BOX?

En algunas oportunidades, para cierto tipo de información que deseamos que el usuario
complete, necesitamos darle a el usuario, cierto tipo de opciones cosa que a través de un List
Box tu puedes ofrecer al usuario el tipo de respuestas que tu desees que selecciones, este tipo
de organización de información ya no es tan sencillo como declarar una información tipo
boolean, toca crear la lista.

Técnica de Programación Orientada a Objetos 23


 Creación y enlace de un JTable

Insertar el JTable y definir la clase DefaultTableModel en el public class por


ejemplo:

DefaultTableModel modTbDatos=new DefaultTableModel();

En el método jbInit establecer el enlace del modal y el total de filas y columnas.

jTable1.setModel(modTbDatos);

modTbDatos.setColumnCount(3);

modTbDatos.setRowCount(5);

 Ejemplo 01:
 Crear una Matriz de 5 X 3 y llenar datos numéricos enteros.
 Realizar el procedimiento de creación y enlace del Jtable.

private void btnAgregar_actionPerformed(ActionEvent e) {

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(JOptionPane.showInputDialog("IngresarNumero"));

modTbDatos.setValueAt(numero[y][x],y,x);

Técnica de Programación Orientada a Objetos 24


 Ejemplo 02:
 Mostrar los resultados de las tablas de multiplicar hasta el 10.

Realizar el procedimiento de creación y enlace del Jtable.

private void btnAgregar_actionPerformed(ActionEvent e) {

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 deberán ser
presentados en el JTable por columnas.

private void btnAgregar_actionPerformed(ActionEvent e) {


final int filas=15;

int Edad[]=new int[filas];

String apellidos[]=new String[filas];

for (int i = 0; i < filas; i++){ apellidos[i]=JOptionPane.showInputDialog("Ingresar

Apellidos");

Edad[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresar Edad"));

modTbDatos.setValueAt(apellidos[i],i,0);

Técnica de Programación Orientada a Objetos 25


modTbDatos.setValueAt(Edad[i],i,1);

}
}

Técnica de Programación Orientada a Objetos 26


BALOTARIO DE EJERCICIOS – USANDO VECTORES Y MATRICES

1. Dado un vector de números reales:


a) Escriba un método max que nos devuelva el máximo de los valores incluidos en el
vector.
b) Escriba un método min que nos devuelva el mínimo de los valores incluidos en el
vector.
c) Escriba un método media Aritmética que nos devuelva la media de los valores
incluidos en el vector.
d) Dado un vector de números reales, escriba un método que nos devuelva el máximo
y el mínimo de los valores incluidos en el vector.
e) Dado un vector, implemente un método que inserte un elemento en una posición
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 máximo y el mínimo de los valores del vector.
• Hallar la media aritmética 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 números enteros. El
programa dispone de dos vectores, uno llamado positivos y otro negativo, ambos de 8
posiciones. Se trata de meter los números introducidos en uno u otro según su signo
hasta que se llenen los dos. El programa avisará si se intenta meter un número
(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 números + 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.

Técnica de Programación Orientada a Objetos 27


Contenidos

- Definir Ordenamientos de Datos: Método de Burbuja, Método Shell.


- Definición de Búsqueda: Tipos Búsqueda de Datos dentro de un Arreglo.
- Tipos de Búsquedas: Búsqueda Lineal - Búsqueda Binaria.

Algoritmos de Ordenamiento
Ordenar es simplemente colocar información de una manera especial basándonos en un
criterio de ordenamiento.

 Métodos de ordenamientos.
Existen diferentes métodos de ordenamiento entre ellas tenemos por Selección, Inserción,
Quick Sort, Burbuja, Shell, etc. Dentro de las cuales hablaremos de los métodos:
El hecho de que la información está ordenada, nos sirve para poder encontrarla y accesarla de
manera más eficiente ya que de lo contrario se tendría que hacer de manera secuencial.
A continuación se describirán 4 grupos de algoritmos para ordenar información:

 Algoritmos de inserción:
En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a la
vez. Cada elemento es INSERTADO en la posición 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 están 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 BURBUJA y QUICK SORT.
 Algoritmos de selección:

Técnica de Programación Orientada a Objetos 28


En este tipo de algoritmos se SELECCIONA o se busca el elemento más pequeño (o más
grande) de todo el conjunto de elementos y se coloca en su posición 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 enumeración:
En este tipo de algoritmos cada elemento es comparado contra los demás. En la comparación
se cuenta cuántos elementos son más pequeños que el elemento que se está analizando,
generando así una ENUMERACION. El número generado para cada elemento indicará su
posición.
Los métodos simples son: Inserción (o por inserción directa), selección, burbuja y shell, en
dónde el último es una extensión al método de inserción, siendo más rápido. Los métodos más
complejos son el quick-sort (ordenación rápida) y el heap sort.
A continuación se mostrarán los métodos de ordenamiento más simples.

 Método Burbuja.
El bubble sort, también conocido como ordenamiento burbuja, consiste en comparar un valor
con el siguiente valor y de acuerdo a la condición se realizara el intercambio entre los datos, y
este recorrido se va ir haciendo hasta culminar todos los elementos N-1 del arreglo.

Algoritmo:

Desde(g=0 hasta N-1) // recorrido del vector

Desde (i=0 hasta N-1) //posiciones de comparación

si(vector[i] > vector[i+1])

aux= vector[i]

vector[i]= vector[i+1]

vector[i+1]=aux

fin_si

fin_desde

fin_desde

 Método de Shell.
Nombrado así debido a su inventor Donald Shell. Ordenamiento de disminución incremental,
Ordena subgrupos de elementos separados K unidades (respecto de su posición en el arreglo)
del arreglo original. El valor K es llamado incremento.
Después de que los primeros K subgrupos han sido ordenados (generalmente utilizando
INSERCION DIRECTA), se escoge un nuevo valor de K más pequeño, 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 más pequeño 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 inserción directa.

Técnica de Programación Orientada a Objetos 29


El método se basa en tomar como salto N/2 (siendo N el número de elementos) y luego se va
reduciendo a la mitad en cada repetición hasta que el salto o distancia vale 1.

Procedimiento Shell Sort;

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

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

Técnica de Programación Orientada a Objetos 30


 Ejemplos en código JAVA:

. 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;
}
}
}
}

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;
}
}

Técnica de Programación Orientada a Objetos 31


Búsqueda
Un algoritmo de búsqueda es aquel que está diseñado 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
cuestión pertenece o no a dicho conjunto, además de su localización dentro de éste.
Este problema puede reducirse a devolver la existencia de un número en un vector.

 Búsqueda secuencial
Permite localizar el dato dentro del arreglo desde la posición inicial hasta la posición 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).

Datos de Entrada:
vec: nombre de la colección de todos los datos
tam: tamaño 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

 Búsqueda 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 búsqueda
considerablemente, ya que disminuye exponencialmente con el número de iteraciones.

Técnica de Programación Orientada a Objetos 32


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 Aplicación donde permita llenar datos a los vectores Nombres, Apellidos Año de
Nacimiento y edad. Permitirá hasta 20 registros.
• La edad se calcula de acuerdo al Año de Nacimiento
• El programa permitirá :
o Ordenar por Apellido
o Buscar Datos por Nombres y decir cuántos Nombres son iguales.

public class FrmEjem01 extends JFrame { Se define la dimensión y


final int filas=20; los nombres de los
String nom[]=new String[filas]; Arreglos
String ape[]=new String[filas];
int edad[]=new int[filas];
int anac[]=new int[filas];

Técnica de Programación Orientada a Objetos 33


int Reg;
Se define el Contador
del Registro

private void jbInit() throws Exception {


------------------------------------------------------
//llenando el combo con las fechas
for(int g=1970;g<=2010;++g) Se Establece valores
cboAnac.addItem(g); al Combo

void LeerDatos(){
Preguntando si el Registro es
if(Reg<filas){
nom[Reg]=txtNom.getText(); menor al total de Filas.
ape[Reg]=txtApe.getText(); Llena los datos a los Arreglos
}
else
JOptionPane.showMessageDialog(null,"Ya no puede ingresar mas registros");

}
Muestra los datos que tiene el
void llenarRegistros(){
modTbDatos.setValueAt((Reg+1),Reg,0); Arreglo
modTbDatos.setValueAt(nom[Reg],Reg,1);
modTbDatos.setValueAt(ape[Reg],Reg,2);
modTbDatos.setValueAt(anac[Reg],Reg,3); Incremento el Registro para
modTbDatos.setValueAt(edad[Reg],Reg,4); controlar el total de datos
++Reg; ingresados.
}
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]; Calcula la edad según el año
lbledad.setText(""+edad[Reg]); seleccionado.

}
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) {
Ordenamiento Burbuja.
tempA = ape[j];
ape[j] = ape[j+1]; Por medio del Apellido
ape[j+1] = tempA;

Técnica de Programación Orientada a Objetos 34


//
tempN = nom[j];
nom[j] = nom[j+1];
nom[j+1] = tempN;
El resto de los vectores tambien
// deben de realizar solo el
tempAn = anac[j]; intercambio para seguir el orden .
anac[j] = anac[j+1];
anac[j+1] = tempAn;

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

// visualizar datos ordenados Establecer el total de filas


modTbDatos.setRowCount(15); según al total de registros.
for(int g=0;g<Reg;++g){
modTbDatos.setValueAt((g+1),g,0); Mostrar los Datos Ordenados.
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) {
modTbDatos.setRowCount(0);
OrdenarB(); Eliminar todos las filas de la
} tabla.

Llamar al Ordenamiento y
volver a mostrar los datos. Y
se Visualizara en la tabla
ordenado por Apellido.

Técnica de Programación Orientada a Objetos 35


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=JOptionPane.showInputDialog("Ingresar Nombres a Buscar");
while(f<Reg){
if(Vb.equalsIgnoreCase(nom[f])){
c=c+1;
}
++f;
}
if(c>0)
JOptionPane.showMessageDialog(null,"Nombre Encontrado"+"\n"+"y se Repite
:"+(c)+"Veces");
else
JOptionPane.showMessageDialog(null,"No se Encontrado el Nombre");
}

Técnica de Programación Orientada a Objetos 36


private void btnBusqueda_actionPerformed(ActionEvent e) {
busqueda_Nom();
}

Insertar el Botón Eliminar Registro Intenta estableciendo el siguiente código

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;
}

Técnica de Programación Orientada a Objetos 37


Contenidos

- Introducción a la programación Orientada a Objetos POO.


- Caracteristicas de la programación orientada a objetos.
- Definición de Clases
- Constructores, Estructura de una clase
- Nivel de acceso(public, private, protected)
- Uso de atributo static.
- Interfaces, definición.
- Paquete, distribución, mencionar la razón de trabajar en capas, manejo de capas
(Lógica y Presentación )
- Encapsulación (get y set de los atributos)
- Herencia: extends, Polimorfismo
- Sobrecarga de Métodos

Programación Orientada a Objetos

Es un paradigma de programación que usa objetos y sus interacciones, para diseñar


aplicaciones y programas de ordenador. Está basado en varias técnicas, incluyendo herencia,
modularidad, polimorfismo y encapsulamiento. Su uso se popularizó a principios de la década
de 1990. En la actualidad, existe variedad de lenguajes de programación que soportan la
orientación 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 (método) e identidad:

 El estado está compuesto de datos, será uno o varios atributos a los que se habrán
asignado unos valores concretos (datos).
 El comportamiento está definido por los procedimientos o métodos 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 análogo al de identificador de una variable o
una constante).

Técnica de Programación Orientada a Objetos 38


La programación 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 módulos
más fáciles de escribir, mantener, y reutilizar.

Un objeto contiene toda la información 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
interacción llamados métodos, que favorecen la comunicación entre ellos. Esta comunicación
favorece a su vez el cambio de estado en los propios objetos. Esta característica lleva a
tratarlos como unidades indivisibles, en las que no se separa el estado y el comportamiento.

Los métodos (comportamiento) y atributos (estado) están estrechamente relacionados por la


propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos 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 podría producir el
hábito erróneo de crear clases contenedoras de información por un lado y clases con métodos
que manejen a las primeras por el otro. De esta manera se estaría realizando una
programación estructurada camuflada en un lenguaje de programación orientado a objetos.

La POO difiere de la programación estructurada tradicional, en la que los datos y los


procedimientos están separados y sin relación, ya que lo único que se busca es el
procesamiento de unos datos de entrada para obtener otros de salida. La programación
estructurada anima al programador a pensar sobre todo en términos de procedimientos o
funciones, y en segundo lugar en las estructuras de datos que esos procedimientos manejan.
En la programación estructurada sólo se escriben funciones que procesan datos. Los
programadores que emplean POO, en cambio, primero definen objetos para luego enviarles
mensajes solicitándoles que realicen sus métodos por sí mismos.

 Características de la POO

Existe un acuerdo acerca de qué características contempla la "orientación a objetos", las


características siguientes son las más importantes:

 Abstracción: Denota las características 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 cómo se implementan estas características.
Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo
están, una variedad de técnicas son requeridas para ampliar una abstracción.

 Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse


pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite
aumentar la cohesión de los componentes del sistema. Algunos autores confunden
este concepto con el principio de ocultación, principalmente porque se suelen emplear
conjuntamente.

 Principio de ocultación: Cada objeto está aislado del exterior, es un módulo


natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo
pueden interactuar con los objetos de la clase. El aislamiento protege a las
propiedades de un objeto contra su modificación por quien no tenga derecho a acceder
a ellas, solamente los propios métodos 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 abstracción. La aplicación
entera se reduce a un agregado o rompecabezas de objetos.

Técnica de Programación Orientada a Objetos 39


 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 invocación
de un comportamiento en una referencia producirá el comportamiento correcto para el
tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecución", esta
última característica se llama asignación tardía o asignación dinámica. Algunos
lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de
polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.

 Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una
jerarquía de clasificación. 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 común. Cuando un objeto hereda de más de una clase se
dice que hay herencia múltiple.

 Recolección de basura: la Recolección de basura o Garbage Collector es la técnica


por la cual el ambiente de Objetos se encarga de destruir automáticamente, 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 asignación o
liberación de memoria, ya que el entorno la asignará al crear un nuevo Objeto y la
liberará cuando nadie lo esté usando. En la mayoría de los lenguajes híbridos que se
extendieron para soportar el Paradigma de Programación Orientada a Objetos como
C++ u Object Pascal, esta característica no existe y la memoria debe desasignarse
manualmente.

 Clases en POO
Las clases son declaraciones de objetos, también se podrían definir como abstracciones de
objetos(quiere decir que la definición de un objeto es la clase). Cuando programamos un objeto
y definimos sus características y funcionalidades en realidad lo que estamos haciendo es
programar una clase.

 Propiedades en clases
Las propiedades o atributos son las características 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.

 Métodos en las clases


Son las funcionalidades asociadas a los objetos. Cuando estamos programando las clases las
llamamos métodos. Los métodos son como funciones que están 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 acción de crear un objeto a partir de
una clase se llama instanciar (que viene de una mala traducción de la palabra instace que en
inglés significa ejemplar). Por ejemplo, un objeto de la clase fracción es por ejemplo 3/5. El
concepto o definición de fracción sería la clase, pero cuando ya estamos hablando de una
fracción en concreto 4/7, 8/1000 o cualquier otra, la llamamos objeto.
Para crear un objeto se tiene que escribir una instrucción especial que puede ser distinta
dependiendo el lenguaje de programación que se emplee, pero será algo parecido a esto.
miCoche = new Coche()

Técnica de Programación Orientada a Objetos 40


Con la palabra new especificamos que se tiene que crear una instancia de la clase que sigue a
continuación. Dentro de los paréntesis podríamos colocar parámetros 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 asignación.

 Mensajes en objetos
Un mensaje en un objeto es la acción de efectuar una llamada a un método. Por ejemplo,
cuando le decimos a un objeto coche que se ponga en marcha estamos pasándole el mensaje
“ponte en marcha”.
Para mandar mensajes a los objetos utilizamos el operador punto, seguido del método que
deseamos invocar.
miCoche.ponerseEnMarcha()
En este ejemplo pasamos el mensaje ponerseEnMarcha(). Hay que colocar paréntesis igual
que cualquier llamada a una función, dentro irían los parámetros.

 Otras cosas
Hay mucho todavía que conocer de la POO ya que sólo hemos hecho referencia a las cosas
más básicas. También existen mecanismos como la herencia y el polimorfismo que son unas
de las posibilidades más potentes de la POO.
La herencia sirve para crear objetos que incorporen propiedades y métodos 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 código que sea compatible con objetos de varios
tipos.
Son conceptos avanzados que cuesta explicar en las líneas 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 tengáis que poneros delante de ellas en los
lenguajes de programación que debe conocer un desarrollador del web.

Técnica de Programación Orientada a Objetos 41


 Creación de Clases en JAVA
Crear la aplicación con su proyecto, luego elegir crea la Class y saldrá esta ventana.

 Para crear una sub clase (hija), deberá de seleccionar


la opción public estarás. Y su estructura quedaría así.

public class SubClaseHija1 {

//Cuerpo de la Clase Hija

 Para crear una clase main (principal), deberá de seleccionar la opción public y generate
Main Method. Y su estructura quedaría así.

public class ClassEjecutar {

//Atributos Globales

//Metdos

public static void main(String[] args) {

//referencia de la clase

ClassEjecutar Ejecutar = new ClassEjecutar();

//atributos Locales

 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);
}
}

Técnica de Programación Orientada a Objetos 42


Usando consola

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

public class ClassEjecutar2 {


public static void main(String[] args) {
//referencia de la clase
ClassEjecutar2 Ejecutar = new ClassEjecutar2();
String nombres=JOptionPane.showInputDialog("Ingresar Nombre");
String ape=JOptionPane.showInputDialog("Ingresar Apellido");
String espe=JOptionPane.showInputDialog("Ingresar Especialidad");
JOptionPane.showMessageDialog(null,"Nombres: "+nombres+"\n"+"Apellidos:"+ape
+"\n" +"Especialidad: "+espe,"Datos Personales",1);
}
}

Usando Message

 Ejemplo 03: ingresar 2 números y mostrar las 4 operaciones básicas.

public class ClassEjecutar3 {


public static void main(String[] args) {
int num1, num2, sum,res,mul; double divi;
num1=Integer.parseInt(JOptionPane.showInputDialog("Ingrece el #1"));
num2=Integer.parseInt(JOptionPane.showInputDialog("Ingrece el #2"));
sum=num1+num2;
res=num1-num2;
mul=num1*num2;
divi=num1/num2;
JOptionPane.showMessageDialog(null,"La suma de\t"+num1+"+"+num2+"="+
sum,"Operación de Suma",2);
JOptionPane.showMessageDialog(null,"La resta de\t"+num1+"-"+num2+"="+
res,"Operación de Resta",2);
JOptionPane.showMessageDialog(null,"La multiplicacion de\t"+num1+"*"+num2+"="+
mul,"Operación de Multiplicación",2);
JOptionPane.showMessageDialog(null,"La División de\t"+num1+"/"+num2+"="+

Técnica de Programación Orientada a Objetos 43


divi,"Operación de División",2);

}
}

 Aplicando Herencia entre Clases

 Ejemplo 01: ingresar 2 números y mostrar las 4 operaciones básicas usando


herencia.

public class SubClaseHija1 {


//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
public static void main(String[] args) {
//referencia de la clase
ClassEjecutar Ejecutar = new ClassEjecutar();
//atributos Locales
int num1, num2;

num1=Integer.parseInt(JOptionPane.showInputDialog("Ingrece el #1"));
num2=Integer.parseInt(JOptionPane.showInputDialog("Ingrece el #2"));
JOptionPane.showMessageDialog(null,"La suma de\t"+num1+"+"+num2+"="+
Ejecutar.Suma(num1,num2),"Operacion de Suma",2);

Técnica de Programación Orientada a Objetos 44


JOptionPane.showMessageDialog(null,"La resta de\t"+num1+"-"+num2+"="+
Ejecutar.Resta(num1,num2),"Operacion de Resta",2);
JOptionPane.showMessageDialog(null,"La multiplicacion de\t"+num1+"*"+num2+"="+
Ejecutar.Multiplica(num1,num2),"Operacion de Multiplicación",2);
JOptionPane.showMessageDialog(null,"La División de\t"+num1+"/"+num2+"="+
Ejecutar.divi(num1,num2),"Operacion de División",2);

}
}

 Usando Referencias

public class SubClaseHija1 {


//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
public static void main(String[] args) {
//referencia del Frame
FrmOperaciones llamar=new FrmOperaciones();
llamar.setVisible(true);
//atributos Locales

}
}

//Diseño 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());

Técnica de Programación Orientada a Objetos 45


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 División de\t"+num1+"/"+num2+"="+Ejecutar.divi(num1,num2)+"\n");

}
}

Técnica de Programación Orientada a Objetos 46


 Los constructores
Un objeto de una clase se crea llamando a una función especial denominada constructor de la
clase. El constructor se llama de forma automática 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 específico 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=JOptionPane.showInputDialog("Ingresar Especialidad");

int costo=Integer.parseInt(JOptionPane.showInputDialog("Ingresar Costo"));

ClassConstructor Alum2 = new ClassConstructor(espe);

ClassConstructor Alum3 = new ClassConstructor(costo,espe);

Técnica de Programación Orientada a Objetos 47


 Calificadores: Public, Private, Protected, Static y Final.
El uso de calificadores de acceso en Java tiene sus bases en el uso de librerías
("packages"), al ser diseñado un programa existen diversas funciones/métodos y variables
dentro de éste, algunas de estas requerirán ser modificadas conforme incrementen las
necesidades del programa, mientras otras permanecerán inmóviles, 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 diseño 300 clases que están siendo re-utilizadas por otros programas, sin
embargo, se le ha solicitado una modificación radical a estos objetos base, cuales
métodos/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, además de los calificadores de acceso que permiten restringir el uso de
métodos/campos a determinadas situaciones, también existen otros calificadores que
afectan directamente la creación y uso de instancias por clase estos calificadores son static
yfinal.

 public : Acceso libre .


El uso del calificador public significa que toda definición será accesible de cualquier punto,
ya sea un método, campo o clase. Su uso implica un acceso global, desde luego el uso de
este calificativo en Clases que serán 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 cuestión, si se intenta accesar cualquier elemento de este tipo dentro de otra
Clase será generado un error de compilación.

El calificador private suele utilizarse en Clases que serán 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 sección, 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/métodos definidos como
protected en padre, pero no aquellos declarados como private en padre.

Técnica de Programación Orientada a Objetos 48


 Ningún Calificador : Clase en Librería 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/método carente de calificador será accesible dentro de todas Clases pertenecientes
a su misma librería("package").

 static : Una sola instancia .


El uso del vocablo static ha venido siendo utilizado en los métodos 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 número de instancias generadas o bien
invocar/llamar métodos 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 descripción anterior esta trivializada, sin embargo, conforme se
avance en el presente curso serán ilustrados otros ejemplos con este mecanismo.

La segunda situación para el uso de static puede ser ejemplificada perfectamente a través
del método main Java, el método main puede ser llamado automáticamente al invocarse la
respectiva Clase debido a que no se encuentra asociado con ningún tipo de instancia, esto
implica que su comportamiento siempre será el mismo independientemente de la instancia
que realza su llamada.

Dos aspectos característicos de utilizar el calificador static en un elemento Java 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 teoría del concepto static puede ser un poco difícil de digerir, sin embargo, como fue
mencionado anteriormente, conforme avance el curso serán descritos diversos fragmentos
de código para dejar en claro su uso.

Técnica de Programación Orientada a Objetos 49


 final : Una sola instancia y definitiva.
El calificador final estrechamente relacionado con el uso de static implica una asignación
ú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 definición única y como su nombre lo
implica final.

Generalmente final es utilizado en aquellos elementos que no serán modificados al


momento de ejecutarse ("Run-Time") un programa o clase , a través de final se asigna un
valor que no podrá ser modificado bajo ninguna circunstancia al momento de ejecución
("Run-Time), en efecto logrando un nivel de eficiencia en ejecución.

De igual manera que la utilización 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 código externo a la clase debe llamar a propiedades estáticas utilizando el nombre
de la clase en lugar de un nombre de instancia. Las subclases no heredan las propiedades
estáticas, 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 método estático
sin hacer referencia a la clase en la que se definió.

Técnica de Programación Orientada a Objetos 50


 Interfaces
El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En Java
una interface es una clase abstracta pura, es decir una clase donde todos los métodos son
abstractos (no se implementa ninguno). Permite al diseñador de clases establecer la forma de
una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de
código). Una interface puede también 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 métodos que declara una interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave
implements. El compilador se encargará de verificar que la clase efectivamente declare e
implemente todos los métodos de la interface. Una clase puede implementar más de una
interface.

Declaración 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 métodos y escribiendo el


código correspondiente. Una clase derivada puede también redefinir si es necesario alguno de
los métodos de la interface.

Técnica de Programación Orientada a Objetos 51


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

Extensión de interfaces

Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface
puede extender más de una interface. La sintaxis es:

interface nombre_interface extends nombre_interface , . . . {


tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}

Agrupaciones de constantes

Dado que, por definición, 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

Técnica de Programación Orientada a Objetos 52


 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 número 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) JBuilder de Borland, un proyecto nuevo se crea en


un subdirectorio que tiene el nombre del proyecto. A continuación, se crea la aplicación, un
archivo .java que contiene el código 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 código 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 públicas 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 más económica en código, si


tenemos que crear varias fuentes de texto.

Se pueden combinar ambas formas, por ejemplo, en la definición 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

Técnica de Programación Orientada a Objetos 53


Los paquetes estándar
Paquete Descripción

Contiene las clases necesarias para crear applets que se ejecutan en


java.applet
la ventana del navegador

Contiene clases para crear una aplicación GUI independiente de la


java.awt
plataforma

java.io Entrada/Salida. Clases que definen distintos flujos de datos

Contiene clases esenciales, se importa impícitamente sin necesidad de


java.lang
una sentencia import.

Se usa en combinación con las clases del paquete java.io para leer y
java.net
escribir datos en la red.

java.util Contiene otras clases útiles que ayudan al programador

Herencia
La herencia es uno de los conceptos más cruciales en la POO. La herencia básicamente
consiste en que una clase puede heredar sus variables y métodos a varias subclases (la clase
que hereda es llamada superclase o clase padre). Esto significa que una subclase, aparte de
los atributos y métodos propios, tiene incorporados los atributos y métodos heredados de la
superclase. De esta manera se crea una jerarquía de herencia.

Por ejemplo, imaginemos que estamos haciendo el análisis de un Sistema para una tienda que
vende y repara equipos celulares.

Técnica de Programación Orientada a Objetos 54


En el gráfico vemos 2 Clases más que posiblemente necesitemos para crear nuestro Sistema.
Esas 2 Clases nuevas se construirán a partir de la Clase Celular existente. De esa forma
utilizamos el comportamiento de la SuperClase.

En general, podemos tener una gran jerarquía de Clases tal y como vemos en el siguiente
gráfico:

 ENCAPSULAMIENTO

El encapsulamiento es la característica de autonomía de la OO. Esta característica permite


generar componentes autónomos de software tomando una parte de funcionalidad y ocultando
los detalles de la implementación al mundo exterior.
Los términos módulo, componente o bean se suelen utilizan en lugar de “componente
encapsulado de software”.
Una vez encapsulada, una entidad de software se puede visualizar como una caja negra.

Técnica de Programación Orientada a Objetos 55


 Sobrecarga
En programación orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos o
más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más
funciones con el mismo nombre realizan acciones diferentes. El compilador usará una u otra
dependiendo de los parámetros usados. A esto se llama también sobrecarga de funciones.

También existe la sobrecarga de operadores que al igual que con la sobrecarga de funciones
se le da más de una implementación a un operador.

Sobrecarga es la capacidad de un lenguaje de programación, que permite nombrar con el


mismo identificador diferentes variables u operaciones

El mismo método dentro de una clase permite hacer cosas distintas en función de los
parámetros

Java 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 Métodos y de Constructores


La firma de un método es la combinación del tipo de dato que regresa, su nombre y su lista de
argumentos.

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero con
diferentes firmas y definiciones. Java utiliza el número y tipo de argumentos para seleccionar
cuál definición de método ejecutar.

Java diferencia los métodos sobrecargados con base en el número y tipo de argumentos que
tiene el método y no por el tipo que devuelve.

También existe la sobrecarga de constructores: Cuando en una clase existen constructores


múltiples, se dice que hay sobrecarga de constructores.

Algunos métodos en una clase pueden tener el mismo nombre. Estos métodos deben contar
con diferentes argumentos. El compilador decide qué método invocar comparando los
argumentos. Se generara un error si los métodos sólo varían en el tipo de retorno.

Técnica de Programación Orientada a Objetos 56


Ejemplos

 Caso 01
Crear una sobrecarga que permita sumar 2 números 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 métodos donde permita hallar el sueldo, descuento y el neto.
El sueldo dependerá del costo y cantidad de horas
El descuento según el estado de Honorarios o Planilla
Neto según 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 {

Técnica de Programación Orientada a Objetos 57


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();

private void btnAceptar_actionPerformed(ActionEvent e) {


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");
}

Técnica de Programación Orientada a Objetos 58


 Caso 03
Crear una sobrecarga de métodos 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 según 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
public class ClassEncapsular {
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;

Técnica de Programación Orientada a Objetos 59


}
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 jbInit() throws Exception {


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

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{
public static void main(String[] args) {

FrmVentana ven=new FrmVentana();


ven.setVisible(true);
}

Técnica de Programación Orientada a Objetos 60


}

 Caso 04
Crear una sobrecarga de métodos donde permita hallar el precio, total, igv y el neto.
Según el articulo saldrá el precio. El total será deacuerdo a la cantidad y precio y el neto será
deacuero al total y a la selección del Igv.

// Clase encapsulada
package pckLogico;

public class ClassEncapsular {


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

public int getPrecio() {

Técnica de Programación Orientada a Objetos 61


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

Técnica de Programación Orientada a Objetos 62


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
public class FrmDatos extends JFrame {
ClassEncapsular atributo = new ClassEncapsular();
ClassSobreCarga metodos = new ClassSobreCarga();
String Titulos[]={"registro","articulo","precio","cantidad","total"};
String valores[][]={};
int c=1;
*************
***************
private void jbInit() throws Exception {
*********************
*********************
*********************
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());
}

private void btnAgregar_actionPerformed(ActionEvent e) {


atributo.setCantidad(Integer.parseInt(txtCantidad.getText()));
atributo.setPrecio(atributo.getPrecio());
atributo.setTotal(metodos.Calcular(atributo.getCantidad(),atributo.getPrecio()));
lblTotal.setText(""+atributo.getTotal());

Técnica de Programación Orientada a Objetos 63


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("");

}
}

Técnica de Programación Orientada a Objetos 64


Contenidos

- Manejo de Paneles(JPanel)
- 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
rápidamente un amontonamiento de controles o componentes en la propia forma.
Es más conveniente usar componentes de agrupamiento visuales que faciliten la separación
física y lógica de las diversas partes que componen un programa o aplicación.
Estos controles de agrupamiento son conocidos como paneles, aunque en visual basic se
conocen como frames (no confundirlos con frame de java).
Java tiene los siguientes tipos de paneles, PANEL, SPLITPANE, SCROLLPANE,
TABBEDPANE, TOOLBAR.
Recordar además 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 Java Desktop System en la que se pueden ejecutar aplicaciones y


realizar otras tareas.

La clase Panel es el más simple de los Contenedores de Componentes gráficos. En realidad,


se trataba de crear una clase no-abstracta (Container sí lo es) que sirviera de base a los
applet y a otras pequeñas aplicaciones. La clase Panel consta de dos métodos propios: el
constructor, cuyo fin es crear un nuevo Panel con un LayoutManager de tipo FlowLayout (el de
defecto), y el método addNotify() que, sobrecargando la función del mismo nombre en la clase
Container, llama al método 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 arquitectónico del AWT; se trata
del bien conocido esquema de separación interface/implementación que establece por un lado

Técnica de Programación Orientada a Objetos 65


una clase de interface y por otras distintas clases de implementación para cada una de las
plataformas elegidas.

Técnica de Programación Orientada a Objetos 66


 GregorianCalendar
Según la documentación 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 (año), MONTH (mes), DAY (día), HOUR (hora), etc.

Una subclase de Calendar representa una fecha de acuerdo a las reglas de un calendario
específico. La plataforma provee una subclase concreta de Calendar: GregorianCalendar.
Futuras subclases podrían representar varios tipos de calendarios lunares usados en diferentes
lugares del mundo.

La clase Calendar tiene mucho del comportamiento que esperaríamos de la clase


java.util.Date, es decir, cuando obtenemos una instancia de la clase Calendar obtenemos un
instante de tiempo específico con gran precisión 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 métodos que permiten obtener el año, mes y día,
pero estos métodos están obsoletos precisamente por que para eso existe Calendar y de
hecho cuando usamos el método getYear() de la clase java.util.Date esta recurre a las
funcionalidades que posee la clase Calendar.

Hay que mencionar también que obtener un instante de tiempo específico y diferente del actual
es supremamente sencillo con esta clase, indicándole simplemente el día, mes y año con que
se desea trabajar, o se puede especificar aún más dando hora, minuto y segundo deseado.
Veamos:
El método getInstance() de la clase nos devuelve una subclase de Calendar con el tiempo
ajustado a la hora actual, y usamos el método 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 método 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 más importantes son (al lado los valores que representan):

 YEAR: Año.
 MONTH: Mes.
 DATE, DAY_OF_MONTH: Día del mes.
 DAY_OF_WEEK: Día de la semana entre 1 (MONDAY) y 7 (SATURDAY).
 HOUR: Hora antes o después del medio día (en intervalos de 12 horas).
 HOUR_OF_DAY: Lo hora absoluta del día (en intervalos de 24 horas).
 MINUTE: El minuto dentro de la hora.
 SECOND: El segundo dentro del minuto.

Están también los atributos que representan los meses, como: JANUARY, MARCH, JUNE,
DECEMBER, etc. que van desde 0 (JANUARY) hasta 11 (DECEMBER).

Técnica de Programación Orientada a Objetos 67


También hay atributos que representan los días: SUNDAY, TUESDAY, SATURDAY, etc. estos
empiezan con 1 (SUNDAY) y van hasta 7 (SATURDAY).

Hay más atributos pero con estos es suficiente para los objetivos de este artículo, si deseas
conocerlos todos recurre a la documentación del lenguaje.

Para extraer algún atributo se usa el método get pasándole como parámetro alguna de las
constantes que vimos anteriormente y el método devuelve siempre un dato de tipo int; así para
obtener el año, mes, día y hora, usaríamos el siguiente código:

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.JUNE){
System.out.println("ES JUNIO");
}else{
System.out.println("NO ES JUNIO");
}

Si el objeto tiene la fecha equivalente a 5:30 p.m. del 22 de junio de 2004 se ve la siguiente
salida:

AÑO:2010
MES:Mayo
DIA:02
HORA:5
ES JUNIO

Modificar Un Atributo

Modificar un atributo de Calendar es tan sencillo como obtenerlo, solamente es necesario usar
el método 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.JANUARY) o ahoraCal.set(Calendar.YEAR, 1980)
ajustarían la fecha almacenada en el objeto ahoraCal a enero o al año 1980 sin modificar
ninguno de los otros atributos.

Aclaremos esto con un ejemplo. Mi cumpleaños es en octubre 27 :-), y deseo saber qué día 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 día, 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); //Día 4 = WEDNESDAY = MIÉRCOLES

La salida es: 4, lo que quiere decir que en el 2010 el 27 de octubre será un día miércoles (así
que probablemente lo celebre el viernes 29 :-));

Técnica de Programación Orientada a Objetos 68


Clase GregorianCalendar y operaciones

Realizar operaciones como sumar o restar días no es algo que dependa directamente de
Calendar sino más bien de una subclase de esta que implemente algún tipo de calendario
usado, pues no todos los calendarios tienen 12 meses ni años de 365 días 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 países, por ejemplo 1752 en Gran Bretaña y 1918 en Rusia.

A grandes rasgos sabemos que el calendario gregoriano consta de años que son definidos por
cada traslación (vuelta de la tierra alrededor del sol), cada año tiene doce meses de los cuales
7 tienen 31 días, 4 tienen 30 días y 1 tiene 28 días excepto en años bisiestos que tiene 29.
Estos años bisiestos se implantaron para corregir el desfase que tenemos cada cuatro años (un
año real dura 365 días y 6 horas aproximadamente), regla completa para los años bisiestos
según el calendario gregoriano es la siguiente:

"Un año 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 implementación directa del calendario


gregoriano (de hecho es la única implementación de un calendario en jdk1.4) tal y como lo
conocemos hoy día. Es con esta clase con la que podemos sumar 2 ó 3 días a una fecha sin
preocuparnos por desbordamientos o recalcular meses o años, pues ella lo hace
automáticamente tomando en cuenta las reglas en los párrafos anteriores.
De igual forma podemos obtener información como el día de la semana o la semana del año
que fue una fecha determinada.

Los métodos roll() y add()

Anteriormente vimos los métodos set() y get() de la clase Calendar para obtener fechas y los
datos de esas fechas, ahora veremos los métodos add() y roll() que nos permiten avanzar un
tiempo exacto sobre los datos obtenidos anteriormente.

El método 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 sección anterior (MONTH, YEAR, SECOND, etc).

Por ejemplo agreguemos 3 días 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 años y 50 días (Prúebalo en tu PC):

Calendar hoy = Calendar.getInstance();

Técnica de Programación Orientada a Objetos 69


hoy.add(Calendar.YEAR, -5);
hoy.add(Calendar.DATE, -50);
System.out.println(hoy.getTime());

Técnica de Programación Orientada a Objetos 70


 Clase String
Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y
StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante que
no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una
cadena cuyo tamaño puede variar.

Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de
las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven
valores String.

Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo
cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para
leer ficheros que están escritos desde otro lenguaje.

 MÉTODOS PRINCIPALES:

Para poder aplicar estos métodos es necesario crear un objeto String. Además de estos
métodos, 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
carácter de la String.

Ejemplo:

String s=”SISE tiene 27 años…..!”;


int longitud=str.length();

 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 método, 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 búsqueda no
existe o la String no aparece, devuelve -1. MUY USADO.

Ejemplo:
String s=”Sebastian Aquino”;
Cad=s.indexOf(“t”,s.length());

 int indexOf(char ch): devuelve el índice en el que aparece por primera vez el
carácter que se le pasa al argumento. Si no se encuentra el carácter devuelve -
1. Se observa que el nombre de este método es igual al anterior aunque su
número de argumentos es distinto además de su tipo. A esto, en Java, se le
llama sobrecarga de métodos: mismo nombre pero distinto nº de

Técnica de Programación Orientada a Objetos 71


argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para
comprobar que hay más con este mismo nombre. Este concepto se tratará más
en profundidad en temas posteriores.

String s=”Laboratorios SIse ”;


Cad=s.indexOf(‘S’);

 String replace (char viejoChar, char nuevoChar): cambia el carácter


asociado al primer argumento por el que se le pasa al segundo, de la String
sobre la que se aplica el método generando una nueva. La String sobre la que
se aplica el método no cambia, simplemente se crea otra nueva en base a la
String sobre la que se aplica el método.

Ejemplo:
String s1=”Angie”;
Cad=s.replace(‘e’,’E’);

String toLowerCase(): devuelve una nueva String convirtiendo todos los caracteres
de la String sobre la que se aplica el método, en minúsculas.

String s=”SEBASTIAN”;
JOptionPane.showMessageDialog(null,s.toLowerCase());

String toUpperCase(): devuelve una nueva String convirtiendo todos los caracteres
de la String sobre la que se aplica el método, en mayúsculas.

String s=”william”;
JOptionPane.showMessageDialog(null,s.toUpperCase());

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 mayúsculas. 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.

Técnica de Programación Orientada a Objetos 72


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 s=” Hola William ”;
//primero visualicemos la longitud Int
l=s.length();
JOptionPane.showMessageDialog(null,I)
//quitemos el espacio en blanco
Cad=s.trim();
//vuelve a mostrar la longitud Int
l=s.length();
JOptionPane.showMessageDialog(null,I)

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:

String s=”Docentes de Programacion”;


Cad=s.substring(4,9);

char charAt (int indice): devuelve el carácter asociado al índice que se le pasa como
argumento de la String sobre la que se aplica el método. Si el índice no existe se lanza
una StringIndexOutOfBoundsException que hereda de IndexOutOfBoundsException.
MUY USADO.

Técnica de Programación Orientada a Objetos 73


Contenidos

- Clase String: Definición 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.

Definición de ARCHIVOS.
Los archivos también denominados ficheros (file); es una colección de información (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.

 Introducción a los archivos.

Los archivos como colección 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 dinámico y por
esto en un registro se deben especificar los campos, él número de elementos de un arrays (o
arreglo), el número de caracteres en una cadena; por esto se denotan como "Estructuras
Estáticas".
En los archivos no se requiere de un tamaño predeterminado; esto significa que se pueden
hacer archivos de datos más grandes o pequeños, según se necesiten.
Cada archivo es referenciado por su identificador (su nombre).

Técnica de Programación Orientada a Objetos 74


 Características de los Archivos
Independencia de las informaciones respecto de los programas
La información almacenada es permanente

Un archivo puede ser accedido por distintos programas en distintos momentos


Gran capacidad de almacenamiento.

 Clasificación de los Archivos


Los archivos se clasifican según su uso en tres grupos:

• Permanentes o Maestros:
• Estos contienen información que varia poco. En algunos casos es preciso
actualizarlos periódicamente.
• 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 duración de la ejecución 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 según su
función.

 Según su función.
Se define por:

a.- Archivos Permanentes: Son aquellos cuyos registros sufren pocas o ninguna variación a
lo largo del tiempo, se dividen en:
Constantes: Están formados por registros que contienen campos fijos y campos de baja
frecuencia de variación en el tiempo.
De Situación: Son los que en cada momento contienen información actualizada.

Históricos: Contienen información acumulada a lo largo del tiempo de archivos que han
sufridos procesos de actualización o bien acumulan datos de variación periódica en el tiempo.
b.- Archivos de Movimiento: Son aquellos que se utilizan conjuntamente con los maestros
(constantes), y contienen algún campo común 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 ejecución del programa y borrados habitualmente al terminar el mismo.

 Según sus elementos.


Archivo de Entrada: Una colección de datos localizados en un dispositivo de entrada.
Archivo de Salida: Una colección de información visualizada por la computadora.
Constantes: están formados por registros que contienen campos fijos y campos de baja
frecuencia de variación en el tiempo.
De Situación: son los que en cada momento contienen información actualizada.

Técnica de Programación Orientada a Objetos 75


Históricos: Contienen información acumulada a lo largo del tiempo de archivos que han sufrido
procesos de actualización, o bien acumulan datos de variación periódica en el tiempo.
 Archivos de Movimiento o Transacciones: Son aquellos que se utilizan
conjuntamente con los maestros (constantes), y contienen algún campo común 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
ejecución del programa y borrados habitualmente al terminar el mismo.

 Acceso a los Archivos


Se refiere al método utilizado para acceder a los registros de un archivo prescindiendo de su
organización. 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 dirección
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 dirección relativa de cada registro, y
posterior acceso directo al registro.
Dinámico; es cuando se accede a los archivos en cualquier de los modos anteriormente
citados.
La elección del método 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 exploración
secuencial comenzando desde el primer momento (Pascal permite este acceso)
Secuenciales: archivo de texto que debe ser leído del principio hasta el final.
Acceso Directo. Permite procesar o acceder a un elemento determinado y referencia
directamente por su posición 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 técnicas 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:


Creación. Escritura de todos sus registros.
Consulta. Lectura de todos sus registros.
Actualización. Inserción supresión o modificación de algunos de sus registros

Técnica de Programación Orientada a Objetos 76


Clasificación. Reubicación de los registros de tal forma que queden ordenados según
determinados criterios.
Borrado. Eliminando total del archivo, dejando libre el espacio del soporte que ocupaba.

Excepciones

Excepcion es, o sencillamente problemas. En la programación siempre se producen errores,


más 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 técnica
básica consiste en colocar las instrucciones que podrían provocar problemas dentro de un
bloque try, y colocar a continuación uno o más 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 específico. El bloque catch contendrá el codigo necesario para gestionar ese
tipo específico de error. Suponiendo que no se hubiesen provocado errores en el bloque try,
nunca se ejecutarían los bloques catch.

Veamos ahora la estructura del bloque try/catch/finally:

try {

//Código que puede provocar errores

} catch(Tipo1 var1) {

//Gestión del error var1, de tipo Tipo1

[ ...

catch(TipoN varN) {

//Gestión del error varN, de tipo TipoN

}]

finally {

//Código de finally

Como podemos ver es obligatorio que exista la zona try, o zona de pruebas, donde pondremos
las instrucciones problemáticas. Después vienen una o más zonas catch, cada una
especializada en un tipo de error o excepción. Por último está la zona finally, encargada de
tener un código que se ejecutará siempre, independientemente de si se produjeron o no
errores.

Técnica de Programación Orientada a Objetos 77


Se puede apreciar que cada catch se parece a una función en la cuál sólo recibimos un objeto
de un determinado tipo, precisamente el tipo del error. Es decir sólo 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 aplicación. Existen dos tipos de archivos en Java, en este trial veremos los
primeros. Los archivos de texto en Java 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 presentación a continuación:

Archivos de Texto
Además de los ejemplos y ejercicios de la presentación puedes basarte en el siguiente archivo
para aprender a manejar archivos de texto:

¿Cómo guardar en archivos de texto?

En la computadora, los archivos son un bitstream o "flujo de bits". Esto es para que se puedan
construir fácilmente 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 cuál, la
clase FileWriter le permite escribir a un flujo de archivos.

El constructor de FileWriter es muy importante, puede recibir uno o dos parámetros, el primer
parámetro 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 métodos, el primero es
println() que recibe una línea de texto y la imprime en el archivo con un cambio de línea ("\n") al
final, el segundo método que se utiliza frecuentemente es el método print que funciona
básicamente de la misma manera, pero no pone un salto de línea al final y no imprime los

Técnica de Programación Orientada a Objetos 78


datos al archivo sino únicamente los deja en el buffer, por lo que tenemos que utilizar el método
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 método 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 método close() del PrintWriter.

¿Cómo 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 métodos que nos permiten
escribir a archivos de texto. El primero que vamos a ver es el método read(), que nos devuelve
un int con el código Unicode del carácter leído, para poder convertir este código en un carácter
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 símbolo 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 método del BufferedReader que nos va a ser muy útil es el método readLine(), este
método nos permite leer todo un archivo mucho más rápido y nos es muy útil cuando queremos
obtener datos de un archivo de inicio ya que podemos leer una línea cada vez y utilizarla de la
manera que nos convenga.

Técnica de Programación Orientada a Objetos 79


Al igual que cuando utilizamos el PrintWriter debemos cerrar el archivo al terminarlo de utilizar
utilizando el método 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 rápido 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 métodos:

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

Técnica de Programación Orientada a Objetos 80


 Para poder leer archivos de texto en Java debemos crear un objeto de tipo
BufferedReader. BufferedReader es una clase que contiene métodos predefinidos para
poder leer de una secuencia de bits.
 Para poder guardar archivos de texto en Java debemos crear un objeto de tipo
PrintWriter. PrintWriter es una clase que contiene métodos predefinidos para meter
datos a una secuencia de bits.
 Puedes hacer click en los nombres para ver el API que contiene muchos métodos
ú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 métodos para
leer, él más común es: fileIn.readLine();
 Este método lee una línea 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 ejecución de
nuestro programa ejecuta ciertas instrucciones dependiendo del tipo de error que
sucedió.
 Otro método muy importante es el método: fileIn.read();

 Este método nos permite leer un solo carácter del flujo de datos. El método regresa un
número (int) del 1 al 65535 si puede leer del archivo o regresa -1 si no.

Técnica de Programación Orientada a Objetos 81


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 métodos para escribir, los
más comunes son:
fileOut.print(String);
fileOut.println(String);
 Estos dos métodos reciben un String y lo imprimen en el archivo, el segundo método le
pone un carácter de fin de línea 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 método flush() del PrintWriter para escribir todo al archivo.
 Al terminar de usar el archivo también debemos recordar que debemos cerrarlo
mediante el método 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();
} catch (IOException ioe) {
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();
} catch (IOException ioe) {
}
}
}

Técnica de Programación Orientada a Objetos 82


Ejemplos:
 Caso 01

package prjarchivos;

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

import javax.swing.JFrame;

public class ArchivoApp2{


public static void main(String[] args) {
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 java.io.FileReader;
import java.io.IOException;
import javax.swing.JOptionPane;
import pckPrincipal.FrmLlamar;

Técnica de Programación Orientada a Objetos 83


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();
//JOptionPane.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.io.FileReader;
import java.io.IOException;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
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));

Técnica de Programación Orientada a Objetos 84


String texto="";
while(true){
texto = entrada.readLine();
/* tam=texto.length();
for(int g=0;g<tam;++g){
String j=String.valueOf(texto.charAt(g));
//JOptionPane.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
}
}
}

Técnica de Programación Orientada a Objetos 85


 Caso Práctico: Usando la Técnica P.O.O:
Guarda registro, código, 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 lógica 2 subclases: ClassEncapsulada(se crearan los get y set por cada
atributo que se tenga) y ClassMetodos(se creara los métodos para generar el código 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;
}

Técnica de Programación Orientada a Objetos 86


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 año=formato.get(formato.YEAR);
int mes=formato.get(formato.MONTH)+1;
//Datos del Nombre
char n1=cadN.charAt(0);

Técnica de Programación Orientada a Objetos 87


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=(""+año+devNV(n1)+devNV(n2)+devNV(a1)+devNV(a2)+mes);
return(cad);

}
public int pago(int index){
switch(index){
case 1: pag=850;break;
case 2: pag=750;break;
case 3: pag=600;break;
case 4: pag=700;break;
case 5: pag=750;break;
case 6: pag=680;break;
}
return(pag);
}
}// fin de la clase Metodos

 Uso de los paneles: diseñe 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 JTextField TXTNOM = new JTextField();
private JTextField TXTAPE = new JTextField();
private JComboBox cboespe = new JComboBox();
private JLabel lblp = new JLabel();
private JSeparator jSeparator1 = new JSeparator();
private JSeparator jSeparator2 = new JSeparator();
private JButton btnañadir = new JButton();
private JButton btnsalir = new JButton();
private JScrollPane jScrollPane1 = new JScrollPane();
private JTable jTable1 = new JTable();
private DefaultTableModel modtbdatos = new DefaultTableModel(contenido,titulos);
private JButton btnLsitaAr = new JButton();

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

private void jbInit() throws Exception {


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

Técnica de Programación Orientada a Objetos 88


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

private void btnañadir_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

Técnica de Programación Orientada a Objetos 89


// Panel Pie
package pckPaneles;
public class pnlPie extends JPanel {
GregorianCalendar formato=new GregorianCalendar();
************************

private void jbInit() throws Exception {


********************************
int dia=formato.get(formato.DAY_OF_MONTH);
int mes=formato.get(formato.MONTH)+1;
int año=formato.get(formato.YEAR);
lblf.setText(""+dia+"/"+mes+"/"+año);
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();
GregorianCalendar formato=new GregorianCalendar();
private pnlPie pnlPie1 = new pnlPie();
private pnlContenido pnlEncabezado1 = new pnlContenido();

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

private void jbInit() throws Exception {


this.getContentPane().setLayout( null );
this.setSize(new Dimension(400, 408));
this.setResizable(false);
this.setTitle("Usando Archivos");

Técnica de Programación Orientada a Objetos 90


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);
}
}

Técnica de Programación Orientada a Objetos 91


Contenidos

- Definición de la Clase Vector.


- Definición de la Clase ArrayList.
- Diferencias entre ellas
- Métodos de la clase Vector y ArrayList
- Aplicando atributos encapsulados usando estas clases
- Definición de la la Clase Hashtable.
- Métodos get y put

 Vector
Es una clase que permite crear matrices dinámicas, es decir matrices que varían en cantidad
de elementos durante la ejecución 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 Java. 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
específico 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 método nextElement (), asegurando que nunca se pasará del índice del
vector, esto lo hace mediante el método hasMoreElements().
Solo para eso sirve Enumeration, pero asegura que no habrá error por salirse del índice del
vector. Este es un ejemplo de cómo utilizar ambas clases juntas:

Técnica de Programación Orientada a Objetos 92


 Crear un vector

Para usar la clase Vector hemos de poner al principio del archivo del código fuente la siguiente
sentencia import

import java.util.*;
import java.util.Vector;

Cuando creamos un vector u objeto de la clase Vector, podemos especificar su dimensión


inicial, y cuanto crecerá si rebasamos dicha dimensión.

Vector VecDatos=new Vector(20, 5);

 Tenemos un vector con una dimensión inicial de 20 elementos. Si rebasamos dicha


dimensión y guardamos 21 elementos la dimensión del vector crece a 25.

Al segundo constructor, solamente se le pasa la dimensión inicial.

Vector VecDatos =new Vector(20);

 Si se rebasa la dimensión inicial guardando 21 elementos, la dimensión del vector se


duplica.

El programador ha de tener cuidado con este constructor, ya que si se pretende


guardar un número grande de elementos se tiene que especificar el incremento de la
capacidad del vector, si no se quiere desperdiciar inútilmente la memoria el ordenador.

Con el tercer constructor, se crea un vector cuya dimensión inicial es 10.

Vector VecDatos =new Vector();

 La dimensión del vector se duplica si se rebasa la dimensión inicial, por ejemplo,


cuando se pretende guardar once elementos.

 Añadir elementos al vector


Hay dos formas de añadir elementos a un vector. Podemos añadir un elemento a continuación
del último elemento del vector, mediante la función miembro addElement.

VecDatos.addElement("uno");

Podemos también insertar un elemento en una determinada posición, mediante


insertElementAt. El segundo parámetro o índice, indica el lugar que ocupará el nuevo objeto.
Si tratamos de insertar un elemento en una posición que no existe todavía obtenemos una
excepción del tipo ArrayIndexOutOfBounds. Por ejemplo, si tratamos de insertar un elemento
en la posición 9 cuando el vector solamente tiene cinco elementos.

Técnica de Programación Orientada a Objetos 93


Ejemplo: Para insertar el string "tres" en la tercera posición del vector v, escribimos

VecDatos.insertElementAt("tres", 2);

En la siguiente porción de código, se crea un vector con una capacidad inicial de 10 elementos,
valor por defecto, y se le añaden o insertan objetos de la clase String.

private void btnAgregar_actionPerformed(ActionEvent e) {

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());
}

Técnica de Programación Orientada a Objetos 94


Para saber cuántos elementos guarda un vector, se llama a la función miembro size. Para
saber la dimensión actual de un vector se llama a la función miembro capacity.
Agregue esta 2 líneas al código anterior.

lblT.setText(""+vecDatos.size());

lblD.setText(""+vecDatos.capacity());

Podemos eliminar todos los elementos de un vector, llamando a la función miembro


removeAllElements. O bien, podemos eliminar un elemento concreto, por ejemplo el que
guarda el string "tres".

vecDatos.removeElement("Angie");

 Podemos eliminar dicho elemento, si especificamos su índice.

vecDatos.removeElementAt(2);

 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 función miembro elementAt. Por ejemplo,
vecDatos.elementAt(4) sería equivalente a vecDatos [4], si vecDatos fuese un array.

Para acceder a todos los elementos del vector, escribimos un código 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.

Técnica de Programación Orientada a Objetos 95


public interface Enumeration {
boolean hasMoreElements();
Object nextElement();
}

La función 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 función miembro elements es de la clase VectorEnumerator, sin
embargo no podemos escribir

VectorEnumerator enum= vecDatos.elements();

porque VectorEnumerator no es una clase pública. Como podemos ver en su definición, 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");

Técnica de Programación Orientada a Objetos 96


Desde el objeto enum devuelto por la función miembro elements de la clase Vector llamamos a
las funciones miembro hasMoreElements y nextElement de la clase VectorEnumerator. La
función hasMoreElements devuelve true mientras haya todavía más elementos que se
puedan acceder en el vector v. Cuando se ha llegado al último elemento del vector, devuelve
false. La función nextElement devuelve una referencia al próximo elemento en la estructura de
datos. Esta función devuelve una referencia a un objeto de la clase base Object, que el
programador precisará en ciertos casos, como veremos más abajo, promocionar (casting) a la
clase adecuada.

Para buscar objetos en un vector se puede usar una Enumeration y hacer una comparación
elemento por elemento mediante equals, tal como vemos en la siguiente porción de código

Enumeration enum=vecDatos.elements();
while(enum.hasMoreElements()){
String elemento=(String)enum.nextElement();
if(elemento.equals("William")){
lblEnc.setText("Encontrado William");
break;
}
}

 Algunos de los métodos de la clase Vector se muestran a continuación:

Vector ( )
Constructor: crea un vector inicialmente vacío

void addElement (Objet obj)


Inserta el objeto especificado al final del vector

void setElementAt (Object obj, int indíce)


Inserta el objeto específicado en el vector en la posición específicada

Object remove (int indíce)


Elimina el objeto que se encuentra en la posición específicada y lo regresa

boolean removeElement (Object obj)


Elimina la primera occurencia del objeto específicado en el vector

void removeElementAt (int indíce)


Elimina el objeto específicado en el índice del vector

void clear ( )
Elimina todos los objetos del vector

boolean contains (Object obj)

Técnica de Programación Orientada a Objetos 97


Regresa verdadero si el objeto dado pertenece al vector

int indexOf (Object obj)


Regresa el índice del objeto específicado. Regresa -1 si no fue encontrado
el objeto

Object elementAt (int indíce)


Regresa el componente en el índice específicado

boolean isEmpty ( )
Regresa verdadero si el vector no contiene elementos

int size ( )
Regresa el número de elementos en el vector

 Ejemplo 01:
import java.util.Vector;
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 posición 1 está: " + DocentesSta.elementAt (1));
DocentesSta.insertElementAt ("Angie", 2);

lblT.setTexr("Tamaño de la banda: " + DocentesSta.size ());


for (int i = 0; i < DocentesSta.size (); i++)
ModLstDatos.addElement(DocentesSta);
}
}

Técnica de Programación Orientada a Objetos 98


Si se necesitan añadir valores de datos primitivos a un Vector se pueden utilizar las clases
conocidas como envoltorios que son: Integer, Long, Double y Float. Sus métodos de
conversión respectivos son: intValue ( ), longValue ( ), doubleValue ( ) y floatValue ( ).

Ejercicio:

Complemente la siguiente clase, escribiendo las instrucciones necesarias donde se muestran


los subguiones( ), guíate 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));
vecDatos.add (new Integer (3));
vecDatos.add (new Integer (5));

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 posición 3");

//El nuevo vector es

// Eliminar el objeto que contiene al Integer cuyo valor es 3

//El nuevo vector es

// Escribir el valor del segundo objeto


txtArea.append("El valor del segundo objeto es: " + +”\n”);

// Determinar el número de objetos del vector


txtArea.append ("El tamaño del vector es: " + +”\n”);

// Eliminar el tercer objeto y escribir su valor


txtArea.append ("En la tercera posición había un: " + +”\n”);

Técnica de Programación Orientada a Objetos 99


//El nuevo vector es

}
}

 Ejemplo 02:

package pckLogico;
import java.util.Enumeration;
import java.util.Vector;
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 {

public static void main(String[] args) {


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

Técnica de Programación Orientada a Objetos 10


0
 La clase ArrayList
Las aplicaciones frecuentemente necesitan almacenar un grupo de datos en un sólo objeto.
Los arrays sirven bien para este propósito, pero algunas veces necesitamos incrementar o
reducir dinámicamente el número de elementos del array, o hacer que contenga distintos tipos
de datos

Esto es común entre las aplicaciones como las tiendas online. Un cliente añade una mercancía
a su carro de la compra, y detrás de la escena, los ítems son almacenados y eliminados
automáticamente.

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 cómo necesitemos construir el ArrayList

 Los siguientes dos constructores nos ayudarán a empezar:

• ArrayList() construye un ArrayList con capacidad cero


por defecto, pero crecerá según le vayamos
añadiendo:
ArrayList al = new ArrayList();
• ArrayList(int initialCapacity) construye un ArrayList
vacío con una capacidad inicial especificada:
ArrayList al2 = new ArrayList(5);

Un objeto ArrayList sólo contiene referencias a objetos. Para almacenar tipos primitivos como
double long o float ,

 Si necesitamos circular a través de los elementos del ArrayList , usamos la clase


Iterator y sus métodos hasNext y next :

Iterator alIt = al.iterator();

while (alIt.hasNext()){

ModLstDatos(alIt.next() + " ");

ArrayList es una de las muchas clases del Collection Framework , que proporciona un
conjunto de interfaces y clases bien-diseñados para almacenar y manipular grupos de datos
como una sola unidad, una colección.

Es una Lista volcada en un Array. Se debe utilizar en lugar de Vector como almacenamiento
de objetos de propósito general. Permite un acceso aleatorio muy rápido 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 atrás y hacia delante en la Lista,
pero no para insertar y eliminar elementos.

Ventajas
• Un ArrayList es un array dinámico. No tiene restricciones de capacidad. Su tamaño se ajusta
de forma dinámica.

Técnica de Programación Orientada a Objetos 10


1
• 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 básico, 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 método add y para recoger un elemento usamos el método 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)+" ");
}
}

 Métodos de ArrayList
• int size().- El tamaño actual (puede ser 0)
• void add(obj).- Añade un objeto al final del ArrayList, incrementando su tamaño de
• obj es un objeto.
• Object get(N).- Devuelve el elemento almacenado a la posición 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
método toString() de Object.

 Ejemplo 01: Usando el ArrayList


import java.util.ArrayList; public
class ArrayListEntero { public static
void main(String[] args) { ArrayList
numeros = new ArrayList(); Integer
num1 = new Integer(10); Integer
num2 = new Integer(20); Integer
num3 = new Integer(30); Integer
num4 = new Integer(40);
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 ("=");
}

Técnica de Programación Orientada a Objetos 10


2
txtArea.append(“\n”+suma);
}
}

import java.util.*;
public class ArrayListString {
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++)
Object objecto = Saludo.get(i);
String cadena = objecto.toString();
cadena = cadena.toUpperCase();
txtSalida.append(cadena+" ");
}
}

 Más Métodos de ArrayList


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

Object remove(index) -- Elimina el elemento a la posición 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 métodos de


Collection, cualquier objeto de una clase derivada de Collection debería funcionar, pero se crea
un ArrayList porque es el caballo de batalla de las colecciones y viene a tomar el relevo al
Vector.

El método add(), como su nombre sugiere, coloca un nuevo elemento en la colección. Sin
embargo, la documentación indica claramente que add() "asegura que la colección contiene el
elemento indicado". Esto es para que un Set tenga significado, ya que solamente añadirá el
elemento si no se encuentra en la colección. Para un ArrayList, o cualquier otra lista ordenada,
add() significa siempre "colocarlo dentro".

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

Utiliza un nombre que está históricamente aceptado y es conocido en toda la literatura de


programación orientada a objetos
Utiliza nombres de métodos más cortos que la Enumeration: hasNext() en vez de
hasMoreElements(), o next() en lugar de nextElement().

Técnica de Programación Orientada a Objetos 10


3
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;
}
public int getNota2() {
return nota2;
}
public void setNota2(int nota2) {
this.nota2 = nota2;
}

Técnica de Programación Orientada a Objetos 10


4
public int getNota3() {
return nota3;
}
public void setNota3(int nota3) {
this.nota3 = nota3;
}
public int getNota4() {
return nota4;
}
public void setNota4(int 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 tamaño(){
return(Registros.size());
}
}

Técnica de Programación Orientada a Objetos 10


5
//ClassEjecutar
package PckPrincipal;

import PckPresentacion.FrmAcceso;
import PckPresentacion.FrmDatos;

public class ClassEjecutar {


public static void main(String[] args) {
FrmAcceso prin= new FrmAcceso();
prin.setVisible(true);

// Cerrar una ventana


}
}

// uso del FRAME


public class FrmDatos extends JFrame {
//inicializacion
ClassEncapsulada atri;
ClassMetodo metodos;
String valores[][]={};
Stringnombres[]={"Reg","Nombre","Apellido","Nota 1","Nota 2","Nota 3","Nota 4",
"Promedio","Condicion"};
int R=1;
**********************************
**********************************
private void jbInit() throws Exception {
**********************************
**********************************
**********************************
**********************************
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.setNota2(Integer.parseInt(txtN2.getText()));
atri.setNota3(Integer.parseInt(txtN3.getText()));
atri.setNota4(Integer.parseInt(txtN4.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());
}

Técnica de Programación Orientada a Objetos 10


6
void Eliminar(){
int fila=tbl_d.getSelectedRow();
modTDatos.removeRow(fila);
}
private void btnAgregar_actionPerformed(ActionEvent e) {
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);
}

private void jButton2_actionPerformed(ActionEvent e) {


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

private void jButton3_actionPerformed(ActionEvent e) {


//Ir al Anterio de la Tabla
if ( tbl_d.getSelectedRow() != 0 ) {
tbl_d.setRowSelectionInterval (tbl_d.getSelectedRow()-1, tbl_d.getSelectedRow() -1);
}
}
private void jButton4_actionPerformed(ActionEvent e) {
//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

Técnica de Programación Orientada a Objetos 10


7
//Frame Acceso

private void btnAceptar_actionPerformed(ActionEvent e) {


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();
}
}

Técnica de Programación Orientada a Objetos 10


8
Contenidos

- Uso de menús(JMenu)
- JProgressBar,
- JColorChooser, JFileChooser,
- InternalFrame
- Implementación de Librerías
- Creación de Archivos Jar Ejecutables

 Menús
Un menú en una aplicación no es más que un MenuBar en el que hay varios menús.
Pensemos en un programa cualquiera con las voces de menú File Edit y Help. Estas tres voces
en Java son unos objetos de la clase Menú y se tienen que añadir 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 Java son unos objetos de la
clase MenuItem (o también Menú si incluyen otros submenús).

Por lo tanto, si a una aplicación le quisieramos añadir un menú tendríamos 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 Menús

Además, como siempre, tenemos que escribir unos gestores para los sucesos de los menús y
asociarlos a los menús.

Los sucesos de los MenuItem son los que tenemos que gestionar nosotros a diferencia de los
sucesos de los menús 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:

Técnica de Programación Orientada a Objetos 10


9
 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 opción rápida) definido en MenuShortcut s.

Algunos métodos son:


 addActionListener(ActionListener l), asocia un ActionListener al MenuItem para
escuchar los sucesos de tipo ActionEvent (el clic).
 void deleteShortcut(), borra la tecla de opción rápida para el menuitem.
 String getActionCommand(), da la acción asociada al MenuItem. La acción es la
que pasa al actionListener del botón para identificar el botón mismo. Así varios item
pueden tener el mismo gestor de sucesos que podrá distinguir el botón clicado
basándose 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 definición 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.

Técnica de Programación Orientada a Objetos 11


0
¿Cómo Usar MonitoProgress?

Una tarea ejecutándose en un programa puede tardar un poco en completarse. Un programa


amigable proporciona alguna indicación 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 duración.

 JProgressBar

Una barra de progreso que muestra gráficamente qué cantitad total de la tarea se ha
terminado. Puedes ver Cómo usar Progress Bars para más información.

 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 diálogo con
una descripción de la tarea, una nota de estado, una barra de progreso, un botón Ok, y
un botón Cancel. Puedes ver Cómo usar Progress Monitors para más detalles.

 ProgressMonitorInputStream

Un stream de entrada con un monitor de progreso añadido, 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
configurándolo como se describe en Cómo usar Progress Monitors.

Después de ver una barra de progreso y un monitor de progreso en acción, Decidir si utilizar
una Barra o un Monitor de Progreso puede ayudarnos a decidir cuál es el apropiado para
nuestra aplicación.

Técnica de Programación Orientada a Objetos 11


1
 JFileChooser
JFileChooser es una clase java que nos permite mostrar fácilmente una ventana para la
selección de un fichero.
Si queremos abrirlo para leer el fichero, podemos llamarlo así

JFileChooser fileChooser = new JFileChooser();


int seleccion = fileChooser.showOpenDialog(areaTexto);

A la vuelta, en seleccion tendremos


• JFileChooser.CANCEL_OPTION Si el usuario le ha dado al botón cancelar.
• JFileChooser.APPROVE_OPTION Si el usuario le ha dado al botón aceptar
• JFileCHooser.ERROR_OPTION Si ha ocurrido algún error.

Comprobando que se ha dado al botón aceptar, podemos obtener el fichero seleccionado por
el usuario así

if (seleccion == JFileChooser.APROVE_OPTION){
File fichero = fileChooser.getSelectedFile();
// Aquí debemos abrir y leer el fichero.
...
}

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

JFileChooser fileChooser = new JFileChooser();


int seleccion = fileChooser.showSaveDialog(areaTexto);
if (seleccion == JFileChooser.APPROVE_OPTION){
File fichero = fileChooser.getSelectedFile();
// Aquí debemos abrir el fichero para escritura
// y salvar nuestros datos.
...
}

La única diferencia entre uno y otro es la etiqueta del diálogo 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
añadirle un filtro. Básicamente hay que hacer una clase que herede de FileFilter y definir el
método accept(). Este método recibe un parémetro File y nosotros debemos decidir si pasa o
no el filtro, devolviendo true o false. Por ejemplo, si sólo queremos ver fichero .jpg, podemos
hacer este filtro.

Técnica de Programación Orientada a Objetos 11


2
Import javax.swing.filechooser.FileFilter;
...
public class FiltroDeJPG extends FileFilter{
public boolean accept (File fichero) {
if (tieneExtensionJPG (fichero))
return true;
else
return false;
}
public String getDescription() {
return ("Filtro JPGs");
}
}

Debemos definir ambos métodos. La descripción puede ser cualquier cadena de texto que nos
sirva como descripción del filtro. Finalmente, debemos pasar este filtro al JFileChooser
fileChooser.setFilter(new FiltroDeJPG());

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

JFileChooser jf = new JFileChooser();


FileNameExtensionFilter filter = new
FileNameExtensionFilter("JPG & GIF", "jpg", "gif");
jf.setFilter(filter);

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

JFileChooser chooser = new JFileChooser();

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 == JFileChooser.APPROVE_OPTION)

fichero = chooser.getSelectedFile();

Técnica de Programación Orientada a Objetos 11


3
Si queres trabajar con directorios tenes que cambiar el modo de selección usando la constante
JFileChooser.DIRECTORIES_ONLY. El modo de selección también puede ser cambiado para
permitir elegir mas de un fichero o directorio a la vez:

chooser.setFileSelectionMode(JFileChooser.DIRECTOR IES_ONLY);

Técnica de Programación Orientada a Objetos 11


4
Contenidos

Threads

Una thread es un único flujo de contrrol dentro de un programa. Algunnaas veces es llammado
contexto de ejecución porque cada thread debe tenner sus propios recurssos, como el
prrogram counter y el stack de ejecución, como el contexto dee ejecución. 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).

Compartición de datos

Todos los hilos de proceso que pertenecen a un mismo proceso comparten un área común de
datos que sirve para intercambiar información entre ellos. No es necesario acudir a técnicas de
comunicación 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 conmutación entre hilos de un mismo proceso es muy rápida, puesto que la
cantidad de información 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
contraposición a los cambios de contexto pesados, que implican el manejo de procesos.

Técnica de Programación Orientada a Objetos 11


5
 Ejemplo 01

 Crear una Aplicación que presente la hora del sistema usando hilos.

public class PanelReloj extends JPanel{


JLabel reloj;

public PanelReloj(){
reloj= new JLabel("", JLabel.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();
} catch (Exception e) {
e.printStackTrace();
}
}

public class MiReloj extends Thread{


JLabel lblReloj;

// constructor
public MiReloj(JLabel 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) {}


}
}

Técnica de Programación Orientada a Objetos 11


6
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 JLabel lblJ1 = new JLabel("1",JLabel.CENTER);
public JLabel lblJ2 = new JLabel("2",JLabel.CENTER);
JLabel barrera=new JLabel();
JButton b= new JButton("Inicia carrera");

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

lblJ2.setBounds(0,50, 20, 20);


lblJ2.setBackground(Color.red);
lblJ2.setOpaque(true);
lblJ2.setForeground(Color.white);

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

p.add(lblJ1);
p.add(lblJ2);

Técnica de Programación Orientada a Objetos 11


7
p.add(barrera);

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

public void actionPerformed(ActionEvent e){


lblJ1.setLocation(0, lblJ1.getLocation().y);
lblJ2.setLocation(0, lblJ2.getLocation().y);
ClassCarreraHilo st1= new ClassCarreraHilo(lblJ1, this);
ClassCarreraHilo st2= new ClassCarreraHilo(lblJ2, this);
st1.start();
st2.start();
}
}

// creación de la clase Hilo

class ClassCarreraHilo extends Thread{


JLabel 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.lblJ1.getLocation().x;
c2= p.lblJ2.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) {}
}

Técnica de Programación Orientada a Objetos 11


8
// determina el ganador si alguien llegó a la meta
if (eti.getLocation().x>=290)
if (c1>c2)
JOptionPane.showMessageDialog(null,"Gano 1");
else if (c2>c1)
JOptionPane.showMessageDialog(null,"Gano 2");
else
JOptionPane.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){
ClassFrmHiloJuego Carrera = new ClassFrmHiloJuego();
PanelCarrera panel = new PanelCarrera();
Carrera.setContentPane(panel);
Carrera.setSize(350,200);
Carrera.setTitle("Juego de 2 - Ganador Aleatorio - VER");
Carrera.setLocationRelativeTo(null);
Carrera.setVisible(true);

Técnica de Programación Orientada a Objetos 11


9
 Ejemplo 03
 Muestre la palabra SISEpuede cada cierto tiempo

public class ClassBlink implements Runnable {


Thread Blink=new Thread(this);
JLabel tiempo=new JLabel();
public ClassBlink() {
JFrame ventana = new JFrame("Visualizar Palabra");
ventana.setSize(250,100);
ventana.setVisible(true);
ventana.add(tiempo);

//Blink=new Thread(this);
Blink.start();
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
}
}
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...");
}

public static void main(String[] args) {


new ClassBlink();
}

private void jbInit() throws Exception {


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

Técnica de Programación Orientada a Objetos 12


0
Proyecto Final: Caso Practico.

Crear un Proyecto final donde aplique la Tecnica de programación orientada a Objetos


(herencias, sobrecarga de métodos, encapsulamiento), uso de métodos, paneles establecer
archivos, uso de imágenes, hilo para el reloj activo, etc.
Todos los datos estarán 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

Técnica de Programación Orientada a Objetos 121


Ademas Agregue 2 Frame en la capa Presentacion:
 Para el Acceso de Usuario: Que estarán 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

Presentación Final

Panel Encabezado

Panel Pie: use la Clase GregorianCalendar y Hilos

Técnica de Programación Orientada a Objetos 122


Panel Listado: usara el JFileChooiser para jalar la foto
El botón agregar solo almacenara datos al ArrayList, lo botones modificar, eliminar, dependerá
de la selección del JTable 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: según a las letras o palabra completa se realizará el filtro por apellidos en el Jtable.

Técnica de Programación Orientada a Objetos 123

Você também pode gostar