Buenas Practicas en Java Basico e Intermedio Con Compiladores en Linea y Netbeans 8 - Usta PDF

UNIVERSIDAD SANTO TOMAS DE AQUINO VICE
DECANATURA DE DIVISION DE UNIVERSIDAD

ABIERTA Y DISTANCIA
FACULTAD CIENCIAS Y TECNOLOGIAS PROGRAMA

INGENIERÍA EN INFORMATICA
BUENAS PRÁCTICAS EN JAVA BASICO E INTERMEDIO
CON COMPILADORES EN LINEA Y NETBEANS 8
DNDA No. 10-718-469

MARIO DUSTANO CONTRERAS CASTRO
DOCENTE TIEMPO COMPLETO
BOGOTA, OCTUBRE 2019

ANTECEDENTE. BUENAS PRÁCTICAS EN CODIFICACIÓN DE PROGRAMAS
PRÁCTICA O PROCESO
Existe una distinción importante entre prácticas y procesos. Las prácticas son lo que
debe hacer y el proceso es la estructura para hacer las tareas. El proceso define el
orden en el cual aplicar las prácticas y hacer el trabajo, de forma que obtenga
resultados de ingeniería significativos. Las prácticas aprovechan el proceso de
ingeniería de software que explica las tareas y el orden en el que se deben realizar
para crear productos de trabajo específicos. Las fases generales clave del proceso
son:
•Preparación del proyecto
•Análisis de requisitos
•Análisis funcional
•Síntesis de diseño
•Implementación
•Prueba de unidad
QUE SE ENTIENDE POR BUENAS PRACTICAS
Por buenas prácticas se entiende como un conjunto coherente de acciones que han
rendido buen o incluso excelente servicio en un determinado contexto y que se espera
que, en contextos similares, rindan similares resultados.
BUENAS PRACTICAS EN JAVA BASICO E INTERMEDIO CON COMPILADORES
EN LINEA Y NETBEANS 8
PRIMERA PARTE. GRAMATICA LENGUAJE JAVA

GRAMATICA LENGUAJE JAVA
ANTECEDENTE
Para describir la gramática del lenguaje Java se utilizara la Forma Backus Neur (BNF).
Los Autores de este libro utilizan las siguientes formas:
< > Elemento No Terminal – Compuesto de ó define
:- Se Define como ó compuesto de
… Sucesión
() Agrupa
max

min
Indica cantidad Mínima y máxima de Elementos
1. NATURALEZA DE LOS SIMBOLOS

Java define los símbolos de naturaleza:
<símbolos>:- <letras> <dígitos> <operadores><blanco>
<letras>:- <mayúsculas> <minúsculas>
<dígitos>:-0…9
<operadores>: - <aritméticos> <lógicos> <relación> <bloques> <agrupación>
<puntuación> <literal>
SIMBOLOS NATURALEZA
A…Z <mayúsculas>
a…z <minúsculas>
0…9 <dígitos>
+ - * /% <aritméticos >
& | (Alt 124) <lógicos>
><= <relación>
{} <bloques>
() [] <agrupación>
,;. <puntuación>
“„ <literal>
<blanco>
2. TOKENS: REGLAS (BNF)
Token: Se define como una colección de símbolos de igual naturaleza.
Los Token se pueden definir de naturaleza:
<Token>:- <Operadores><Operandos>
<operadores>:- ><relación><lógicos><aritméticos<literal>
<Relación>:- < > == (igual) <= >= != (diferente)
<Lógicos >:- || (or) && (and) ! (negación)
Ejemplo: i<=a && j!=k || k==z
<Aritméticos>:- <únicos> <dobles>
<Aritméticos únicos>:- + - * / % (residuo)
<Aritméticos dobles>:- <prefijo> <infijo> <postfijos>
<prefijo>:- ++ (incremento) -- (decremento)
Ejemplo: ++i que es i=i+1
<infijo>:- += -= *= /=
Ejemplo: a+=b que es a=a+b
<postfijo>:- ++ (incremento)
-- (decremento)
Ejemplo: i++ que es i=i+1
<Literal>:-<char><cadena>
<char>:- „<símbolo>‟
Ejemplo: „a‟
256
<cadena>:-” 
1
<símbolo> “
Ejemplo: “casa”
<operandos>:- <variable> <objeto>< reservada> < clase>< método><numero>
<todo minúscula>:-   min usculas  Ejemplo: static

2
<titulada>:- <mayúscula> <todo minúscula> Ejemplo: String
<nombre variable>: - <letra>   letra  Ejemplo: a

0
<nombre objeto>: - <letra>   letra 

0
Ejemplo: Cliente
<nombre método>: - <todo minúscula>   titulada 

1
Ejemplo: IndexOf
<nombre clase>: -   titulada 

1
Ejemplo:StringTokenizer
<numero>:- <entero> <real>
<numero entero>:-   digito  Ejemplo: 9

1
<numero real>:- <numero entero> . <numero entero> Ejemplo: 3.1416

<nombre reservada>: - <todo minúscula>
El conjunto de palabras reservadas de Java es el siguiente:
abstract default if private throw
boolean do implements protected throws
break double import public transient
byte else instanceof return try
case extends int short void
catch final interface static volatile
char finally long super while
class float native switch import
for new synchronized null
true false continue package this

2. SINTAXIS
2.1 Declaración de Variables y constantes
En java se puede definir dos tipos de datos a declarar:
<tipo dato>: - <tipo variable> | < nombre clase>
Declaración de Constantes
static final <tipo variable> <nombre variable> = <valor>;
<tipo variable>: - int |float|boolean| long |byte|double|char
<valor>:- <numero> <literal>
Ejemplo: static final int salario=50000;
Declaración de Variables: <declaración de variable>
Formato 1: <tipo variable> <nombre variable>;

Formato 2: <tipo variable> <nombre variable> = <valor>;
Formato 3: <tipo variable> <formato 1 ó 2> 

0
, <Formato 1 ó 2>;
Ejemplos:
int A; int B=5; int C, i=0;
2.2 Declaración de Objetos
<nombre clase> <nombre objeto> = new <nombre clase> ();
Ejemplo:
Hashtable H=new Hashtable();
2.3 Declaración, creación, subindicación e Inicialización de Arreglos
Declaración de un Arreglo:
<tipo dato> <nombre Variable>[];
Ejemplo:
int[] A; // A es un arreglo de enteros
String S[]; // S es un arreglo de la Clase Strings

Creación de un arreglo
<tipo dato> >nombre Variable>[]= new <tipo dato> [ <entero> ] ;
Ejemplo:
int A[]= new int[10]; // A un vector de 10 enteros
Subindicación de un arreglo
A[0], A[1], ..., A[9] // correcto
Tamaño de un arreglo:
<nombre variable> . length
Ejemplo:
A.length
Inicialización de un arreglo:
int A[]= new int[10];
for (int i=0; i<A.length; i++)
A[i]= i;
2.4 Estructura de una Clase Java
Se define una clase como una estructura de la siguiente manera:
class <nombre clase> {
// Definición de variables
<tipo ambiente> <declaración de variable>
// Definición del Constructor . Puede haber varios
public <nombre clase> (<argumentos>.)

{
// Aquí van las sentencias del constructor.
}
// Definición de los métodos de la clase.

<tipo ambiente> <tipo método> <nombre método> ( <argumentos>)
{
// Aquí van declaración de variables, objetos, constantes, sentencias java
return <valor>;
}
}
El nombre de la clase se define al inicio de la estructura. Toda la clase se escribe entre
dos llaves {}.
Lo primero que se suele definir son los atributos de la clase. Esto son variables que
son visibles desde todos los métodos que constituyen la clase.
A continuación se escriben los constructores de la clase. Estos no devuelven ningún

valor y contienen las sentencias que crean los objetos de su clase.
Puede haber varios constructores. Se tienen que diferenciar en los argumentos que
cada uno de ellos recibe.
Después se escriben los diferentes métodos de la clase. Estos son funciones que al
igual que los atributos pueden ser públicos, privados, protegidos, estáticos.
Las sentencias que constituyen un método se escriben entre dos llaves {}. Obsérvese
también que cada instrucción se termina con un punto y coma
BNF:
<tipo ambiente>: - public | static | prívate | protected
<tipo dato>: - <tipo variable> | < nombre clase>
<tipo método>: - void | <tipo dato>
<tipo variable>: - int |float|boolean| long |byte|double|char
<argumento>: - <tipo dato> <nombre objeto> | <nombre variable>
<argumentos>:- <blanco> | <argumento> 0

, <argumento>
2.5 Estructura de los Programas escritos en Java
La estructura de los programas escritos en Java está sujeta a las siguientes reglas:
 Regla 1. Cada Programa es una Clase (clausula class)

 Regla 2. El nombre del archivo debe ser el mismo que el de la clase, y la
extensión debe ser .java
 Regla 3. La ejecución de un programa comienza por una función principal ó o
función main(). Esta función debe pertenecer a una y solamente a una clase.
La clase que posee la función main() puede declararse como public class y se
debe cumplir que el nombre del archivo debe ser el mismo que el de la clase, y
la extensión debe ser .java
 Regla 4. Un programa puede ser una colección de clases, que se
interrelacionan. Por lo tanto, se debe cumplir la Regla 3 si existe una clase con
la función main()
 Regla 5. Las clausula import como package es lo único permitido a estar por
fuera de cualquier clase.
Nota 1. Con la clausula import se puede acceder a todas las clases de un paquete
de clases.
Por ejemplo: import java.util.*; Se puede acceder a las clases StringTokenizer,

Hashtable, Scanner, etc del paquete de clases util
Nota 2. La manera como se escribe la función main() es:
public static void main(String[] args)
2.5 COMPILADORES
2.5.1 Compiladores en Línea de Java
Existen numerosas plataformas online de aprendizaje de lenguajes de programación

Java, mediante las cuales se puede editar el programa fuente, compilar la sintaxis,
ejecutar el programa y ver los resultados sin necesidad de tener plataformas robustas
como JCreator, NetBeans, Eclipse. Estas plataformas online compilan al instante
decenas de lenguajes distintos, sin necesidad de tener que instalar un IDE y un
compilador.
Caso TutorialsPoint - http://www.tutorialspoint.com/codingground.htm -
Colocar o pegar en esta ventana
El siguiente código java
import java.util.*;
import javax.swing.*;
public class CasoToken
{
{
int i,j,k;
String Cod="33,55,28,12";
String Nom="Pedro.Luis.Ines.Carlos";
String Not="2.5,4.2,1.3}4.3,2.8,2.5}2.5,3.6,1.8}4.6,3.8,4.2";
String S;
StringTokenizer T1=new StringTokenizer(Cod.toString (),",");
StringTokenizer T2=new StringTokenizer(Nom.toString(),".");
StringTokenizer T3=new StringTokenizer(Not.toString(),"}");
while(T1.hasMoreTokens() && T2.hasMoreTokens () && T3.hasMoreTokens())
{
System.out.println();
System.out.print(" Codigo: "+T1.nextToken());
System.out.print(" Nombre: "+T2.nextToken());
System.out.print(" Notas: "+T3.nextToken());
}
}
}
Pulsar el Botón Execute
Observar la ventana de resultados…

Caso Online Compiler and Editor Java IDE - www.jdoodle.com -
Colocar en la ventana de Código las siguientes líneas:

import java.util.*;
public class CasoToken
{
{
int i,j,k;
String Cod="33,55,28,12";
String Nom="Pedro.Luis.Ines.Carlos";
String Not="2.5,4.2,1.3}4.3,2.8,2.5}2.5,3.6,1.8}4.6,3.8,4.2";
String S;
StringTokenizer T2=new StringTokenizer(Nom.toString(),".");
StringTokenizer T3=new StringTokenizer(Not.toString(),"}");
{
System.out.print(" Codigo: "+T1.nextToken());
System.out.print(" Notas: "+T3.nextToken());
}
}
}
Cambiar versión JDK a:
Compilar y Ejecutar
2.5.2 Compilador en Plataforma Netbeans
Taller Primer Programa Aplicativo NetBeans
Selección y ejecución
Tipo de Proyecto
Pulsar
Colocar como nombre Proyecto: Primero
Pulsar
Estructura del Proyecto:
Código Generado:
Nombre de Paquete: primero
Quitar comentarios para quedar así….
Antecedente
El método main en java es un estándar utilizado por la JVM (Java Virtual Machine)
para iniciar la ejecución de cualquier programa Java. Dicho método se conoce como
punto de entrada de la aplicación java

{
}
}
Algoritmo a Realizar
Se hace la multiplicación de dos números (c = a x b) por medio de sumas sucesivas, lo
primero que se debe hacer es forma algorítmica
Entero a, b, c, i
c=0
a=3
b=5
Para i = 1 hasta b
c=c+a
Fpara
Escriba c
Codificar
Colocar después de:
El siguiente Codigo java

int a=3, b=5,c=0, i ;
for(i=1; i<= b; i++)
c+=a;
System.out.println(“ La Suma igual a “+ c);
Quedando…
Ejecutar
Pulsar o F5
En la ventana OutPut-
Práctica De Potencia
Selección y ejecución
Tipo de Proyecto
Pulsar
. Pulsar
Quitar Comentarios…
Algoritmo a Realizar
Lo primero que se debe hacer es en forma algorítmica
Entero pot, b, n, i
pot=1
b= 3
n=5
Para i = 1 hasta n
pot = pot * b
Fpara
Escriba pot
Codificar
Colocar después de:
código java
int i,n=5,b=4,pot=1;
for(i=1;i<=n;i++)
pot=pot*b;
System.out.println("La Potencia es: "+pot);
Quedando….
Ejecutar
Pulsar o F5
En ventana Output-
2.6 Sentencias de Entrada/Salida
Entrada de Datos:
Forma 1: Clase DataInputStream
String S;
DataInputStream in=new DataInputStream(System.in);
System.out.println("Digite Cadena");
try
{
S=in.readLine();
}
catch(IOException e){}
Forma 2: El método showInputDialog
Este método nos permite mostrar diálogos estandarizados que nos piden que
introduzcamos algún dato. Al igual que en los métodos anteriores los argumentos que
utilizan principalmente son el mensaje a mostrar, el título, etc. A continuación vemos
un ejemplo de uso de este método.
String n = JOptionPane.showInputDialog(null, "Introduce el dato");
Como podemos observar en el código anterior este método nos devuelve una cadena
que contiene los datos que hemos introducido en el diálogo.
Nota: Debe utilizarse import javax.swing.*;
Forma 3:Clase Scanner

Se puede usar la Clase Scanner para realizar la entrada de datos desde teclado.
Scanner scanner = new Scanner(System.in);
System.out.print("Escriba dos números: ");
double x = scanner.nextDouble();
double y = scanner.nextDouble();
System.out.println("producto: " + (x + y));
La clase Scanner ofrece una serie de métodos que permiten ingresar tipos primitivos
de datos utilizando:
int nextInt() double nextDouble() boolean nextBoolean()

byte nextByte() float nextFloat()
short nextShort()
long nextLong()
Nota: Debe utilizarse import java.util.*;
Salida de Datos: System.out.println
Forma 1:
System.out.println( <Cadena> ); // Salta línea e publica cadena
System.out.print( <Cadena> ); // Publica cadena
Ejemplo:
System.out.println(“H o l a”);
Forma 2. El método showMessageDialog
Este método nos permite mostrar diálogos que muestran un mensaje y contienen un
botón de aceptación. Los parámetro mínimos necesarios dependen del carácter del
mensaje aunque general mente son la ventana padre, el mensaje a mostrar, el título
del diálogo y el tipo de mensaje que se mostrará. En las siguientes figuras podremos
ver algunos ejemplos junto al código que lo genera.
JOptionPane.showMessageDialog( null, “Diálogo de información”);
JOptionPane.showMessageDialog( null, “Diálogo de advertencia”, “Título del Mensaje”,

JOptionPane.WARNING_MESSAGE);
JOptionPane.showMessageDialog( null, “Diálogo de error”, “Título del Mensaje”,

JOptionPane.ERROR_MESSAGE);
Nota. Debe utilizarse import javax.swing.*;

2.7 ARBOL DE CONDICION
Cuando es necesario evaluar la presencia ó no de una condición
Es más sencillo entenderlo inicialmente como un árbol de condición para determinar
cuál es el camino lógico cuando se presente o no esta condición
Presencia
Condición
Ausencia
Ejemplo. Determinar cuándo es mayor de edad.
Árbol de Condición
ESCRIBA Mayor de Edad
Presencia
Edad>=18
Ausencia
ESCRIBA Menor de Edad
Ejemplo. Puntos Mínimos
Árbol de Condición
ESCRIBA Pasa la prueba
Presencia
Puntos>=6
Ausencia
ESCRIBA Repetir Prueba
SINTAXIS JAVA
Forma 1:
If( <condición> )
<sentencia> | <Bloque de Sentencias>
Forma 2:
If( <condición> )
else
Donde:
La palabra reservada else indica Ausencia
Las BNF son:
<condición>: : - < condicionante > ∫ <operador lógico> <condicionante>
<operador lógico>: : - && | |
<condicionante> : : - < variable > <operador de relación> <operación>
<operador de relación>:: - > < >= <= == !=
<operación> :: - <operando> ∫ <operador aritmético> <operando>
<operando>:: - <variable> | <numero>
<operador aritmético> :: - + / * -
<Bloque de Sentencias>: - { <sentencia> ; <sentencia>…}

PROGRAMAS EN JAVA COMPILADOS EN
http://www.tutorialspoint.com/codingground.htm
Programa De Mayor De Edad
Programa Puntos Mínimos

2.8 AUTOMATA DE CICLO FINITO
Se conoce el número de veces a realizar determinada(s) actividad(es)
Se realiza en cuatro momentos:
E0. Previo al Autómata
a. Inicializar el Índice
b. Comparar el Índice contra una cota o limite superior e inferior
c. Actividad(es) a Realizar
d. Incremento o decremento de Índice
b
d
Existen dos clases de Autómata de Ciclo Finito:
- Incremental
- Decremental
MOMENTOS INCREMENTAL DECREMENTAL
a INDICE=LIMITE INFERIOR INDICE=LIMITE SUPERIOR
b INDICE <= LIMITE SUPERIOR INDICE >= LIMITE INFERIOR
c SENTENCIA(S) SENTENCIA(S)
d INDICE=INDICE+1 INDICE=INDICE-1
IR AL MOMENTO b IR AL MOMENTO b
SINTAXIS JAVA:
for( a; b; d)
c
Donde
c::- ; | <Sentencia> | <Bloque de Sentencias>
EJEMPLOS:
1. La Multiplicación de A X B por medio de Suma. Esta suma se representa como la
sumatoria de B en A – Veces.
A
∑ B=0+B+B+B
i=1 A - Veces
El índice i va desde 1 hasta A ó sea

i = 1… A
Limite Inferior =1
Limite Superior = A
E0.
S=0 La Sumatoria se debe iniciar en 0
Lea A
Lea B
Autómata
a. i=1
b. i <= A
c. S=S+B
d. i=i+1
ir al Momento b
2. El Factorial de un numero n.
Lea n
Л i = 1*1*2*3*….n (Multiplicatoria de i n veces)
i=1 n - Veces
El índice i va desde 1 hasta n ó sea

i = 1… n
Limite Inferior =1
Limite Superior = n
E0.
F=1 La Multiplicatoria se debe iniciar en 1
Lea n
Autómata
a. i=1
b. i <= n
c. F = F * i
d. i=i+1
ir al Momento b
3. Listar hasta el Termino n esimo de la serie de Fibonacci

El índice i va desde 1 hasta n ó sea
i = 1… n
Limite Inferior =1
Limite Superior = n
E0.
Padre=0
Abuelo= 1
Lea n
Autómata
a. i=1
b. i <= n
c. Nieto = Padre + Abuelo
Escribir Nieto
Abuelo = Padre
Padre = Nieto
d. i=i+1
ir al Momento b
4. Lectura y escritura de un vector

Un vector es un Arreglo Unidimensional
Se debe declarar un Vector de n – posiciones. Las posiciones de un vector en este
caso inician en 0 y llegan hasta la posición n-1
0 1 2 3 4 . . . n -1
A
Entonces para recorrer un vector se requiere de un índice que:

indice = 0 … n – 1
Limite Inferior = 0
Limite Superior = n – 1
E0:
Constante Entera n = 10
Entera A [n] Se declara el Vector A de n – posiciones
Autómata de Lectura
a. i = 0
b. i < n // También se puede colocar i < = n - 1
c. Lea A[ i ]
d. i =i + 1
ir al Momento b
Autómata de Escritura
a. i = 0
b. i < n
c. Escribir A[ i ]
d. i =i + 1
ir al Momento b
PROGRAMA EN JAVA
public class Prueba6

{
public static void main(String args[])
{
int n,i,j,aux;
int A[];
n=(int) (Math.random()*10)+3;
System.out.println("n: "+n);
A=new int[n];
for(i=0;i<A.length;i++)
{
System.out.print("Digite A["+i+"]: ");
A[i]=(int) (Math.random()*20)+3;
}
System.out.println("Vector Leido");
{
System.out.print(A[i]+" ");
}
System.exit(0);
}
}
CICLO ANIDADOS
Se presenta cuando un Autómata hace parte del momento c de otro Autómata. Se

representa de la siguiente manera:
Entonces se habla de un Autómata Externo y un Autómata Interno.

5. A nivel de interpretación, se va a ilustrar un Autómata de Horas y un Autómata de
Minutos.
El Autómata de Horas es el Externo y su índice Hora va desde 0 hasta 23
El Autómata de Minutos es el interno y su índice Minuto va desde 0 hasta 59
Autómata Externo
a. Hora = 0
b. Hora < = 23
c. Autómata Interno
a. Minuto = 0
b. Minuto < = 59
c. Mostrar Hora: Minuto
d. Minuto = Minuto +1
Ir al Momento b del Autómata Interno
Fin Autómata Interno
d. Hora = Hora +1
Ir al Momento b del Autómata externo
PROGRAMA EN JAVA

{
{
int Hora, Minuto;
for(Hora=0;Hora<24;Hora++)
{
for(Minuto=0;Minuto<60;Minuto++)
System.out.println(Hora+":"+Minuto);
}
}
}
6. Lectura y Escritura de una matriz

Una Matriz es un Arreglo Bidimensional. Se puede representar como un conjunto de
Vectores, donde se estructura por filas y columnas
Se debe declarar una Matriz de n – posiciones por n - posiciones.
Donde las primeras n – Posiciones representan las Filas
Las Segundas n – Posiciones representan las Columnas
En el caso de Java como C, las filas como las columnas inician en 0 y llegan hasta la
posición n-1
0 1 2 3 4 . . . n -1
0
A FILAS
n-1
COLUMNAS
Para recorrer una Matriz se requiere de un índice para las filas y otro índice para las
columnas:
Entonces, se necesita de dos Autómatas uno Externo para recorrer filas y un Interno
para recorrer columna por columna de la fila activa ( índice autómata externo).
indice Externo= 0 … n – 1. Se toma como el índice i
Indice Interno= 0… n – 1. Se toma como el índice j
Limite Inferior = 0
Limite Superior = n – 1
E0:
Entera A [n] [n] Se declara una Matriz A de n – posiciones por n - posiciones
Autómata de Lectura
Autómata Externo
a. i = 0
b. i < n
c.
Autómata Interno
a. j=0
b. j < n
c. Lea A[ i ] [ j ]
d. j = j +1
ir al momento b del Autómata Interno
d. i =i + 1
ir al Momento b del Autómata Externo
Autómata de Escritura
Autómata Externo
a. i = 0
b. i < n
c.
Salto de Línea
Autómata Interno
a. j=0
b. j < n
c. Escriba A[ i ] [ j ]
d. j = j +1
d. i =i + 1
PROGRAMA EN JAVA
{
{
int filas, columnas,i,j;
filas=(int) (Math.random()*10)+3;
System.out.println("filas: "+filas);
columnas=(int) (Math.random()*10)+3;
System.out.println("columnas: "+columnas);
int A[][]=new int[filas][columnas];
//Lectura()
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
System.out.print("Digite A["+i+"]["+j+"]: ");
A[i][j]=(int) (Math.random()*20)+3;
}
}
//Escritura
System.out.println(" ------ Matriz Leida -------");
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
if(A[i][j]>=10)
System.out.print(A[i][j]+" ");
else
}
}
System.exit(0);
}
}
7. Ordenamiento de un Vector
Solo se analiza el Autómata de Ordenamiento de un vector n – posiciones porque los
autómatas de lectura y escritura en un vector fueron ya analizados.
Se toma como caso un ordenamiento sencillo que este autor lo denomina lineal que
consiste en dos índices (indica posición dentro del vector) comparado y comparante:
Comparado Comparante
Posición 0 Posición 1 hasta n -1
Se concluye entonces
Autómata Externo Autómata Interno
Posición i= 0…n - 2 Posición j= i + 1 …. n - 1

E0:
Autómata de lectura de vector
Autómata de Escritura de Vector
Autómata Externo(Comparado)
a. i=0
b. i < n -1 // Igual a n < = n-2
c.
Autómata Interno(Comparante)
a. j = i + 1
b. j < n // Igual a n<= n -1
c. Si A[ i ] > A[ j ]
k= A[ i]
A[ i ] = A[ j ]
A[ j ] = k
Fin Si
d. j = j +1
d. i =i + 1
Fin Autómata Externo
Autómata Escritura vector
public class OrdenVector
{
{
int n,i,j,aux;
int A[];
System.out.println("Dimension: "+n);
A=new int[n];
{
}
{
}
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
System.out.println("Vector Ordenado");
{
}
}
}
AUTOMATA DE CICLO MIENTRAS QUE
Se realiza una sentencia(s) siempre y cuando se presente una condición. Esta
condición se denomina Condición de Permanencia (CP) .
Semánticamente se expresa Mientras que se cumpla con la condición de
Permanencia se realizan las sentencias
Es muy importante, tener en cuenta que la condición cambie de valor en algún
instante.
E0
b
d
Este Autómata evalúa la condición de Permanencia antes de realizar sentencias

(momento c), por eso se denomina Autómata de Pre Condición de Permanencia
MOMENTOS QUE PASA
E0 Estado Previo al Autómata
b. Si se cumple CP(Condición de Permanencia)
c. Sentencia(s)
d. Ir al Momento b
e. Condición de Salida = negacion(CP)
SINTAXIS JAVA:
while( b)
c
Donde
El BNF es el siguiente:
<condición de Permanencia>: : - < condicionante > ∫ <operador lógico>

<condicionante>
8. Digitalización de un Numero
Un número es un conjunto de dígitos:
<Digito>:-|0|1|...|9|
<Numero>:- ∫ <digito>
Dado un número se debe llevar cada digito a una posición de un vector. Entonces,
La Unidad del Número a la Posición 0
La Décima del Número a la Posición 1
La Centésima del Número a la posición 2
y así sucesivamente.
E0:
Entero A[n] Vector de n - posiciones
Lea x // Numero
tope=-1 // Cuando ingresa al ciclo se incrementa y debe cumplir tope=0…n-1
Condición de Permanencia (CP)

CP:: tope<n AND x>0 // x>0 Porque debe tener dígitos a obtener
Autómata Mientras Que
b. si tope<n AND x>0 (CP)

c.
tope=tope+1
A[tope]= residuo(x,10) // x residuo de 10
x= x /10
d. ir a b
Fin Autómata Mientras Que
Autómata Escribir Vector:( 0…tope)
PROGRAMA EN Java
public class Digital
{
{
int n,i,x,tope=-1;
int A[];
n=6;
System.out.println("Numero de Digitos: "+n);
A=new int[n];
x=(int) (Math.random()*100000)+1000;
System.out.println("Numero a Digitalizar: "+x);
while(tope<n && x>0)
{
tope++;
A[tope]= x % 10;
x/=10;
}
System.out.println("Numero Digitalizado: ");
for(i=tope;i>=0;i--)
System.out.println("A["+i+"]: "+A[i]+" ");
}
}
9. Búsqueda de un valor x en un vector no ordenado
E0:
Lectura x // valor a buscar dentro del vector
Autómata de Escritura de vector
Condición de Permanencia (CP):: i<n AND A[ i ] sea diferente de x
i=0
Autómata de Búsqueda de Valor:
b. i<n AND A[ i ] sea diferente de x
c.
i= i +1
d. ir a b
Fin Autómata de Búsqueda de Valor
ESCRIBA Existe x en la posición i
Presencia
i<n
Ausencia
ESCRIBA No exista el valor x

PROGRAMA EN Java
public class Busqueda1
{
{
int n,i,j,x;
int A[];
A=new int[n];
{
}
{
}
x=(int) (Math.random()*20)+3;
System.out.println("Numero a Buscar: "+x);
i=0;
while(i<n && A[i]!=x)
i++;
if(i<n)
System.out.println(" Encontrado en la Posicion: "+i);
else
System.out.println(" No Encontrado ");
}
}
10. Verificar si el número n es primo o no.
Los Números primos son aquellos que son divisible por si mismo y por la unidad.
Entonces, el índice debe empezar en 2 y terminar en la raíz cuadrada o en la mitad del
número.
Se toma entonces el intervalo del índice como de 2 hasta n/2
E0.
Lea n
i=2
CP:: i<=n/2 AND residuo(n,i) no sea 0 , ó sea, n no sea múltiplo de i
Autómata del Primo

b. si i<=n/2 AND residuo(n,i) no sea 0
c.
i=i+1
d.
ir a b
ESCRIBA n no es primo
Presencia
i<= n /2
Ausencia
ESCRIBA n es primo
Fin Autómata del Primo
PROGRAMA EN JAVA
public class Primo
{
{
int i,n;
i=2;
while(i<=(int) Math.sqrt(n) && n%i!=0)
i++;
if(i<=(int) Math.sqrt(n))
System.out.println(n+" No es primo ");
else
System.out.println(n+" Es primo ");
}
}
Algo muy interesante para enriquecer y relacionar los dos autómatas cíclicos (finito y
mientras que) se presenta bajo dos antecedentes:
- Antecedente 1: Existe un conteo ó rango que comprende un límite inferior

hasta límite superior
- Antecedente 2: Cuando el índice que controla el conteo o rango esta presente
en los condicionantes de la condición de Permanencia.
En el caso de verificar si el número n es primo o no.
El índice i se establece entre 2 hasta n/2(condicionante 1)
El residuo(n,i) no sea 0 (condicionante 2)
Por lo tanto, se puede realizar también en el autómata de ciclo finito con condición de
permanencia
SINTAXIS JAVA:
for( a; b; d)
c
E0.
Lea n
CP:: i<=n/2 AND residuo(n,i) no sea 0 , ó sea, n no sea múltiplo de i
Autómata del Primo
a. i = 2
b. si i<=n/2 AND residuo(n,i) no sea 0
c.
d. i = i + 1
ir a b
Fin Autómata del Primo
ESCRIBA n no es primo
Presencia
i<= n /2
Ausencia
ESCRIBA n es primo
PROGRAMA EN JAVA
{
{
int i,n;
i=2;
for(i=2;i<=n/2 && n%i!=0;i++);
if(i<=n/2)
System.out.println(n+" No es primo ");
else
System.out.println(n+" Es primo ");
}
}
OTRO PROGRAMA DE BUSQUEDA EN UN VECTOR

{
{
int n,i,j,x,aux;
int A[];
A=new int[n];
{
}
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
{
}
System.out.println("Numero a Buscar: "+x);
i=0;
while(i<A.length && A[i]<x)
i++;
if(i<A.length && A[i]==x)
System.out.println("Existe: "+x+" en la Posicion: "+i);
else
System.out.println("No Existe ");
System.exit(0);
}
}
AUTOMATA DE CICLO HAGA MIENTRAS QUE
Se realiza una sentencia(s) siempre y cuando se presente una condición. Esta
condición se denomina Condición de Permanencia (CP).
Semánticamente se expresa como Haga las sentencias Mientras que se cumpla con
la condición de Permanencia.
Es muy importante, tener en cuenta que la condición cambie de valor en algún
instante.
E0
Este Autómata realizar sentencias (momento c) y después evalúa la condición de

Permanencia , por eso se denomina Autómata de Post Condición de Permanencia
MOMENTOS QUE PASA
E0 Estado Previo al Autómata
c. Sentencia(s)
b. Si se cumple CP(Condición de Permanencia)
ir al Momento c
e. Condición de Salida = negacion(CP)
SINTAXIS Java:
do
{
c
while( b);
Donde
El BNF es el siguiente:
<condición de Permanencia>: : - < condicionante > ∫ <operador lógico>

<condicionante>
11. Validación de un Numero
Se desea que una Calificación este este entre 1…100
E0:
En este caso se aplica la conceptualización de:
CP = negación (Condición de Salida – CS)
CS:: nota>= 1 && nota < = 100 ; entonces
CP:: nota< 1 || nota > 100
Autómata Haga Mientras Que
c. Lea Nota
b. Si nota< 1 || nota > 100 ir a c
Fin Autómata Haga Mientras Que
ESCRIBA Pasa la prueba
Presencia
Nota>=60
Ausencia
ESCRIBA Repetir Prueba
Programa compilado

{
{
int nota;
do
{
nota=(int) (Math.random()*1000)+1;
System.out.println(" calificacion generada "+nota);
}
while(nota<1 || nota>100);
if(nota>=60)
System.out.print(nota+" Paso la Prueba ");
else
System.out.print(nota+" Perdio...repetir la Prueba ");
}
}
12. Búsqueda Binaria
Previamente debe estar ordenado el Vector
Se deben declarar tres índices minimo, maximo y mitad
Se debe buscar un numero x en la mitad…de la mitad…del vector
donde mitad= (minimo+maximo)/2
E0:
Autómata de Ordenamiento de Vector
minimo=0
maximo=n-1
Lea x // valor a buscar
En este caso se aplica la conceptualización de:
CP = negación (Condición de Salida – CS-)
CS:: minimo > maximo || A[mitad] == x
CP:: minimo <= maximo || A[mitad] no es igual a x

Autómata Haga Mientras Que
c.
mitad = (minimo+maximo) /2
minimo= mitad +1
Presencia
A[mitad]< x
Ausencia
maximo= mitad -1
Presencia
A[mitad]> x
Ausencia
b.
Si minimo <= maximo || A[mitad] no es igual a x vaya a c.
Fin Autómata Haga Mientras Que
Existe posición mitad
Presencia
A[mitad]= = x
Ausencia
No existe
Programa compilado
{
{
int n,i,j,x,aux;
int menor,mayor,mitad;
int A[];
A=new int[n];
{
}
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
{
}
menor=0;
mayor=A.length-1;
do
{
mitad=(menor+mayor)/2;
if(A[mitad]>x)
mayor=mitad-1;
if(A[mitad]<x)
menor=mitad+1;
}
while(A[mitad]!=x && mayor>=menor);
if(A[mitad]==x)
System.out.println("Existe: "+x+" en la Posicion: "+mitad);
else
System.out.println("No Existe ");
}
}
AUTOMATA DE SELECCION
De Acuerdo al valor de una y solamente una variable se realiza una acción.

La Categoría de Selección se da mediante:
- Atómico: Valor Unico.
- Conjunto de Valores: Valor1, Valor2, Valor3
- Cota: >= Valor
<= Valor
< Valor
> Valor
- SINO: Cuando no se presenta los anteriores valores
También se puede crear un árbol de selección así:
Único
Valor1, Valor2
Variables
Valor3 Hasta Valor4
Cota
En el caso del lenguaje Java la categoría de selección es Único.
SINTAXIS JAVA:
switch(variable)
{
case valor1 :
<sentencia> | <conjunto de sentencias>
[ break; ]
case valor2 :
[ break; ]
[ default:
]
}
La cláusula break: Es opcional. Rompe la continuidad de casos.
La cláusula default: Es opcional. Cuando el valor de variable no está en el rango o

caso de valores.
Ejemplo:
Se desea clasificar por edades del 1 al 9.
La edad del 2 al 4 es Párvulos
La edad del 5 al 6 es Kinder
La edad del 7 al 9 es Infantil
switch (edad)
{
case 2:
case 3:
case 4:
cout<<”Parvulos “;
break;
case 5:
case 6:
cout<<”Kinder “;
break;
case 7:
case 8:
case 9:
cout<<”Infantil“;
default:
cout<<” Mal Leída la Edad”;
}
Si la edad leída es de valor 3 se toma el caso 3 y 4 caso escribiendo “Párvulos” y se
sale del switch por la cláusula break
Si la edad leída no está en el rango de 2 al 9 se activa el segmento default

imprimiendo
Mal Leída la Edad

13. Identificar Categoría según la Edad.
La edad del 2 al 4 es Párvulos
La edad del 5 al 6 es Kinder
La edad del 7 al 9 es Infantil
E0:
Lea Edad
Autómata de Selección
Parvulos
2,3,4
5,6
kinder
edad
7,8,9
infantil
sino
Error
PROGRAMA EN JAVA
import java.util.*;
{
{
int edad;
edad=(int) (Math.random()*10)+1;
System.out.println("Edad: "+edad);
switch (edad)
{
case 2:
case 3:
case 4:
System.out.println("Parvulos ");
break;
case 5:
case 6:
System.out.println("Kinder ");
break;
case 7:
case 8:
case 9:
System.out.println("Infantil");
default:
System.out.println("Mal Generada la Edad");
}
}
}
16. Identificar Digito: Unidad, decena, centena, mil de un número
Autómata Haga Mientras Que (Validar que el numero este entre 1…9999)
c.
Lea numero
b. si numero <1 || numero> 9999 ir a c
Fin Autómata Haga Mientras Que (Validar que el numero este entre 1…9999)
Autómata Mientras Que (Digitalizar el numero)
E0:
n = -1
b. si numero >0
c.
n++
A[n]=residuo(n,10)
n = n /10
ir a b
Fin Autómata Mientras Que (Digitalizar el numero)
unidad
0
1
decena
i
2
centena
3
mil
PROGRAMA EN JAVA
{
{
int i,x,n=-1;
int A[]=new int[4];
System.out.println("Numero a digitalizar[1...9999]: "+x);
while(x>0)
{
n++;
A[n]= x % 10;
x/=10;
}
System.out.println("Numero Digitalizado: ");
for(i=0;i<=n;i++)
switch(i)
{
case 0:
System.out.println("Unidad: "+A[i]+" ");
break;
case 1:
System.out.println("Decena: "+A[i]+" ");
break;
case 2:
System.out.println("Centena: "+A[i]+" ");
break;
case 3:
System.out.println("Mil: "+A[i]+" ");
break;
}
}
}
17. Un Menú de Operaciones Aritméticas
Se lee una variable denominada opción.
Si tecla = 1 se hace suma( c= a + b)
Si tecla = 2 se hace resta( c= a - b)
Si tecla = 3 se se hace multiplicación(c= a * b)
Si tecla = 4 se se hace división(c= a / b)
Si tecla = 5 se sale del programa.
Para este programa se necesita un autómata Haga Mientras Que opción no sea igual
a5
E0:
Lea a,b
Autómata Haga Mientras Que (permanencia en el Programa)
c.
Autómata Haga Mientras Que (Validar que opcion sea 1 a 5)
c.
Borrar Pantalla
Mostrar Opciones
Lea opcion
b. si opcion <1 || opcion > 5 ir a c
Fin Autómata Haga Mientras Que (Validar que opcion sea 1 a 5)
c = a+b
1
2
c= a -b
opcion
3
c= a * b
4
c = a /b
Mostar resultado de Operación
b. si opcion no es igual a 5 ir a c
PROGRAMA EN JAVA
{
{
int a,b,c,opcion;
b = (int) (Math.random()*10)+2;
System.out.println(" Valor de b: "+b);
a = (int) (Math.random()*20)+b;
System.out.println(" Valor de a: "+a);
do
{
do
{
System.out.println("1. Suma ");
System.out.println("2. Resta");
System.out.println("3. Multiplicacion");
System.out.println("4. Division");
System.out.println("5. Salir ");
opcion = (int) (Math.random()*5)+1;
System.out.println("Opcion:"+opcion);
}
while(opcion<1 || opcion>5);
switch(opcion)
{
case 1:
c=a+b;
System.out.println(c+" = "+a+" + "+b);
break;
case 2:
c=a-b;
System.out.println(c+" = "+a+" - "+b);
break;
case 3:
c=a*b;
System.out.println(c+" = "+a+" * "+b);
break;
case 4:
c=a/b;
System.out.println(c+" = "+a+" / "+b);
break;
}
}
while(opcion!=5);
}
}
SEGUNDA PARTE. SISTEMAS BASADOS EN CLASES

SISTEMAS BASADOS EN CLASES
1. ¿Qué es una clase?
Una clase es algo abstracto que define la "forma" del objeto, se podría hablar de la
clase como el molde o la plantilla de los objetos.
En el mundo real existen objetos del mismo tipo, por ejemplo una cuenta bancaria es
solo una más de todas cuentas bancarias de un banco.. Entonces se dira que una
cuenta bancaria es una instancia de la clase "Cuenta Bancaria". Todas las cuentas
bancarias tienen los cuenta habiente, número de cuenta, saldo, tipo y métodos: retirar,
depositar, consultar, transferir.
Si se pensara de manera febril, la fábrica de cuentas bancaria utiliza moldes o
plantillas para producir y ofrecer productos como cuenta corriente o cuenta de ahorros.
Por lo tanto, de la misma forma en SOO se utiliza la clase cuenta bancaria (molde)
para producir sus instancias (objetos).
Los objetos son instancias de clases.
Ejemplo: Podríamos tener la clase Perro, una instancia de esta clase podría ser el
objeto perro llamado "Balú". La clase Perro especificaría que todos los perros tendrían
un nombre, color de pelo, raza, una altura. Mientras que la instancia "Balú" contendrá
valores específicos para cada uno de estos atributos.
Podemos definir a una clase como una plantilla que define variables y métodos
comunes para todos los objetos de cierto tipo.
Se representa una clase mediante un diagrama de clase, así:
Es similar el diagrama de objetos con el diagrama de clase. Pero, al diagrama de clase

se le ha adicionado los posibles estados que pueden tener los objetos que se
instancian a partir de la clase.
Estos estados se determinan mediante una condición, a saberse:
Normal:: saldo >10000
Sobregiro:: saldo <0
Base:: 0 < saldo < 10000
2. Mensajes
Un objeto por si solo no tiene mucho significado. Ejemplo: el objeto "cuenta" no tiene
mucho sentido si no interactúa con un objeto "persona" o un sistema que haga uso de
los métodos.
La interacción entre objetos se produce mediante mensajes. Los mensajes son
llamados a métodos de un objeto en particular.
Podemos decir que el objeto persona envía el mensaje "retiro" al objeto cuenta.
Los mensajes pueden contener parámetros. Por ejemplo teniendo un método en la
clase cuenta llamado "retiro" que recibe como parámetro el monto.
Un mensaje esta compuesto por los siguientes tres elementos:
El objeto destino, hacia el cual el mensaje es enviado
El nombre del método a llamar
Los parámetros solicitados por el método.
Entonces para el caso de la cuenta::
Cuenta.retiro(50000). El nombre del objeto es Cuenta, el método a emplearse es
Retiro y el parámetro es $50000
3. Beneficios de los Mensajes
Como todo lo que un objeto puede hacer esta expresado mediante métodos, el envío
de mensajes soporta todas las posibles interacciones entre objetos.
Para enviar o recibir mensajes, los objetos no necesitan formar parte del mismo
proceso, ni siquiera de la misma máquina.
4. Herencia
Los sistemas orientados a objetos permiten definir clases en término de otras clases.
Por ejemplo cuenta corriente y cuenta de ahorros son diferentes tipos de cuentas
bancarias. En la terminología orientada a objetos "Cuenta de Ahorros" y "Cuenta
Corriente" son subclases de la clase Cuenta. De forma similar Cuenta es la
superclase de "Cuenta de Ahorros".
Entonces tenemos la siguiente jerarquía de clases:
En este gráfico se representa la relación de herencia mediante una flecha.

Cada subclase hereda los atributos de la superclase. Tanto la clase "Cuenta de
Ahorros" como "Cuenta Corriente" tendrán los atributos Número, titular, saldo definido
en la clase Cuenta
Una subclase no está limitada únicamente a los atributos de su superclase, también
puede tener atributos propios, o redefinir algunos definidos anteriormente en la
superclase.
No se está limitado tampoco a un solo nivel de herencia, se pueden tener todos los
que se consideren necesarios.
Ejemplo:
Clase Empleado hereda de clase Humano, y esta a su vez hereda de clase Mamífero
5. Polimorfismo
En Sistemas Orientados a Objetos (SOO) el polimorfismo se refiere a la capacidad
para que varias clases derivadas (subclases) de una superclase utilicen un mismo
método de forma diferente.
Por ejemplo, podemos crear dos clases distintas: Pez y Ave que heredan de la
superclase Animal. La superclase Animal tiene el método mover que se implementa de
forma distinta en cada una de las subclases (peces y aves se mueven de forma
distinta).
6. Clases finales
Se puede declarar una clase como final, cuando no se interesa en heredar o crear
objetos derivados de dicha clase.
Por ejemplo, la clase Matemáticas tiene variables y métodos para realizar operaciones
trigonométricas, aritméticas.
Las variables pueden ser:
E (nepper) = 2.7182818284590452354
PI = 3.14159265358979323846
Los Métodos pueden ser:
Valor absoluto
Mínimo y Máximo entre dos números
Raíz Cuadrada
Potencia
Seno, Coseno
Generación de Numero Randomico
7. Clases Abstractas
La abstracción es un recurso de la mente (quizás el más característico de nuestra
pretendida superioridad respecto del mundo animal). Por su parte, los sistemas
orientados a objetos (SOO) permiten expresar la solución de un problema de forma
comprensible simultáneamente en un sistema artificial y el humano. Constituyen un
puente entre la abstracción de la mente y una serie de métodos a programar en un
lenguaje de programación orientado a objetos (LPOO). En consecuencia, la capacidad
de abstracción es una característica deseable de los SOO, pues cuanto mayor sea,
mayor será su aproximación al lado humano. Es decir, con la imagen existente en la
mente del diseñador de sistemas.
De hecho, las clases abstractas presentan un nivel de "abstracción" tan elevado que
no sirven para instanciar objetos de ellas. Representan los escalones más elevados de
algunas jerarquías de clases y solo sirven para derivar otras clases, en las que se van
implementando detalles y concreciones, hasta que finalmente presentan un nivel de
definición suficiente que permita instanciar objetos concretos. Se suelen utilizar en
aquellos casos en que se quiere que una serie de clases mantengan una cierta
característica o interfaz común. Por esta razón a veces se dice de ellas que son pura
interfaz.
Resulta evidente en el ejemplo de la figura que los diversos tipos de motores tienen
características diferentes. Realmente tienen poco en común un motor eléctrico de
corriente alterna y una turbina de vapor. Sin embargo, la construcción de una jerarquía
en la que todos motores desciendan de un ancestro común, la clase abstracta
"Motores", presenta la ventaja de unificar la interfaz. Aunque evidentemente su
definición será tan "abstracta", que no pueda ser utilizada para instanciar directamente
ningún tipo de motor. En los SOO, las clases abstractas representa la noción de un
concepto general de clase del que solo pueden expresar métodos o actividades
comunes (métodos abstractos).
8. Interfaces
Las interfaces son expresiones puras de diseño. Se trata de auténticas
conceptualizaciones no implementadas que sirven de guía para definir un determinado
concepto (clase) y lo que debe hacer, pero sin desarrollar un mecanismo de solución.
Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser
implementados de diferentes maneras según las necesidades de un sistema.
9. Relaciones entre objetos/clases
En un sistema orientado a objetos, los diversos objetos que lo componen han de
interactuar entre sí para lograr una serie de objetivos comunes.
Existen varios tipos de relaciones que pueden unir a los diferentes objetos, pero entre
ellas destacan las relaciones de: asociación, todo/parte, y
generalización/especialización.
a.) Relaciones de Asociación

Una asociación es una relación entre dos objetos que indica alguna conexión
significativa entre ellos. Las asociaciones útiles a determinar, suelen incluir el
conocimiento de una relación que ha de preservarse por algún tiempo: puede tratarse
de milisegundos o de años (según el contexto). Por ejemplo, ¿cuáles transacciones
están asociadas a cuenta corriente? Claro que sí, porque de lo contrario no sería
posible reconstruir la cuenta, imprimir el listado de transacciones ni calcular el total de
transacciones. Por otra parte, ¿necesitamos recordar una relación entre una Cuenta y
Gerente Sucursal? Probablemente no es indispensable ni útil dentro del contexto.
Una asociación se representa como una línea entre objetos, con el nombre de la
asociación. La asociación es intrínsecamente bidireccional, es un posible nexo lógico
entre los objetos. Este nexo es totalmente abstracto, no es una afirmación sobre las
conexiones entre las clases. Los extremos de una asociación pueden contener una
expresión de multiplicidad que indica la relación numérica entre los objetos.
Opcionalmente se puede poner una flecha que indique la dirección en que debe leerse
el nombre de la asociación (no indica nada más, es sólo una ayuda para leer la
asociación).
Realiza
Cuenta Corriente 1 * Transacción
Para identificar las asociaciones más comunes, la siguiente lista es de gran ayuda.
Categoría de la asociación Ejemplos
A es una parte física de B Auto- Partes
A es una parte lógica de B Detalle - Factura
A está físicamente contenido en B Caja-Tienda, Producto-Estante
A está contenido lógicamente en B Descripción de Producto-Catálogo
A es una descripción de B Descripción de Producto-Producto
A es un elemento de línea (o renglón) en una

Transacción - Cuenta
transacción o reporte B
A se
conoce/introduce/registra/presenta/captura en Venta-Caja
B
A es miembro de B Gerente-Banco
A es una unidad organizacional de B Departamento-Tienda
A usa o dirige a B Cajero-Caja
A se comunica con B Cliente-Cajero
A se relaciona con una transacción B Pago-Venta
A es una transacción relacionada con otra

Pago-Venta
transacción B
A es propiedad de B Caja-Tienda
Las asociaciones más importantes son las siguientes:
· A es una parte física o lógica de B
· A está física o lógicamente contenido en B
· A está registrado en B
Las asociaciones son importantes, pero no se debe dedicar tiempo excesivo a ellas.
Es más importante identificar los objetos que las asociaciones. Muchas asociaciones
tienden a confundir el modelo conceptual, en vez de aclararlo. Se pueden incorporar
las que se indican en los casos de uso, y las que se consideren necesarias para un
adecuado entendimiento del problema.
La multiplicidad define cuántas instancias de un tipo A pueden asociarse a una
instancia del tipo B en determinado momento. Las expresiones de multiplicidad son las
siguientes:
* cero o más, muchos
.* uno o más
.40 de uno a cuarenta
5 exactamente cinco
2,4,6 exactamente dos, cuatro o seis
b.) Relaciones de Todo/Parte
Muchas veces una determinada entidad existe como conjunción de otras entidades,
como un conglomerado de ellas. La orientación al objeto recoge este tipo de
relaciones como dos conceptos; la agregación y la composición.
En este tipo de relaciones un objeto componente se integra en un objeto compuesto.
La diferencia entre agregación y composición es que mientras que la composición
se entiende que dura durante toda la vida del objeto componedor. En la agregación
(referencia) no tiene por qué ser así. Es un tipo de relación dinámica, en donde el
tiempo de vida del objeto incluido es independiente del que lo incluye (el objeto base
utiliza al incluido para su funcionamiento).
Esto se puede implementar como un objeto (objeto compuesto) que cuenta entre sus
atributos con otro objeto distinto (objeto componente).
Un ejemplo es el siguiente:
Un Almacén posee Clientes y Cuentas (los rombos van en la clase que posee la
composición como la referencia).
Cuando se destruye el Objeto Almacén también son destruidos los objetos Cuenta
asociados, en cambio no son afectados los objetos Cliente asociados.
La composición (por Valor) se destaca por un rombo relleno.
La agregación (por Referencia) se destaca por un rombo transparente.
c.) Relaciones de Generalización/Especialización
A veces sucede que dos clases tiene muchas de sus partes en común, lo que
normalmente se abstrae en la creación de una tercera clase (padre de las dos) que
reúne todas sus características comunes.
El ejemplo más extendido de este tipo de relaciones es la herencia, propiedad por la
que una clase (clase hija) recoge aquellos métodos y atributos que una segunda clase
(clase padre) ha especificado como "heredables".
Este tipo de relaciones es característico de los sistemas orientados a objetos.
En realidad, la generalización y la especialización son diferentes perspectivas del
mismo concepto, la generalización es una perspectiva ascendente (bottom-up),
mientras que la especialización es una perspectiva descendente (top-down).
d) Dependencia.
La dependencia de clases es un concepto de sistemas orientados a objetos que nos
indica la relación existente entre dos clases. Como su nombre indica nos está diciendo
que una clase depende de otra para realizar su funcionamiento.
Cuando trabajamos con clases es una buena práctica que una clase realice una única
función. De manera que las clases que deban realizar funciones complejas estarán
formadas a partir de una asociación de diversas pequeñas clases en las que delegará
cada funcionalidad en concreto.
10. Modelo Conceptual o de Dominio (Diagrama de Clases)modelo conceptual o de
dominio muestra gráficamente, a través de un grupo de diagramas, los objetos, los
atributos y las asociaciones más importantes del dominio o sistema que se está
analizando.
Tipos de Relaciones
Tipos de Asociación
11. Que es una Metaclase
Es una clase cuyas instancias son clases en lugar de objetos. Es decir, si para
construir un objeto usas una clase, para construir una clase usas una metaclase.
Resulta muy útil principalmente para dos cosas:
o Cuando no sea posible determinar el tipo de un objeto hasta el momento de la
ejecución del programa, o cuando sea necesario crear una clase a la medida
de las circunstancias. Se podría decir que en este caso la metaclase funciona
como una “fábrica de clases” especializada.
o Cuando se desea componer o modificar el comportamiento o características de
una clase en el momento de su creación por medio de herencia o por
mecanismos de construcción dinámicos ( similar a patrón decorator)
PRIMER TALLER SISTEMAS BASADOS EN CLASES CON NETBEANS 8.0
PRIMERA PARTE. PLATAFORMA NETBEANS Y SU RELACION CON LA

PROGRAMACION BASADA EN CLASES
Ejecutar
Seleccionar File>>New Project…
Se va a crear un nuevo proyecto. Seleccionar y picar sobre el icono
Se debe seleccionar Java de la ventana de categorías
Ahora, se selecciona Java Application de tipo de proyecto. Pulsar el Botón Next

Nombre del Proyecto: Numeros
Verificar:
Pulsar el Botón Finish
El Netbeans genera la estructura de un proyecto con:
- Paquete de Programas Fuentes(Source Packages):: numeros
- Programa Principal:: Numeros.java

SEGUNDO MOMENTO CREACION DE LA CLASE BASE
Se debe posicionar sobre el paquete numeros y pulsar el botón derecho del

mouse>>opción new>>Java Class
La clase base sobre la que se va a trabajar se denomina Numero, por tanto:
Nombre de la Clase: Numero
El Netbeans genera:
Una clase publica Numero que se encuentra en el paquete de clases denominada

numeros.
La clase Numero debe cumplir:
- Definición de Variables
- Método Constructor con un argumento entero(int)
- Métodos de la clase como: conteo de dígitos, digitalizar, verificación de dígitos

únicos, naturaleza (perfecto, ególatra, amigo de)
Primer Paso Colocar las bibliotecas de clase (import) necesarias. La declaración de

bibliotecas de clases se debe colocar antes del public class Numero así:
Entonces, coloque import java.util.Arrays; antes de la línea public class Numero
Segundo Paso Colocar Variables. La definición de la variables se deben colocar

después de public class Numero {
int i,j,k; //variables índices

int n; // numero de digitos
int A[], B[]; // vector para almacenar los digitos
int s; // variable de sumatoria
int x;// numero a evaluar
int c;//variable contador
Quedando:
Tercer Paso. Generar los métodos constructores.
Con el argumento x que representa el número a evaluar y d es el número de dígitos

exigidos ( para el juego de picas y fijas es de 4)
public Numero(int x,int d)// numero y cantidad de dígitos

{
this.x=x;
n=cuantos(x);
if(d>n)
n=d;
A=new int[n];
B=new int[n];
digitaliza();
}
public Numero(int x)// numero a digitalizar
{
this.x=x;
n=cuantos(x);
A=new int[n];
B=new int[n];
digitaliza();
}
La cláusula this hace referencia al objeto contenedor de la variable, y en este caso,

evita ambigüedades porque en el método constructor emplea argumentos (int x) con el
mismo nombre de las variables de la clase Numero (this.x) diferenciando la variable de
la clase con el argumento recibido.
Además, se hace un llamado al método Digitaliza que su objetivo es convertir el
numero en un vector de dígitos que representa unidades, decenas, centenas, miles…
Cuarto Pasó Métodos de la clase. Colocar después del método constructor los
siguientes métodos
int cuantos(int p) //cuenta el numero de digitos

{
c=0;
while(p>0)
{
c++;
p/=10;
}
return c;
}
void digitaliza() //convierte el numero en un vector de digitos representando unidades,
decenas...
{
n=cuantos(x);
k=x;
A=new int[n];
B=new int[n];
for(i=0;i<n;i++)
{
A[i]=k%10;
k/=10;
}
}
int multiplos(int p) // suma los multiplos de un numero

{
s=0;
for(j=1;j<=p/2;j++)
if(p%j==0)
s+=j;
return s;
}
int base10(int C[],int base)//obtener el numero en una base
{
k=1;
s=0;
for(j=0;j<C.length;j++)
{
s=s+C[j]*k;
k*=base;
}
return s;
}
boolean unico()// verificacion de digitos unicos
{
boolean doble=false;
if(A[i]==A[j])
doble=true;
return doble;
}
int[] valor()
{
return A;
}
int potencia(int b,int m) // potencia de b elevado a la m
{
k=1;
for(j=1;j<=m;j++)
k*=b;
return k;
}
void duplicaContrario()
{
k=A.length-1;
{
B[k]=A[i];
k--;
}
}
//Naturalezas de Numeros
boolean perfecto() //suma de sus multiplos es igual a el mismo
{
if(x==multiplos(x))
return true;
else
return false;
}
void amigo()
{
int amigo1=multiplos(x);
int amigo2=multiplos(amigo1);
if(amigo2==x)
System.out.println(amigo1+" es amigo de "+x);
}
boolean egolatra()// la suma de las potencias n de sus digitos es igual a el mismo
{
s=0;
for(i=0;i<n;i++)
s=s+potencia(A[i],n);
if(s==x)
return true;
else
return false;
}
boolean magico()
int s1,s2;
Arrays.sort(A);
duplicaContrario();
s1=base10(A,10);
s2=base10(B,10);
if((s1-s2)==x)
return true;
else
return false;
Pulsar para salvar

TERCER MOMENTO CREACION DE LA CLASE VISTA
Se diseña una clase que liste los enteros de 100 a 999 para evaluar que naturaleza es
cada número

El nombre de la clase es Vista. Se pulsa el Botón Finish
El siguiente método se debe colocar después de public class Vista {
void listado()
{
int i;
Numero N;
for(i=100;i<=999;i++)
{
N=new Numero(i);
if(N.perfecto())
System.out.println(i+" es un numero perfecto");
if(N.magico())
System.out.println(i+" es un numero magico");
if(N.egolatra())
System.out.println(i+" es un numero egolatra");
N.amigo();
}
}
Pulsar para salvar
CUARTO MOMENTO ACTUALIZAR LA CLASE Numeros.java(Main)
Seleccione la clase Numeros(Main) del proyecto y de doble click
Escriba lo siguiente en // TODO code application logic here

Vista V=new Vista();
V.listado();
Pulsar la tecla F6 o el botón
Pulsar para salvar

SEGUNDO PARTE. CREACION DE LA CLASE PICAFIJA Y REUSO DE LA CLASE
NUMERO
El propósito de la clase PicaFija es simular el juego a partir de dos números:
El primer número es generado aleatoriamente.
El segundo número es leído desde el teclado por el usuario.
Ambos, números deben cumplir con:
- Ser digitalizados (digito unidad, decena, centena, mil)
- Los dígitos deben ser únicos
- Los valores recibidos deben ser hasta 9999
Las salidas deben ser:
Fija: cuando el digito i tanto del usuario y del computador son iguales
Pica: cuando el digito i del usuario esta en la posición j del computador

La clase base sobre la que se va a trabajar se denomina PicaFija, por tanto:
Nombre de clase. PicaFija. Pulse el Botón Finish

Se deben declarar a continuación del enunciado public class PicaFija { las variables
como el método:
int i,j;
void conteo(int A[],int B[],int P[])//A vector del computador B vector digitado
{
P[0]=0; //contador de fijas
P[1]=0; //contador de picas
for(j=0;j<A.length;j++)
if(A[i]==B[j])
if(i==j)
P[0]++;
else
P[1]++;
}
Pulsar para salvar

CREACION DE LA CLASE VISTA JUEGO
Se diseña una clase que permita realizar el juego haciendo uso de las clase Numero y
PicaFija. Entonces, se debe cumplir con:
El primer número es generado aleatoriamente en el objeto N.

El segundo número es leído desde el teclado por el usuario en el objeto M.
Ambos, números deben cumplir con:
- Ser digitalizados (digito unidad, decena, centena, mil)
- Los dígitos deben ser únicos
- Los valores recibidos deben ser hasta 9999
Las salidas deben ser:
Fija: cuando el digito i tanto del usuario y del computador son iguales
Pica: cuando el digito i del usuario esta en la posición j del computador

El nombre de la clase es Juego. Pulsar el Botón Finish
Primer Paso. Colocar las bibliotecas de clase (import) necesarias. La declaración de

bibliotecas de clases se debe colocar antes del public class Juego así:
Entonces, coloque:
import java.util.Date;
import java.util.Random;
antes de la línea public class Juego

Segundo paso. Las siguientes líneas se deben colocar después de public class Juego
{
public void jugar()

{
Numero N; // Numero a ser generado por el computador
Numero M; // Numero a ser digitador por el usuario
int P[]=new int[2];// Conteo de fijas y picas
PicaFija F=new PicaFija();
int n;
Date d=new Date();
Random R=new Random(d.getSeconds());
do
{
n=Math.abs(R.nextInt()%9999+1);
N=new Numero(n,4);
}while(N.unico());
do
{
do
{
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Numero "));
M=new Numero(n,4);
}
while(M.unico());
F.conteo(N.valor(), M.valor(), P);
JOptionPane.showMessageDialog(null,"Fijas:"+P[0]+" Picas:"+P[1]);
}
while(P[0]!=4); // se termina el juego cuando hay 4 fijas
}
Pulsar para salvar

ACTUALIZAR LA CLASE Numeros.java(Main)
Seleccione la clase Numeros.java del proyecto y de doble click
Modificar, el main con el siguiente código:
Juego J=new Juego();

J.jugar();
Termina el juego cuando se tenga 4 fijas o sea la condición de salida

cs:: P[0]==4
Cerrar la ventana de ejecución (Output)-Numeros(run):
Cerrar el proyecto:
Sobre el nombre del proyecto (Archivo)>>Botón derecho del Mouse>>Opción Close
SEGUNDO TALLER SISTEMAS BASADOS EN CLASES CON NETBEANS 8.0

Ejecutar

Nombre del Proyecto: Tokens
Verificar:
- Paquete de Programas Fuentes(Source Packages):: tokens
- Programa Principal:: Tokens.java

Se debe posicionar sobre el paquete tokens y pulsar el botón derecho del

La clase base sobre la que se va a trabajar se denomina Token, por tanto:
Nombre de la Clase: Token
El Netbeans genera:
Una clase publica Token que se encuentra en el paquete de clases denominada

tokens.
La clase Token debe cumplir:
- Método Constructor con un argumento String(String)
- Métodos de la clase como: Titulada, Numero, Parrafo, Fecha
Primer Paso Colocar las bibliotecas de clase (import) necesarias. La declaración de
bibliotecas de clases se debe colocar antes del public class Token así:
Entonces, coloque antes de la línea public class Token:

import java.text.*;
import java.util.*;
Segundo Paso Colocar Variables. La definición de la variables se deben colocar
después de
public class Token { quedando:
public class Token {
int i;
boolean es;
StringBuffer B;
String P;
}
Tercer Paso Generar los métodos constructores.
Con el argumento P que representa la cadena a evaluar:
public Token(String P)
this.P=P;
La cláusula this hace referencia al objeto contenedor de la variable, y en este caso,

evita ambigüedades porque en el método constructor emplea argumentos (String P)
con el mismo nombre de las variables de la clase Token (this.P) diferenciando la
variable de la clase con el argumento recibido.
siguientes
// Método que verifica si todos los caracteres son letras

String soloLetras()
{
es=true;
B=new StringBuffer();
for(i=0;i<P.length();i++)
if(!Character.isLetter(P.charAt(i)))
{
B.append(P.charAt(i));
B.append(" ");
es=false;
}
if(es)
return "Es solo Letras";
else
{
B.append(" No son letras");
return B.toString();
}
}
// Método que verifica si todos los caracteres son letras minuscula
String soloMinusculas()
{
es=true;
if(!Character.isLetter(P.charAt(i)) || !Character.isLowerCase(P.charAt(i)))
{
B.append(" ");
es=false;
}
if(es)
return "Es solo Minuscula";
else
{
B.append("No son Minusculas");
}
}
// Método que verifica si todos los caracteres son digitos
String soloDigitos()
{
es=true;
if(!Character.isDigit(P.charAt(i)))
{
B.append(" ");
es=false;
}
if(es)
return "Es solo Digitos";
else
{
B.append("No son Digitos");
}
}
// Método que verifica si todos los caracteres son letras y espacios en blanco
String soloParrafo()
{
es=true;
if(!Character.isLetter(P.charAt(i)) && !Character.isSpace(P.charAt(i)))
{
B.append(" ");
es=false;
}
if(es)
return "Es un Parrafo";
else
{
B.append(" No son elementos de un parrafo");
}
}
String soloFechas()
{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT, new
Locale("es"));
if (P == null)
return "No es formato fecha";
FormatoFecha.setLenient(false);
try {
FormatoFecha.parse(P.trim());
}
catch (ParseException pe)
{
return "No es formato fecha";
}
return "Es una Fecha";
}
String soloTituladas()
{
es=true;
for(i=0;i<P.length() && es;i++)
if(Character.isLetter(P.charAt(i)))
{
if(i==0) // Si es la primera letra
{
if(!Character.isUpperCase(P.charAt(i)))
es=false;
}
else // No es la primera letra
if(!Character.isLowerCase(P.charAt(i)))
es=false;
}
else
es=false;
if(es)
return "Es titulada";
else
return "No es titulada";
}
boolean soloLetra()
{
es=true;
{
es=false;
}
return es;
}
// Método que verifica si todos los caracteres son letras minuscula
boolean soloMinuscula()
{
es=true;
if(!Character.isLetter(P.charAt(i)) || !Character.isLowerCase(P.charAt(i)))
{
es=false;
}
return es;
}
boolean soloDigito()
{
es=true;
{
es=false;
}
return es;
}
boolean soloFecha()
{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT, new
Locale("es"));
if (P == null)
return false;
try {
FormatoFecha.parse(P.trim());
}
{
return false;
}
return true;
}
boolean soloTitulada()
{
es=true;
for(i=0;i<P.length() && es;i++)
{
{
es=false;
}
es=false;
}
else
es=false;
return es;
}
Pulsar para salvar

TERCER MOMENTO CREACION DE LA CLASE VISTA
Se diseña una clase que lea una cadena para evaluar que naturaleza de token.

El nombre de la clase es Vista. Se pulsa el Botón Finish
Colocar las bibliotecas de clase (import) necesarias. La declaración de bibliotecas de

clases se debe colocar antes del public class Vista así:
Entonces, coloque antes de la línea public class Vista:

void listado()
{
String S=JOptionPane.showInputDialog(null,"Digite Cadena");
Token T;
String A[]=S.split(" ");
int i;
{
T=new Token(A[i]);
S=A[i]+"\n";
S=S+T.soloDigitos()+"\n";
S=S+T.soloFechas()+"\n";
S=S+T.soloLetras()+"\n";
S=S+T.soloMinusculas()+"\n";
S=S+T.soloTituladas()+"\n";
JOptionPane.showMessageDialog(null, S);
}
}
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Tokens.java (Clase Main)
Seleccione la clase Tokens.java del proyecto y de doble click

V.
Seleccionar listado(). Quedando:

Pulsar para salvar

SEGUNDO PARTE. CREACION DE LA CLASE VISTA VALIDAR
Se diseña una clase que permita realizar validaciones haciendo uso de la clase Token.
Entonces, se debe cumplir que la cadena leída sea:
- titulada
- solo letra
- numero
- fecha

El nombre de la clase es Validar. Pulsar el Botón Finish

clases se debe colocar antes del public class Validar así:
Entonces, coloque antes de la línea public class Validar:

El siguiente método se debe colocar después de public class Validar {
void control()
{
String S="";
Token T;
do
{
S=JOptionPane.showInputDialog(null,"Teclee solo Letras: ",S).trim();
T=new Token(S);
}
while(!T.soloLetra());
do
{
S=JOptionPane.showInputDialog(null,"Teclee solo Digitos: ",S).trim();
T=new Token(S);
}
while(!T.soloDigito());
do
{
S=JOptionPane.showInputDialog(null,"Teclee Fecha(dia/mes/año): ",S).trim();
T=new Token(S);
}
while(!T.soloFecha());
do
{
S=JOptionPane.showInputDialog(null,"Teclee palabra Titulada: ",S).trim();
T=new Token(S);
}
while(!T.soloTitulada());
}
Pulsar para salvar

ACTUALIZAR LA CLASE Tokens.java (Clase Main)
Seleccione la clase Tokens.java del proyecto y de doble click
Escriba lo siguiente en el main

Validar V=new Validar();
V.control();

Cerrar la ventana de ejecución (Output)-Tokens(run):
Cerrar el proyecto:
Sobre el nombre del proyecto (Tokens)>>Botón derecho del Mouse>>Opción Close
TERCER TALLER SISTEMAS BASADOS EN CLASES CON NETBEANS 8.0

Ejecutar


Nombre del Proyecto: Arreglos
Verificar:

- Paquete de Programas Fuentes(Source Packages):: arreglos
- Programa Principal:: Arreglos.java
Se debe posicionar sobre el paquete arreglos y pulsar el botón derecho del

La clase base sobre la que se va a trabajar se denomina Admin, por tanto:
Nombre de la Clase: Admin

El Netbeans genera:
Reemplazar el Contenido por:

package arreglos;
public class Admin {
int i,k,max,n;
int A[];
public Admin(int n)
{
this.n=n;
A=new int[n];
max=-1;
}
public boolean vacio()
{
if(max==-1)
return true;
else
return false;
}
public boolean unico()
{
if(max==0)
return true;
else
return false;
}
public boolean buscar(int p)// p: valor
{
boolean esta=false;
i=0;
while(i<=max && !esta)
if(A[i]==p)
esta=true;
else
i++;
return esta;
}
public boolean lleno()
{
if(max==n-1)
return true;
else
return false;
}
public int maximo()
{
return max;
}
public String listar()
{
String cadena=" ";
for(i=0;i<=max;i++)
cadena=cadena+" "+A[i];
return cadena;
}
public void adicion(int p)// p: valor

{
max++;
A[max]=p;
}
public void insertar(int p, int q)// p: valor q: posicion
{
max++;
for(i=max;i>q;i--)
A[i]=A[i-1];
A[q]=p;
}
public void borrar(int q)//q: posicion
{
max--;
for(i=q;i<=max;i++)
A[i]=A[i+1];
}
public int[] consulta()
{
return A;
}
}
Pulsar para salvar
TERCER MOMENTO CREACION DE LA CLASE MENU

La clase base sobre la que se va a trabajar se denomina Menu, por tanto:

clases se debe colocar antes del public class Menu así:
Entonces, coloque antes de la línea public class Menu:

El siguiente método se debe colocar después de public class Menu {
void opciones()
{
int i,opc,p,q;
Admin V=new Admin(10);
Object [] valores = {"1. Adicion","2.Insertar","3.Borrar","4.Consultar","5.Salir"};
do
{
String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de
datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]);
opc=Character.digit(resp.charAt(0),10);
switch(opc)
{
case 1:
case 2:
if(V.lleno())
{
JOptionPane.showMessageDialog(null,"Vector LLeno");
break;
}
if(opc==2 && V.vacio())
break;
p=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número"));
if(V.buscar(p))
{
JOptionPane.showMessageDialog(null,"Existe Numero");
break;
}
if(opc==1)
{
V.adicion(p);
break;
}
do
{
q=Integer.parseInt(JOptionPane.showInputDialog(null,"Posicion
{0..."+V.maximo()+"]"));
}
while(q<0 || q>V.maximo());
V.insertar(p,q);
break;
case 3:
if(V.vacio())
{
JOptionPane.showMessageDialog(null,"Vector vacio");
break;
}
do
{
{0..."+V.maximo()+"]"));
}
V.borrar(q);
break;
case 4:
if(V.vacio())
{
break;
}
JOptionPane.showMessageDialog(null,V.listar());
}
}
while(opc!=5);
}
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Arreglos.java (Clase Main)
Seleccione la clase Arreglos.java del proyecto y de doble click

Menu M=new Menu();
M.
Seleccionar opciones(). Quedando:
Adicionar: 45, 18, 33, 27,18
Insertar: 20
Borrar:
Consulta:
Pulsar para salvar

CUARTO TALLER SISTEMAS BASADOS EN CLASES CON NETBEANS 8.0

Ejecutar

Nombre del Proyecto: ManejoFifo
Nota. El principio 'Primero en entrar, primero en salir' (F.I.F.O.='First In, First Out') se
aplica para las operaciones de Adición y Borrado de un Vector. En este ejercicio se
simulara una cola de atención de clientes (Adición: Llegada Borrar: Atención)
Verificar:

- Paquete de Programas Fuentes(Source Packages):: manejofifo
- Programa Principal:: ManejoFifo.java
PRIMER MOMENTO CREACION DE LA CLASE Cliente

Nombre de Clase: Cliente
Reemplazar contenido por:
package manejofifo;
public class Cliente {
int nit;
String nomCliente;
int telefono;
}
SEGUNDO MOMENTO CREACION DE LA CLASE Admin
La clase base sobre la que se va a trabajar se denomina Admin, por tanto:
Nombre de la Clase: Admin
El Netbeans genera:
Reemplazar el Contenido por:

package manejofifo;
int min,max,n;
Cliente A[];
int i;
public Admin(int n)
{
min=-1;
max=-1;
this.n=n;
A=new Cliente[n];
}
boolean vacia()
{
if(min==-1)
return true;
else
return false;
}
boolean llena()
{
if(max==n-1)
return true;
else
return false;
}
void adicion(Cliente C)
{
if(min==-1)
min++;
max++;
A[max]=new Cliente();
A[max].nit=C.nit;
A[max].telefono=C.telefono;
A[max].nomCliente=C.nomCliente;
}
void borra(Cliente C)
{
C.nit=A[min].nit;
C.telefono=A[min].telefono;
C.nomCliente=A[min].nomCliente;
if(min==max)
min=max=-1;
else
min++;
}
boolean existe(int nit)
{
boolean esta=false;
if(!vacia())
for(i=min;i<=max && ! esta;i++)
if(A[i].nit==nit)
esta=true;
return esta;
}
String imprime(String Aviso)
{
String S=" Elemenos de la Cola de: "+Aviso.toString()+"\n";
for(i=min;i<=max;i++)
{
S=S+" "+new String().valueOf(A[i].nit).toString();
S=S+" "+A[i].nomCliente;
S=S+" "+new String().valueOf(A[i].telefono).toString()+"\n";
}
return S.toString();
}
}
Pulsar para salvar

TERCER MOMENTO CREACION DE LA CLASE MENU

La clase base sobre la que se va a trabajar se denomina Menu, por tanto:
Se genera:

clases se debe colocar antes del public class Menu así:
Entonces, coloque antes de la línea public class Menu:

public void opciones()
{
int i,opc,nit;
Admin A=new Admin(10);
Admin B=new Admin(20);
Cliente C=new Cliente();
Object [] valores = {"1. Adicion","2. Borrar","3. Consulta Por Atender","4. Consulta
Atendidos","5.Salir"};
do
{
switch(opc)
{
case 1:
C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit"));
if(A.existe(C.nit) || B.existe(C.nit))
JOptionPane.showMessageDialog(null,"Existe Nit");
else
if(A.llena())
JOptionPane.showMessageDialog(null,"No se Puede Atender Mas");
else
{
C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre");
C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono"));
A.adicion(C);
}
break;
case 2:
if(A.vacia())
JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia");
else
{
A.borra(C);
if(!B.llena())
B.adicion(C);
}
break;
case 3:
if(A.vacia())
else
JOptionPane.showMessageDialog(null,A.imprime(" Atencion "));
break;
case 4:
if(B.vacia())
JOptionPane.showMessageDialog(null,"Cola de Atendidos Vacia");
else
JOptionPane.showMessageDialog(null,B.imprime(" Atencion "));
}
}
while(opc!=5);
}
Pulsar para salvar
CUARTO MOMENTO ACTUALIZAR LA CLASE ManejoFifo.java (Clase Main)

Seleccione la clase Arreglos.java del proyecto y de doble click

Menu M=new Menu();
M.
Seleccionar opciones (). Quedando:

Adicion: 45, 18, 33, 27

Consulta Por Atender
Borrar 2 Elementos
Consulta Atendidos
Consulta:
Pulsar para salvar

PRIMER TALLER CLASES ABSTRACTAS CON NETBEANS 8.0
Clases Abstractas en Java

Tomado de: http://www.arrakis.es/~abelp/ApuntesJava/ClasesAbstractas.htm
Java proporciona las clases y métodos abstractos. Un método abstracto es un
método declarado en una clase para el cual esa clase no proporciona la
implementación (el código). Una clase abstracta es una clase que tiene al
menos un método abstracto. Una clase que extiende a una clase abstracta
debe implementar los métodos abstractos (escribir el código) o bien volverlos a
declarar como abstractos, con lo que ella misma se convierte también en clase
abstracta.
Declaración e implementación de métodos abstractos
Siguiendo con el ejemplo del apartado anterior, se puede escribir:
abstract class FiguraGeometrica {
abstract void dibujar();
}
class Circulo extends FiguraGeometrica {
...
void dibujar() {
// codigo para dibujar Circulo
...
}
}
La clase abstracta se declara simplemente con el modificador abstract en su
declaración. Los métodos abstractos se declaran también con el mismo
modificador, declarando el método pero sin implementarlo (sin el bloque de
código encerrado entre {}). La clase derivada se declara e implementa de forma
normal, como cualquier otra. Sin embargo si no declara e implementa los
métodos abstractos de la clase base (en el ejemplo el método dibujar) el
compilador genera un error indicando que no se han implementado todos los
métodos abstractos y que, o bien, se implementan, o bien se declara la clase
abstracta.
DESARROLLO DE TALLER
Ejecutar
Nombre de Proyecto: Abstracta1
Verificar:

- Paquete de Programas Fuentes(Source Packages):: abstracta1
- Programa Principal:: Abstracta1.java
PRIMER MOMENTO CREACION DE LA CLASE ABSTRACTA Fibo (Serie de

Fibonacci)
Se debe posicionar sobre el paquete abstracta1 y pulsar el botón derecho del
Nombre de Clase: Fibo

Reemplazar el contenido del archivo por:
package abstracta1;
abstract class Fibo
{
abstract void opera();
int termino(int k)
{
int a=0;
int b=1;
int c=0;
for(int i=1;i<=k;i++)
{
c=a+b;
b=a;
a=c;
}
System.out.println("Termino: "+k+" de Serie Fibonacci:"+c);
return(c);
}
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO CREACION DE LA CLASE Media (Primera Clase que
extiende la clase Abstracta Fibo)
Nombre de Clase: Media

package abstracta1;
class Media extends Fibo
{
final int n=8;
int x;
int prom;
void opera()
{
prom=x/n;
}
public int valor()
{
x=super.termino(n);
opera();
System.out.println(prom+"="+x+"(x)/"+n+"(n)");
return(prom);
}
}
Quedando:
Pulsar para salvar

CUARTO MOMENTO CREACION DE LA CLASE Multi (Segunda Clase que
extiende la clase Abstracta Fibo)

Nombre de Clase: Multi

package abstracta1;
class Multi extends Fibo
{
final int n=6;
int x;
int m;
void opera()
{
m=x*n;
}
public int genera()
{
x=super.termino(n);
opera();
System.out.println(m+"="+x+"(x)*"+n+"(n)");
return(m);
}
}
Quedando:
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Abstracta1.java (Clase Main)
Seleccione la clase Abstracta1.java del proyecto y de doble click

package abstracta1;
public class Abstracta1 {
public static void main(String[] args) {
Media A=new Media();
Multi B=new Multi();
System.out.println(A.valor());
System.out.println(B.genera());
}
}
Quedando:
Pulsar para salvar

Ejecución
Pulsar la tecla F6 o
Cerrar Proyecto…sobre nombreproyecto>>Close

SEGUNDO TALLER CLASES ABSTRACTAS CON NETBEANS 8.0
DESARROLLO DE TALLER
Ejecutar

Nombre de Proyecto: Abstracta3
Verificar:

- Paquete de Programas Fuentes(Source Packages):: abstracta3
- Programa Principal:: Abstracta3.java
PRIMER MOMENTO CREACION DE LA CLASE ABSTRACTA Operaciones

(Operaciones Aritmeticas)
Nombre de Clase: Operaciones

package abstracta3;
abstract class Operaciones
{
abstract int suma(int a,int b);
abstract int resta(int a,int b);
abstract int multiplica(int a,int b);
abstract int division(int a,int b);
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO CREACION DE LA CLASE Operario (Clase que extiende la
clase Abstracta Operaciones)
Nombre de Clase: Operario

package abstracta3;
class Operario extends Operaciones {
int c,i,j;
@Override
int suma(int a,int b)
{
c=a+b;
return c;
}
@Override
int resta(int a,int b)
{
c=a-b;
return c;
}
@Override
int multiplica(int a,int b)
{
j=0;
for(i=1;i<=b;i++)
j=suma(j,a);
return j;
}
@Override
int division(int a,int b)
{
j=0;
while(a>=b)
{
j++;
a=a-b;
}
return j;
}
}
Quedando:
Pulsar para salvar

TERCER MOMENTO CREACION DE LA CLASE Menu
Nombre de Clase: Menu

package abstracta3;
public class Menu {
void opciones()
{
int fila=0,opc=0;
int c=0,d=0,e=0;
Operario A=new Operario();
do
{
System.out.println("1. Adicion ");
System.out.println("2. Resta ");
System.out.println("3. Division ");
System.out.println("4. Multiplicar");
System.out.println("5. Salir");
opc=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite
Opcion"));
if(opc!=5)
{
do
{
c=Integer.parseInt(JOptionPane.showInputDialog(null,"Primera
Variable"));
d=Integer.parseInt(JOptionPane.showInputDialog(null,"Segunda
Variable"));
}
while(c==0 || d==0);
}
switch(opc)
{
case 1:e=A.suma(c,d);
JOptionPane.showMessageDialog(null,c+"+"+d+"="+e);
break;
case 2:e=A.resta(c,d);
JOptionPane.showMessageDialog(null,c+"-"+d+"="+e);
break;
case 3:e=A.division(c,d);
JOptionPane.showMessageDialog(null,c+"/"+d+"="+e);
break;
case 4:e=A.multiplica(c,d);
JOptionPane.showMessageDialog(null,c+"*"+d+"="+e);
break;
}
for(fila=1;fila<=24;fila++)
System.out.println("\n");
}
while(opc!=5);
}
}
Quedando:
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Abstracta3.java (Clase Main)
Seleccione la clase Abstracta3.java del proyecto y de doble click

package abstracta3;
Menu M=new Menu();
M.opciones();
}
}
Quedando:
Pulsar para salvar

Ejecución
TALLER A REALIZAR
Implementar en Netbeans….clase Abstracta2… con los siguientes archivos:
Primer Archivo
package abstracta2;
Circulo C=new Circulo(10.5,10.5,6.0);
Cuadrado P=new Cuadrado(10.5,10.5,6.0);
Triangulo T=new Triangulo(10.5,10.5,6.0,5.0);
System.out.println(C.imprime());
System.out.println(P.imprime());
System.out.println(T.imprime());
}
}
Segundo Archivo
package abstracta2;
abstract class Figura
{
protected double x, y;
public Figura(double x, double y)
{
this.x=x;
this.y=y;
}
abstract double area();
String puntos()
{
String T=
"Punto ( "+x+","+y+")";
return T.toString();
}
}
Tercer Archivo
package abstracta2;
class Circulo extends Figura
{
private double radio;
public Circulo(double x, double y,double radio)
{
super(x,y);
this.radio=radio;
}
double area()
{
return Math.PI*radio*radio;
}
String imprime()
{
return "area del circulo: "+area()+" a partir del "+super.puntos();
}
}
Cuarto Archivo
package abstracta2;
class Cuadrado extends Figura
{
private double lado;
public Cuadrado(double x, double y,double lado)
{
super(x,y);
this.lado=lado;
}
double area()
{
return lado*lado;
}
String imprime()
{
return "area del cuadrado: "+area()+" a partir del "+super.puntos();
}
}
Quinto Archivo
package abstracta2;
class Triangulo extends Figura
{
private double b,h;
public Triangulo(double x, double y,double b,double h)
{
super(x,y);
this.b=b;
this.h=h;
}
double area()
{
return (b*h)/2;
}
String imprime()
{
return "area del triangulo: "+area()+" a partir del "+super.puntos();
}
}
TALLER INTERFACE CON JAVA NETBEANS 8.0
Las interfaces es un conjunto de métodos que describen qué se debe hacer
sin su desarrollo (sin el cómo). Entonces, cuando una clase implementa una
interfaz se especifica una lista de métodos (acciones) que debe llevar a cabo
(que debe hacer)
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.
A partir de Java 8, las interfaces son funcionales porque incluyen declaración
de variables estáticas, declaración de métodos, declaración como
implementación de métodos, como también, desarrollo de expresiones lambda.
Antes de Java 8, solo se podía tener declaraciones de métodos.
Cuando una expresión lambda implementa una interface, está implementa un

método abstracto, es por esta razón, por la que solo puede existir un método
abstracto y muchos otros métodos.
DESARROLLO DEL PRIMER TALLER. INICIO EN NETBEANS INTERFACE
Ejecutar

Nombre de Proyecto: Interface1
Verificar:

- Paquete de Programas Fuentes(Source Packages):: interface1
- Programa Principal:: Interface1.java
PRIMER MOMENTO CREACION DE LA INTERFACE Operaciones (Operaciones
Aritmeticas)
Se debe posicionar sobre el paquete Interface1 y pulsar el botón derecho del
Nombre de Clase: Operaciones

package interface1;
interface Operaciones
{
int suma(int a,int b);
int resta(int a,int b);
int multiplica(int a,int b);
int division(int a,int b);
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO CREACION DE LA CLASE Operario (Clase que implmenta
la interface Operaciones)
Nombre de Clase: Operario

package interface1;
public class Operario implements Operaciones {
int c,i,j;
@Override
public int suma(int a,int b)
{
c=a+b;
return c;
}
@Override
public int resta(int a,int b)
{
c=a-b;
return c;
}
@Override
public int multiplica(int a,int b)
{
j=0;
for(i=1;i<=b;i++)
j=suma(j,a);
return j;
}
@Override
public int division(int a,int b)
{
j=0;
while(a>=b)
{
j++;
a=a-b;
}
return j;
}
}
Quedando:
Pulsar para salvar

TERCER MOMENTO CREACION DE LA CLASE Menu
Nombre de Clase: Menu

package interface1;
public class Menu {
void opciones()
{
int fila=0,opc=0;
int c=0,d=0,e=0;
Operario A=new Operario();
do
{
System.out.println("1. Adicion ");
System.out.println("2. Resta ");
System.out.println("3. Division ");
System.out.println("4. Multiplicar");
System.out.println("5. Salir");
opc=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite
Opcion"));
if(opc!=5)
{
do
{
c=Integer.parseInt(JOptionPane.showInputDialog(null,"Primera
Variable"));
d=Integer.parseInt(JOptionPane.showInputDialog(null,"Segunda
Variable"));
}
while(c==0 || d==0);
}
switch(opc)
{
case 1:e=A.suma(c,d);
JOptionPane.showMessageDialog(null,c+"+"+d+"="+e);
break;
case 2:e=A.resta(c,d);
JOptionPane.showMessageDialog(null,c+"-"+d+"="+e);
break;
case 3:e=A.division(c,d);
JOptionPane.showMessageDialog(null,c+"/"+d+"="+e);
break;
case 4:e=A.multiplica(c,d);
JOptionPane.showMessageDialog(null,c+"*"+d+"="+e);
break;
}
for(fila=1;fila<=24;fila++)
System.out.println("\n");
}
while(opc!=5);
}
}
Quedando:
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Interface1.java (Clase Main)
Seleccione la clase Interface1.java del proyecto y de doble click
Reemplazar el contenido por:

package interface1;
public class Interface1 {
Menu M=new Menu();
M.opciones();
}
}
Quedando:
Pulsar para salvar

Ejecución
TALLER A REALIZAR
Implementar en Netbeans….clase Interface2… con los siguientes archivos:
Primer Archivo
package interface2;

Prueba P=new Prueba();
P.opciones();
}
}
Segundo Archivo
package interface2;
//Interface de la Naturaleza de los Numeros
interface Numeros {
void narcizos(int inf, int sup);
boolean perfecto(int x);
void amigo(int x);
boolean magico(int x);
}
Tercer Archivo
package interface2;
import java.util.*;
public class Numero implements Numeros
{
int i,j,k; //variables índices
int n; // numero de digitos
int A[], B[]; // vector para almacenar los digitos
int s; // variable de sumatoria
int x;// numero a evaluar
int c;//variable contador
public Numero(int x)// numero a digitalizar
{
this.x=x;
n=cuantos(x);
A=new int[n];
B=new int[n];
digitaliza(x);
}
final int cuantos(int p) //cuenta el numero de digitos
{
c=0;
while(p>0)
{
c++;
p/=10;
}
return c;
}
final void digitaliza(int x) //convierte el numero en un vector de digitos representando
unidades, decenas...
{
n=cuantos(x);
k=x;
A=new int[n];
B=new int[n];
for(i=0;i<n;i++)
{
A[i]=k%10;
k/=10;
}
}
int base10(int C[],int base)//obtener el numero en una base
{
k=1;
s=0;
for(j=0;j<C.length;j++)
{
s=s+C[j]*k;
k*=base;
}
return s;
}
boolean unico()// verificacion de digitos unicos
{
boolean doble=false;
if(A[i]==A[j])
doble=true;
return doble;
}
void duplicaContrario()
{
k=A.length-1;
{
B[k]=A[i];
k--;
}
}
public int multiplos(int p) // suma los multiplos de un numero
{
s=0;
for(j=1;j<=p/2;j++)
if(p%j==0)
s+=j;
return s;
}
public int potencia(int b,int m) // potencia de b elevado a la m
{
k=1;
for(j=1;j<=m;j++)
k*=b;
return k;
}
/**
*
* @param inf
* @param sup
*/
@Override
public void narcizos(int inf, int sup)// la suma de las potencias n de sus digitos es igual
a el mismo
{
int numdigitos,temp;
double digital;
String numero;
for(i=inf;i<=sup;i++)
{
numero=String.valueOf(i); //se convierte i en Cadena
numdigitos=numero.length(); //se obtiene numero de digitos
digital=0.0;
for(j = 0; j < numdigitos; j++)
{
temp=Character.digit(numero.charAt(j),10);//Conversion de caracter a entero
digital=digital+Math.pow((double) temp, (double) numdigitos);
}
if ((int)digital == i)
System.out.println("Numero Narcizo: "+i);
}
}
@Override
public boolean perfecto(int x) //suma de sus multiplos es igual a el mismo
{
return x==multiplos(x);
}
@Override
public void amigo(int x)
{
int amigo1=multiplos(x);
int amigo2=multiplos(amigo1);
if(amigo2==x)
System.out.println(amigo1+" es amigo de "+x);
}
@Override
public boolean magico(int x)
{
int s1,s2;
digitaliza(x);
Arrays.sort(A);
duplicaContrario();
s1=base10(A,10);
s2=base10(B,10);
return (s1-s2)==x;
}
}
Cuarto Archivo
package interface2;
public class Prueba {
void opciones()
{
int i;
Numero N = null;
for(i=100;i<=999;i++)
{
N=new Numero(i);
if(N.perfecto(i))
System.out.println(i+" es un numero perfecto");
if(N.magico(i))
System.out.println(i+" es un numero magico");
N.amigo(i);
}
N=new Numero(i);
N.narcizos(100, 1000);
}
}
DESARROLLO DEL SEGUNDO TALLER. IMPLEMENTACION DE UNA INTERFACE
Ejecutar
Verificar:

PRIMER MOMENTO CREACION DE LA INTERFACE Profesor
mouse>>opción new>> Java Interface…
Nombre de Clase: Profesor

package interface2;
public interface Profesor {
final int hora_diurna_inicio=7;
final int hora_diurna_final=17;
final int hora_nocturna_inicio=18;
final int hora_nocturna_final=22;
public void saludar(int h);
}
Quedando:
Pulsar para salvar
SEGUNDO MOMENTO CREACION DE LA CLASE Persona (Clase Base)

Nombre de Clase: Persona

package interface2;
public class Persona {
int edad;
static int semestre_maximo=10;
}
Quedando:
Pulsar para salvar
TERCER MOMENTO CREACION DE LA CLASE Roberto (Clase que hereda e

implementa interface)
Nombre de Clase: Roberto

package interface2;
public class Roberto extends Persona implements Profesor {
int estatura;
@Override
public void saludar(int h)
{
if(h>=Profesor.hora_diurna_inicio && h<=Profesor.hora_diurna_final )
System.out.println(" Buenas Tardes... estudiante jornada Diurna");
if(h>=Profesor.hora_nocturna_inicio && h<=Profesor.hora_nocturna_final )
System.out.println(" Buenas Tardes... estudiante jornada Nocturna");
}
}
Quedando:
Pulsar para salvar

CUARTO MOMENTO ACTUALIZAR LA CLASE Interface2.java (Clase Main)

package interface2;
Roberto R=new Roberto();
Roberto A=new Roberto();
Roberto B=new Roberto();
Profesor P=(Profesor) new Roberto();// P es un comportamiento
R.edad=28;
R.saludar(10);
P.saludar(21);
A.estatura=150;
B.estatura=165;
System.out.println("Estatura de A: "+A.estatura);
System.out.println("Estatura de B: "+B.estatura);
System.out.println("Semestre Maximo: "+Roberto.semestre_maximo);
System.out.println("Horario Diurno: "+Roberto.hora_diurna_inicio+"-
"+Roberto.hora_diurna_final);
System.out.println("Horario Nocturno: "+Roberto.hora_nocturna_inicio+"-
"+Roberto.hora_nocturna_final);
}
}
Quedando:
Pulsar para salvar

Ejecución

DESARROLLO DEL TERCER TALLER. IMPLEMENTACION DE UNA INTERFACE
Ejecutar
Verificar:

PRIMER MOMENTO CREACION DE LA INTERFACE Socio

mouse>>opción new>>Java Interface…
Nombre de Clase: Socio

package interface3;
public interface Socio {
public void comprar(int a);
public int numero();
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO CREACION DE LA CLASE Mario (Clase que implementa
interface Socio)
Nombre de Clase: Mario

package interface3;
public class Mario implements Socio{
int edad;
int cedula;
int acciones;
String Nombre;
public Mario(int acciones,int cedula,int edad,char[] Nombre)
{
this.acciones=acciones;
this.cedula=cedula;
this.edad=edad;
this.Nombre=String.valueOf(Nombre);
}
@Override
public void comprar(int a)
{
if(edad>=18)
acciones=acciones+a;
}
@Override
public int numero()
{
return acciones;
}
}
Quedando:
Pulsar para salvar

TERCER MOMENTO ACTUALIZAR LA CLASE Interface3.java (Clase Main)

package interface3;
char[] Nombre={'M','a','r','i','a'};
Mario M=new Mario(10,45234567,22,Nombre);
M.comprar(10);
System.out.println(M.Nombre+" posee estas acciones: "+M.acciones+ " a la edad
de:"+M.edad);
}
}
Quedando:
Pulsar para salvar
Ejecución

DESARROLLO DEL CUARTO TALLER. IMPLEMENTACION DE UNA INTERFACE
Ejecutar
Verificar:

PRIMER MOMENTO CREACION DE LA INTERFACE Decorador
Nombre de Clase: Decorador

package interface4;
public interface Decorador {
public String decorar(String s);
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO CREACION DE LA CLASE DecoradorAsterisco (Clase que
implementa interface Decorador)
Nombre de Clase: DecoradorAsterisco

package interface4;
public class DecoradorAsterisco implements Decorador {
String p="*";
int longitud;
int i;
@Override
public String decorar(String s)
{
String T="";
longitud=(120-s.length())/2;
for(i=1;i<=longitud;i++)
T=T+p;
T=T+s;
T=T+p;
return T;
}
}
Quedando:
Pulsar para salvar

TERCER MOMENTO ACTUALIZAR LA CLASE Interface4.java (Clase Main)

package interface4;
public class JavaApplication3 {
DecoradorAsterisco P=new DecoradorAsterisco();
System.out.println(P.decorar(" H O L A"));
}
}
Quedando:
Pulsar para salvar

Ejecución

DESARROLLO DEL QUINTO TALLER. IMPLEMENTACION Y EJECUCION DE
INTERFACE EN UN MAIN
Ejecutar

Verificar:



package interface5;
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO ACTUALIZAR LA CLASE Interface5.java (Clase Main que
implementa interface Decorador)

package interface5;
Decorador d=new Decorador() {
String p="*";
int longitud;
int i;
@Override
public String decorar(String s) {
String T="";
longitud=(120-s.length())/2;
T=T+p;
T=T+s;
T=T+p;
return T;
}
};
System.out.println(d.decorar(" J A V A"));
}
}
Quedando:
Pulsar para salvar

Ejecución

DESARROLLO DEL SEXTO TALLER. EXPRESION LAMBDA
Ejecutar

Verificar:



package interface6;
}
Quedando:
Pulsar para salvar

SEGUNDO MOMENTO ACTUALIZAR LA CLASE Interface6.java (Clase Main que
desarrolla la expresión Lambda)

package interface6;
Decorador d=(s)->".."+s+"..";
String x=d.decorar("hola");
System.out.println(x);
}
}
Quedando:
Pulsar para salvar

Ejecución

TERCERA PARTE. SISTEMAS ORIENTADOS A OBJETOS

SISTEMAS ORIENTADOS A OBJETOS (SOO)
Introducción
Un objeto es nada más ni nada menos que aquello que está delante de mí o ante mí.
Es aquello que puedo reconocer con sus atributos (propiedades) y comportamiento.
Para reconocer el objeto debo:
1. Percibirlo con los sentidos (Objeto Material)
2. Utilizar una operación mental denominada abstracción o reflexión (Objeto Formal)
Objeto es el concepto clave de la Sistemas Orientados a Objetos, la idea de objeto es
similar a la del mundo real, un objeto puede ser un auto, una cuenta bancaria, una
persona.
1 El Objeto Como Una Unidad De Atributos Y Propiedades
Los atributos se definen como los que podemos decir de un objeto.
Las propiedades se definen como la relación de un atributo con su dominio de valores
o los posibles valores que puede tener cada atributo.
Por ejemplo del objeto Auto se puede señalar:
ATRIBUTO DOMINIO DE VALOR
Marca Chevrolet
Mazda
Renault
Año 1980 hasta 2017
Color Verde
Amarillo
Cilindraje 1000
1300
Dirección Hidráulica
Asistida
Mecánica
Transmisión Automática
Mecánica
Encendido Eléctrico
Electrónico
Entonces:
Marca: Mazda es una propiedad
Modelo: 2018 es una propiedad
2 El Objeto Como Un Elemento Dinámico
Un objeto, desde el punto de vista dinámico tiene cuatro características:
Comportamiento. Es el conjunto de estados con sus posibles eventos
Estado. Es el conjunto de propiedades de un objeto en un momento dado.
Evento. Es la transición o continuidad de un estado.
Actividad. Es lo que se puede hacer a partir de los atributos.
Un ejemplo una cuenta de Ahorros puede tener el siguiente comportamiento:
Estados: Crear Cuenta, Normal (cuando el saldo es mayor que $100.000) , Sin Ahorro
( cuando el saldo es mayor que cero y menor o igual que $100.000), en rojo ( cuando
el saldo es menor que cero)
ESTADOS
CREAR CUENTA
ACTIVIDAD
DEPOSITO
EVENTOS NORMAL
DEPOSITO
RETIRO
DEPOSITO
RETIRO
RETIRO
RETIRO
EN ROJO SIN AHORRO
DEPOSITO
RETIRO DEPOSITO
RETIRO
3 El Objeto Como Una Estructura
Entonces, se define un Objeto en SOO como una estructura que posee atributos y
actividades relacionadas. A los atributos ahora en adelante se definen como variables,
y a las actividades se define como métodos.
Por tanto, un objeto es una estructura que posee variables y métodos relacionados
con estas variables.
4 Representación De Un Objeto
Para representar un objeto se puede utilizar el siguiente diagrama de objetos:
Nombre del objeto:
Variables
Métodos
Un ejemplo de un objeto podría ser el siguiente:

Objeto: Cuenta bancaria
Atributos: tipo, titular, saldo.
Métodos: Depositar, Retirar
Aquí se ve la necesidad de que el atributo "saldo" sea solo accesible a través de los
métodos "Deposito" y "Retiro"
Nombre del objeto: Cuenta bancaria
Numero, titular, saldo
Retiro
Deposito
PRIMER TALLER SISTEMA ORIENTADO A OBJETOS CON NETBEANS 8.0
PRIMERA PARTE. PLATAFORMA NETBEANS Y SU RELACION CON SISTEMA

ORIENTADO A OBJETOS (S.O.O)
Ejecutar
Nombre del Proyecto: Negocios
Seleccionar acorde con:

- Paquete de Programas Fuentes(Source Packages):: negocios
- Programa Principal:: Negocios.java

CREACION DE LA CLASE DEL NEGOCIO
Se debe posicionar sobre el paquete negocio y pulsar el botón derecho del

La clase de negocio sobre la que se va a trabajar se denomina cuenta, por tanto:
Nombre de la Clase: Cuenta
Pulsar el Botón Finish.

El Netbeans genera:
Una clase publica Cuenta que se encuentra en el paquete de clases denominada

negocios.
La clase Cuenta debe cumplir con ser una clase de negocios:
- Variables
- Métodos getter(obtener valor) y setter(colocar valor) para cada variable
- Constructor con argumentos similares a las variables (formato y nombre)
- Constructor con argumentos en blanco
- Métodos del negocio, en este caso, consignar y retirar dinero
Primer Paso Colocar Variables. La definición de la variables se deben colocar después

de
public class Cuenta { quedando:
public class Cuenta {
int numero;
String nombre;
int saldo;
}
Segundo Caso Generar los métodos getter y setter de las variables
Seleccionar la variables y pulsar el botón derecho del mouse>>opción Insert

Code…>>Getter and Setter
Pulsar click sobre Cuenta y pulsar el botón Generate

Tercer Paso Constructor con argumentos similares a las variables (formato y nombre)
Después de los Getter y Setter generados se debe adicionar el constructor:
public Cuenta(int numero, String nombre, int saldo)
{
this.numero=numero;
this.nombre=nombre;
this.saldo=saldo;
}
La cláusula this hace referencia al objeto contenedor del código, y en este caso, evita
ambigüedades porque en el método constructor emplea argumentos (int numero,
String nombre, int saldo) con el mismo nombre de las variables de la clase Cuenta
(numero, nombre, saldo) diferenciando la variable de la clase con el argumento
recibido.
Cuarto Paso Constructor Vacío
Colocar después de Getter y Setter de la variables
public Cuenta()
}
Cuarto Paso Métodos del Negocio.
En el caso de un cuenta bancaria seria consignar (dinero) y retirar(dinero). Se debe
colocar después de los constructores
public void consignar(int dinero)
{
setSaldo(getSaldo()+dinero);
}
public void retirar(int dinero)
{
if(getSaldo()>dinero)
setSaldo(getSaldo()-dinero);
}
CLASE ESTRUCTURA DE INFORMACION
Se diseña una clase que solo tenga las variables de la clase Cuenta (numero, nombre,
saldo) entonces:

El nombre de la clase es Info

La definición de la variables se deben colocar después de
public class Info { quedando:
public class Info {
int numero;
String nombre;
int saldo;
}
ADMINISTRADOR DE LA CLASE NEGOCIO
Se diseña una clase que administre por medio de un vector la clase negocio ( cada
posición es un objeto cuenta) entonces:

El nombre de la clase es Cuentas
Pulsar el botón Finish
Colocar dentro de public class Cuentas
El siguiente código:
int min,max,n;
Cuenta A[];
int i;
public Cuentas(int n)
{
min=-1;
max=-1;
this.n=n;
A=new Cuenta[n];
}
boolean vacia()
{
if(min==-1)
return true;
else
return false;
}
boolean llena()
{
if(max==n-1)
return true;
else
return false;
}
void adicion(Info C)
{
if(min==-1)
min++;
max++;
A[max]=new Cuenta(C.numero,C.nombre,C.saldo);
}
void borra(Info C)
{
C.numero=A[min].getNumero();
C.saldo=A[min].getSaldo();
C.nombre=A[min].getNombre();
if(min==max)
min=max=-1;
else
min++;
}
int existe(int cuenta)
{
boolean esta=false;
if(!vacia())
for(i=min;i<=max && ! esta;i++)
if(A[i].getNumero()==cuenta)
esta=true;
if(esta)
i--;
else
i=-1;
return i;
}
void consignar(int x,int y)
{
A[x].consignar(y);
}
void retirar(int x,int y)
{
A[x].retirar(y);
}
String imprime(String Aviso)
{
String S=" Elemenos de la Cola de: "+Aviso.toString()+"\n";
for(i=min;i<=max;i++)
{
S=S+" "+A[i].getNumero();
S=S+" "+A[i].getNombre();
S=S+" "+A[i].getSaldo()+"\n";
}
}
CREACION DE LA CLASE MENU
Se diseña una clase que administre por medio de un vector la clase negocio ( cada
posición es un objeto cuenta) entonces:

El nombre de la clase es Menu
Colocar antes de public class Menu {
void opciones()
{
int i,opc,cuenta;
Cuentas A=new Cuentas(10);
Cuentas B=new Cuentas(20);
Info C=new Info();
Object [] valores = {"1. Adicion","2. Borrar","3. Consulta Por Atender","4.
Consulta Atendidos","5. Consignar","6. Retirar","7.Salir"};
do
{
String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion",
"Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]);
switch(opc)
{
case 1:
C.numero=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el
número de cuenta"));
if(A.existe(C.numero)>=0 || B.existe(C.numero)>=0)
JOptionPane.showMessageDialog(null,"Existe cuenta");
else
if(A.llena())
JOptionPane.showMessageDialog(null,"No se Puede Atender Mas");
else
{
C.nombre=JOptionPane.showInputDialog(null,"Digite Nombre");
C.saldo=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite
saldo"));
A.adicion(C);
}
break;
case 2:
if(A.vacia())
else
{
A.borra(C);
if(!B.llena())
B.adicion(C);
}
break;
case 3:
if(A.vacia())
else
JOptionPane.showMessageDialog(null,A.imprime(" Atencion "));
break;
case 4:
if(B.vacia())
JOptionPane.showMessageDialog(null,"Cola de Atendidos Vacia");
else
JOptionPane.showMessageDialog(null,B.imprime(" Atencion "));
break;
case 5:
i=A.existe(C.numero);
System.out.println(i);
if(i>=0)
{
saldo"));
A.consignar(i,C.saldo);
}
break;
case 6:
i=A.existe(C.numero);
if(i>=0)
{
saldo"));
A.retirar(i,C.saldo);
}
break;
}
}
while(opc!=7);
}
ACTUALIZAR LA CLASE Negocios
Seleccione la clase Main.java del proyecto y de doble click

Menu M=new Menu();
M.opciones();

SEGUNDA PARTE. CREACION DE INTERFACES Y HERENCIA SENCILLA
CREACION INTERFACE ARITMETICA
Opción 1. Se debe posicionar sobre el paquete negocio y pulsar el botón derecho del
mouse>>opción new>>Java Interface
mouse>>opción new>>Other
Categoría Archivo>>Java>>Java Interface. Pulsar el Botón Next

La interface sobre la que se va a implementar se denomina Aritmetca, por tanto:
Nombre de la Clase: Aritmetica
El Netbeans genera:
Una interface Aritmetica que se encuentra en el paquete de clases denominada

negocios.
Colocar los siguientes métodos después de public interface Aritmetica {:
public int suma(int a,int b);
public int resta(int a,int b);
Quedando:
CREACION DE LA CLASE OPERACIÓN QUE IMPLEMENTA LA INTERFACE
ARITMETICA
Se diseña una clase que implemente la interface Aritmetica, entonces:

El nombre de la clase es Operacion

NetBeans genera:
Se debe agregar implements Aritmetica después de public class Operación, así:
Se implementan los métodos de suma y resta asi:
public int suma(int a,int b)

{
return a+b;
}
public int resta(int a,int b)
{
return a-b;
}
El símbolo indica que el método debe adicionar una anotación.
.
APLICACIÓN DE HERENCIA SENCILLA SOBRE LA CLASE CUENTA
Se va a hacer uso de la cláusula extends para indicar que la clase Cuenta hereda
métodos de la clase Operación, entones:
Hacer un clic sobre la clase Cuenta en el proyecto
Colocar la cláusula extends Operacion después public class Cuenta, así:
Se debe modificar el método consignar para estar acorde con la herencia, así:
public void consignar(int dinero)

{
setSaldo(super.suma(getSaldo(),dinero));
}
También, se debe modificar el método retirar para estar acorde con la herencia, así:
public void retirar(int dinero)
{
if(getSaldo()>dinero)
setSaldo(super.resta(getSaldo(),dinero));
}
Se hace uso de los métodos suma y resta de la clase super en este caso Clase
Operación que implementa estos métodos a partir de la interface Aritmetica

SEGUNDO TALLER SISTEMA ORIENTADO A OBJETOS CON NETBEANS 8.0
PRIMERA PARTE. PLATAFORMA NETBEANS Y SU RELACION CON SISTEMA

ORIENTADO A OBJETOS (S.O.O)
Ejecutar
Nombre del Proyecto: Jugar
Seleccionar acorde con:

- Paquete de Programas Fuentes(Source Packages):: jugar
- Programa Principal:: Jugar.java
CREACION DE LA CLASE BASE
Se debe posicionar sobre el paquete jugar y pulsar el botón derecho del

La clase base sobre la que se va a trabajar se denomina Juego, por tanto:
Nombre de la Clase: Juego

El Netbeans genera:
Una clase publica Juego que se encuentra en el paquete de clases denominada jugar.
Colocar dentro de public class Juego
boolean es;
String A[];
int i,j,k;
String S;
boolean esSoloTitulada(String P)// verifica si el parrafo(P) posee palabras tituladas
{
es=true;
A=P.split(" ");
if(A.length==0)
return false;
for(i=0;i<A[j].length();i++)
if(Character.isLetter(A[j].charAt(i)))
{
{
if(!Character.isUpperCase(A[j].charAt(i)))
es=false;
}
if(!Character.isLowerCase(A[j].charAt(i)))
es=false;
}
else
es=false;
return es;
}
boolean esSoloLetra(String P)// verifica si el contenido de p es solo letras
{
es=true;
P=P.toLowerCase();
A=P.split(" ");
if(A.length==0)
return false;
if(!Character.isLetter(A[j].charAt(i)))
es=false;
return es;
}
boolean esFormatofecha(String P)// Mascara Aceptada::dd/dd/dddd
{
if(P.length()!=10)
return false;
es=true;
if(i==2 && i==5)
{
if(P.charAt(i)!='/')
es=false;
}
else
es=false;
return es;
}
boolean esSoloNumero(String P)// verifica si el contenido de p es solo digitos
{
es=true;
A=P.split(" ");
if(A.length==0)
return false;
if(!Character.isDigit(A[j].charAt(i)))
es=false;
return es;
}
boolean unico(String P)
{
es=true;
for(i=0;i<P.length()-1;i++)
for(j=i+1;j<P.length();j++)
if(P.charAt(i)==P.charAt(j))
es=false;
return es;
}
String aleatorio(int limite)

{
k=randomico(limite);
return String.valueOf(k);
}
int randomico(int limite)
{
double d=Math.random()*999999999;
int n=(int) d%limite;
//System.out.println(n);
return n;
}
String cadenaAleatoria()
{
String
H[]={"monteria","cartagena","bogota","barranquilla","medellin","cucuta","armenia","perei
ra"};
k=randomico(H.length);
return H[k];
}
void tantos(String P,String Q,int H[])
{
H[0]=0;
H[1]=0;
if(P.length()==Q.length())
{
for(j=0;j<P.length();j++)
if(P.charAt(i)==Q.charAt(j))
if(i==j)
H[0]++;
else
H[1]++;
}
}
int conteoLetra(String P)//Cuenta letras en una cadena
{
k=0;
P=P.toLowerCase();
A=P.split(" ");
k++;
return k;
}
int conteoLetras(char B[])//Cuenta letras en un vector char
{
k=0;
for(i=0;i<B.length;i++)
if(Character.isLetter(B[i]))
k++;
return k;
}
boolean colocarLetra(char B[],String P,char c)//coloca el caracter c en el vector char en
las mismas posiciones donde se encuentra c en la cadena P
{
es=false;
i=0;
while(i!=-1 && i<P.length())
{
i=P.indexOf(c,i);
if(i!=-1)
{
es=true;
B[i]=c;
i++;
}
}
return es;
}
String imprimaVectorChar(char B[])
{
S="";
if(Character.isLetter(B[i]))
S+=B[i];
else
S+=" ";
return S;
}
CREACION DE LA CLASE AHORCADO
Se diseña una clase que para el juego del ahorcado entonces:

El nombre de la clase es Ahorcado
Netbeans genera:
Colocar antes de public class Ahorcado {
En la clase Ahorcado va la lógica del juego a partir de la generación de un objeto

Juego.
Se necesita:
- Generar un cadena aleatoria P – capital de un departamento – a partir de la
función String cadenaAleatoria()
- Generar un vector espejo B con formato carácter cuyo contenido son las letras
acertadas por el usuario (igual posición) – uso de la función boolean
colocarLetra(char B[],String P,char c) -
- Imprimir el contenido del vector espejo B – uso de la función String
imprimaVectorChar(char B[]) -
- Contar cantidad de letras tanto en la cadena generada como en el vector
espejo B - uso de la funciones int conteoLetra(String P) y int conteoLetras(char
B[]) respectivamente –. Se termina el juego cuando ambos conteos son
iguales.
Entonces, colocar después de public class Ahorcado {
public void jugar()
{
String P;
String S=" ";
char B[];
char c;
int conteo=0;
Juego H=new Juego();
P=H.cadenaAleatoria();
B=new char[P.length()];
do
{
S=JOptionPane.showInputDialog(null,"Digite Letra ");
c=S.charAt(0);
if(!H.colocarLetra(B, P, c))
conteo++;
//System.out.println(P);
System.out.println(H.imprimaVectorChar(B));
}
while(conteo<3 && H.conteoLetra(P)!=H.conteoLetras(B));
if(conteo<3)
JOptionPane.showMessageDialog(null,"Ha ganado ");
else
JOptionPane.showMessageDialog(null,"Ha perdido ");
}
CREACION DE LA CLASE FAMAS
Se diseña una clase que para el juego de fijas y picas entonces:

El nombre de la clase es Famas
Netbeans genera:
Colocar antes de public class Famas {
En la clase Famas va la lógica del juego a partir de la generación de un objeto Juego.
Se necesita:
- Generar un cadena con un número aleatorio a partir de la función String
aleatorio(int limite) y que este posee dígitos únicos – uso de la función boolean
unico(String P) -
- Validar ingreso de un número y que sus dígitos sean únicos – uso de las
funciones boolean esSoloNumero(String P) y boolean unico(String P) -.
Ademas que este en el rango de 1 y 9999
- Contar picas y fijas haciendo uso del vector B. Por eso, la impresión "Fijas:
"+B[0]+" Picas:"+B[1]
Entonces, colocar después de public class Famas {
public void jugar()

{
String P;
String Q=" ";
int B[]=new int[2];
int n;
Juego H=new Juego();
do
{
P=H.aleatorio(10000);
}
while(!H.unico(P));
do
{
do
{
do
{
Q=JOptionPane.showInputDialog(null,"Digite Numero");
}
while(!H.esSoloNumero(Q) || !H.unico(Q));
n=Integer.parseInt(Q);
}
while(n<0 || n>9999);
//System.out.println(P+" "+Q);
H.tantos(P, Q, B);
JOptionPane.showMessageDialog(null,"Fijas: "+B[0]+" Picas:"+B[1]);
}
while(B[0]!=4);
}
CREACION DE LA CLASE MENU
El nombre de la clase es Menu
Colocar antes de public class Menu {
void opciones()
{
int opc;
Ahorcado A=new Ahorcado();
Famas B=new Famas();
Object [] valores = {"1. Ahorcado","2. Picas y Fijas","3. Salir"};
do
{
String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion",
"Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]);
switch(opc)
{
case 1:
A.jugar();
break;
case 2:
B.jugar();
break;
}
}
while(opc!=3);
}
ACTUALIZAR LA CLASE Jugar
Seleccione la clase Main.java del proyecto y de doble click

Menu M=new Menu();
M.opciones();

SEGUNDA PARTE. CREACION DE INTERFACES Y HERENCIA SENCILLA
CREACION INTERFACE CADENA
mouse>>opción new>>Java Interface
mouse>>opción new>>Other
Categoría Archivo>>Java>>Java Interface. Pulsar el Botón Next
La interface sobre la que se va a implementar se denomina Cadena, por lo tanto:

Nombre de la Clase: Cadena
El Netbeans genera:
Una interface Cadena que se encuentra en el paquete de clases denominada jugar.

Colocar los siguientes métodos después de public interface Cadena {:
public boolean soloTitulada(String P);

public boolean soloLetra(String P);
public boolean formatofecha(String P);
public boolean soloNumero(String P);
public boolean esunico(String P);
Quedando:
CREACION DE LA CLASE MANIPULACIÓN QUE IMPLEMENTA LA INTERFACE
ARITMETICA
Se diseña una clase que implemente la interface Cadena, entonces:

El nombre de la clase es Manipulacion

NetBeans genera:
Se debe agregar implements Cadena después de public class Manipulacion, así:
Se deben agregar las siguientes variables a la clase Manipulacion:
boolean es;
String A[];
int i,j,k;
String S;
Se implementan los métodos así (deben quedar debajo de la declaración de
variables):
public boolean soloTitulada(String P)// verifica si el parrafo(P) posee palabras tituladas

{
es=true;
A=P.split(" ");
if(A.length==0)
return false;
{
{
if(!Character.isUpperCase(A[j].charAt(i)))
es=false;
}
if(!Character.isLowerCase(A[j].charAt(i)))
es=false;
}
else
es=false;
return es;
}
public boolean soloLetra(String P)// verifica si el contenido de p es solo letras
{
es=true;
P=P.toLowerCase();
A=P.split(" ");
if(A.length==0)
return false;
if(!Character.isLetter(A[j].charAt(i)))
es=false;
return es;
}
public boolean formatofecha(String P)// Mascara Aceptada::dd/dd/dddd

{
if(P.length()!=10)
return false;
es=true;
if(i==2 && i==5)
{
if(P.charAt(i)!='/')
es=false;
}
else
es=false;
return es;
}
public boolean soloNumero(String P)// verifica si el contenido de p es solo digitos
{
es=true;
A=P.split(" ");
if(A.length==0)
return false;
if(!Character.isDigit(A[j].charAt(i)))
es=false;
return es;
}
public boolean esunico(String P)
{
es=true;
for(i=0;i<P.length()-1;i++)
for(j=i+1;j<P.length();j++)
if(P.charAt(i)==P.charAt(j))
es=false;
return es;
}
El símbolo indica que el método debe adicionar una anotación.

Entonces, la clase Manipulación queda así:
El símbolo indica que el método ha sido implementado.

APLICACIÓN DE HERENCIA SENCILLA SOBRE LA CLASE JUEGO
Se va a hacer uso de la cláusula extends para indicar que la clase Juego hereda
métodos de la clase Manipulacion, entones:
Hacer un clic sobre la clase en el proyecto
Primero. Colocar la cláusula extends Manipulacion después public class Juego
Segundo. Eliminar las variables

Entonces la clase Juego queda así:
Se debe modificar los siguientes métodos:
boolean esSoloTitulada(String P)
boolean esSoloLetra(String P)
boolean esFormatofecha(String P)
boolean esSoloNumero(String P)
con el siguiente código:
boolean esSoloTitulada(String P)// verifica si el parrafo(P) posee palabras tituladas

{
return super.soloTitulada(P);
}
boolean esSoloLetra(String P)// verifica si el contenido de p es solo letras
{
return super.soloLetra(P);
}
boolean esFormatofecha(String P)// Mascara Aceptada::dd/dd/dddd
{
return super.formatofecha(P);
}
boolean esSoloNumero(String P)// verifica si el contenido de p es solo digitos
{
return super.soloNumero(P);
}
{
return super.esunico(P);
}
Se hace uso de los métodos soloTitulada, soloLetra, formatoFecha, soloNumero y

esunico de la clase super en este caso Clase Manipulacion que implementa estos
métodos a partir de la interface Cadena
CUARTA PARTE. PRACTICAS CON VARIABLES

PRIMERA PARTE. ADMINISTRACION DE UN VECTOR
Ejecutar

Nombre del Proyecto: Arreglo
Chequee . Pulsar el Botón Finish
Este proyecto pretende simular las operaciones de:

- Adición
- Inserción
- Borrado
- Consulta
en un vector con dimensión n.
Se hace uso de un índice max que indica el último elemento adicionado.
Estados:
- Si max== -1 entonces Vector Vacío (Solo se puede Adicionar)
- Si max== n-1 entonces Vector Lleno (Solo se puede borrar)
- Si max>=0 and max<n-1 entonces operaciones de adición, borrado e
inserción
Operaciones:
- adicion(p):: valor p
Se incrementa max
A[max]<- p
- borrar(q):: posición q
Se decrementa max
Se mueve desde p hasta max los elementos siguientes
- insertar(p,q):: valor p y posición q
Se incrementa max
Se mueven desde max hasta q los elementos anteriores
Se coloca el valor p en la posición q
Programa Administrador del Vector
Pulsar >>Java>>Java Class >>
Pulsar
package arreglo;
int i,k,max,n;
int A[];
public Admin(int n)
{
this.n=n;
A=new int[n];
max=-1;
}
public boolean vacio()
{
if(max==-1)
return true;
else
return false;
}
public boolean unico()
{
if(max==0)
return true;
else
return false;
}
public boolean buscar(int p)// p: valor
{
boolean esta=false;
i=0;
while(i<=max && !esta)
if(A[i]==p)
esta=true;
else
i++;
return esta;
}
public boolean lleno()
{
if(max==n-1)
return true;
else
return false;
}
public int maximo()
{
return max;
}
public String listar()
{
String cadena=" ";
for(i=0;i<=max;i++)
cadena=cadena+" "+A[i];
return cadena;
}
public void adicion(int p)// p: valor
{
max++;
A[max]=p;
}
public void insertar(int p, int q)// p: valor q: posicion
{
max++;
for(i=max;i>q;i--)
A[i]=A[i-1];
A[q]=p;
}
public void borrar(int q)//q: posicion
{
max--;
for(i=q;i<=max;i++)
A[i]=A[i+1];
}
}
Salvar
Programa Menu
Pulsar >>Java>>Java Class >>
Class Name: Menu
Pulsar
package arreglo;
public class Menu {
void opciones()
{
int i,opc,p,q;
Admin V=new Admin(10);
Object [] valores = {"1. Adicion","2.Insertar","3.Borrar","4.Consultar","5.Salir"};
do
{
switch(opc)
{
case 1:
case 2:
if(V.lleno())
{
JOptionPane.showMessageDialog(null,"Vector LLeno");
break;
}
if(opc==2 && V.vacio())
break;
p=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número"));
if(V.buscar(p))
{
JOptionPane.showMessageDialog(null,"Existe Numero");
break;
}
if(opc==1)
{
V.adicion(p);
break;
}
do
{
{0..."+V.maximo()+"]"));
}
V.insertar(p,q);
break;
case 3:
if(V.vacio())
{
break;
}
do
{
{0..."+V.maximo()+"]"));
}
V.borrar(q);
break;
case 4:
if(V.vacio())
{
break;
}
JOptionPane.showMessageDialog(null,V.listar());
}
}
while(opc!=5);
}
}
Salvar
Abrir el programa Arreglo.java y reemplazar por:

package arreglo;
public class Arreglo {
Menu M=new Menu();
M.opciones();
}
Salvar
Ejecutar
Adicionar 5 elementos…No acepta números repetidos…

Adicionar 12 14 56 60 78
Borrar la posición 2
Consultar
Ahora se Inserta en la Posición 2 el valor de 20.

SEGUNDA PARTE. VISTAS DE UNA MATRIZ

Project Name: Matrices
Pulsar
Programa Matriz
Sobre matrices>>new>>Java Class..
Class Name: Matriz
Pulsar
package matrices;
public class Matriz {
int i,j,k,n;
int A[][];
boolean C[][];
public Matriz(int n)
{
this.n=n;
A=new int[n][n];
C=new boolean[n][n];
negar();
cargar();
}
public void negar()
{
for(i=0;i<n;i++)
for(j=0;j<n;j++)
C[i][j]=false;
}
public void cargar()
{
for(i=0;i<n;i++)
for(j=0;j<n;j++)
A[i][j]=(int) (Math.random() * 90 + 10);
}
public void toda()
{
negar();
for(i=0;i<n;i++)
for(j=0;j<n;j++)
C[i][j]=true;
}
public void diagonal()
{
negar();
for(i=0;i<n;i++)
C[i][i]=true;
}
public void transversal()
{
negar();
for(i=0;i<n;i++)
C[i][n-i-1]=true;
}
public void superior()
{
negar();
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
C[i][j]=true;
}
public void inferior()
{
negar();
for(i=0;i<n;i++)
for(j=0;j<i;j++)
C[i][j]=true;
}
public void imprimir()
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
if(C[i][j])
else
System.out.print(" ");
}
}
}
Salvar
Programa Menu
Sobre matrices>>new>>Java Class..
Class Name: Menu
Pulsar
package matrices;
public class Menu {
void opciones()
{
int n=6;
int opc;
String resp;
Matriz M=new Matriz(10);
do
{
Object [] valores= {"1.Diagonal Principal","2.Transversal Principal","3. Triangular
Superior","4.Triangular Inferior","5. Consulta","6. Salir"};
resp=(String)JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de
switch(opc)
{
case 1:
M.diagonal();
M.imprimir();
break;
case 2:
M.transversal();
M.imprimir();
break;
case 3:
M.superior();
M.imprimir();
break;
case 4:
M.inferior();
M.imprimir();
break;
case 5:
M.toda();
M.imprimir();
}
}
while(opc!=6);
}
}
Salvar
Editar programa main

package matrices;
public class Matrices {
Menu M=new Menu();
M.opciones();
}
Salvar
Ejecutar
TERCERA PARTE. MATRIZ DISPERSA
Project Name: Dispersas
Pulsar
Programa Matriz
Sobre dispersa>>new>>Java Class..
Class Name: Matriz
Pulsar
package dispersas;
import java.util.Random;
public class Matriz {
int n,i,j,max;
int A[][];
int Fila[];
int Columna[];
int Valor[];
Random aleatorio= new Random(System.currentTimeMillis());;
public Matriz(int n)
{
this.n=n;
A=new int[n][n];
max=0;
}
void cargar()
{
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
A[i][j]=aleatorio.nextInt(5);
if(A[i][j]!=0)
max++;
}
}
void generar()
{
Fila=new int[max];
Columna=new int[max];
Valor=new int[max];
max=-1;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(A[i][j]!=0)
{
max++;
Fila[max]=i;
Columna[max]=j;
Valor[max]=A[i][j];
}
}
void imprimir()
{
System.out.println("Fila Columna Valor");
for(i=0;i<=max;i++)
System.out.println(" "+Fila[i]+" "+Columna[i]+" "+Valor[i]);
}
}
Salvar
Editar programa main

package dispersas;
public class Dispersas {
Matriz M=new Matriz(10);
M.cargar();
M.generar();
M.imprimir();
}
}
Salvar
Ejecutar
QUINTA PARTE. INICIO DE CLASES DE DATOS JAVA

PRIMERA CLASE String
Un objeto String representa una cadena alfanumérica de un valor constante
que no puede ser cambiada después de haber sido creada o inicializada.
Su uso es:
1. Como Lectura
String S;
S=JOptionPane.showInputDialog(null,”Digite Nombre: “):
2. Como Asignación
De una sola cadena:
String S;
StringTokenizer H=new StringTokenizer(“hola buenos dias “);
S=H.nextToken();
De Múltiples cadenas:
Strinhg A[]={“hola”,”Buenos Dias”,”universitarios”};
3. Como Consulta
Objeto Anónimo: new String().valueOf(35);
Impresión: JOptionPane.showInputDialog(null,” valor : “+S.toString()):
4. Inicialización
String A=new String(); de acuerdo a un constructor
Existen muchos constructores para crear nuevas cadenas:
String();
String( String str );
String( char val[] );
String( char val[],int offset,int count );
String( byte val[],int hibyte );
String( byte val[],int hibyte,int offset,int count );
Funciones Básicas
La primera devuelve la longitud de la cadena y la segunda devuelve el carácter
que se encuentra en la posición que se indica en indice:
int length();
char charAt( int indice );
Funciones de Comparación de Strings
boolean equals( Object obj );
boolean equalsIgnoreCase( Object obj );
Lo mismo que equals() pero no tiene en cuenta mayúsculas o minúsculas.
int compareTo( String str2 );
Devuelve un entero menor que cero si la cadena es léxicamente menor que
str2. Devuelve cero si las dos cadenas son léxicamente iguales y un entero
mayor que cero si la cadena es léxicamente mayor que str2.
Funciones de Comparación de Subcadenas
boolean regionMatch( int thisoffset,String s2,int s2offset,int len );
boolean regionMatch( boolean ignoreCase,int thisoffset,String s2,
int s2offset,int 1 );
Comprueba si una región de esta cadena es igual a una región de otra cadena.
boolean startsWith( String prefix );
boolean startsWith( String prefix,int offset );
boolean endsWith( String suffix );
Devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo
comenzando en un determinado desplazamiento.
int indexOf( int ch );
int indexOf( int ch,int fromindex );
int lastIndexOf( int ch );
int lastIndexOf( int ch,int fromindex );
int indexOf( String str );
int indexOf( String str,int fromindex );
int lastIndexOf( String str );
int lastIndexOf( String str,int fromindex );
Devuelve el primer/último índice de un carácter/cadena empezando la
búsqueda a partir de un determinado desplazamiento.
String substring( int beginindex );
String substring( int beginindex,int endindex );
String concat( String str );
String replace( char oldchar,char newchar );
String toLowerCase();
String toUpperCase();
String trim();
Ajusta los espacios en blanco al comienzo y al final de la cadena.
void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
void getBytes( int srcBegin,int srcEnd,byte dst[],int dstBegin );
String toString();
char toCharArray();
int hashCode();
Funciones ValueOf
La clase String posee numerosas funciones para transformar valores de otros
tipos de datos a su representación como cadena. Todas estas funciones tienen
el nombre de valueOf, estando el método sobrecargado para todos los tipos de
datos básicos.
Veamos un ejemplo de su utilización:
String Uno = new String( "Hola Mundo" );
float f = 3.141592;
String PI = Uno.valueOf( f );
String PI = String.valueOf( f ); // Mucho más correcto
Funciones de Conversión
String valueOf( boolean b );
String valueOf( int i );
String valueOf( long l );
String valueOf( float f );
String valueOf( double d );
String valueOf( Object obj );
String valueOf( char data[] );
String valueOf( char data[],int offset,int count );
Usa arrays de caracteres para la cadena.
String copyValueOf( char data[] );

String copyValueOf( char data[],int offset,int count );
Crea un nuevo array equivalente para la cadena.
PRACTICA DE LABORATORIO
Practica 1. Comprobar:
- cómo se crea un vector de tipo String
- cómo se inicializa cada una de las posiciones de ese vector
- Si el resultado de las tres inicializaciones es igual*/
Ejecutar
Seleccionar Java de Categories

Seleccionar java Application de Projects:
Pulsar Botón
Diligencie Proyect Name: Cadena1.

Se genera el proyecto:
Generación de otras clases

Sobre el paquete cadena1 pulse el botón derecho del mouse
Seleccione New>>Java Class
Nombre de Clase: Arreglo. Pulsar Botón Finish
Se genera:
Coloque el siguiente código después de la línea public class Arreglo {

public void mostrar()
{
String A[]=new String[3];
A[0]="Hola ";
A[1]="Buenos ";
A[2]="Dias ";
int i;
System.out.print(" Cadena A:");
System.out.print(A[i].toString());
String B[] = new String[3];
B[0]=new String("Hola");
B[1]=new String("Buenos ");
B[2]=new String("Dias ");
System.out.print(" Cadena B:");
System.out.print(B[i].toString());
System.out.print(" Cadena C:");
String C[]={"Hola ","Buenos ","Dias "};
System.out.print(C[i].toString());
}
Quedando:
De click sobre el programa Cadena1.java

Eliminar el siguiente código:
Coloque en ese espacio:

Arreglo A=new Arreglo();
A.
Aparecen los métodos de la clase Arreglo
Seleccione mostrar () o se doble click. Quedando:
Pulse o Tecla F6 o
La salida generada es:
C
errar la ventana de ejecución (Output)-Cadena1(run):
Cerrar el proyecto:
Sobre el nombre del proyecto (Cadena1)>>Botón derecho del Mouse>>Opción
Close
Practica 2. Buscar vocales en una cadena de caracteres
Seleccionar File>>New Project…o

Pulsar Botón
Project Name: Cadena2
Chequear
Pulsar Boton
Para crear la clase base es necesario hacer click sobre cadena2 y luego botón
derecho del mouse. Entonces new>>Java Class…
Nombre de la Clase: Vocales. Pulsar el botón Finish
Se abre el programa Vocales….coloque:

import javax.swing.*; debajo de package de esta manera:
Luego el procedimiento recorre (void recorre) así:

A continuación el código java del procedimiento recorre:
public void recorre()
{
String A="aeiou";
String S;
S=JOptionPane.showInputDialog(null,"Digite Parrafo ").toLowerCase(); //
Convierte a Minuscula
int i,j;
boolean esta;
for(i=0;i<A.length();i++)
{
j=0;
esta=false;
System.out.print("La vocal "+A.charAt(i)+": ");
while(j!=-1 && j<S.length())
{
j=S.indexOf(A.charAt(i),j);//Busca siguiente ocurrencia de caracter
if(j!=-1)
{
esta=true;
System.out.print((j+1)+" ");
j++;
}
}
if(!esta)
System.out.print("No hay ");
}
System.exit(0);
}

Vocales V=new Vocales();
V.
Aparecen los métodos de la clase Vocales
Seleccione recorre () o se doble click. Quedando:
Se salva el proyecto:
Pulse o Tecla F6
Resultado:
Cerrar la ventana de ejecución (Output)-Cadena2(run):
Cerrar el proyecto:
Close
Practica 3. Buscar una cadena dentro de otra cadena de caracteres. Si esta
generar una subcadena desde donde su intersección hasta el final.
Seleccionar File>>New Project…o

Pulsar Botón
Project Name: Cadena3

Chequear
Pulsar Boton
Para crear la clase base es necesario hacer click sobre cadena3 y luego botón
derecho del mouse. Entonces new>>Java Class…
Nombre de la Clase: Palabras. Pulsar el botón Finish
Se abre el programa Palabras….coloque:

import javax.swing.*; debajo de package de esta manera:
Luego el procedimiento recorre (void recorre) así:
El código java es el siguiente:

String A;
String P;
String Q;
P=JOptionPane.showInputDialog(null,"Digite Parrafo donde se
Busca").toLowerCase();
A=JOptionPane.showInputDialog(null,"Digite Cadena a
Buscar").toLowerCase();
int j;
j=P.indexOf(A);
if(j!=-1)
Q=P.substring(j,P.length());
else
Q="No esta";
JOptionPane.showMessageDialog(null,"Resultado: "+Q);

Palabras P=new Palabras();
P.
Aparecen los métodos de la clase Palabras
Seleccione recorre () o se doble click. Quedando:
Se salva el proyecto:
Pulse o Tecla F6
Resultado:
Cerrar la ventana de ejecución (Output)-Cadena3(run):
Cerrar el proyecto:
Close
Taller
Ahora, ustedes los alumnos deben:
1. Dado un vector de símbolos (que usted genera) y un párrafo leído por
teclado se debe hacer un explorador que verifica si los símbolos existen
dentro del párrafo y sino están marcar un error “símbolo inexistente”.
2. Se debe simular un buscador de texto dentro de un párrafo leído. Por
ejemplo la cadena “los” en que posiciones del siguiente párrafos “los
camellos verdes eran lelos al amanecer”. Posiciones: 0 9 26
3. Verificar sin un párrafo termina y comienza con una misma cadena
SEGUNDA CLASE Character
Al trabajar con caracteres se necesitan muchas funciones de comprobación y

traslación. Estas funciones están empleadas en la clase Character. De esta
clase sí que se pueden crear instancias, como también el llamado de métodos
enunciando a la clase a saber: Character.Metodo ()
Casos y diferencias:
La primera sentencia creará una variable carácter y la segunda un objeto

Character:
char c;
Character C;
Comprobaciones booleanas
Character.isLowerCase( c )
Character.isUpperCase( c )
Character.isDigit( c )
Character.isSpace( c )
En este caso, si tuviésemos un objeto Character C, no se podría hacer

C.isLowerCase, porque no se ha hecho un new de Character. Estas funciones
son estáticas y no conocen al objeto, por eso hay que crealo antes.
Traslaciones de caracteres
char c2 = Character.toLowerCase( c );
char c2 = Character.toUpperCase( c );
Traslaciones de carácter/dígito
int i = Character.digit( c,base );
char c = Character.forDigit( i,base );
Traslaciones desde la clase Character a char y String
C = new Character( 'J' );
char c = C.charValue();
String s = C.toString();
Para realizar la siguiente práctica se necesita saber o recordar de la clase
String:
charAt( int indice ):: Devuelve el carácter que se encuentra en la posición que
se indica en índice
int length()::la longitud de la cadena ó número de caracteres
String trim():: Elimina espacios al comienzo como al final de la cadena
Se desea validar
Practica 1. Que la cadena leída solamente tiene letras
Practica 2. Que la cadena leída solamente tiene dígitos
Practica 3. Que la cadena leída empieza con mayúscula y las demás
minúsculas
Practica 4. Si la cadena es un número bajar los dígitos a un vector int
Practica 1. Que la cadena leída solamente tiene letras
Ejecutar

Pulsar Botón
Diligencie Proyect Name: ValChar1.

Ahora, sobre el paquete valchar1>>botón derecho del mouse
Diligencie Class Name: Cadena1.

Se debe colocar los set de clases necesarios debajo de package así:
import javax.swing.* ;
Ahora, se debe colocar el método asociado a la clase Cadena1
public void mostrar(){

String P;
int i;
boolean es;
do
{
es=true;
P=JOptionPane.showInputDialog(null,"Digite Palabra a Validar ").trim();
// Grupo De sentencias que valida si todos los caracteres son letras
es=false;
}
while(!es);
JOptionPane.showMessageDialog(null," Palabra correcta "+P.toString());
}
Relación Clase Main con otras Clases
Ahora, seleccione la clase main y de doble click

Cadena1 C=new Cadena1();
C.
Seleccione el método mostrar

Quedando:
Salve el proyecto
Pulse o Tecla F6
Solo acepta letras

Cerrar la ventana de ejecución (Output)-
Cerrar el proyecto:
Sobre el nombre del proyecto (ValChar1)>>Botón derecho del Mouse>>Opción
Close
Practica 2. Que la cadena leída solamente tiene dígitos

Pulsar Botón



{
String P;
int i;
boolean es;
do
{
es=true;
P=JOptionPane.showInputDialog(null,"Digite Numero a Validar ").trim();
es=false;
}
while(!es);
JOptionPane.showMessageDialog(null," Numero Correcto "+P.toString());
}
Quedando:

C.

Quedando:
Salve el proyecto
Pulse o Tecla F6

Cerrar el proyecto:
Close
Practica 3. Que la cadena leída empieza con mayúscula y las demás
minúsculas (palabra titulada)

Pulsar Botón



{
String P;
int i;
boolean es;
do
{
es=true;
P=JOptionPane.showInputDialog(null,"Digite Palabra a Validar ").trim();
{
{
es=false;
}
es=false;
}
else
es=false;
}
while(!es);
JOptionPane.showMessageDialog(null," Palabra Correcto "+P.toString());
}

C.

Quedando:
Salve el proyecto
Pulse o Tecla F6

Cerrar el proyecto:
Close
Taller
Ahora, ustedes los alumnos deben:
1. Dado un párrafo ( solo letras y espacios en blancos) verificar que cada
palabra empieza con mayúscula y las demás minúscula
2. Dado un número ( solo dígitos) imprimir los dígitos en letras Ejemplo: „1‟
es “uno”
TERCERA CLASE StringBuffer
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.
La clase StringBuffer dispone de muchos métodos para modificar el contenido
de los objetos StringBuffer. Si el contenido de una cadena va a ser modificado
en un programa, habrá que sacrificar el uso de objetos String en beneficio de
StringBuffer, que aunque consumen más recursos del sistema, permiten ese
tipo de manipulaciones.
Al estar la mayoría de las características de los StringBuffers basadas en su
tamaño variable, se necesita un nuevo método de creación:
StringBuffer();
StringBuffer( int len );
StringBuffer( String str );
Se puede crear un StringBuffer vacío de cualquier longitud y también se puede
utilizar un String como punto de partida para un StringBuffer.
StringBuffer Dos = new StringBuffer( 20 );
StringBuffer Uno = new StringBuffer( "Hola Mundo" );
Métodos Comunes
Método Descripción
Empleado para añadir al objeto un String (String) o una variable
append(...)
(int, char, double, ...)
capacity() Devuelve el espacio libre del StringBuffer.
charAt(int) Devuelve el caracter de la posición especificada (int)
getChars(int, int, Copia los caracteres indicados en la posición indicada de un
char[], int) string
Devuelve la posición en la que aparece por primera vez un
indexOf(String, [int]) String (String) en otro, puede ser a partir de una posición dada
([int]) opcional.
Devuelve la posición en la que aparece por última vez un String
lastIndexOf(String,
(String) en otro, puede ser a partir de una posición dada ([int])
[int])
opcional.
Inserta en la posición indicada (int) de un StringBuffer, un
insert(int, ...)
String(String) o un valor (int, double, float, ...)
length() Devuelve el número de ccaracteres del String
reverse() Cambia el orden de los caracteres de un String
setCharAt(int, char) Cambia el caracter en la posición indicada
setLength(int) Cambia el tamaño (int) de un StringBuffer
toString() Convierte el objeto en un String
Modificación del Contenido
Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos:
append() e insert().
En el ejemplo se ve el uso de estos dos métodos:
class CadAgregar {
public static void main( String args[] ) {
String A=”abcdefghijklmnopqrstuvwxyz”;
StringBuffer str = new StringBuffer();
int i;
for(i=0;i<A.length();i++)
str.append( A.charAt(i));
System.out.println( str.toString());
}
}
En este otro ejemplo, se cambia el sentido de una cadena:
class CadenaInversa {
public static String cadenaInversa(String fuente) {
int i;
StringBuffer destino = new StringBuffer();
for( i=fuente.length()-1; i >= 0; i-- )
destino.append( fuente.charAt( i ) );
return( destino.toString() );
}
System.out.println( cadenaInversa( "Programación Java" ));
}
}
Entones, los métodos que hacen inserción y adición son las siguientes:
StringBuffer append( Object obj );
StringBuffer append( String str );
StringBuffer append( char str[] );
StringBuffer append( char str[],int offset,int len );
StringBuffer append( boolean b );
StringBuffer append( int i );
StringBuffer append( long l );
StringBuffer append( float f );
StringBuffer append( double d );
StringBuffer append( char ch );
StringBuffer insert( int offset,Object obj );
StringBuffer insert( int offset,String str );
StringBuffer insert( int offset,char str[] );
StringBuffer insert( int offset,boolean b );
StringBuffer insert( int offset,int i );
StringBuffer insert( int offset,long l );
StringBuffer insert( int offset,float f );
StringBuffer insert( int offset,double d );
StringBuffer insert( int offset,char ch );
Operadores de Concatenación
Hay que recordar que los operadores "+" y "+=" también se pueden aplicar a
cadenas. Ambos realizan una concatenación y están implementados con
objetos StringBuffer.
Por ejemplo, la sentencia:
String s = "¿Qué" + " tal ?";
es interpretada por el compilador como:
String s = new StringBuffer().append( "¿Qué" ).append( " tal ?" ).toString();
y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto
String. También, la sentencia:
s += " por ahí!";
sería interpretada por el sistema como:
String s =
new StringBuffer().append( s ).append( " por ahí!" ).toString();
y volvería a marcar para borrar el nuevo StringBuffer.
TALLER AHORCADO
Ejecutar

Pulsar Botón
Diligencie Proyect Name: JuegoAhorcado.

Sobre el paquete juegoahorcado pulse el botón derecho del mouse
>>New>>Java Class
Class Name: Ahorcado. Pulsar el Botón Finish

import java.util.*;
Donde:
El set util, se toma la clase Random con el método nextInt() que genera
números aleatorios enteros.
Ahora colocar las líneas de código como lo indica la siguiente figura:
Líneas de Código:
String texto[]={"La flor es Bonita","La azucena es Hermosa","El clavel
representa la Madre"};
Random r=new Random();
int max=Math.abs(r.nextInt()%3+0);//Numero aleatorio de 0 a 3
String linea=new String(texto[max].toUpperCase());
StringBuffer S=new StringBuffer();
int i,cm,n;
public Ahorcado(int k)
{
cm=0;
n=k;
for(i=0;i<linea.length();i++)
S.append(" "); // Llenado de Blancos
}
public String buscar(char c)
{
boolean hay=false;
i=0;
while(i<linea.length() && i!=-1)
{
i=linea.indexOf(c,i); // Búsqueda de un Carácter a partir de una posición
if(i!=-1)
{
S.setCharAt(i,c); // Colocar un character en la position
hay=true;
i++;
}
}
if(!hay)
cm++;
}
public int malas()
{
return cm;
}
public boolean acabo()
{
if(cm==n)
return true;
else
return false;
}
public boolean termino()
{
String A=linea.trim();
String B=new String(S.toString().trim());
if(A.equals(B))
return true;
else
return false;
}
Ahora, seleccione la clase JuegoAhorcado y de doble click

Coloque debajo del package juegoahorcado lo siguiente:
quedando:

Ahorcado C=new Ahorcado(5);
char p;
do
{
p=Character.toUpperCase(JOptionPane.showInputDialog(null,"Digite Letra
").charAt(0));
JOptionPane.showMessageDialog(null,"Cadena: "+C.buscar(p).toString()+" \n
Malas: "+C.malas());
}
while(!C.termino() && !C.acabo());
if(C.termino())
JOptionPane.showMessageDialog(null,"Ha ganado...");
if(C.acabo())
JOptionPane.showMessageDialog(null,"Ha perdido...");
System.exit(0);
Salve el proyecto
Pulse o Tecla F6
Cerrar la ventana de ejecución (Output)-JuegoAhorcado(run):
Cerrar el proyecto:
Sobre el nombre del proyecto (JuegoAhorcado)>>Botón derecho del Mouse>>Opción
Close
TALLER NUMERO ROMANO
Ejecutar

Pulsar Botón
Diligencie Proyect Name: NumeroRomano.

Sobre el paquete numeroromano pulse el botón derecho del mouse
>>New>>Java Class
Ahora colocar las líneas de código como lo indica la siguiente figura:

Las líneas de código son las siguientes:
char unidad[]={'I','X','C','M'};
char quinto[]={'V','L','D'};
int digito[]=new int[4];
int i,j,dominio;
public String pasar(int valor)
{
StringBuffer linea=new StringBuffer();
dominio=valor;
for(i=0;i<4;i++)
{
digito[i]=dominio%10;
dominio/=10;
}
for(i=3;i>=0;i--)
switch(digito[i])
{
case 4:
linea.append(unidad[i]);linea.append(quinto[i]);
break;
case 9:
linea.append(unidad[i]);linea.append(unidad[i+1]);
break;
case 0:break;
default:
if(digito[i]>=5)
linea.append(quinto[i]);
for(j=1;j<=(digito[i]%5);j++)
linea.append(unidad[i]);
}
return linea.toString();
}
}
Ahora, seleccione la clase NumeroRomano y de doble click
Coloque debajo del package numeroromano lo siguiente:

quedando:

StringBuffer N=new StringBuffer();
Romano A=new Romano();
int r;
String s;
do
{
r=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Numero
1…3899"));
}
while(r<0 || r>3899);
JOptionPane.showMessageDialog(null,"Numero: "+r+" es:
"+A.pasar(r).toString());
Salve el proyecto
Pulse o Tecla F6
Cerrar la ventana de ejecución (Output)-NumeroRomano(run):
Cerrar el proyecto:
Sobre el nombre del proyecto (NumeroRomano)>>Botón derecho del Mouse>>Opción
Close
La Clase StringBuilder
Tomado de:
http://puntocomnoesunlenguaje.blogspot.com.co/2013/03/java-
stringbuilder-stringbuffer.html
Java proporciona la clase StringBuffer y a partir de Java 5 la clase StringBuilder
para trabajar con cadenas de caracteres sobre las que vamos a realizar
modificaciones frecuentes de su contenido.
La diferencia entre StringBuffer y StringBuilder es que los métodos de
StringBuffer están sincronizados y los de StringBuilder no lo están. Por este
motivo StringBuilder ofrece mejor rendimiento que StringBuffer y la utilizaremos
cuando la aplicación tenga un solo hilo de ejecución.
En general decidiremos cuando usar String, StringBuilder o StringBuffer según
lo siguiente:
- Usaremos String si la cadena de caracteres no va a cambiar.
- Usaremos StringBuilder si la cadena de caracteres puede cambiar y
solamente tenemos un hilo de ejecución.
- Usaremos StringBuffer si la cadena de caracteres puede cambiar y
tenemos varios hilos de ejecución.
En esta entrada utilizaremos StringBuilder teniendo en cuenta que todo lo que
se explica aquí es aplicable a StringBuffer.
Constructores de la Clase StringBuilder
Un objeto de tipo StringBuilder gestiona automáticamente su capacidad
– Se crea con una capacidad inicial.
– La capacidad se incrementa cuando es necesario.
La clase StringBuilder proporcionan varios constructores, algunos de ellos
son:
CONSTRUCTOR DESCRIPCIÓN
Crea un StringBuilder vacío.
StringBuilder ()
StringBuilder sb = new StringBuilder ();
StringBuilder(int n) Crea un StringBuilder vacío con capacidad para n caracteres.
Crea un StringBuilder y le asigna el contenido del String s.
StringBuilder(String
String s = "ejemplo";
s);
StringBuilder sb = new StringBuilder (s);
Métodos de la Clase StringBuilder
La clase StringBuilder proporcionan métodos para acceder y modificar la
cadena de caracteres. Algunos de ellos son:
MÉTODO DESCRIPCIÓN
length() Devuelve la longitud de la cadena
append(X); Añade X al final de la cadena. X puede ser de cualquier tipo
Inserta X en la posición indicada. X puede ser de cualquier
insert(posicion, X)
tipo.
Cambia el carácter que se encuentra en la posición
setCharAt(posicion, c)
indicada, por el carácter c.
Devuelve el carácter que se encuentra en la posición
charAt(posicion)
indicada.
indexOf(„caracter‟) Devuelve la posición de la primera aparición de carácter
lastIndexOf(„caracter‟) Devuelve la posición de la última aparición de carácter
Devuelve la subcadena (String) comprendida entre las
substring(n1,n2) posiciones n1 y n2 ambas incluidas. Si no se especifica n2,
devuelve desde n1 hasta el final.
delete(inicio, fin) Elimina los caracteres desde la posición inicio hasta fin.
reverse() Invierte el contenido de la cadena
toString() Devuelve el String equivalente.
Los puedes consultar todos en la API de Java:
http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html
http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html
EJERCICIOS A REALIZAR
Realizar los ejercicios haciendo uso de la clase StringBuffer o StringBuilder
1. Dada una cadena(solo letras y espacios en blanco), convertir a una
cadena de Titulo (Toda palabra debe iniciar con Letra Mayúscula y las
demás minúsculas)
2. Leer un Código y Nombre de Alumno por teclado y así, generar una
cadena de códigos y nombres separados por un espacio en blanco
3. Dada una serie de números(1...3899), generar dos cadenas con el
número ordinal y otra en número romano separados por espacios en
blanco.
BUENAS PRACTICAS EN JAVA BASICO E INTERMEDIO CON
COMPILADORES EN LINEA Y NETBEANS 8
SEXTA PARTE. PAQUETE UTIL

PAQUETE UTIL
INTERFAZ ENUMERATION
La interfaz Enumeration define los métodos que permiten enumerar (obtener
cada vez) los elementos de un conjunto de objetos. Esta interfaz define los dos
métodos siguientes:
Bolean hasMoreElements()
Object nextElement()
Cuando se implementa, hasMoreElements() debe devolver true mientras haya
elementos para extraer y false cuando se hayan enumerado todos los
elementos. El método nextElement() devuelve el siguiente objeto de la
enumeración como una referencia genérica a objeto, es decir, cada llamada a
nextElement() obtiene el siguiente objeto de la enumeración. La rutina que
llama a este método tiene que convertir ese objeto al tipo de objeto de la
enumeración.
El siguiente ejemplo utiliza una clase llamada EString para implementar una
enumeración de objetos String, y una clase llamada EnumeracionDemo para
crear una instancia de EString, iterar sobre sus valores e imprimir cada uno de
ellos. Observe que EString devuelve la secuencia de String. Sin embargo, las
implementaciones de ambos métodos cumplen los requisitos especificados por
la interfaz Enumeration.
Proyecto en Netbeans
Primer Programa: EString

package enumeracionstring;
import java.util.*;
class EString implements Enumeration {
String A[ ]={"Bogota","Cali","Medellin","Barranquilla","Bucaramanga","Ibague"};
private int conteo = -1;
private boolean mas = true;
public boolean hasMoreElements() {
return mas;
}
public Object nextElement() {
conteo++;
if (conteo == A.length-1)
mas = false;
return (A[conteo].toString());
}
}
Segundo Programa: EString
package enumeracionstring;
import java.util.*;
public class EnumeracionString {
public static void main(String args[]) {
Enumeration estring= new EString();
StringBuffer B=new StringBuffer();
while (estring.hasMoreElements())
{
B.append("\n"); B.append(estring.nextElement());
}
JOptionPane.showMessageDialog(null," Lista de Ciudades: "+B.toString());
}
}
Ejecución o F5
CLASE STRINGTOKENIZER
Que es un Token. Conjunto de caracteres (números, letras) delimitado por un
espacio en blanco (por defecto) u otro carácter.
Clase StringTokenizer Permite descomponer una cadena en partes
lexicográficas (tokens) las cuales constituyen a ésta.
Los tokens se dividen entre sí mediante ciertos caracteres que, en este caso,
se les llama delimitadores.
Constructores:
StringTokenizer(String str) se crea un string divisible conteniendo str y con el
set de delimitadores por defecto " "
StringTokenizer(String str, String delim) se crea un string divisible y con el set
de delimitadores dad en delim
StringTokenizer(String str, String delim, boolean returnTokens) se crea un
string divisible y con el set de delimitadores dado en delim. Si returnTokens es
true los delimitadores son retornados como palabras de longitud uno, si false
los delimitadores dividen las palabras pero no se retornan
Métodos Descripción
boolean hasMoreTokens() true si existen mas palabras por retornar
String nextToken() retorna la siguiente palabra
String nextToken(String retorna la siguiente palabra utilizando un nuevo set
delim) de delimitadores
public int countTokens() retorna el numero de palabras que quedan
A Continuación se muestra la manera de trabajar la clase StringTokenizer, se
supone que se crea a partir de tres String(a, b, c) a medida que se utiliza el
método nextToken() el índice de siguiente token avanza hasta no mas tolens
T0.
A B C
nextToken
T1.
C
B
nextToken
T2.
nextToken
T3.
hasMoreTokens() Se hace igual a False.
Un ejemplo es el siguiente código :
import java.util.*;
public class CasoToken{
public static void main(String []args){
int i,j,k;
String Cuenta="33.55.28.12";
String Nombre="Pedro Contreras, Luis Cardenas, Ines Forero, Carlos Daza";
String Movimiento="2.5,4.2,1.3/4.3,2.8,2.5/2.5,3.6,1.8/4.6,3.8,4.2";
String S;
StringTokenizer T1=new StringTokenizer(Cuenta,".");
StringTokenizer T2=new StringTokenizer(Nombre,",");
StringTokenizer T3=new StringTokenizer(Movimiento,"/");
while(T1.hasMoreTokens() && T2.hasMoreTokens () &&
T3.hasMoreTokens())
{
System.out.print(" Cuenta: "+T1.nextToken());
System.out.print(" Movimiento Cuentas: "+T3.nextToken());
}
}
}
COLECCIONES EN JAVA
 Permite almacenar y organizar objetos de manera útil para un acceso
eficiente.
 Núcleo de abstracciones de colecciones de utilidad (interfaces) e
implementaciones ampliamente útiles.
 Las interfaces proporcionan métodos para todas las operaciones
comunes y las implementaciones concretas especifican la decisión de
las operaciones no permitidas.
o (java.lang.UnsupportedOperationException)
 Sobre los elementos se puede iterar (Iterator)
Interfaz Collections
Collections es una clase que proporciona una serie de métodos estáticos
para manejar colecciones que pueden ser de mucha utilidad. Los métodos son
los siguientes:
 int binarySearch(List list, Object key): Busca un
elemento en una lista ordenada utilizando un algoritmo de búsqueda
binaria. El método devuelve un entero indicando la posición en la que se
encuentra el elemento, o bien un número negativo si no se encontró.
Este número negativo indica la posición la que se encontraría el
elemento de haber estado en la colección.
 int frequency(Collection c, Object o): Devuelve el número
de veces que se repite el elemento especificado en la colección.
 Object max(Collection coll): Devuelve el mayor elemento de la
colección.
 Object min(Collection coll): Devuelve el menor elemento de la
colección.
 boolean replaceAll(List list, Object oldVal, Object
newVal): Reemplaza todas las ocurrencias en la lista de un cierto
elemento por otro objeto.
 void reverse(List list): Invierte la lista.
 void shuffle(List list): Modifica la posición de distintos
elementos de la lista de forma aleatoria.
 void sort(List list): Ordena una lista utilizando un algoritmo
merge sort.
Interfaz List
Una colección cuyos elementos permanecen en un orden particular a menos
que se modifique la lista (no significa lista enlazada aunque es una posible
implementación).
 boolean add(E o): Añade un nuevo elemento al final de la colección.
 boolean add(int index, E element): Añade un nuevo elemento en la
posición especificada.
 boolean addAll(Collection<? extends E> c): Añade todos los elementos
de la colección especificada a esta colección.
 void clear(): Elimina todos los elementos de la colección.
 boolean contains(Object o): Comprueba si el elemento especificado es
parte de la colección.
 get(int index): Recupera el elemento que se encuentra en la posición
espeficicada.
 int indexOf(Object o): Devuelve la primera posición en la que se
encuentra el elemento especificado en la colección, o -1 si no se
encuentra.
 int lastIndexOf(Object o): Devuelve la última posición en la que se
encuentra el elemento especificado en la colección, o -1 si no se
encuentra.
 remove(int index): Elimina el elemento de la posición indicada.
 boolean remove(Object o): Elimina la primera ocurrencia del elemento
indicado. Si se encontró y se borró el elemento, devuelve true, en caso
contrario, false.
 set(int index, E element): Reemplaza el elemento que se encuentra en la
posición indicada por el elemento pasado como parámetro. Devuelve el
elemento que se encontraba en dicha posición anteriormente.
 int size(): Devuelve el número de elementos que se encuentran
actualmente en la colección.
Interfaz Map
La interfaz Map<K,V> y las clases que la implementan vienen a reemplazar la
antigua clase Dictionary.
HashMap<K,V> es el tipo de mapeo más sencillo y probablemente el más
usado. Es la clase a utilizar si queremos asociar pares de claves y valores sin
orden, sin más. Internamente, como su nombre indica, utiliza un hash para
almacenar la clave. No permite claves duplicadas, pero si utilizar null como
clave.
Hashtable<K,V> es una vieja conocida del JDK 1.0, que, como Vector<E>
pasó a formar parte del framework de colecciones en Java 1.2. Esta clase es
muy similar a HashMap<K,V>, con la excepción de que es sincronizada y que
no acepta utilizar el valor null como clave. Como en el caso de Vector<E>
contra ArrayList<E>, nos interesará utilizar HashMap<K,V> siempre que no
estemos utilizando varios hilos de ejecución. En el caso de que necesitemos
sincronización, otra opción es utilizar el método
Collections.synchronizedMap sobre un HashMap, que funciona de
forma similar a Collections.synchronizedList.
LinkedHashMap<K,V> es una clase introducida con el J2SE 1.4 que extiende
HashMap<K,V> y utiliza una lista doblemente enlazada para poder recorrer los
elementos de la colección en el orden en el que se añadieron. Esta clase es
ligeramente más rápida que HashMap<K,V> a la hora de acceder a los
elementos, pero es algo más lenta al añadirlos.
Por último tenemos TreeMap<K,V>, en el que los pares clave-valor se
almacenan en un árbol ordenado según los valores de las claves. Como es de
esperar es la clase más lenta a la hora de añadir nuevos elementos, pero
también a la hora de accederlos.
De entre los métodos comunes a las cuatro clases los más utilizados son:
 void clear(): Elimina todos los elementos de la colección.
 boolean containsKey(Object key): Comprueba si la clave
especificada se encuentra en la colección.
 boolean containsValue(Object value): Comprueba si el valor
especificado se encuentra en la colección.
 get(Object key): Devuelve el valor asociado a la clave especificada
o null si no se encontró.
 boolean isEmpty(): Comprueba si la colección está vacía.
 keySet(): Devuelve un conjunto con las claves contenidas en la
colección.
 put(K key, V value): Añade un nuevo par clave-valor a la colección
 remove(Object key): Elimina el par clave-valor correspondiente a
la clave pasada como parámetro.
 int size(): Devuelve el número de pares clave-valor que contiene la
colección.
 Collection values(): Devuelve una colección con los valores que
contiene la colección.
Un ejemplo:
import java.util.*;
class Contador
{
private int i;
public Contador()
{
i=1;
}
public void incrementar()
{
++i;
}
public String toString()
{
return Integer.toString(i);
}
}
public class Estadistico {
HashMap tabla = new HashMap();
for(int i=0; i < 10000; i++) {

// Generar un número entre 0 y 20
Integer num = new Integer((int)(Math.random()*20));
if(tabla.containsKey(num))
//Incrementamos el contador asociado al número
((Contador)tabla.get(num)).incrementar();
else
//Añadimos nuevo par: numero-contador
tabla.put(num, new Contador());
}
System.out.println(tabla);
}
}
Clase ArrayList
Declaración y creación
De forma general un ArrayList en Java se crea de la siguiente forma:
ArrayList Arreglo = new ArrayList();
Esta instrucción crea el ArrayList Arreglo vacío.
Un arrayList declarado así puede contener objetos de cualquier tipo.
Por ejemplo:
ArrayList a = new ArrayList();
Métodos de ArrayList
Algunos métodos que proporciona ArrayList son:
MÉTODO DESCRIPCIÓN
size() Devuelve el número de elementos (int)
add(X) Añade el objeto X al final. Devuelve true.
add(posición, X) Inserta el objeto X en la posición indicada.
get(posicion) Devuelve el elemento que está en la posición indicada.
remove(posicion) Elimina el elemento que se encuentra en la posición indicada.
Devuelve el elemento eliminado.
remove(X) Elimina la primera ocurrencia del objeto X. Devuelve true si el
elemento está en la lista.
clear() Elimina todos los elementos.
set(posición, X) Sustituye el elemento que se encuentra en la posición indicada
por el objeto X. Devuelve el elemento sustituido.
contains(X) Comprueba si la colección contiene al objeto X. Devuelve true
o false.
indexOf(X) Devuelve la posición del objeto X. Si no existe devuelve -1
Se pueden consultar todos en:

http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html
Recorrer un ArrayList
Con un ciclo for
for(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
for(Integer i: numeros){
System.out.println(i);
}
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
for(Object o: nombreArray){
System.out.println(o);
}
INTERFAZ ITERATOR
Un Iterator o Iterador es un patrón de diseño que nos ofrece una interfaz

estándar para recorrer una estructura de datos sin que nos tengamos que
preocupar por la representación interna de los datos de dicha estructura.
Esta forma de recorrer estructuras de datos ofrece muchas ventajas entre las
que podemos destacar que nuestro código no depende de la estructura de
datos.
Por lo tanto la “estructura” puede ser un árbol binario o una lista doblemente
enlazada ya que el iterador nos abstrae del modo de realizar el recorrido. De
este modo podemos sustituir de manera sencilla estructuras de datos en
nuestro código sin que se nos presenten problemas desagradables.
Este patrón lo podemos sustituir por un bucle for, que haría básicamente lo
mismo, pero la velocidad en la búsqueda es superior en el patrón iterator con
respecto al bucle for.
En Java tenemos reflejado el patrón Iterator en la clase java.util.Iterator que es
ampliamente utilizada en las conocidas Collections.
interface Iterator{
boolean hasNext(); /* Devuelve true si la iteración tiene mas
elementos */
Object next(); /* Devuelve el siguiente elemento de la
iteración
Lanza excepción NoSuchElementException */
void remove(); /* Elimina el último elemento devuelto por la
iteración
Está capacitado para decir que no lo implementa
UnsupportedOperationException */
Por ejemplo, recorrer un array de empleados:
Clase Empleado
package listaempleado;
public class Empleado {
String nom;
int nit;
String cargo;
int sueldo;
}
Programa Principal: ListaEmpleado
package listaempleado;
import java.util.*;
public class ListaEmpleado {
{
Scanner leer = new Scanner(System.in);
int op;
Empleado nodo=new Empleado();
ArrayList lista = new ArrayList();
do{
System.out.println( "Ingrese el nombre del Empleado" );
do
{
nodo.nom = leer.nextLine();
}
while(nodo.nom.length()<2);
System.out.println( "Ingrese el nit:" );
nodo.nit = leer.nextInt();
System.out.println( "Ingrese el cargo:" );
do
{
nodo.cargo = leer.nextLine();
}
while(nodo.cargo.length()<2);
System.out.println(nodo.cargo);
System.out.println( "Ingrese sueldo:" );
nodo.sueldo= leer.nextInt();
lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("nit:\n"+nodo.nit);
lista.add("cargo:\n"+nodo.cargo);
lista.add("sueldo:\n"+nodo.sueldo);
System.out.println( "¿Desea ingresar otro Empleado?" );
System.out.println( "1.-Si\t 2.-No" );
op = leer.nextInt();
}
while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
}
}
}
Ejecución o F5
Clase Scanner
Analizador léxico simple. Se construye sobre algún tipo de fuente de
caracteres:
Scanner (String source) Scanner (Readable source) Scanner (Reader source)
Scanner (InputStream source) Scanner (File source)
Sobre la fuente de caracteres, va seleccionando lexemas (tokens) separados
por espacio en blanco. Proporciona los resultados por medio de una interface
Iterator:
String s ="Martes, 13 de septiembre de 2005, actualizado a las 16:16 h.";
Scanner scanner = new Scanner(s);
for (Iterator it = scanner; it.hasNext(); ) {
String token = (String) it.next();
System.out.println(token);
}
Martes,
13
de
septiembre
de
2005,
actualizado
a
las
16:16
h.
Además, ofrece una serie de métodos que, habiendo leído un token, lo
intentan interpretar como algún tipo primitivo de java:
int nextInt() double nextDouble() boolean nextBoolean()
byte nextByte() float nextFloat() short nextShort() long nextLong()

Dichos métodos intentan interpretar el token que toca leer, lanzando una
excepción si no puede:
· InputMismatchException si el token no responde al tipo deseado
· NoSuchElementException si no quedan más tokens
Es muy frecuente usar un Scanner para analizar la entrada de datos desde
consola:
Scanner scanner = new Scanner(System.in);
System.out.print("Escriba dos números: ");
double x = scanner.nextDouble();
double y = scanner.nextDouble();
System.out.println("producto: " + (x + y));
Escriba dos números: 3,1416 2
producto: 5.1416
Por último cabe mencionar el método
String nextLine() que retorna lo que queda por leer de la línea actual; es decir,
desde donde estemos hasta el primer fin de línea. Llamadas consecutivas a
nextLine() van proporcionando líneas sucesivas de texto.
Clase Vector
Permite crear un arreglo de Objetos que puede cambiar de tamaño (Dinámico)
Constructores:
Vector() crea un arreglo vacío
Vector(int initialCapacity) crea un arreglo con la capacidad dada por
initialCapacity
addElement(Object) Adiciona un objeto
Int indexOf(Objeto) Busca un objeto dentro del vector. Retorna la
Int indexOf(Objeto,int pos) primera ocurrencia o sino -1 por inexistencia
Int pos:: indica desde que posición de
búsqueda
Int lastIndexOf(Objeto) Busca un objeto dentro del vector. Retorna la
Int lastIndexOf(Objeto,int pos) uúltima ocurrencia o sino -1 por inexistencia
Int pos:: indica desde que posición de
búsqueda
Object elementAt(int index) retorna el componente con el índice dado por
index
void setElementAt(object obj, el elemento dado por el índice index es
int index) igualado a obj
void setSize(in newSize) modifica el tamaño actual del vector, si
disminuye de tamaño los elementos por
encima del newSize son eliminados
int capacity() retorna la capacidad actual
int size() retorna el numero de componentes del vector
copyInto(Object anArray[]) Copia el contenido de un arreglo de objetos en
el Vector
Object firstElement(); Retorna el primer elemento
Object lastElement(); Retorna el último elemento
insertElementAt(Object obj, Inserta un objeto a partir de la posición index
int index);
boolean isEmpty(); Retorna True si el vector esta vacio
void removeAllElements(); Elimina todos los objetos del vector
boolean Retorna True si elimino el Objeto obj del
removeElement(Object obj); vector de objetos
void removeElementAt(int Elimina el Objeto de la posición index
index);
String toString(); Retorna el contenido del vector de objetos en
forma de cadena
void trimToSize(); Ajusta la capacidad del vector al tamaño o
número de elementos
Clase Arrays
Clase que permite hacer algunas operaciones sobre arreglos. Estas
operaciones son las siguientes:
binarySearch
equals
fill
sort
BinarySearch.- Permite buscar un valor en un arreglo ordenado
ascendentemente utilizando para ello el algoritmo de búsqueda binaria. Se ha
resaltado que el arreglo a de estar previamente ordenado para que funcione
apropiadamente el método, caso contrario puede obtenerse resultados
inesperados. Como se indicó antes se trata de un método sobrecargado para
los diferentes tipos de datos primitivos y para Object. Por ejemplo veamos el
método específico de double (los otros son practicamente iguales):
public static int binarySearch(double[] a, double key)
el método recibe el arreglo y el valor que se quiere buscar; este valor
obviamente siempre es del mismo tipo. Devuelve un entero que corresponde al
índice del elemento que coincide con el valor buscado
Ejemplo:
double[] c = {10, 20, 30, 40, 50};
int i;
i = Arrays.binarySearch(c, 30);
//devuelve i = 2
i = Arrays.binarySearch(c, 10);
// i = 0, recordando que el índice siempre empieza en 0
¿Qué pasa si no encuentra el valor?
Devuelve el valor que representa el punto de inserción con el signo - . Punto
de inserción es el punto donde, de acuerdo al orden, se esperaría que
estuviera ese valor. Utilizando el mismo arreglo c que hemos creado, veamos
algunas búsquedas:
i = Arrays.binarySearch(c, 25); // i = -2
i = Arrays.binarySearch(c, 45); //i = -4
equals.- Su nombre lo dice todo, sirve para indicarnos si dos matrices son
iguales. Dos matrices son iguales si tienen los mismos elementos y en el
mismo orden. También se consideran iguales si sus refencias valen null.
Devuelve un boolean: true si son iguales y false si no lo son.
Ejemplo:
char[] uno = {'j', 'a', 'v', 'a', 'm', 'a', 'n', 'i', 'a'};
char[] dos = {'j', 'a', 'v', 'a', 'm', 'a', 'n', 'i', 'a'};
System.out.println(Arrays.equals(uno, dos));
//imprimirá true
fill.- Sirve para asignar valores a varios elementos de una matriz.
Ejemplo:
double[] cambiarValores = {4, 5, 6, 4, 3, 6, 8};
Arrays.fill(cambiarValores, 0);
//todos los elementos de la matriz asumen el valor 0
Hay una forma de indicarle un rango para que se efectue el cambio de manera
en el mismo.
Tomando la declaración anterior de cambiarValores, tendriamos:
Arrays.fill(cambiarValores, int desde, int hasta, 0);
//El primer int indica el índice desde (incluido) y el segundo el índice hasta (no
incluido), el tercero es el valor utilizado para reemplazar.
El resultado es un array con los siguientes valores:
Arrays.fill(cambiarValores, 2, 5, 0);
{4, 5, 0, 0, 0, 6, 8}
sort.- Ordena los elementos de forma ascendente. Para ello internamente
utiliza un algoritmo muy eficiente conocido como quicksort. Ejemplo:
double[] ordenarArreglo = {4, 0, 3, 9, 7, 43, 64, 32, 45, 23, 2, 6};
Arrays.sort(ordenarArreglo);
También permite el ordenamiento de un rango. Igualmente el primer int indica
el índice desde (incluido) y el segundo el índice hasta (no incluido).
Arrays.sort(ordenarArreglo, 3, 5);
//ordena los elementos 4 y 5(no olvidar que comienza de 0)
Preguntas:
1. ¿Cómo ordena la clase Arrays objetos de tipo String?
2. ¿Cómo ordena la clase Arrays objetos genéricos Object?
Respuestas Anteriores:
1. Todas son válidas. El problema se soluciona entendiendo 2 cosas. En primer
lugar, que se pueden repartir los corchetes (para cada arreglo anidado) entre el
tipo de dato y el nombre de la variable de tal manera que todas las siguientes
expresiones son equivalentes:
int myInt[][][] ...
int[] myInt[][] ...
int[][] myInt[] ...
int[][][] myInt ... //etc.
En segundo lugar, algo visto en el primer post sobre este tema que se puede
asignar directamente los valores encerrandolo entre llaves o bien utilizando el
operador new, el tipo, los corchetes vacíos y los valores entre llaves (remitirse
a la Cuarta y Quinta forma de crear arreglos, el mensaje Arreglos). En un
arreglo de arreglos, se pueden combinar indistintamente estas formas.
//***********
Finalmente solo indicar que los arrays son una forma muy eficiente de
manipular estructuras lineales de datos cuando el tamaño no varía (o por lo
menos se tiene un máximo posible razonablemente estable, por lo cual puede
crearse el array de este tamaño) y no hay (o hay muy pocas) modificación (nes)
en el orden de los elementos. El acceso a una posición determinada es muy
rápida comparativamente hablando, pues "se salta" a la posición de memoria
(del dato primitivo o la referenncia en caso de objetos). Debe preferirse esta
estructura a otras como ArrayList cuando las condiciones anteriores se
cumplan (lo cual implica ausencia de inserciones o borrados de elementos),
pues lo contario supondría un despedicio de recursos
Ejemplo:
import java.util.*;
public class Arreglo1
{
int []a;
Arreglo1 ()
{
a=new int [10];
}
void cargar()
{
for(int i=0;i<a.length;++i)
a[i]=(int)(Math.random()*100);
}
void mostrar()
{
String s= "Vector:";
for(int i=0;i<a.length;++i)
s+=" "+a[i];
System.out.println(s);
}
public static void main(String[]args)
{
Arreglo1 m=new Arreglo1();
//m.crear();
m.cargar();
m.mostrar();
Arrays.sort(m.a);
m.mostrar();
System.exit(0);
}//Cierro main
}// Cierro
Clase Stack
Permite crear un arreglo de Objetos (Pila) que puede cambiar de tamaño
(Dinámico) cuya administración es LIFO (Ultima en Entrar primera en salir)
Constructores:
Stack() crea una Pila de Objetos Vacía
push(Object) Adiciona un objeto ( Apila)
int search(Objeto) Busca un objeto dentro del vector. Retorna la
posición del mismo o sino -1 por inexistencia
boolean empty(); Retorna True si el vector esta vacio
Object pop(); Retorna y saca el último Objeto ingresado
(Desempila)
Object peek(); Retorna el último objeto ingresado ( Tope)
push(A) push(B) push(C) pop() == C
pop()==B pop()==A empty()==True
Apila Apila Apila Desempila Desempila
B
Una aplicación de la clases: B Vector y Stack
StringTokenizer,
Se requiere crear una clase denominada HashVector donde:
Existe una cadena donde A los nombres y A códigos están separados por una
comaA(,) B A
Se deben crear dos vectores: uno para códigos y otro para nombres
Dada una cadena de código buscar en el vector de códigos, A si existe llevar el
código a una pila de hallados y sino a una pila de no hallados
Listar la pila de hallados y no hallados.
Programa: HashVector
package simulahash;
import java.util.*;
class HashVector {
String A="10,Juana,25,Diego,3,Danna,8,Sofia,20,Maria,13,Sandra,25,Maria";
StringTokenizer T=new StringTokenizer(A.toString(),",");
Stack Hallado=new Stack();
Stack NoHallado=new Stack();
Vector Codigo=new Vector();
Vector Nombre=new Vector();
public HashVector() {
boolean estado=true;
while(T.hasMoreTokens()) {
if(estado)
Codigo.addElement(T.nextElement());
else
Nombre.addElement(T.nextElement());
estado=!estado;
}
}
void buscar(String Cod)
{
if(Codigo.contains(Cod))
{
if(Hallado.search(Cod)==-1)
Hallado.push(Cod);
}
else
{
if(NoHallado.search(Cod)==-1)
NoHallado.push(Cod);
}
}
String listar()
{
StringBuffer B=new StringBuffer("Codigos Encontrados \n");
while(!Hallado.empty())
{
B.append(Hallado.pop());
B.append("\n");
}
B.append("Codigos No Encontrados \n");
while(!NoHallado.empty())
{
B.append(NoHallado.pop());
B.append("\n");
}
}
}
Programa: SimulaHash
package simulahash;
public class SimulaHash
{
{
HashVector H=new HashVector();
String S;
int i,n;
for(i=1;i<=7;i++)
{
do
{
S=JOptionPane.showInputDialog(null," Digite Codigo (Solo Numero): ");
n=Integer.parseInt(S);
}
while(n==0);
H.buscar(S);
}
JOptionPane.showMessageDialog(null,H.listar().toString());
System.exit(0);
}
}
Ejecución o F5
La Clase Random
La clase Random es un generador de números pseudo-aleatorios ya que
genera secuencias distribuidas uniformemente.
Constructores:
Random() Random(long semilla)
El primer constructor crea un generador de números que utiliza la hora actual
como semilla inicial. El segundo, permite especificar el valor de la semilla.
Métodos
double nextDouble() Devuelve el siguiente número aleatorio double.
float nextFloat() Devuelve el siguiente número aleatorio flota.
double nextGaussian() Devuelve el siguiente número aleatorio gaussiano.
int nextInt() Devuelve el siguiente número aleatorio int.
long nextLong() Devuelve el siguiente número aleatorio long.
Establece una semilla, es decir, el punto de inicio
void setSeed(long semilla)
del generador de números aleatorios.
El siguiente programa obtiene 100 valores aleatorios y calcula la media. El
programa también cuanta el número de valores comprendidos dentro de una
desviación estándar utilizando incrementos de 0,5 para cada categoría.
import java.util.*;
public class RandDemos {
Random r = new Random();
double val;
double sum = 0;
int campana[] = new int[10];
for (int i=0; i < 100; i++) {
val = r.nextGaussian();
sum += val;
double t = -2;
for (int x=0; x < 10; x++, t += 0.5)
if (val < t) {
campana[x]++;
break;
}
}
System.out.println("Media de los valores: " + (sum/100));
// Visualizar la campana de Gauss
for (int i=0; i < 10; i++) {
for (int x=campana[i]; x > 0; x--)
System.out.println("*");
}
}
}
La Clase Hashtable
La Clase Hashtable implementa un mecanismo de almacenaje de tabla
Hashing para almacenar pares de clave y valor.
Las tablas Hashing están diseñadas para localizar y recuperar rápidamente
información almacenada, usando una clave.
Constructores:
Hashtable: Construye un HashTable Vacia
Hashtable(int): Construye un Hashtable con capacidad int
Métodos
Borra todos los elementos de la
clear()
Hashtable
contains(Objeto)
True si el objeto está en la tabla
clone() Crea un igual

Devuelve true si la tabla está vacía y false
Boolean isEmpty()
si contiene al menos una clave.
Devuelve una enumeración de la claves
Enumeration keys()
contenidas la tabla
True si la tabla contiene la clave indicada
containsKey(Objeto)
Almacena una clave y su valor en el

diccionario. Devuelve null si la clave no
Object put(Object clave, Object
estaba ya en el diccionario, o el valor
valor)
anterior que tenía asociado si la clave ya
estaba en el diccionario.
Elimina la clave y su valor. Devuelve el
Object remove(Object clave) valor asociado a la clave. Si la clave no
está en la tabla, devuelve un objeto nulo.
get(Objeto) Devuelve el objeto asociado con la clave
dada
El siguiente ejemplo utiliza la clase Hashtable, creando una lista de claves
(generando aleatoriamente) asociadas con nombres que se encuentran en un
vector tipo String. Además, se verifica que la clave sea única para poder
adicionar a la tabla mediante el método put. El public class crea un objeto Tabla
y se verifica la existencia de un código en la tabla.
Programa: Tabla
package demotablahash;
import java.util.*;
class Tabla
{
String lista="Juan Pedro Tomas Sebastian Juana Ines";
StringTokenizer cadena=new StringTokenizer(lista);
int numero=cadena.countTokens();
Hashtable ht=new Hashtable(numero*2);
Random r=new Random();
int n;
public Tabla()
{
while(cadena.hasMoreTokens())
{
do
{
n=Math.abs(r.nextInt()%20+1);
}
while(ht.containsKey(new String().valueOf(n).toString()));
ht.put(new String().valueOf(n).toString(),cadena.nextToken());
}
JOptionPane.showMessageDialog (null, "Las claves: "+ht.toString());
}
void buscar(String llave)
{
if(ht.containsKey(llave))
JOptionPane.showMessageDialog (null,llave+" = "+ht.get(llave));
else
JOptionPane.showMessageDialog (null, "No existe la clave");
}
}
Programa: DemoTablaHash
package demotablahash;
public class DemoTablaHash
{
public static void main(String Args[])
{
Tabla A=new Tabla();
String S;
S=JOptionPane.showInputDialog (null,"Digite la Llave: ");
A.buscar(S);
}
}
Ejecución o F5
La Clase Dictionary
Dictionary es una clase abstracta que representa un depósito para almacenar
claves/valor. Una clave es un nombre que se utiliza posteriormente para
recuperar un valor. Dada una clave y un valor, se puede almacenar el valor en
un objeto Dictionary. Una vez almacenado el valor, se puede recuperar
utilizando su clave.
Métodos Clase Dictionary
Devuelve una enumeración de los valores contenidos
Enumeration elements()
en el diccionario.
Devuelve el objeto que contiene el valor asociado con la
Object get(Object clave) clave. Si la clave no está en el diccionario, devuelve un
objeto nulo.
Devuelve true si el diccionario está vacío y false si
Boolean isEmpty()
contiene al menos una clave.
Devuelve una enumeración de las claves Contenidas en
Enumeration keys()
el diccionario.
Almacena una clave y su valor en el diccionario.
Object put(Object clave, Devuelve null si la clave no estaba ya en el diccionario,
Object valor) o el valor anterior que tenía asociado si la clave ya
estaba en el diccionario.
Elimina la clave y su valor. Devuelve el valor asociado a
Object remove(Object
la clave. Si la clave no está en el diccionario, devuelve
clave)
un objeto nulo.
Devuelve el número de parejas clave/valor de
int size()
diccionario.
Dictionary es una superclase de la clase Hashtable (tabla hash). Además, se
puede utilizar como superclase de cualquier clase que utilice una relación
clave/valor, pero será necesario implementar todos los métodos definidos por
Dictionary.
La Clase Properties
La clase Properties es una subclase de Hashtable que se utiliza para mantener
listas de valores en las que la clave es una cadena y el valor también es un
objeto String. La clase Properties es utilizada por otras clases de Java.
Constructores:
Properties()
Properties(Properties propDefecto)
El primer constructor crea un objeto Properties que no tiene valores por
defecto. El segundo crea un objeto que utiliza propDefecto para sus valores por
defecto. En ambos casos, la lista está vacía.
Métodos Clase Properties
Devuelve el valor asociado a la clave. Devuelve
String getProperty(String clave) el objeto null si la clave no está en la lista ni en
la lista de propiedades por defecto.
Devuelve el valor asociado a la clave. Devuelve
String getProperty(String clave,
propDefecto si la clave no está en la lista ni en
String propDefecto)
la lista de propiedades por defecto.
Envía la lista de propiedades al flujo de salida
void list(PrintStream flujoSalida)
asociado a flujoSalida.
void load(InputStream Introduce una lista de propiedades del flujo de
flujoEntrada) throws IOException entrada asociado a flujoEntrada.
Devuelve la enumeración de las clasves. Aquí
Enumeration propertyNames() se incluyen las claves encontradas en la lista de
propiedades por defecto.
Después de escribir la cadena especificada por
void save(OutputStream
descripción, escribe la lista de propiedades en el
flujoSalida, String descripción)
flujo de salida asociado a flujoSalida.
El siguiente ejemplo utiliza la clase Properties, creando una lista de
propiedades en la que las claves son nombres de Departamentos Colombianos
y los valores son los nombres de sus capitales. Además, se especifica una lista
de propiedades por defecto cuando se construye un objeto
Properties(Departamento,Capital).
import java.util.*;
public class DemoPropiedad {
Properties defList = new Properties();
defList.put("Cundinamarca", "Bogota");
defList.put("Bogota", "Bogota");
Properties ciudades = new Properties(defList);
Enumeration comunidades;
String str;
ciudades.put("Valle","Cali");
ciudades.put("Antioquia","Medellin");
ciudades.put("Atlantico","Barranquilla");
ciudades.put("Bolivar","Cartagena");
comunidades = ciudades.keys();
while (comunidades.hasMoreElements()) {
str = (String) comunidades.nextElement();
System.out.println("Capital de " + str + " es " +
ciudades.getProperty(str));
}
// Ahora encontrará Bogota en la lista por defecto.
str = ciudades.getProperty("Cundinamarca");
System.out.println("La ciudad de Cundinamarca: "+ str);
}
}
La Clase Date
La clase Date representa una fecha y hora.
Constructores:
Date()
Date(int año, int mes, int dia)
Date(int año, int mes, int dia, int horas, int minutos)
Date(int año, int mes, int dia, int horas, int minutos, int segundos)
Date(long milisegundos)
Date(String fecha)
Estos tres constructores establecen el día, mes y año. El parámetro año
especifica el número de años que han transcurrido desde 1900; mes establece
el mes del año, comenzado en 0 para Enero. El penúltimo constructor permite
construir un objeto Date especificando el número de milisegundos transcurridos
desde el 1 de Enero de 1970. El último, permite establecer la fecha utilizando
una cadena que contenga dicha fecha. Por ejemplo, new Date("Thu Feb 15
1999 22:24:24") construirá un objeto con la fecha y hora especificada.
La clase Date define los métodos que se muestran en la siguiente tabla. Hay
varios métodos que permiten establecer y obtener la fecha y la hora. No se
puede establecer el día de la semana, ya que depende del día del mes.
Métodos Clase Date
Devuelve true si el objeto Date contiene
una fecha que es posterior a la fecha
boolean after(Date fecha)
especificada. En caso contrario, devuelve
false.
una fecha que es anterior a la fecha
boolean before(Date fecha)
false.
la misma fecha y hora que la fecha
boolean equals(Object fecha)
false.
Devuelve el día del mes, que será un
int getDate()
valor comprendido entre 1 y 31.
Devuelve el día de la semana en forma
de entero, correspondiendo el valor 0 al
int getDay()
Domingo, el 1 al Lunes y así
sucesivamente.
Devuelve la hora. Las horas se
int getHours() representan en función de un reloj de 24
horas.
Convierte una cadena que contiene una
fecha y hora en el número de
static long parse(String str) milisegundos que han transcurrido desde
el 1 de Enero de 1900. Devuelve el
número de milisegundos transcurridos.
Establece como el día del mes el valor
void setDate(int dia)
especificado por día.
Establece la hora con el valor
void setHours(int hoas) especificado. Para ello, se utiliza un reloj
de 24 horas.
Establece el año especificando el
número de milisegundos que han
void setYear(int año)
transcurrido desde el 1 de Enero de
1900.
Convierte el objeto Date en una cadena y
String toLocaleString() devuelve el resultado. La hora y la fecha
son locales.
Convierte el objeto Date en una cadena y
String toString()
devuelve el resultado.
Al igual que getDate(), getDay() y getHours() define los métodos: getMinutes(),
getMonth(), getSeconds() y getTime().
Comparación de fechas
Hay dos formas de comparar dos objetos Date. La primera es utilizar el método
getTime() en los dos objetos para obtener el número de milisegundos que han
transcurrido desde el 1 de enero de 1970 y comparar estos dos valores. Sin
embargo, hay una forma más sencilla que consiste en utilizar los métodos
before(), after() y equals().
Por ejemplo, como el día 12 del mes es anterior al 18, new
Date(99,2,12).before(new Date(99,2,18)) devuelve true.
Cadenas y zonas horarias
Los objetos Date se pueden convertir en cadenas de varias formas. El método
toString() convierte un objeto Date en una cadena como ésta: "Thu Feb 15
22:40:02 2001". El método toLocaleString() convierte un objeto Date en una
cadena más corta como ésta: "02/15/99 22:30:02".
Por último, el método toGMTString() convierte un objeto Date en un formato de
hora del meridiano de Greenwich como éste: "14 Feb 1976 20:00:30 GMT".
Para determinar la diferencia entre la zona horaria local y GMT se utiliza el
método getTimezoneOffset(), que devuelve la diferencia en minutos.
A continuación se muestra un breve programa que utiliza estos métodos:
import java.util.Date;
public class FormatoFechas {
Date curDate = new Date();
// Muestra la fecha y hora utilizando toString()
System.out.println("Formato por defecto: " + curDate);
System.out.println("Fecha y hora local: " + curDate.toLocaleString());
System.out.println("Fecha y hora GMT " + curDate.toGMTString());
System.out.println("Diferencia de la zona horaria:: " +
curDate.getTimezoneOffset());
}
}
La salida generada por este programa es similar a la siguiente:
APLICACIÓN DE INVENTARIO
El siguiente integra las clases StringBuffer, StringTokenizer, Hashtable.
Programa: InventarioUtil
package kardexutil;
import java.util.*;
class InventarioUtil {
int i,j,k;
final int n=10;
String Cod="33,55,28";
String Nom="Pino,Cedro,Guayacan";
String Cant="33,18,25";
Hashtable H1=new Hashtable();
Hashtable H2=new Hashtable();
int A[][]=new int[n][4];
Random R=new Random();
public InventarioUtil()
{
String S;
StringTokenizer T2=new StringTokenizer(Nom.toString(),",");
StringTokenizer T3=new StringTokenizer(Cant.toString(),",");
{
S=T1.nextToken();
H1.put(S,T2.nextToken());
H2.put(S,T3.nextToken());
}
}
boolean existe(int x)
{
return H1.containsKey(new String().valueOf(x));
}
void venta(int x,int cant)
{
int k=Integer.parseInt((String) H2.get(new String().valueOf(x)));
if(k>=cant)
{
H2.remove(new String().valueOf(x));
k=k-cant;
H2.put(new String().valueOf(x),new String().valueOf(k));
}
else
JOptionPane.showMessageDialog(null,"No se puede realizar la venta...no
hay existencia");
}
void compra(int x,int cant)
{
int k=Integer.parseInt((String) H2.get(new String().valueOf(x)));
H2.remove(new String().valueOf(x));
k=k+cant;
H2.put(new String().valueOf(x),new String().valueOf(k));
}
String impresion()
{
StringBuffer P=new StringBuffer(" CODIGO NOMBRE SALDO");
Enumeration claves=H1.keys();
String S;
while (claves.hasMoreElements())
{
S=(String) claves.nextElement ();
P.append("\n");
P.append(S);
P.append(" ");
P.append(H1.get(S));
P.append(" ");
P.append(H2.get(S));
}
return P.toString();
}
}
Programa: KardexUtil
package kardexutil;
public class KardexUtil{
public static void main(String[] args){
InventarioUtil X=new InventarioUtil();
Object[] Opcion={"1. Compra","2. Venta","3. Consulta","4.Cierre"};
int opc,cod=0;
String S;
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Almacen
Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[2]);
opc=Character.digit (S.charAt(0),10);
switch(opc)
{
case 1:
cod=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "));
if(!X.existe(cod))
JOptionPane.showMessageDialog (null,"No existe Codigo");
else
X.compra(cod,Integer.parseInt(JOptionPane.showInputDialog(null," Digite
Cantidad a Comprar ")));
break;
case 2:
cod= Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "));
if(!X.existe(cod))
JOptionPane.showMessageDialog(null,"No existe Codigo");
else
X.venta(cod,Integer.parseInt(JOptionPane.showInputDialog(null," Digite
Cantidad a Venta ")));
break;
case 3:
JOptionPane.showMessageDialog(null," Inventario
\n"+X.impresion().toString());
}
}while(opc!=4);
System.exit(0);
}
}
Ejecución o F5
APLICACIÓN DE PAISES
El siguiente integra las clases StringTokenizer, Hashtable E Interfaz
Enumeration:
Programa: Paises
package paises;
import java.util.*;
public class Paises
{
{
String Pais="Colombia,Peru,Chile,Venezuela,Bolivia";
String Ciudad="Bogota,Lima,Santiago,Caracas,La Paz";
String Poblacion="45000000,20000000,15000000,25000000,10000000";
Hashtable ciudades=new Hashtable();
Hashtable gente=new Hashtable();
StringTokenizer T1=new StringTokenizer(Pais.toString(),",");
StringTokenizer T2=new StringTokenizer(Ciudad.toString(),",");
StringTokenizer T3=new StringTokenizer(Poblacion.toString(),",");
Object Menu[]=new Object[T1.countTokens()];
String S;
while(T1.hasMoreTokens() && T2.hasMoreTokens() && T2.hasMoreTokens())
{
S=T1.nextToken().toUpperCase();
ciudades.put(S,T2.nextToken().toUpperCase());
gente.put(S,T3.nextToken().toUpperCase());
}
Enumeration comunidad=ciudades.keys();
int opc=-1;
while(comunidad.hasMoreElements())
{
opc++;
Menu[opc]=comunidad.nextElement();
}
Object[] Opcion={"1. Capital","2. Poblacion","3.Cierre"};
do
{
if(opc!=3)
{
S=(String) JOptionPane.showInputDialog(null,"Paises: "," O N
U",JOptionPane.QUESTION_MESSAGE,null,Menu,Menu[0]);
switch(opc)
{
case 1:
JOptionPane.showMessageDialog(null,"Pais: "+S.toString()+" Capital:
"+ciudades.get(S).toString());
break;
case 2:
JOptionPane.showMessageDialog(null,"Pais: "+S.toString()+"
Poblacion: "+gente.get(S).toString());
break;
}
}
}
while(opc!=3);
}
}
Ejecución o F5
SEPTIMA PARTE. PAQUETE IO

Figura 1. Paquete java.io
Se presenta el paquete que el API (siglas de 'Application Programming
Interface') estándar de Java proporciona para gestionar las operaciones de I/O
tanto del sistema como desde/hacia Archivo.
1. ARCHIVOS Y DIRECTORIOS
CLASE FILE
La Clase File permite acceder a la información sobre un archivo, incluyendo
sus atributos y la ruta de acceso
Constructor:
File(String Path): Nombre completo del archivo, incluido el directorio
File(String Path, String Name): Nombre del directorio y Nombre del Archivo.
Métodos:
Método Propósito
String getName() Obtiene el nombre del archivo
String getPath() Devuelve la ruta de acceso
String getAbsolutePath() Devuelve la Ruta completa
boolean exists() Indica existencia ó no de archivo
boolean canWrite() Si puede ser modificado
boolean canRead() Si puede ser leído
boolean isFile() Si es un archivo válido
boolean isDirectory() Información de directorio es válida
boolean isAbsolute() Si el nombre del archivo es completo
long lastModified() Hora y fecha de última modificación
long length() Longitud
boolean mkdir() Éxito en la creación de un directorio
boolean renameTo(File dest) Renombra un archivo con el parámetro
boolean delete() Indica éxito en borrado
String[] listFiles() Listado de archivo con el contenido del
directorio
String[] listFiles(FilenameFilter Permite filtrar los archivos utilizando un objeto
Filter) FilenameFilter
Ejecutar


Paquete de Programas Fuentes(Source Packages):: archivos
Programa Principal:: Archivos.java
Ahora, reemplace el contenido de la ventana Source por el siguiente codigo
import java.io.*;
class Archivos {
public static void main (String args[])throws IOException
{
String s;
System.out.println("Digite el Nombre del Archivo: ");
s=in.readLine();
File archivo = new File(s);
if (archivo.exists()) {
System.out.println("Nombre del archivo "+archivo.getName());
System.out.println("Camino "+archivo.getPath());
System.out.println("Camino absoluto "+archivo.getAbsolutePath());
System.out.println("Se puede escribir "+archivo.canRead());
System.out.println("Se puede leer "+archivo.canWrite());
System.out.println("Tamaño "+archivo.length());
}
else
System.out.println("No Existe el Archivo.");
}
}
Salvar con
Ejecute con F5 o
Abrir la aplicación Bloc de Notas

Colocar cinco frases… y guardar como Ejemplo.txt en la carpeta:
Normalmente esta en Mis Documentos…buscar la carpeta Archivos y abrirla

Pulsar botón
Volver al NetBeans Ejecute con F5 o

La salida del programa es la siguiente:
Para obtener la lista de los archivos del directorio actual se redefine un nuevo
objeto de la clase File
archivo=new File(".");
Para obtener la lista de los archivos que contiene este directorio se llama a la
función miembro list, la cual nos devuelve un vector de Strings.
String[] listaArchivos=archivo.list();
System.out.println("Nombre de Archivos.");
for(int i=0; i<listaArchivos.length; i++){
System.out.println(listaArchivos[i]);
}
Entonces el programa completo es el siguiente:
package archivos;
import java.io.*;
class Archivos {
public static void main (String args[])throws IOException
{
String s;
System.out.println("Digite el Nombre del Archivo: ");
s=in.readLine();
File archivo = new File(s);
if (archivo.exists()) {
System.out.println("Nombre del archivo "+archivo.getName());
System.out.println("Camino "+archivo.getPath());
System.out.println("Camino absoluto "+archivo.getAbsolutePath());
System.out.println("Se puede escribir "+archivo.canRead());
System.out.println("Se puede leer "+archivo.canWrite());
System.out.println("Tamaño "+archivo.length());
}
else
archivo=new File(".");
String[] listaArchivos=archivo.list();
System.out.println("Nombre de Archivos.");
for(int i=0; i<listaArchivos.length; i++)
System.out.println(listaArchivos[i]);
}
}
La salida es la siguiente
Clase FilenameFilter
A menudo se desea limitar el número de archivos devueltos por el método
listFiles para que se incluyan únicamente aquellos archivos que cumplan un
cierto patrón de nombre de archivo. Con este fin, el paquete java.io incluye una
interfaz llamada FilenameFilter. Un objeto que implemente FilenameFilter tiene
un único método, accept, al que se llama una vez por cada archivo de una lista.
El método accept devuelve el valor true si se debiera incluir el archivo en la lista
acorde con el filtro (en este caso extensión java).
Ejecutar

Verificar:

- Paquete de Programas Fuentes(Source Packages):: listaarchivo
- Programa Principal:: ListaArchivo.java
Reemplace el contenido del archive ListaArchivo.java por:
package listaarchivo;
import java.io.*;
public class ListaArchivo {
public static void main(String[] args) throws IOException {
File Archivo = new File("."); // Directorio Actual
FilenameFilter FiltroTexto = new FilenameFilter() {
public boolean accept(File dir, String name) {
String lowercaseName = name.toLowerCase();
if (lowercaseName.endsWith(".java")) {
return true;
} else {
return false;
}
}
};
File[] Archivos = Archivo.listFiles(FiltroTexto);
for (File indice : Archivos) {
if (indice.isDirectory()) {
System.out.print("Directorio:");
} else {
System.out.print(" Archivo:");
}
System.out.println(indice.getCanonicalPath());
}
}
}
Salvar con
Ejecute con F5 o
Ir a
normalmente esta en Mis Documentos
Buscar la carpeta y abrirla
Seleccionar y Copiar en el portapapeles el archivo ListaArchivo.java
Y pegar en la carpeta
Ejecute con F5 o
APLICACIÓN CARGAR UN ARCHIVO TEXTO
PRIMERA PARTE. ANTECEDENTE CLASE JFileChooser
La clase JFileChooser proporciona un GUI para navegar por el sistema de
archivos. También proporciona una forma para que el usuario elija un archivo o
directorio desde una lista o introduciendo un nombre de archivo o de directorio.
JFileChooser, que desciende de Container y de Component, crea un
componente Swing, Un objeto JFileChooser sólo representa el GUI para elegir
archivos. Nuestra aplicación es responsable de hacer algo con el archivo
elegido, como abrirlo o grabarlo.
El objeto JFileChooser consiste en un diálogo que contiene una lista de
archivos, un campo de texto, un botón como Save u Open, un botón Cancel, y
si se necesita, otros botones de selección.
Creamos un selector de archivos inicializando un objeto de la clase
JFileChooser:
JFileChooser chooser = new JFileChooser();
Ahora se analiza, la clase con sus constructores y sus Métodos:
Crear y Mostrar un Selector de Archivos
Método Propósito
JFileChooser()
JFileChooser(File, FileSystemView)
JFileChooser(File) Crea un ejemplar de
JFileChooser(FileSystemView) JFileChooser.
JFileChooser(String, FileSystemView)
JFileChooser(String)
int showOpenDialog(Component) Muestra un diálogo modal
int showSaveDialog(Component) conteniendo el selector de
int showDialog(Component, String) archivos.
El diálogo permanece activo hasta que el usuario lo cierra pulsando el botón
Save o Cancel, haciendo doble click en un archivo o usando el botón de cerrar
de sobre la barra de herramientas del diálogo. El valor de retorno de retorno de
la pulsación de uno de estos botones es el siguiente:
 APPROVE_OPTION
Valor devuelto si se aprobó puslando Yes, OK, o Save.
 CANCEL_OPTION
Valor devuelto si se canceló la elección.
Cuando el valor de retorno es APPROVE_OPTION, el archivo seleccionado se
puede recuperar con un método getSelectedFile. El método getAbsolutePath
de la clase File devuelve la forma absoluta del path abstracto que se ha
seleccionado en el selector de archivos o se ha tecleado en el campo de texto.
Navegar por la Lista del Selector de Archivos
Método Propósito
Fuerza el archivo indicado a
void ensureFileIsVisible(File) ser visible en la lista de
archivos.
Selecciona u obtiene el
void setCurrentDirectory(File) directorio cuyos archivos se
File getCurrentDirectory están mostrando en el selector
de archivos.
Cambia la lista para mostrar el
void changeToParentDirectory() directorio padre del directorio
actual.
Comprueba el sistema de
void rescanCurrentDirectory() archivos y actualiza la lista del
selector.
Personalizar el Selector de Archivos
Método Propósito
JComponent getAccessory()
accesorio del selector de
void setAccessory(JComponent)
archivos.
void setFileFilter(FileFilter)
filtro primario del selector
FileFilter getFileFilter()
de archivos.
void setFileView(FileView)
visor de archivos del
FileView getFileView()
selector.
FileFilter[] getChoosableFileFilters()
void setChoosableFileFilters(FileFilter[])
Selecciona, obtiene o
void addChoosableFileFilter(FileFilter)
modifica la lista de filtros
boolean removeChoosableFileFilter(FileFilter)
seleccionables.
void resetChoosable(FileFilter)
FileFilter getAcceptAllFileFilter()
Selecciona u obtiene si
void setFileHidingEnabled(boolean)
se muestran los archivos
boolean isFileHidingEnabled()
ocultos.
SEGUNDA PARTE. ANTECEDENTE LA CLASE FileFilter
La Clase FileFilter permite personalizar estos diálogos determinando que tipo
de archivos, extensiones, directorios, etc como en el caso del sistema operativo
MS-Dos el comando dir *.txt por ejemplo.
Seleccionar Archivos y Directorios
Método Propósito
Selecciona el modo de
void setFileSelectionMode(int) selección de archivos. Los
int getFileSelectionMode() valores aceptables son
boolean isDirectorySelectionEnabled() FILES_ONLY,
boolean isFileSelectionEnabled() DIRECTORIES_ONLY, y
FILES_AND_DIRECTORIES.
Selecciona u obtiene si se
void setMultiSelectionEnabled(boolean)
pueden seleccionar varios
boolean isMultiSelectionEnabled()
archivos a la vez.
void setSelectedFile(File)
archivo actualmente
File getSelectedFile()
seleccionado.
void setSelectedFiles(File[])
File[] getSelectedFiles()
A menudo se desea limitar e incluir el número de archivos que cumpla un cierto
patrón (ya sea por nombre o extensión) por un JFileChooser. Con este fin, el
paquete javax.swing.filechooser incluye una clase abstracta llamada FileFilter.
Un objeto que extiende FileFilter tiene un método, accept, al que se llama una
vez por cada archivo seleccionado en la ventana de abrir archivo. El método
accept devuelve el valor true si cumple con el patrón preestablecido (ya sea por
nombre o extensión).
El ejemplo siguiente aplica la visibilidad o filtro de los nombres de archivo con
una determinada extensión de archivo (variable ext) que se pasa como
parámetro cuando se construye el objeto de clase Filtro:
import java.io.*;
public class Filtro extends javax.swing.filechooser.FileFilter
{
String ext;
public Filtro(String ext)
{
this.ext = "." + ext;
}
public boolean accept(File f)
{
return f.isDirectory() || f.getAbsolutePath().endsWith(".java");
}
public String getDescription()
{
return "Todos los Archivos con extension "+ext;
}
}
Para obtener la lista de archivos con extensión .java en el directorio actual,

creamos un objeto de la clase Filtro y se lo pasamos a la función setFileFilter
de un objeto JFileChooser
Filtro filtro=new Filtro("java");

JFileChooser fileChooser = new JFileChooser();
fileChooser.setCurrentDirectory(new File(System.getProperty("user.dir")));
fileChooser.setFileFilter(filtro);
La salida es ahora la siguiente

TERCERA PARTE. PLATAFORMA NETBEANS
Primer Momento Creación del Proyecto
Ejecutar


Nombre del Proyecto: ArchivoVentana
Verificar:

- Paquete de Programas Fuentes(Source Packages):: archivoventana
- Programa Principal:: ArchivoVentana.java
Segundo Momento Creación de la Clase Base
Se debe posicionar sobre el paquete archivoventana y pulsar el botón derecho
del mouse>>opción new>>Java Class
La clase base sobre la que se va a trabajar se denomina Filtro, por tanto:
Nombre de la Clase: Filtro

El Netbeans genera:
Una clase publica Filtro que se encuentra en el paquete de clases denominada

archivoventana.
La clase Filtro debe cumplir:

- Extender la clase abstracta FileFilter
- Método Constructor con un argumento String(String)
- Métodos de la clase como: accept , getDescription
Primer Paso Colocar las bibliotecas de clase (import) necesarias. La
declaración de bibliotecas de clases se debe colocar antes del public class Fitro
así:
Entonces, coloque import java.io.*; antes de la línea public class Filtro
También se debe extender la clase abstracta FileFilter asi:
Entonces después de class Filtro coloque extends

javax.swing.filechooser.FileFilter
Segundo Paso Colocar Variables. La definición de la variables se deben

colocar después de
class Filtro extends javax.swing.filechooser.FileFilter{ quedando:
public class Filtro extends javax.swing.filechooser.FileFilter
{
String ext;
}
Tercer Paso. Generar el método constructor.

Después de la declaración del objeto ext se coloca el constructor:
public Filtro(String ext)
{
this.ext = "." + ext;
}
siguientes métodos:
public boolean accept(File f)
{
return f.isDirectory() || f.getAbsolutePath().endsWith(ext);
}
public String getDescription()
{
return "Todos los Archivos con extension "+ext;
}
Quedando:
Tercer Momento Creación de la Clase Vista
Se diseña una clase que opere sobre la clase Filtro a partir de un Objeto
JFileChooser para generar ventanas como:
Se debe posicionar sobre el paquete archivoventana y pulsar el botón derecho

del mouse>>opción new>>Java Class
El nombre de la clase es Vista
Se pulsa el Botón Finish
Se deben colocar los siguientes import antes del public class Vista
import java.io.*;
Quedando:
public void ventana()
{
Filtro filtro=new Filtro("java");
JFileChooser fileChooser = new JFileChooser();
fileChooser.setMultiSelectionEnabled(false);
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
fileChooser.setCurrentDirectory(new File(System.getProperty("user.dir")));
fileChooser.setFileFilter(filtro);
int result = fileChooser.showOpenDialog(null);
System.out.println(result);
if (result == JFileChooser.APPROVE_OPTION)
{
File file = fileChooser.getSelectedFile();
if (file == null)
{
JOptionPane.showMessageDialog(null,"No se ha seleccionado ningua
archivo");
System.exit(0);
}
if (file.getName().equals(""))
{
JOptionPane.showMessageDialog(null,"No se ha seleccionado ningua
archivo");
System.exit(0);
}
if(!filtro.accept(file))
{
JOptionPane.showMessageDialog(null,"El Archivo no es fuente java");
System.exit(0);
}
if (file.exists()) {
JOptionPane.showMessageDialog(null,"\n Nombre del Archivo: " +
file.getName()+"\n Camino : " + file.getPath()+("\n Camino Absoluto : "
+ file.getAbsolutePath()+"\n Modificable : " + file.canWrite()+"\n Lectura
: " + file.canRead()+"\n Longitud : " + file.length() + " Bytes"));
System.exit(0);
}
else
}
}
Quedando:
Cuarto Momento Actualizar la Clase ArchivoVentana
Seleccione la clase ArchivoVentana.java del proyecto y de doble click

V.ventana();
Quedando:

Seleccione el directorio src
Seleccione el directorio archivoventana
Seleccione Filtro.java
Cerrar la ventana de ejecución (Output)- (run):

2. FLUJOS DE DATOS
Todos los datos fluyen a través del Compuador desde una entrada hacia una
salida. Este flujo de datos se denomina también stream. Hay un flujo de
entrada (input stream) que manda los datos desde el exterior (por ejemplo el
teclado) del Compuador, y un flujo de salida (output stream) que dirige los
datos hacia los dispositivos de salida (por ejemplo, la pantalla o un archivo).
El proceso para leer o escribir datos consta de tres pasos
 Abrir el flujo de datos
 Mientras exista más información (leer o escribir ) los datos
 Cerrar el flujo de datos
Las jerarquías de clases
En el lenguaje Java los flujos de datos se describen mediante clases que
forman jerarquías según sea el tipo de dato char Unicode de 16 bits
(caracteres) o byte de 8 bits. A su vez, las clases se agrupan en jerarquías
según sea su función de lectura o de escritura.
La característica de internacionalización del lenguaje Java es la razón por la
que existe una jerarquía separada de clases para la lectura y escritura de
caracteres.
Todas estas clases se encuentran en el paquete java.io, por lo que al principio
del código fuente tendremos que escribir la sentencia: import java.io.*;
Figura 2. Jerarquía de clases para flujos de caracteres (char Unicode, 16
bits)
Figura 3. Jerarquía de clases para flujos de byte (8 bits).

Reader y Writer son las clases bases de la jerarquía para los flujos de
caracteres. Para leer o escribir datos binarios tales como imágenes o sonidos,
se emplea otra jerarquía de clases cuyas clases base son InputStream y
OutputStream.
Lectura
Las clases Reader e InputStream son similares aunque se refieren a distintos
tipos de datos, lo mismo ocurre con Writer y OutputSream.
Por ejemplo, Reader proporciona tres métodos para leer un carácter char o un
vector de caracteres
int read()
int read(char buf[])
int read(char buf[], int offset, int len)
La primera versión lee un byte como entero del flujo de entrada, devuelve –1 si
no hay más datos que leer. La segunda versión, lee un vector de bytes
devolviendo el número de bytes leídos. La tercera versión, lee también, un
vector de bytes, pero nos permite especificar, la posición de comienzo del
vector en la que se empiezan a guardar los bytes, y el máximo número de
bytes que se van a leer.
Escritura
La clase Writer proporciona tres métodos para escribir un carácter char o un
vector de caracteres
int write(int c)
int write(char buf[])
int write(char buf[], int offset, int len)
La clase OutputStream proporciona métodos similares
int write(int c)
int write(byte buf[])
int write(byte buf[], int offset, int len)
Clase FileInputStream
Es útil para realizar la lectura de caracteres de 8 bits desde un archivo
Constructores.
FileInputStream(String ): String es el nombre del archivo
FileInputStream(Objeto File): Indica el archivo a usar de entrada
La clase FileInputStream forma parte del paquete java.io
Métodos.
abstract int read(): Lectura de byte y los retorna como entero
int read(byte[]): Lectura de varios bytes. Retorna cantidad de Byte leidos ¢ -1 si
es final
int read(byte[],int desde,int tantos):Idem a segunda,permitiendo indicar desde
donde empezar
El final del archivo viene dado cuando la función read devuelve
-1. El resto del código es similar.
long skip(long n):Saltar bytes de entrada
int avalaible(): Devuelve el número de bytes disponibles. Asegura que existan
datos de entrada.
synchronized void mark(int): Marca la posici¢n actual del flujo. El parametro
indica cantidad de byte puede leer hacia delante.
synchronized void reset(): Ir a la primera posici¢n
boolean markSupported(): Boolean o que devuelve true si soporta reset y mark
void close(): cierra un flujo de entrada.
Programa java
package mario12;
import java.io.*;
class Mario12 {
public static void main (String args[]) throws IOException
{
StringBuilder linea=new StringBuilder ();
FileInputStream en = new FileInputStream("Ejemplo.txt");
int numero=en.available();
int k;
for(k=1;(k<=numero);k++)
linea.append((char) en.read());
System.out.println(linea.toString ());
en.close();
}
}
Clase FileOutputStream
Es útil para realizar la Salida simple (caracteres de 8 bits) de archivos
Constructores.
FileOutputStream(String ): String es el nombre del archivo
FileOutPutStream(Objeto File): Indica el archivo a usar de Salida
La clase FileOutputStream forma parte del paquete java.io
Métodos.
abstract int write(): Escribe un único byte
void write(byte[]): Escribe varios bytes.
void write(byte[],int desde ,int tantos):Idem a segunda, permitiendo indicar
desde donde empezar y cuantos a escribir
void flush():Limpiar un flujo de Salida
void close(): Cierra un flujo de Salida.
Programa java
import java.io.*;
import java.util.*;
class Mario13 {
public static void main (String args[]) throws IOException {
StringBuilder linea=new StringBuilder ();
StringBuilder frase=new StringBuilder ();
FileOutputStream out= new FileOutputStream("Ejemplo.txt");
DataInputStream in=new DataInputStream (System.in);
int numero;
int k;
String s=new String ();
System.out.println("Introduzca cinco frases");
for(k=1;k<=5;k++) {
s=in.readLine();
linea.append(s);
}
for(k=0;k<linea.length();k++)
out.write((byte) linea.charAt(k));
out.close();
FileInputStream en = new FileInputStream("Ejemplo.txt");
numero=en.available();
System.out.println("Número de Bytes disponibles: "+String
.valueOf(numero));
for(k=1;(k<numero);k++)
frase.append((char) en.read());
System.out.println(frase.toString ());
en.close();
}
}
3. ENTRADA/SALIDA ESTÁNDAR
Los objetos System.in y System.out
La entrada/salida estándar (normalmente el teclado y la pantalla,
respectivamente) se definen mediante dos objetos que puede usar el
programador sin tener que crear flujos específicos.
Figura 4. Clase System

La clase System tiene un miembro dato denominado in que es una instancia de
la clase InputStream que representa al teclado o flujo de entrada estándar. Sin
embargo, el miembro out de la clase System es un objeto de la clase
PrintStream, que imprime texto en la pantalla (la salida estándar).
Para leer un carácter solamente tenemos que llamar a la función read desde
System.in.
try{
System.in.read();
}catch (IOException ex) { }
Obligatoriamente, el proceso de lectura ha de estar en un bloque try…catch
Esta porción de código es la que se ha empleado en muchas aplicaciones para
detener la ejecución de una aplicación hasta que se pulse la tecla TECLA
ENTER.
Para leer un conjunto de caracteres hasta que se pulse la tecla TECLA ENTER
escribimos
StringBuffer str=new StringBuffer();
char c;
try{
while ((c=(char)System.in.read())!='\n'){
str.append(c);
}
}catch(IOException ex){}
La clase StringBuffer(ver Taller Clase StringBuffer) es una clase que nos
permite crear strings. Contiene métodos para añadir nuevos caracteres a un
buffer y convertir el resultado final en un string. Las principales funciones
miembro son insert y append. Usamos una versión de esta última función para
añadir un carácter al final de un objeto de la clase StringBuffer.
Para convertir un objeto str de la clase StringBuffer a String se usa la función
miembro (método) toString. Esta llamada se hace de forma implícita cuando
dicho objeto se le pasa a System.out.println.
System.out.println(str);
Finalmente, se ha de hacer notar, que el método read de InputStream devuelve
un int que es promocionado (casting) a char.
El siguiente código contiene lo explicado anteriormente:
import java.io.*;
public class TeclaEnter
{
{
char c;
System.out.println("Introduce una línea de texto y pulsa TECLA ENTER ");
try{
while ((c=(char)System.in.read())!='\n'){
str.append(c);
}
System.out.println(str.toString());
}
}
Conexión con la clase Reader
Existe la posibilidad de conectar el objeto System.in con un objeto de la clase
InputStreamReader para leer los caracteres tecleados por el usuario.
Esta conexión se realiza mediante la sentencia
Reader entrada=new InputStreamReader(System.in);
Para leer una sucesión de caracteres se emplea un código similar

char c;
try{
while ((c=(char)entrada.read())!='\n'){
str.append(c);
}
Ahora, se coloca un código que complementa lo anterior:
import java.io.*;
public class TeclaEnter1{
char c;
try{
// while ((c=(char)System.in.read())!='\n'){
while ((c=(char)entrada.read())!='\n'){
str.append(c);
}
try {
//espera la pulsación de una tecla y luego TECLA ENTER
System.in.read();
}catch (Exception e) { }
}
}
Para imprimir los caracteres leídos se escribe como en la sección anterior
Podemos usar la segunda versión de la función read para leer el conjunto de
caracteres tecleados por el usuario.
char[] buffer=new char[255];
try{
int numBytes=entrada.read(buffer);
System.out.println("Número de bytes leídos "+numBytes);
}catch(IOException ex){ }
En esta segunda porción de código, se lee un conjunto de caracteres hasta que

se pulsa la tecla TECLA ENTER, los caracteres se guardan en el array buffer.
La función read devuelve el número de caracteres leídos.
Para imprimir los caracteres leídos se crea un objeto str de la clase String a
partir de un array de caracteres buffer, empleando uno de los contructores de
dicha clase. A continuación, se imprime el string str.
String str=new String(buffer);
Ahora, se coloca un código que complementa e integra lo anterior:
import java.io.*;
public class TeclaEnter2{
char[] buffer=new char[255];
try{
int numBytes=entrada.read(buffer);
System.out.println("Número de bytes leídos "+numBytes);
}catch(IOException ex){
System.out.println("Error entrada/salida");
}
System.out.println("La línea de texto que has escrito es ");
String str=new String(buffer);
try {
//espera la pulsación de una tecla y luego TECLA ENTER
System.in.read();
}catch (Exception e) { }
}
}
4. OPERACIONES DE ENTRADA/SALIDA DESDE ARCHIVOS
Lectura de un archivo
El proceso de lectura de un archivo de texto es similar a la lectura desde el
dispositivo estándar. Creamos un objeto entrada de la clase FileReader en vez
de InputStreamReader.
CLASE FileReader
Es útil para realizar la lectura de caracteres de 16 bits desde un archivo
Constructores.
FileReader (String): String es el nombre del archivo
FileReader (Objeto File): Indica el archivo a usar de entrada
Métodos.
abstract int read(): Lectura de byte y los retorna como entero
int read(byte[ ]): Lectura de varios bytes. Retorna cantidad de Byte leidos -1 si
es final
int read(byte[ ],int desde,int tantos):Idem a segunda, permitiendo indicar desde
donde empezar
El final del archivo viene dado cuando la función read devuelve
-1. El resto del código es similar.
long skip(long n):Saltar bytes de entrada
int avalaible(): Devuelve el número de bytes disponibles. Asegura que existan
datos de entrada.
synchronized void mark(int): Marca la posición actual del flujo. El parámetro
indica cantidad de byte puede leer hacia delante.
synchronized void reset(): Ir a la primera posición
boolean markSupported(): Booleano que devuelve true si soporta reset y mark
void close(): cierra un flujo de entrada.
FileReader entrada=null;
try {
entrada=new FileReader("Archivo.java");
int c;
while((c=entrada.read())!=-1){
str.append((char)c);
}
}catch (IOException ex) {}
Para mostrar el archivo de texto en la pantalla del monitor, se imprime el
contenido del objeto str de la clase StringBuffer.
Una vez concluido el proceso de lectura, es conveniente cerrar el flujo de
datos, esto se realiza en una cláusula finally que siempre se llama
independientemente de que se produzcan o no errores en el proceso de
lectura/escritura.
}finally{
if(entrada!=null){
try{
entrada.close();
}
}
import java.io.*;
public class ArchivoLectura {
try {
int c;
str.append((char)c);
}
System.out.println("--------------------------------------");
}catch (IOException ex) {
System.out.println(ex);
}finally{
//cerrar los flujos de datos
if(entrada!=null){
try{
entrada.close();
}
System.out.println("el bloque finally siempre se ejecuta");
}
}
}
Clase FileWriter
Es útil para realizar la Salida de caracteres de 16 bits a archivos
Métodos.
abstract int write(): Escribe un único byte
void write(byte[]): Escribe varios bytes.
void write(byte[],int desde,int tantos):Idem a segunda,permitiendo indicar desde
donde empezar y cuantos a escribir
void flush():Limpiar un flujo de Salida
void close(): Cierra un flujo de Salida.
Constructores.
FileWriter (String): String es el nombre del archivo
FileWriter (Objeto File): Indica el archivo a usar de Salida
import java.io.*;
import java.util.*;
class ArchivoEscritura {
{
StringBuffer frase=new StringBuffer();
FileWriter out= new FileWriter("Ejemplo.txt");
DataInputStream in=new DataInputStream (System.in);
int k;
String s=new String();
for(k=1;k<=5;k++)
{
s=in.readLine();
linea.append(s);
}
for(k=0;k<linea.length();k++)
out.write((byte) linea.charAt(k));
out.close();
}
}
Ahora verifique el contenido del archivo Ejemplo.txt en la carpeta donde esta el
programa ArchivoEscritura.java
Nota. FileReader y FileWriter leen y escriben caracteres de 16 bits. Sin
embargo, la mayoría del sistemas de archivos nativos están basados en bytes
de 8 bits. Estos streams codifican los caracteres según operan de acuerdo al
esquema de codificación de caracteres por defecto. Podemos encontrar la
codificación de caracteres por defecto usando
System.getProperty("file.encoding"). Para especificar otra codificación,
deberíamos construir un OutputStreamWriter sobre un FileOutputStream y
especificarla.
Nota. Cuando se trate de leer y escribir datos binarios se sustituye FileReader
por FileInputStream y FileWriter por FileOutputStream. De hecho, si se realiza
esta sustitución en el código fuente de este ejemplo, los resultados no cambian.
Lectura/escritura
Los pasos para leer y escribir en disco son los siguientes:
1. Se crean dos objetos de las clases FileReader y FileWriter, llamando a
los respectivos constructores a los que se les pasa los nombres de los
archivos o bien, objetos de la clase File, respectivamente
salida=new FileWriter("copia.java");
2. Se lee mediante read los caracteres del flujo de entrada, hasta llegar al
final (la función read devuelve entonces -1), y se escribe dichos
caracteres en el flujo de salida mediante write.
salida.write(c);
}
3. Finalmente, se cierran ambos flujos llamando a sus respectivas
funciones close en bloques try..catch
entrada.close();
salida.close();
import java.io.*;
public class ArchivoLecturaEscritura {
FileWriter salida=null;
try {
salida=new FileWriter("copia.java");
int c;
salida.write(c);
}
}catch (IOException ex) {
System.out.println(ex);
}finally{
//cerrar los flujos de datos
if(entrada!=null){
try{
entrada.close();
}
if(salida!=null){
try{
salida.close();
}
System.out.println("el bloque finally siempre se ejecuta");
}
}
}
5. LEER Y ESCRIBIR DATOS PRIMITIVOS
Los flujos de datos DataInputStream y DataOutputStream
La clase DataInputStream es útil para leer datos del tipo primitivo de una forma
portable. Esta clase tiene un sólo constructor que toma un objeto de la clase
InputStream o sus derivadas como parámetro.
Se crea un objeto de la clase DataInputStream vinculándolo a un un objeto

FileInputStream para leer desde un archivo en disco denominado pedido.txt.
FileInputStream fileIn=new FileInputStream("pedido.txt");

DataInputStream entrada=new DataInputStream(fileIn));
o en una sola línea
DataInputStream entrada = new DataInputStream ( new FileInputStream
("pedido.txt"));
La clase DataInputStream define diversos métodos readXXX que son
variaciones del método read de la clase base para leer datos de tipo primitivo
boolean readBoolean();
byte readByte();
int readUnsignedByte();
short readShort();
int readUnsignedShort();
char readChar();
int readInt();
String readLine();
long readLong();
float readFloat();
double readDouble();
La clase DataOutputStream es útil para escribir datos del tipo primitivo de una
forma portable. Esta clase tiene un sólo constructor que toma un objeto de la
clase OutputStream o sus derivadas como parámetro.
Se crea un objeto de la clase DataOutputStream vinculándolo a un objeto
FileOutputStream para escribir en un archivo en disco denominado pedido.txt.
FileOutputStream fileOut=new FileOutputStream("pedido.txt");
DataOutputStream salida=new DataOutputStream(fileOut));
o en una sola línea
DataOutputStream salida=new DataOutputStream(new
FileOutputStream("pedido.txt"));
La clase DataOutputStream define diversos métodos writeXXX que son
variaciones del método write de la clase base para escribir datos de tipo
primitivo
void writeBoolean(boolean v);
void writeByte(int v);
void writeBytes(String s);
void writeShort(int v);
void writeChars(String s);
void writeChar(int v);
void writeInt(int v);
void writeLong(long v);
void writeFloat(float v);
void writeDouble(double v);
Ejemplo: un pedido
En este ejemplo, se escriben datos a un archivo y se leen del mismo, que

corresponden a un pedido
 La descripción del item, un objeto de la clase String
 El número de unidades, un dato del tipo primitivo int
 El precio de cada item, un dato de tipo double.
Observamos en la tabla y en el código el nombre de las funciones que leen y
escriben los distintos tipos de datos.
Escritura Lectura
Un carácter writeChar readChar
Un entero writeInt readInt
Un número decimal writeDouble readDouble
Un string writeChars readLine
Veamos el código que escribe los datos a un archivo pedido.txt en disco

1. Se parte de los datos que se guardan en los arrays denominados
descripciones, unidades y precios
2. Se crea un objeto de la clase DataOutputStream vinculándolo a un un
objeto FileOutputStream para escribir en un archivo en disco
denominado pedido.txt..
3. Se escribe en el flujo de salida los distintos datos llamando a las
distintas versiones de la función writeXXX según el tipo de dato
(segunda columna de la tabla).
4. Se cierra el flujo de salida, llamando a su función miembro close.
import java.io.*;
public class ArchivoEscritura1 {
double[] precios={1350, 400, 890, 6200, 8730};
int[] unidades={5, 7, 12, 8, 30};
DataOutputStream salida=null;
String[] descripciones={"paquetes de papel", "lápices", "bolígrafos", "carteras",
"mesas"};
try
{
salida=new DataOutputStream(new FileOutputStream("pedido.txt"));
for (int i=0; i<precios.length; i ++) {
salida.writeChars(descripciones[i]);
salida.writeChar('\n');
salida.writeInt(unidades[i]);
salida.writeChar('\t');
salida.writeDouble(precios[i]);
}
salida.close();
}
}
}
Para leer bien los datos, el string ha de separase del siguiente dato con un
carácter nueva línea '\n'. Esto no es necesario si el string se escribe en el
último lugar, después de los números. Por otra parte, el carácter tabulador
como separador no es estrictamente necesario.
Veamos el código que lee los datos a un archivo pedido.txt en disco

1. Se crea un objeto de la clase DataInputStream vinculándolo a un objeto
FileInputStream para leer en un archivo en disco denominado pedido.txt.
2. Se lee el flujo de entrada los distintos datos en el mismo orden en el que
han sido escritos, llamando a las distintas versiones de la función
readXXX según el tipo de dato (tercera columna de la tabla).
3. Se guardan los datos leídos en memoria en las variables denominadas
descripción, unidad y precio y se usan para distintos propósitos
4. Se cierra el flujo de entrada, llamando a su función miembro close.
import java.io.*;
public class ArchivoLectura1 {
double precio;
int unidad;
String descripcion;
double total=0.0;
DataInputStream entrada=null;
boolean sepuede=true;
try
{
entrada=new DataInputStream(new FileInputStream("pedido.txt"));
}
catch(FileNotFoundException e)
{
System.out.println("No existe el archivo pedido.txt");
sepuede=false;
}
if(sepuede)
try
{
while ((descripcion=entrada.readLine())!=null) {
unidad=entrada.readInt();
entrada.readChar(); //lee el carácter tabulador
precio=entrada.readDouble();
System.out.println("has pedido "+unidad+" "+descripcion+" a "+precio+"
Pesos.");
total=total+unidad*precio;
}
System.out.println("por un TOTAL de: "+total+" Pesos.");
entrada.close();
}catch (IOException e) {}
}
}
Como vemos en esta porción de código, según se van leyendo los datos del
archivo, se imprimen y se calcula el precio total del pedido.
System.out.println("has pedido "+unidad+" "+descripcion+" a "+precio+"

Pesos.");
total=total+unidad*precio;
EJEMPLO QUE INTEGRA ALGUNOS CASOS
Primer Archivo : ArchivoEscritura.java

package gestionarchivos;
import java.io.*;
class ArchivoEscritura{
FileWriter arch;
boolean abrir()
{
try
{
arch=new FileWriter("alumnos.dat");
}
catch(IOException e) { return false; }
return true;
}
void leer(String Cod,String Nom,String Fac)
{
linea.append(Cod); linea.append(","); linea.append(Nom); linea.append(",");
linea.append(Fac); linea.append(";");
}
boolean cerrar()
{
int k;
if(linea.length()==0)
return false;
for(k=0;k<linea.length()-1;k++)
try
{
arch.write((char) linea.charAt(k));
}
catch(IOException e)
{
return false;
}
try
{
arch.close();
}
{
return false;
}
return true;
}
}
Segundo Archivo: ArchivoLectura.java
import java.io.*;
import java.util.*;
public class ArchivoLectura {
FileReader arch;
boolean lectura()
{
try
{
arch=new FileReader("alumnos.dat");
}
{
return false;
}
File fuente=new File("alumnos.dat");
int k;
for(k=1;k<=fuente.length();k++)
try
{
linea.append((char) arch.read());
}
{
return false;
}
try
{
arch.close();
}
{
return false;
}
return true;
}
void tabla()
{
StringTokenizer T=new StringTokenizer(linea.toString(),";");
String S=null;
int i;
while(T.hasMoreTokens())
{
linea=new StringBuffer();
StringTokenizer U=new StringTokenizer(T.nextToken(),",");
i=-1;
while(U.hasMoreTokens())
{
i++;
switch(i)
{
case 1:
S=U.nextToken();
break;
case 2:
linea.append(U.nextToken());
linea.append(" ");
break;
case 3:
linea.append(U.nextToken());
linea.append("\n");
}
}
H.put(S.toString(),linea.toString());
}
}
String Consulta()
{
Enumeration codigo=H.keys();
String S=null;
linea.append(" Codigo Nombre Facultad \n");
while(codigo.hasMoreElements())
{
S=(String) codigo.nextElement();
linea.append(S.toString());
S=(String) H.get(S);
linea.append(" ");
linea.append(S.toString());
}
}
}
Tercer Archivo: GestionArchivos.java
import java.io.*;
public class GestionArchivos{
public static void main(String[] args){
ArchivoEscritura archivo=new ArchivoEscritura();
char c;
String Cod;
String Nom;
String Fac;
if(!archivo.abrir()){
System.out.println("No se pudo crear archivo de escritura");
System.exit(0);
}
do{
Cod=JOptionPane.showInputDialog(null,"Digite Codigo: ");
Nom=JOptionPane.showInputDialog(null,"Digite Nombre: ");
Fac=JOptionPane.showInputDialog(null,"Digite Facultad: ");
archivo.leer(Cod,Nom,Fac);
System.out.println("desea continuar S/N");
do
{
try
{
c=(char)System.in.read();
}
catch(IOException ex)
{
c=' ';
}
}
while(c!='n' && c!='N' && c!='S' && c!='s');
}
while(c=='S' || c=='s');
if(!archivo.cerrar())
{
System.out.println("No se pudo cerrar el archivo");
System.exit(0);
}
ArchivoLectura arch=new ArchivoLectura();
if(!arch.lectura())
{
System.out.println("No se pudo crear archivo de lectura");
System.exit(0);
}
arch.tabla();
JOptionPane.showMessageDialog(null,arch.Consulta());
}
}
6. CLASE RandomAccessFile
Figura 5. Clase RandomAccessFile

Constructor
Modo:
Métodos de desplazamiento
Cuenta con una serie de funciones para realizar el desplazamiento del puntero
del archivo. Hay que tener en cuenta que cualquier lectura o escritura de datos
se realizará a partir de la posición actual del puntero del archivo.
long getFilePointer();Devuelve la posición actual del puntero del archivo.
void seek( long l ); Coloca el puntero del archivo en la posición indicada por l.
Un archivo siempre empieza en la posición 0.
int skipBytes( int n ); Intenta saltar n bytes desde la posición actual.
long length(); Devuelve la longitud del archivo.
void setLength( long l); Establece a l el tamaño de este archivo.
FileDescriptor getFD(); Devuelve el descriptor de este archivo.
Métodos de escritura
La escritura del archivo se realiza con una función que depende el tipo de datos
que se desee escribir.
void write( byte b[], int ini, int len ); Escribe len caracteres del vector b.
void write( int i ); Escribe la parte baja de i (un byte) en el flujo.
void writeBoolean( boolean b ); Escribe el boolean b como un byte.
void writeByte( int i ); Escribe i como un byte.
void writeBytes( String s ); Escribe la cadena s tratada como bytes, no
caracteres.
void writeChar( int i ); Escribe i como 1 byte.
void writeChars( String s ); Escribe la cadena s.
void writeDouble( double d ); Convierte d a long y le escribe como 8 bytes.
void writeFloat( float f ); Convierte f a entero y le escribe como 4 bytes.
void writeInt( int i ); Escribe i como 4 bytes.
void writeLong( long v ); Escribe v como 8 bytes.
void writeShort( int i ); Escribe i como 2 bytes.
void writeUTF( String s ); Escribe la cadena s utilizando la codificación UTF-8.
Métodos de lectura
La lectura del archivo se realiza con una función que depende del tipo de datos
que queremos leer.
boolean readBoolean(); Lee un byte y devuelve false si vale 0 o true sino.
byte readByte(); Lee y devuelve un byte.
char readChar(); Lee y devuelve un caracter.
double readDouble(); Lee 8 bytes, y devuelve un double.
float readFloat(); Lee 4 bytes, y devuelve un float.
void readFully( byte b[] ); Lee bytes del archivo y los almacena en un vector b.
void readFully( byte b[], int ini, int len ); Lee len bytes del archivo y los almacena
en un vector b.
int readInt(); Lee 4 bytes, y devuelve un int.
long readLong(); Lee 8 bytes, y devuelve un long.
short readShort(); Lee 2 bytes, y devuelve un short.
int readUnsignedByte(); Lee 1 byte, y devuelve un valor de 0 a 255.
int readUnsignedShort(); Lee 2 bytes, y devuelve un valor de 0 a 65535.
String readUTF(); Lee una cadena codificada con el formato UTF-8.
int skipBytes(int n); Salta n bytes del archivo.
Si no es posible la lectura devuelven –1.

import java.io.*;
import java.util.*;
class Escritura2 {
{
RandomAccessFile out=new RandomAccessFile("Ejemplo.txt","rw"); // E/S
BufferedReader in=new BufferedReader(new
InputStreamReader(System.in));
StringBuffer s=new StringBuffer();
String p;
int k;
for(k=1;k<=5;k++)
{
s.append(in.readLine());
}
out.writeChars(s.toString());
out.close();
RandomAccessFile en=new RandomAccessFile("Ejemplo.txt","r");
p=en.readLine();
System.out.println(p.toString());
en.close();
}
}
El siguiente programa simula una tabla de índices (llave primaria y número de
registro) usando para ello, las clases RandomAccessFile y Hashtable.
import java.io.*;
import java.util.*;
class ArchivoEscritura{
RandomAccessFile arch;
int longreg=34;
boolean abrir()
{
try
{
arch=new RandomAccessFile("Cliente.txt","rw");
}
{
return false;
}
return true;
}
String alinear(String S,int k)
{
StringBuffer B=new StringBuffer(S.toString());
B.setLength(k);
}
void leer(String Cod,String Nom,String Tel)
{
linea.append(Cod.toString());
linea.append(Nom.toString());
linea.append(Tel.toString());
}
boolean cerrar()
{
int k;
return false;
try
{
arch.writeChars(linea.toString());
arch.close();
}
{
return false;
}
return true;
}
}
class ArchivoLectura
{
long pos=-1,k;
byte alumno[]=new byte[40];
int longreg=34;
boolean lectura()
{
try
{
arch=new RandomAccessFile("cliente.txt","r");
}
{
return false;
}
return true;
}
void tabla()
{
long i=-1;
pos=0;
i=-1;
try
{
do
{
i++;
bajar();
String S=new String(linea.toString()).substring(0,7);
H.put(S.toString(),new String().valueOf(i));
pos=pos+longreg;
}
while(pos<arch.length());
}
{
}
}
void bajar()
{
try
{
arch.seek(pos);
for(k=pos;k<pos+longreg;k++)
{
if(k==pos+7 || k==pos+27)
linea.append(" ");
linea.append(arch.readChar());
}
}
{
}
}
String Consulta(String cod)

{
String S=null;
if(H.containsKey(cod))
{
linea.append(" Codigo Nombre Facultad
\n");
pos=Long.parseLong((String) H.get(cod))*longreg;
bajar();
}
else
linea.append("No existe codigo");
}
String Consulta()
{
String S=null;
linea.append(" Codigo Nombre Telefono \n");
{
pos=Long.parseLong((String) H.get(S))*longreg;
bajar();
linea.append("\n");
}
}
}
public class ArchivoRandom
{
{
char c;
String Cod=null;
String Nom=null;
String Tel=null;
int cod;
int tel;
if(!archivo.abrir())
{
System.exit(0);
}
do
{
do
{
Cod=JOptionPane.showInputDialog(null,"Digite Nit: ");
cod=Integer.parseInt(Cod);
}
while(cod<1000000);
do
{
Tel=JOptionPane.showInputDialog(null,"Digite Telefono: ");
tel=Integer.parseInt(Tel);
}
while(tel<1000000);
Cod=archivo.alinear(Cod,7);
Nom=archivo.alinear(Nom,20);
Tel=archivo.alinear(Tel,3);
archivo.leer(Cod,Nom,Tel);
do
{
try
{
}
{
c=' ';
}
}
while(c!='n' && c!='N' && c!='S' && c!='s');
}
while(c=='S' || c=='s');
{
System.exit(0);
}
if(!arch.lectura())
{
System.out.println("No se pudo abrir archivo de lectura");
System.exit(0);
}
arch.tabla();
// JOptionPane.showMessageDialog(null,arch.Consulta().toString());
do
{
Cod=JOptionPane.showInputDialog(null,"Digite Nit a Consultar: ");
}
while(cod<1000000);
JOptionPane.showMessageDialog(null,arch.Consulta(Cod).toString());
}
}
Pulsar F5 o
PRIMER PROGRAMA DIRECCION RELATIVA DE REGISTRO
El siguiente programa actualiza y consulta un archivo de acceso random con
base a una tabla de índices (llave primaria y numero de registro) usando para
ello, las clases RandomAccessFile y Hashtable.
El código es siguiente:
package archivorandom;
import java.io.*;
import java.util.*;
class ArchivoEscritura
{
int longreg=34;
boolean abrir()
{
try
{
arch=new RandomAccessFile("Cliente.txt","rw");
}
{
return false;
}
return true;
}
{
B.setLength(k);
}
void leer(String Cod,String Nom,String Tel)
{
linea.append(Cod.toString());
linea.append(Nom.toString());
linea.append(Tel.toString());
}
boolean cerrar()
{
int k;
return false;
try
{
arch.writeChars(linea.toString());
arch.close();
}
{
return false;
}
return true;
}
}
class ArchivoLectura
{
long pos=-1,k;
byte alumno[]=new byte[40];
int longreg=34;
boolean lectura()
{
try
{
arch=new RandomAccessFile("cliente.txt","r");
}
{
return false;
}
return true;
}
void tabla()
{
long i=-1;
pos=0;
i=-1;
try
{
do
{
i++;
bajar();
H.put(S.toString(),new String().valueOf(i));
pos=pos+longreg;
}
while(pos<arch.length());
}
{
}
}
void bajar()
{
try
{
arch.seek(pos);
{
linea.append(" ");
}
}
{
}
}
String Consulta(String cod)
{
String S=null;
if(H.containsKey(cod))
{
linea.append(" Codigo Nombre Facultad \n");
pos=Long.parseLong((String) H.get(cod))*longreg;
bajar();
}
else
linea.append("No existe codigo");
}
String Consulta()
{
String S=null;
linea.append(" Codigo Nombre Telefono \n");
{
pos=Long.parseLong((String) H.get(S))*longreg;
bajar();
linea.append("\n");
}
}
}
public class ArchivoRandom
{
{
char c;
String Cod=null;
String Nom=null;
String Tel=null;
int cod;
int tel;
if(!archivo.abrir())
{
System.exit(0);
}
do
{
do
{
Cod=JOptionPane.showInputDialog(null,"Digite Nit: ");
}
while(cod<1000000);
do
{
Tel=JOptionPane.showInputDialog(null,"Digite Telefono: ");
tel=Integer.parseInt(Tel);
}
while(tel<1000000);
Tel=archivo.alinear(Tel,3);
archivo.leer(Cod,Nom,Tel);
do
{
try
{
}
{
c=' ';
}
}
while(c!='n' && c!='N' && c!='S' && c!='s');
}
while(c=='S' || c=='s');
{
System.exit(0);
}
if(!arch.lectura())
{
System.out.println("No se pudo abrir archivo de lectura");
System.exit(0);
}
arch.tabla();
// JOptionPane.showMessageDialog(null,arch.Consulta().toString());
do
{
Cod=JOptionPane.showInputDialog(null,"Digite Nit a Consultar: ");
}
while(cod<1000000);
JOptionPane.showMessageDialog(null,arch.Consulta(Cod).toString());
}
}
Pulsar F5 o
SEGUNDO PROGRAMA CON NUMERO DE REGISTRO
El código es siguiente:
package archivoreg;
import java.io.*;
import java.util.*;
class ArchivoBase
{
long longreg;
RandomAccessFile Temp;
long numreg=-1,pos=0,k;
void crearTemp(String Nom,long l)
{
longreg=l;
try
{
Temp=new RandomAccessFile(Nom.toString(),"rw");
}
catch(IOException e){ }
}
void crearDatos(String Nom)
{
try
{
arch=new RandomAccessFile(Nom.toString(),"rw");
}
catch(IOException e){ }
}
boolean lectura(String Nom)
{
try
{
arch=new RandomAccessFile("Alumno.dat","rw");
}
{
return false;
}
return true;
}
{
B.setLength(k);
}
void tabla()
{
numreg=-1;
pos=0;
try
{
while(arch.getFilePointer()<arch.length())
{
numreg++;
pos=numreg*(longreg*2);
bajar();
H.put(S.toString(),new String().valueOf(numreg));
}
}
{
}
}
void bajar()
{
try
{
arch.seek(pos);
{
linea.append(" ");
}
}
{
}
}
boolean existe(String cod)
{
return H.containsKey(cod);
}
String consulta(String cod)
{
String S=null;
\n");
pos=Long.parseLong((String) H.get(cod));
pos=pos*(longreg*2);
bajar();
}
String verTodos()
{
Enumeration alumno=H.keys();
\n");
while (alumno.hasMoreElements())
{
String cod=(String) alumno.nextElement();
bajar();
linea.append("\n");
}
}
void borrar(String Cod)
{
H.remove(Cod);
}
void adicion(String Cod,String Nom,String Fac)
{
try
{
numreg++;
pos=numreg*(longreg*2);
arch.seek(pos);
arch.writeChars(Cod.toString());
arch.writeChars(Nom.toString());
arch.writeChars(Fac.toString());
}
{
}
H.put(Cod,new String().valueOf(numreg));
}
void pasar()
{
Enumeration alumno=H.keys();
while (alumno.hasMoreElements())
{
String cod = (String) alumno.nextElement();
try
{
arch.seek(pos);
}
}
try
{
Temp.writeChars(linea.toString());
}
}
void cerrarTemp()
{
try
{
Temp.close();
}
}
void cerrarDatos()
{
try
{
arch.close();
}
}
}
public class ArchivoReg
{
static ArchivoBase archivo;
static File NomDatos=new File("alumno.dat");
static File NomTemp=new File("Temp.dat");
static char c;
static String Cod=null;
static String Nom=null;
static String Fac=null;
static int cod;
static int fac;
{
archivo=new ArchivoBase();
if(NomDatos.exists())
{
archivo.crearTemp("Temp.dat",40);
archivo.lectura("alumno.dat");
archivo.tabla();
}
else
{
archivo.crearTemp("Temp.dat",40);
archivo.crearDatos("alumno.dat");
}
Object[] Opcion={"1. Adicion","2. Borrar","3.Consulta","4. Ver Todos","5. Salir"};
String S;
int opc=0;
do
{
switch(opc)
{
case 1:
adicion();
break;
case 2:
borrar();
break;
case 3:
consulta();
break;
case 4:
JOptionPane.showMessageDialog(null,archivo.verTodos().toString());
}
}
while(opc!=5);
cerrar();
System.exit(0);
}
static void lecturaCod()
{
do
{
Cod=JOptionPane.showInputDialog(null,"Digite Codigo a Consultar: ");
}
while(cod<1000000);
}
static void lectura()
{
do
{
Fac=JOptionPane.showInputDialog(null,"Digite Facultad: ");
fac=Integer.parseInt(Fac);
}
while(fac<10 && fac>=100);
Fac=archivo.alinear(Fac,3);
}
static void adicion()
{
lecturaCod();
if(archivo.existe(Cod))
JOptionPane.showMessageDialog(null,"Ya Existe Codigo");
else
{
lectura();
archivo.adicion(Cod.toString(),Nom.toString(),Fac.toString());
}
}
static void borrar()
{
lecturaCod();
if(!archivo.existe(Cod))
JOptionPane.showMessageDialog(null,"No Existe Codigo");
else
{
archivo.borrar(Cod);
}
}
static void consulta()
{
lecturaCod();
if(!archivo.existe(Cod))
JOptionPane.showMessageDialog(null,"No Existe Codigo");
else
{
JOptionPane.showMessageDialog(null,archivo.consulta(Cod).toString()
);
}
}
static void cerrar()
{
archivo.pasar();
archivo.cerrarTemp();
archivo.cerrarDatos();
if(NomDatos.delete())
NomTemp.renameTo(new File("alumno.dat"));
}
}
Pulsar F5 o
Adicionar:
1234567 Pedro Perez 12
5678906 Maria Aleja 23
Pulsar F5 o
OCTAVA PARTE. EXCEPCIONES

EXCEPCIONES
Los programadores de cualquier lenguaje se esfuerzan por escribir programas
libres de errores, sin embargo, es muy difícil que los programas reales se vean
libres de ellos. En Java las situaciones que pueden provocar un fallo en el
programa se denominan excepciones.
Java lanza una excepción en respuesta a una situación poco usual. El
programador también puede lanzar sus propias excepciones. Las excepciones
en Java son objetos de clases derivadas de la clase base Exception.
Diapositivas tomadas de: http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf
Se toma como ejemplo, la conversión de una cadena a número entero

haciendo uso de la función estática Integer.parseInt, a saber:
String A=" 12 ";
int numero=Integer.parseInt(str);
Como se nota, al inicio de la cadena A aparece un espacio en blanco, al hacer
la conversión, se lanza una excepción NumberFormatException como:
AppAccelerator(tm) 1.1.034 for Java (JDK 1.1), x86 version.
Copyright (c) 1998 Borland International. All Rights Reserved.
java.lang.NumberFormatException: 12
at java.lang.Integer.parseInt(Compiled Code)
at java.lang.Integer.parseInt(Integer.java:390)
at excepcion.ExcepcionApp.main(ExcepcionApp.java:8)
Captura de las excepciones: Bloques try…catch

Estudio de Caso. Para solucionar el error que se produce en el programa
durante su ejecución, cuando se hace uso de Integer.parseInt en el siguiente
bloque try...catch.
String str=" 12 ";
int numero;
try{
numero=Integer.parseInt(str);
}catch(NumberFormatException ex){
System.out.println("No es un número");
}
Clausula finally

La sentencia throw
Para permitirle a los métodos responder a lo inesperado, Java provee un medio
alternativo de terminar la ejecución de un método y lanzar una excepción. Esto
se realiza a través de enunciado throw:
throw referencia-a-excepción;
Diapositiva tomada de: http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf

Propagación de Excepciones (throws)
Diapositiva tomada de: http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf
Supongamos el siguiente ejemplo de una implementación de una clase Pila:

class Pila
{
private int arreglo[], top;
public Pila(int n)
{
arreglo = new int[n];
tope=-1;
}
public void apila(int elem)
{
tope++;
arreglo[tope]=elem;
}
public int desempila()
{
int elem=arreglo[tope];
tope--;
return elem;
}
}
Análisis.
El constructor recibe el tamaño de la Pila y se utiliza método apila para
adicionar elementos y el método desempila para sacar elementos.
Caso Adicionar Elementos (Apilar). Puede suceder que se insertan más
elementos de la capacidad de la Pila. Entonces, se debe disparar una
excepción. Se hace uso de un método estaLLena que retorna true en el caso
que la pila está llena. El método apila propaga la excepción mediante throws
Exception y la sentencia throw new Exception("Pila llena!") lanza una excepción
con el aviso Pila llena!
public boolean estaLLena()
{
return (tope==arreglo.length-1);
}
public void apila(int elem) throws Exception

{
if (estaLLena()) throw new Exception("Pila llena!");
top++;
arreglo[tope]=elem;
}
Caso Borrar Elementos (Desempliar). Puede suceder que se eliminen
elementos sin tener en cuenta que no hay más elementos. Entonces, se debe
disparar una excepción. Se hace uso de un método estaVacia que retorna true
en el caso que la pila está vacía. El método desempila propaga la excepción
mediante throws Exception y la sentencia throw new Exception("Pila vacia!")
lanza una excepción con el aviso Pila vacia!
public boolean estaVacia()
{
return (tope==-1);
}
public int desempila()throws Exception
{
if (estaVacia()) throw new Exception("Pila Vacia!");
tope--;
return elem;
}
Concluyendo. Cualquier método que pueda disparar una excepción debe de
advertirlo en su declaración con la clausula throws. Esta clausula consiste en
la palabra reservada throws seguido por una lista de las subclases de
Exception que pueden tratar la excepción del respectivo método. Este
requerimiento aplica no solo a métodos que incluyen el enunciado throws sino
que a todos los métodos que pueden disparar una excepción al invocar otros
métodos que incluyen throws Exception.
Desarrollo de la práctica
Ejecutar

Seleccionar . Pulsar el Botón Finish

El Netbeans genera la estructura de un proyecto.
Se debe posicionar sobre el paquete pilas y pulsar el botón derecho del

mouse>>opción new>>Java Class…
Nombre de Clase: Pila. Pulsar el Botón Finish
Ahora, debe colocar el código:
private int arreglo[], tope;

public Pila(int n)
{
arreglo = new int[n];
tope=-1;
}
public boolean estaVacia()
{
return (tope==-1);
}
public boolean estaLLena()
{
return (tope==arreglo.length-1);
}
public void apila(int elem) throws Exception
{
if (estaLLena()) throw new Exception("Pila llena!");
tope++;
arreglo[tope]=elem;
}
public int desempila() throws Exception
{
if (estaVacia()) throw new Exception("Pila vacia!");
tope--;
return elem;
}
Quedando:
Seleccione y de doble click sobre la clase Pilas.java( clase main)
Reemplazar por el siguiente código:

Pila p = new Pila(5);
int i,k=0;
for(i=1;i<=10;i++)
{
try
{
k=(int) (Math.random() * 20 + 1);
p.apila(k);
}
catch(Exception e)
{
System.out.println("No se pudo insertar más números..."+k);
}
}
for(i=1;i<=10;i++)
try
{
System.out.println("Número desempilado: "+p.desempila());
}
catch(Exception e)
{
System.out.println("No se pudieron sacar todos los elementos.");
}
Quedando:
Pulsar
Agregando Información Adicional a las Excepciones
Algunas veces se desea devolver información adicional al disparar una
excepción. Por ejemplo, si al disparar una excepción en el caso que no se
pueda apilar (adicionar) un elemento, se hace una llamado a una excepción
(clase que hereda de la clase Exception), con un aviso por ejemplo Pila llena:
no se pudo insertar el elemento
Caso Pila Llena. Se debe posicionar sobre el paquete pilas y pulsar el botón
derecho del mouse>>opción new>>Other…>>Java Exception
Pulsar Botón Next
Nombre de la Clase: PilaLLena. Pulsar el Botón Finish

Quitar los comentarios del archivo…..
super("Pila llena: no se pudo insertar el elemento " + msg);

Quedado:
Caso Pila Vacía. Se debe posicionar sobre el paquete pilas y pulsar el botón
derecho del mouse>>opción new>>Java Exception…
Pulsar Botón Next
Nombre de la Clase: PilaVacia. Pulsar el Botón Finish

Quitar los comentarios del archivo…..
super("Pila Vacia…no hay elementos.. " + msg);

Quedado:
Se debe editar el archivo Pila.java así:
El método apila entonces quedaría así:

public void apila(int elem) throws PilaLLena
{
if (estaLLena()) throw new PilaLLena(String.valueOf(elem));
tope++;
arreglo[tope]=elem;
}
El método desempila entonces quedaría así:
public int desempila() throws PilaVacia
{
if (estaVacia()) throw new PilaVacia ("Pila vacia!");
tope--;
return elem;
}
El cambio debe quedar así:
Hacer click sobre Pilas.java….
Reemplazar entonces por:

Pila p = new Pila(5);
int i,k=0;
for(i=1;i<=10;i++)
{
try
{
k=(int) (Math.random() * 20 + 1);
p.apila(k);
}
catch (PilaLLena e)
{
System.out.println(e.getMessage());
}
}
for(i=1;i<=10;i++)
try
{
System.out.println("Número desempilado: "+p.desempila());
}
catch (PilaVacia e)
{
System.out.println(e.getMessage());
}
Quedando:
Pulsar
Para realizar la siguiente práctica se necesita saber o recordar de la clase
String:
charAt( int indice ):: Devuelve el carácter que se encuentra en la posición que
se indica en índice
int length()::la longitud de la cadena ó número de caracteres
String trim():: Elimina espacios al comienzo como al final de la cadena
La clase valChar verifica
Que la cadena leída solamente tiene letras y dispara una excepción
ExceptoLetras
Que la cadena leída solamente tiene dígitos y dispara una excepción
ExceptoDigitos
Que la cadena leída solamente tiene letras, espacios en blanco y dispara una
excepción ExceptoParrafo
Que la cadena leída solamente sea de formato fecha (día/mes/año) y dispara
una excepción ExceptoFechas
Que el párrafo leido solamente tiene letras, espacios en blanco, y palabras
tituladas y dispara una excepción ExceptoPalabraTitulada
El parámetro String P en el administrador de excepciones posee los caracteres
de excepción
Debe llevarse a ambiente NetBeans 8
Programa: ExceptoLetras
class ExceptoLetras extends Exception
{
public ExceptoLetras(String msg)
{
super(" Las Caracteres no Letras son: "+msg);
}
}
Programa: ExceptoDigitos
class ExceptoDigitos extends Exception
{
public ExceptoDigitos(String msg)
{
super(" Las Caracteres no Digitos son: "+msg);
}
}
Programa: ExceptoParrafo
class ExceptoParrafo extends Exception
{
public ExceptoParrafo(String msg)
{
super(" Las Caracteres Letras y No espacios en blanco: "+msg);
}
}
Programa: ExceptoPalabraTitulada
class ExceptoPalabraTitulada extends Exception
{
public ExceptoPalabraTitulada(String msg)
{
super(" Las Palabras No son Tituladas: "+ msg);
}
}
Programa: ExceptoFechas
class ExceptoFechas extends Exception
{
public ExceptoFechas(String msg)
{
super("No se cumple con el formato Fecha: "+msg);
}
}
Programa: ValChar
import java.util.*;
import java.text.*;
class ValChar
{
int i;
boolean es;
StringBuffer B;
// Método que verifica si todos los caracteres son letras
void soloLetras(String P)throws ExceptoLetras
{
es=true;
{
B.append(" ");
es=false;
}
if(!es)
throw new ExceptoLetras(B.toString());
}
void soloDigitos(String P)throws ExceptoDigitos
{
es=true;
{
B.append(" ");
es=false;
}
if(!es)
throw new ExceptoDigitos(B.toString());
}
// Método que verifica si todos los caracteres son letras y espacios en blanco
void soloParrafo(String P)throws ExceptoParrafo
{
es=true;
if(!Character.isLetter(P.charAt(i)) && !Character.isSpace(P.charAt(i)))
{
B.append(" ");
es=false;
}
if(!es)
throw new ExceptoParrafo(B.toString());
}
public void soloFecha(String fecha)throws ExceptoFechas
{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT,
new Locale("es"));
if (fecha == null)
throw new ExceptoFechas(B.toString());
try {
FormatoFecha.parse(fecha.trim());
}
{
throw new ExceptoFechas("(dia/mes/año) :"+fecha.toString());
}
}
public void soloTitulada(String P)throws ExceptoPalabraTitulada
{
int i;
boolean error=false,noes=false;;
String S="";
StringTokenizer T=new StringTokenizer(P);
while(T.hasMoreTokens())
{
P=T.nextToken();
noes=false;
for(i=0;i<P.length() && !noes;i++)
{
{
noes=true;
}
noes=true;
}
else
noes=true;
if(noes)
{
error=true;
S=S+" "+P;
}
}
if(error) throw new ExceptoPalabraTitulada(S.toString());
}
}
Programa: ExceptoLectura:
public class ExceptoLectura
{
public void verifica()
{
ValChar V=new ValChar();
String S=" ";
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Digitos: ").trim();
V.soloDigitos(S);
}
catch(ExceptoDigitos e)
{
JOptionPane.showMessageDialog(null,e.getMessage());
}
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Letras: ").trim();
V.soloLetras(S);
}
catch(ExceptoLetras e)
{
}
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Palabras Tituladas y
Espacios en Blanco: ").trim();
V.soloTitulada(S);
}
catch(ExceptoPalabraTitulada e)
{
}
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Letras y Espacios en
Blanco: ").trim();
V.soloParrafo(S);
}
catch(ExceptoParrafo e)
{
}
try
{
S=JOptionPane.showInputDialog(null,"Teclee Fecha(dia/mes/año):
").trim();
V.soloFecha(S);
}
catch(ExceptoFechas e)
{
}
System.exit(0);
}
}
La clase principal Excepciones o main:
Al pulsar
CASO DE ESTUDIO. EXPRESIONES REGULARES
Tomado de:
http://www.programacion.com/articulo/expresiones_regulares_en_java_127
Las expresiones regulares son una forma de coincidencia de patrones que se
pueden aplicar en el contenido textual. Tomemos por ejemplo los comodines
de DOS? Y * que se puede utilizar cuando usted está buscando un archivo. Se
trata de un tipo de subconjunto muy limitado de expresiones regulares. Por
ejemplo, si desea encontrar todos los archivos que comienzan con "fn", seguido
de 1 a 4 caracteres al azar, y terminando con "ht.txt", no se puede hacer eso
con los comodines DOS habitual. Las expresiones regulares, por el contrario,
podría manejar eso y mucho más complicados patrones.
Las expresiones regulares son, en definitiva, una forma de manejar
eficazmente los datos, buscar y reemplazar cadenas, y proporcionar control de
cadenas extendidas. A menudo una expresión regular puede de por sí el
manejo de cadenas que otras funcionalidades, como el incorporado en los
métodos y propiedades de cadena sólo se puede hacer si usted los utiliza en
una función complicada o bucle.
Las expresiones regulares se rigen por una serie de normas y hay una
construcción para cualquier patrón de caracteres. Una expresión regular sólo
puede contener (aparte de letras y números) los siguientes caracteres:
< $, ^, ., *, +, ?, [, ], . >
Una expresión regular, nos servirá para buscar patrones en una cadena de
texto, por ejemplo encontrar cuantas veces se repite una palabra en un texto,
para comprobar que una cadena tiene una determinada estructura, por ejemplo
que el nombre de archivo que nos proponen tiene una determinada extensión,
o comprobar que un email esta bien escrito... Para cada uno de estos casos
existe una expresión regular que los representa:
Por medio de la expresión regular "camion" podemos encontrar cuantas veces
se repite camión en un texto. Es la construcción mas sencilla.
Esta expresión "^www.*.es" comprueba que una cadena sea una dirección web
que comience por www y sea de un servidor español.
Y esta, para ver la potencia de las expresiones regulares, comprueba la buena
formación de los correos electrónicos: "[Â-Za-z0-9.@_-~#]+".
[Para ver como formar expresiones regulares puede ir al Apéndice A]
Uso en Java
El paquete java.util.regex esta formado por dos clases, la clase Matcher y la
clasePattern y por una excepción, PatternSyntaxException.
La clase Pattern (segun la documentacion del jdk1.4) es la representacion
compilada de una expresion regular, o lo que es lo mismo, representa a la
expresion regular, que en el paquetejava.util.regex necesita estar compilada.
En castellano significa patrón.
La clase Matcher es un tipo de objeto que se crea a partir de un patrón
mediante la invocación del método Pattern.matcher. Este objeto es el que nos
permite realizar operaciones sobre la secuencia de caracteres que queremos
validar o la en la secuencia de caracteres en la que queremos buscar. En
castellano lo mas parecido a esto es la palabra encajador.
Por lo tanto tenemos patrones que deben ser compilados, a partir de estos
creamos objetosMatcher (encajadores) para poder realizar las operaciones
sobre la cadena en cuestión.
Vamos con la clase Pattern, para crear un patrón necesitamos compilar una
expresión regular, esto lo conseguimos con el método compile:
Pattern patron = Pattern.compile("camion");
El método pattern devuelve la expresión regular que hemos compilado, el
método matchercrea un objeto Matcher a partir del patrón, el
método split divide una cadena dada en partes que cumplan el patrón
compilado y por último el método matches compila una expresión regular y
comprueba una cadena de caracteres contra ella.
Ahora la clase Matcher. Esta clase se utiliza para comprobar cadenas contra el
patrón indicado. Un objeto Matcher se genera a partir de un objeto Pattern por
medio del método matcher:
Pattern patron = Pattern.compile("camion");
Matcher encaja = patron.matcher();
Una vez que tenemos el objeto creado, podemos realizar tres tipos de
operaciones sobre una cadena de caracteres. Una es a través del
método matches que intenta encajar toda la secuencia en el patrón (para el
patrón "camion" la cadena "camion" encajaría, la cadena "mi camion es verde"
no encajaría). Otra es a través del método lookingAt, intenta encajar el patrón
en la cadena (para el patrón "camion" tanto la cadena "camion" como la cadena
"mi camion es verde" encajaria). Otra es la proporcionada por el
método find que va buscando subcadenas dentro de la cadena de caracteres
que cumplan el patrón compilado (una vez encontrada una ocurrencia, se
puede inspeccionar por medio de los métodos start que marca el primer
carácter de la ocurrencia en la secuencia y el método end que marca el ultimo
carácter de la ocurrencia). Todos estos métodos devuelven un booleano que
indica si la operación ha tenido éxito.
Ejemplos
El siguiente es un ejemplo del uso del método replaceAll sobre una cadena. El
ejemplo sustituye todas las apariciones que concuerden con el patron "a*b" por
la cadena "-".
// se importa el paquete java.util.regex
import java.util.regex.*;
public class EjemploReplaceAll{

public static void main(String args[]){
// compilamos el patron
Pattern patron = Pattern.compile("a*b");
// creamos el Matcher a partir del patron, la cadena como parametro
Matcher encaja = patron.matcher("aabmanoloaabmanoloabmanolob");
// invocamos el metodo replaceAll
String resultado = encaja.replaceAll("-");
System.out.println(resultado);
}
}
El siguiente ejemplo trata de validar una cadena que supuestamente contiene
un email, lo hace con cuatro comprobaciones, con un patrón cada una, la
primera que no contenga como primer caracter una @ o un punto, la segunda
que no comience por www. , que contenga una y solo una @ y la cuarta que no
contenga caracteres ilegales:
public class ValidacionEmail {
public static void main(String[] args) throws Exception {
String input = "www.?regular.com";
// comprueba que no empieze por punto o @
Pattern p = Pattern.compile("^.|^@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Las direcciones email no empiezan por punto o @");
// comprueba que no empieze por www.

p = Pattern.compile("^www.");
m = p.matcher(input);
if (m.find())
System.out.println("Los emails no empiezan por www");
// comprueba que contenga @

p = Pattern.compile("@");
if (!m.find())
System.out.println("La cadena no tiene arroba");
// comprueba que no contenga caracteres prohibidos
p = Pattern.compile("[Â-Za-z0-9.@_-~#]+");
StringBuffer sb = new StringBuffer();
boolean resultado = m.find();
boolean caracteresIlegales = false;
while(resultado) {
caracteresIlegales = true;
m.appendReplacement(sb, "");
resultado = m.find();
}
// Añade el ultimo segmento de la entrada a la cadena

m.appendTail(sb);
input = sb.toString();
if (caracteresIlegales) {
System.out.println("La cadena contiene caracteres ilegales");
}
}
}
Conclusión
Hasta ahora la única opción para conseguir un efecto parecido era el uso de
StringTokenizer en conjunción con llamadas repetidas al método charAt que
producía un código demasiado enrevesado. Las expresiones regulares tienen
un amplio abanico de posibilidades, principalmente para hacer búsquedas, para
sustituir ocurrencias y para comprobar la buena formación de cadenas, como
se ha visto en el ejemplo del email.
Enlaces
Java Developers Kit de Sun v.1.4: http://java.sun.com/j2se/
Documentacion de Sun del paquete
java.util.regex:http://java.sun.com/j2se/1.4/docs/api/java/util/regex/package-
summary.html
Tutorial de expresiones
regulares: http://bulmalug.net/body.phtml?nIdNoticia=770
Apéndice A
Lo que viene a continuación no es mas que la traducción del la documentación
de una parte de la clase Pattern. Para una referencia completa puede consultar
la versión en ingles de Sun inc. sobre la clase Pattern
enhttp://java.sun.com/j2se/1.4/docs/api/java/util/regex/Pattern.html.
Expresion Encaja con
Caracteres
x El caracter x
El caracter
n El caracter con valor octal 0n (0 <= n <= 7)
nn El caracter con valor octal 0nn (0 <= n <= 7)
El caracter con valor octal 0mnn (0 <= m <= 3,
mnn
0 <= n<= 7)
xhh El caracter con valor hexadecimal 0xhh
uhhhh El caracter con valor hexadecimal 0xhhhh
El tabulador ('u0009')
Nueva linea (line feed) ('u000A')
Retorno de carro ('u000D')
f Nueva pagina ('u000C')
a Un beep de alerta (bell) ('u0007')
e Escape ('u001B')
cx El caracter de control que corresponde a x
Intervalos de caracteres
[abc] a, b, o c
[âbc] Cualquier caracter excepto a, b, o c (negacion)
[a-zA-Z] Desde la a a la z o desde la A hasta la Z, incluidos
Desde la a hasta la d, o desde la m a la p: [a-dm-p]
[a-d[m-p]]
(union)
[a-z&&[def]] La d, la e, o la f (interseccion)
Desde la a hasta la z, excepto la b y la c: [ad-
[a-z&&[^bc]]
z] (resta)
Desde la a hasta la z, excepto desde la m hasta
[a-z&&[^m-p]]
la p: [a-lq-z](resta)
predefinidos
Cualquier caracter (puede que no se incluyan
.
losterminadores de linea)
d Un numero: [0-9]
D Todo menos un numero: [^0-9]
s Un espacio en blanco: [ x0Bf ]
S Todo menos un espacio en blanco: [^s]
w Una letra: [a-zA-Z_0-9]
W Todo menos letras: [^w]
POSIX
(solo para US-ASCII)
{lower} Letras minusculas: [a-z]
{upper} Letras mayusculas:[A-Z]
{alpha} Letras:[{lower}{upper}]
{digit} Numero decimal: [0-9]
{alnum} Caracter alfanumerico:[{alpha}{digit}]
Signos de puntuacion: uno de !"#$%&'()*+,-
{punct}
./:;<=>?@[]^_`{|}~
Los caracteres visibles: [{alnum}{punct}]
{graph}
PRACTICA DE EXPRESIONES REGULARES EN NETBEANS
Programa: ExceptoDigitos
class ExceptoDigitos extends Exception{
public ExceptoDigitos(String P)
{
super(" Los siguentes caracteres "+P+" no son Enteros");
}
}
Programa: ExceptoLetras
public class ExceptoLetras extends Exception {
public ExceptoLetras(String P)
{
super(" Los siguentes caracteres "+P+" por lo tanto no Sustantivo comun");
}
}
Programa: ExceptoPalabraTitulada
class ExceptoPalabraTitulada extends Exception{
public ExceptoPalabraTitulada(String P)
{
super(" La siguente Palabra "+P+" No es Titulada");
}
}
Programa: ExceptoCorreo
class ExceptoCorreo extends Exception
{
public ExceptoCorreo(String P)
{
super(" El siguente correo "+P+" no es valido ejemplo@dominio.com");
}
}
Programa: ExceptoPorcentaje
class ExceptoPorcentaje extends Exception
{
public ExceptoPorcentaje(String P)
{
super(" El formato del porcenteje debe ser NN,NN : "+P);
}
}
Programa: ExceptoFechas
class ExceptoFechas extends Exception
{
public ExceptoFechas(String P)
{
super("No se cumple con el formato Fecha: "+P);
}
}
Programa: ExceptoDecimal
class ExceptoDecimal extends Exception
{
public ExceptoDecimal(String P)
{
super("No se cumple con el formato decimal: "+P);
}
}
Programa: ValChar
import java.text.*;
import java.util.*;
public class ValChar {
int i;
boolean es;
StringBuffer B;
Pattern p =null;
Matcher m = null;
void soloDigitos(String P)throws ExceptoDigitos
{
p = Pattern.compile("^[0-9-]+$");
m = p.matcher(P);
if (!m.find()) {
throw new ExceptoDigitos(P);
}
JOptionPane.showMessageDialog(null, "El dato Ingresado es correcto");
}
void soloLetras(String P)throws ExceptoLetras
{
p = Pattern.compile("^([a-z]|[A-Z]|á|é|í|ó|ú|ñ|ü|^s)+$");
m = p.matcher(P);
if (!m.find())
throw new ExceptoLetras(P);
}
//Metodo que verifica que cada palabra empiese con Mayuscula
public void soloTitulada(String P)throws ExceptoPalabraTitulada
{
String mayus = "[A-Z]{1}";
String minus="^([a-z]|á|é|í|ó|ú|ñ|ü|^s)+$";
String primera=String.valueOf(P.charAt(0));
String segunda=P.substring(1,P.length());
boolean error=false;
p = Pattern.compile(mayus);
m = p.matcher(primera);
if (!m.find())
error=true;
p = Pattern.compile(minus);
m = p.matcher(segunda);
if (!m.find())
error=true;
if(error)
throw new ExceptoPalabraTitulada(P);
}
//Validar correo
void soloCorreo(String P)throws ExceptoCorreo
{
p = Pattern.compile("^[A-Za-z0-9._%-]+@[A-Za-z0-9.-]+\\.[a-zA-Z]{2,4}$");
m = p.matcher(P);
if (!m.find())
throw new ExceptoCorreo(P);
JOptionPane.showMessageDialog(null, "El correo Ingresado es correcto");
}
//Valida porcentaje
void SoloPorcentaje(String P)throws ExceptoPorcentaje
{
p = Pattern.compile("^[0-9%-]+,[0-9%-]+$");
m = p.matcher(P);
if (!m.find())
throw new ExceptoPorcentaje(P);
JOptionPane.showMessageDialog(null, "El porcentaje Ingresado es
correcto");
}
//Validar Fecha
public void soloFecha(String fecha)throws ExceptoFechas
{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT,
new Locale("es"));
if (fecha == null)
throw new ExceptoFechas(B.toString());
try {
FormatoFecha.parse(fecha.trim());
}
{
throw new ExceptoFechas("(dia/mes/año) :"+fecha.toString());
}
JOptionPane.showMessageDialog(null, "El fecha Ingresada es correcta");
}
void soloDecimal(int enteros, int decimales, String P)throws ExceptoDecimal
{
String cadena="^(?:\\+|-
)?\\d{"+String.valueOf(enteros)+"}\\.\\d{"+String.valueOf(decimales)+"}+$";
p = Pattern.compile(cadena);
m = p.matcher(P);
if (!m.find())
throw new ExceptoDecimal(P);
JOptionPane.showMessageDialog(null, "El Numero Real Ingresado es
correcto");
}
Programa: Capturador
public class Capturador {
ValChar V=new ValChar();
String S=" ";
boolean error;
String Digitos(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Digitos: ",S).trim();
V.soloDigitos(S);
}
catch(ExceptoDigitos e)
{
error=true;
}
}
while(error);
return S;
}
String Letras(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee solo Letras: ",S).trim();
V.soloLetras(S);
}
catch(ExceptoLetras e)
{
error=true;
}
}
while(error);
return S;
}
String Titulada(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee palabra titulada: ",S).trim();
V.soloTitulada(S);
}
catch(ExceptoPalabraTitulada e)
{
error=true;
}
}
while(error);
return S;
}
String Correo(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee un correo: ",S).trim();
V.soloCorreo(S);
}
catch(ExceptoCorreo e)
{
error=true;
}
}
while(error);
return S;
}
String Porcentaje(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee un Porcentaje: ",S).trim();
V.SoloPorcentaje(S);
}
catch(ExceptoPorcentaje e)
{
error=true;
}
}
while(error);
return S;
}
String Fecha(String S){
this.S=S;
do
{
error=false;
try
{
S=JOptionPane.showInputDialog(null,"Teclee Fecha(dia/mes/año):
",S).trim();
V.soloFecha(S);
}
catch(ExceptoFechas e)
{
error=true;
}
}
while(error);
return S;
}
String decimales(String S){
this.S=S;
do
{
error=false;
try
{
int enteros=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el
Numero de Digitos Enteros:"));
int decimales=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el
Numero de Digitos Decimales:"));
S=JOptionPane.showInputDialog(null,"Digite el Numero e evaluar:");
V.soloDecimal(enteros,decimales,S);
}
catch(ExceptoDecimal e)
{
error=true;
}
}
while(error);
return S;
}
}
Programa Menu
public class Menu {
public void opciones()
{
Capturador C=new Capturador();
String Nenteros="";
String Text="";
String Nombre="";
String Correo="";
String Porcentaje="";
String fecha="";
String decimales="";
String titulada="";
boolean salir = true;
int opc;
String S;
Object[] Opcion={"1. Enteros","2. Sustantivo comun","3. Sustantivo
propio","4. Correo ","5. Porcentajes","6. Fechas","7. Decimales","8.
Tituladas","9. Cierre"};
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones de ingreso: ","
Verificador",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[0]);
opc=Character.digit(S.charAt(0),10);
switch(opc)
{
case 1:Nenteros=C.Digitos(Nenteros);
break;
case 2: Text=C.Letras(Text);
break;
case 3: Nombre=C.Titulada(Nombre);
break;
case 4: Correo=C.Correo(Correo);
break;
case 5: Porcentaje=C.Porcentaje(Porcentaje);
break;
case 6: fecha=C.Fecha(fecha);
break;
case 7: decimales=C.decimales(decimales);
break;
case 8:
titulada=C.Titulada(titulada);
break;
}
}while(opc!=9);
System.exit(0);
}
}
Programa ExpresionesRegurales
public class ExpresionesRegulares {

Menu M=new Menu();
M.opciones();
}
}

Buenas Practicas en Java Basico e Intermedio Con Compiladores en Linea y Netbeans 8 - Usta PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Buenas Practicas en Java Basico e Intermedio Con Compiladores en Linea y Netbeans 8 - Usta PDF

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD SANTO TOMAS DE AQUINO VICE

DECANATURA DE DIVISION DE UNIVERSIDAD

FACULTAD CIENCIAS Y TECNOLOGIAS PROGRAMA

BUENAS PRÁCTICAS EN JAVA BASICO E INTERMEDIO

CON COMPILADORES EN LINEA Y NETBEANS 8

DNDA No. 10-718-469

DOCENTE TIEMPO COMPLETO

BOGOTA, OCTUBRE 2019

•Preparación del proyecto

QUE SE ENTIENDE POR BUENAS PRACTICAS

PRIMERA PARTE. GRAMATICA LENGUAJE JAVA

< > Elemento No Terminal – Compuesto de ó define

:- Se Define como ó compuesto de

1. NATURALEZA DE LOS SIMBOLOS

& | (Alt 124) <lógicos>

Token: Se define como una colección de símbolos de igual naturaleza.

Los Token se pueden definir de naturaleza:

<Relación>:- < > == (igual) <= >= != (diferente)

<Lógicos >:- || (or) && (and) ! (negación)

Ejemplo: i<=a && j!=k || k==z

<Aritméticos>:- <únicos> <dobles>

<Aritméticos únicos>:- + - * / % (residuo)

<Aritméticos dobles>:- <prefijo> <infijo> <postfijos>

<prefijo>:- ++ (incremento) -- (decremento)

Ejemplo: ++i que es i=i+1

Ejemplo: a+=b que es a=a+b

Ejemplo: i++ que es i=i+1

<todo minúscula>:-   min usculas  Ejemplo: static

<titulada>:- <mayúscula> <todo minúscula> Ejemplo: String

<nombre variable>: - <letra>   letra  Ejemplo: a

<nombre objeto>: - <letra>   letra 

<nombre método>: - <todo minúscula>   titulada 

<nombre clase>: -   titulada 

<numero>:- <entero> <real>

<numero entero>:-   digito  Ejemplo: 9

<numero real>:- <numero entero> . <numero entero> Ejemplo: 3.1416

El conjunto de palabras reservadas de Java es el siguiente:

abstract default if private throw

boolean do implements protected throws

break double import public transient

byte else instanceof return try

case extends int short void

catch final interface static volatile

char finally long super while

class float native switch import

for new synchronized null

true false continue package this

2.1 Declaración de Variables y constantes

En java se puede definir dos tipos de datos a declarar:

<tipo dato>: - <tipo variable> | < nombre clase>

static final <tipo variable> <nombre variable> = <valor>;

<tipo variable>: - int |float|boolean| long |byte|double|char

<valor>:- <numero> <literal>

Ejemplo: static final int salario=50000;

Declaración de Variables: <declaración de variable>

Formato 1: <tipo variable> <nombre variable>;

Formato 3: <tipo variable> <formato 1 ó 2> 

int A; int B=5; int C, i=0;

2.2 Declaración de Objetos

<nombre clase> <nombre objeto> = new <nombre clase> ();

Hashtable H=new Hashtable();

2.3 Declaración, creación, subindicación e Inicialización de Arreglos

<tipo dato> <nombre Variable>[];