Escolar Documentos
Profissional Documentos
Cultura Documentos
Modulo A
Bibliografía: ……………………………………………………………………………………………
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.
Contenidos
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.
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]
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
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]
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.
leer(Arreglo[x])
mostrar(Arreglo[x)
fin_desde
T = 10;
decimal: notas[T]
decimal : notas[10] = {2.3 , 3.5 , 4.2 , 3.3 , 3.0 , 4.9 , 4.2 , 3.0 , 2.0 , 1.5 };
fin_desde
mostrar ( notas[i] )
fin_desde
Carácter: Apellidos[10]
fin_desde
2. Crear un Arreglo que permita ingresar 15 promedios del aula 307 del curso de
fundamentos de programación
decimal: Promedios[15]
fin_desde
Constante N=20
Carácter: Institutos[N]
Carácter: Zonas[N]
leer(Zonas[i] )
mostrar(Institutos[i])
mostrar (Zonas[i] )
fin_desde
Constante N=50
entero: Numeros[N]
mostrar(Numeros[i])
fin_desde
Constante N=10
decimal: Promedios[N]
si(Promedios[i]>=10.5)
ca=ca+1
sino
cd=cd+1
fin_si
fin_desde
Constante N=15
entero:Sueldo[N]
Carácter:Area[N]
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
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).
Antes de ser instanciada con new no consume memoria, simplemente es una declaración de
tipo. Por ejemplo:
int edades[];
O También:
Casos Prácticos
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] );
modLstf.addElement((i+1)+".- "+Amigos[i] );
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) {
modLstf.addElement((i+1)+".- "+apellidos[i] );
modLstE.addElement(edades[i]);
ModLstD.addElement(distritos[i]);
modLstf.addElement((i+1)+".- "+apellidos[i] );
modLstE.addElement(edades[i]);
ModLstD.addElement(distritos[i]);
int cc=0,cmay=0,cme=0;
if(distritos[i].equalsIgnoreCase("Surco") | distritos[i].equalsIgnoreCase("Chorrillos"))
cc=cc+1;
if(edades[i]>31)
cmay=cmay+1;
else
cme=cme+1;
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.
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
Numeros[0][1]=1975
Numeros[1][2]=1972
Numeros[3][1]=1999
Numeros[4][2]=2004
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”
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]
Ejemplo:
X=Letras[0][3]
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).
Ejemplos:
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
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.
Asignar datos:
numero[0][0]=123;
numero[0][1]=456
Leer datos:
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:
for(int y=0;y<filas;++y){
for(int x=0;x<columnas;++x){
numero[y][x]= Integer.parseInt(JOptionPane.showInputDialog(“Ingresar
Numero));
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.
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.
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.
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);
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.
Apellidos");
Edad[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresar Edad"));
modTbDatos.setValueAt(apellidos[i],i,0);
}
}
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:
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:
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.
Ejemplo:
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.
Caso 01
Dentro de una lista de 10 nombres, verifique si el nombre ingresado existe o no.
Caso 02
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.
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();
}
}
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;
//
tempE = edad[j];
edad[j] = edad[j+1];
edad[j+1] = tempE;
}
}
}
}
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.
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");
}
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).
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.
Características de la POO
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.
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.
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()
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.
Para crear una clase main (principal), deberá de seleccionar la opción public y generate
Main Method. Y su estructura quedaría así.
//Atributos Globales
//Metdos
//referencia de la clase
//atributos Locales
Ejemplo 01: mostrar mis datos personales desde una clase Main.
Ejemplo 02: mostrar datos personales ingresado por el usuario desde una clase
Main.
Usando Message
}
}
package prjcaso1;
import javax.swing.JOptionPane;
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);
}
}
Usando Referencias
// 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
}
}
}
}
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.
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.
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.
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ó.
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.
interface se declara:
interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}
Por ejemplo:
interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}
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:
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:
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:
System.out.println(Meses.NOMBRES_MESES[ENERO]);
• 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.
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);
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
Se usa en combinación con las clases del paquete java.io para leer y
java.net
escribir datos en la red.
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.
En general, podemos tener una gran jerarquía de Clases tal y como vemos en el siguiente
gráfico:
ENCAPSULAMIENTO
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.
El mismo método dentro de una clase permite hacer cosas distintas en función de los
parámetros
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.
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.
Caso 01
Crear una sobrecarga que permita sumar 2 números y será llamado de acuerdo al tipo
de dato que se le envie.
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);
}
Package pckLogico;
package pclPrincipal;
public class FrmDatos extends JFrame {
ClassSobre metodos=new ClassSobre();
ClassEncapsular atri=new ClassEncapsular();
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;
// Frame:
public class FrmVentana extends JFrame {
Class1 x = new Class1();
*****
public FrmVentana() {
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
}
}
// Clase Main
public class Class1 extends ClassMetodos{
public static void main(String[] args) {
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;
// 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"))
//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");
}
atributo.setArticulo(cboArticulo.getSelectedItem().toString());
lblPrecio.setText(""+metodos.Calcular(atributo.getArticulo()));
atributo.setPrecio(metodos.Calcular(atributo.getArticulo()));
lblPrecio.setText(""+atributo.getPrecio());
}
}
}
- 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.
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.
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:
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).
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:
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 :-));
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.
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).
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.
Ejemplo:
int indexOf(String str, int indice): devuelve el índice en el que aparece por
primera vez la String del primer argumento en la que se aplica el 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
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 startsWith(String str, int indice): devuelve true si la String sobre la que se
aplica comienza por la del argumento a partir de un determinado índice asociado al
segundo argumento; false si esto no ocurre.
String 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:
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.
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.
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).
• 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.
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
Excepciones
try {
} catch(Tipo1 var1) {
[ ...
catch(TipoN varN) {
}]
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.
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:
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
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.
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.
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:
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.
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.
package prjarchivos;
import java.io.FileReader;
import java.io.IOException;
import javax.swing.JFrame;
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;
}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;
} catch (IOException e) {
// TODO
}
}
}
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;
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);
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
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();
*******************
datos.Grabar(atri.getReg(),atri.getCod(),atri.getNom(),atri.getApe(),atri.getCod(),atri.getP());
++c;
}
public FrmPresenta() {
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
}
}
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:
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;
VecDatos.addElement("uno");
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.
lblT.setText(""+vecDatos.size());
lblD.setText(""+vecDatos.capacity());
vecDatos.removeElement("Angie");
vecDatos.removeElementAt(2);
Para acceder a todos los elementos del vector, escribimos un código semejante al empleado
para acceder a todos los elementos de un array.
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.
El objeto enum devuelto por la función miembro elements es de la clase VectorEnumerator, sin
embargo no podemos escribir
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;
}
}
Vector ( )
Constructor: crea un vector inicialmente vacío
void clear ( )
Elimina todos los objetos del vector
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{
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);
Ejercicio:
import java.util.*;
/**
* Uso de las clases Vector e Integer
*/
public class EjercicioVector
{
}
}
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
}
package pckEjecutar;
import pckLogico.ClassVector1;
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 objeto ArrayList sólo contiene referencias a objetos. Para almacenar tipos primitivos como
double long o float ,
while (alIt.hasNext()){
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.
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.
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+" ");
}
}
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:
// Clase Encapsulada
package PckLogico;
// 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());
}
}
import PckPresentacion.FrmAcceso;
import PckPresentacion.FrmDatos;
Nombre= txtNombre.getText();
clave=txtClave.getText();
if(Nombre.equalsIgnoreCase("SISE")&&clave.equalsIgnoreCase("2010")){
FrmDatos prin=new FrmDatos();
prin.setVisible(true);
this.dispose();
}
}
- 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:
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:
Por lo tanto, para crear los Item del menú Archivo descrito antes tendremos que escribir:
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
ProgressMonitorInputStream
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.
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()
La única diferencia entre uno y otro es la etiqueta del diálogo y de los botones. Uno pondrá
"Abrir" y otro "Guardar"
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:
Tenes definir un FileFilter , es decir, creas una clase que herede de FileFilter y le das las
propiedades que deseas. Por ejemplo:
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();
chooser.setFileSelectionMode(JFileChooser.DIRECTOR IES_ONLY);
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.
Crear una Aplicación que presente la hora del sistema usando hilos.
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();
}
}
// constructor
public MiReloj(JLabel lblReloj){
this.lblReloj= lblReloj;
}
lblReloj.setText(sdf.format(hoy));
Ejemplo 02
crear el Panel por medio de Codigo: Solo inserte el panel y digite los siguiente, crea una
clase main y una subclase.
//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);
barrera.setBounds(310,0, 2,400);
barrera.setBackground(Color.green);
barrera.setOpaque(true);
b.addActionListener(this);
p.add(lblJ1);
p.add(lblJ2);
add(p, BorderLayout.CENTER);
add(b, BorderLayout.SOUTH);
}
//contructor de la clase
public ClassCarreraHilo(JLabel eti, PanelCarrera p){
this.eti=eti;
this.p= p;
}
}
}
// 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);
//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...");
}
Presentación Final
Panel Encabezado
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.