PDF Curso PDF

Repaso de ciclos, estructuras de control y arreglos
Sentencia while
Ejecuta una secuencia de instrucciones, cero o más veces, dependiendo
de la condición de evaluación.
While (condicion){
secuencia de instrucciones
}
Ejemplo:
public class Ciclos {

public static void main(String[] args) {
int i=0;
while(i<=10){ //mientras i es menor o igual a 10
System.out.print(i + " ");
i++; //es igual a i=i+1;
}
}
}
Ing. Miguel Angel Sánchez Hernández
Sentencia do .. while
Ejecuta una secuencia de instrucciones, una o más veces, dependiendo de
la condición de evaluación.
do{
secuencia de instrucciones
} While (condicion);
Ejemplo:

int i=0;
do{
i++; //es igual a i=i+1;
}while(i<=10); //mientras i es menor o igual a 10
}
}
Sentencia for
Ejecuta una secuencia de instrucciones, una o más veces, dependiendo de
la condición de evaluación.
//La instrucción for en su encabezado contiene
//inicialización(variable de ontrol);condicion;incremento
for( [v1=e1[,v2=e2]…];[condición];incremento){
secuencia de instrucciones;
}
Ejemplo:

for (int i = 0; i < 10; i++) {
}
}
}
package semana6;
import java.util.Scanner;
public class Factorial {
Scanner entrada = new Scanner(System.in);
System.out.println("Dame un valor: ");
int valor = entrada.nextInt();
double n = 1;
double fact = 1;
while (n <= valor) {
fact *= n;
n++;
}
System.out.println("El factorial de " + valor + " es "+fact);
}
}

package semana6;
public class CalcularE {
double n=1,m=1;
double fact=1;
double e=1;
while(m<10){
n=1;
while(n<=m){
fact*=n;
n++;
}
e+=1/fact;
fact=1;
m++;
}
System.out.println("El valor de e "+e);
}
}

package semana6;
public class ExpX {
Scanner entrada=new Scanner(System.in);
System.out.println("Dame el valor de x: ");
int x=entrada.nextInt();
int xx=x;
double n = 1, m = 1;
double fact = 1;
double e = 1;
while (m <= 20) {
n = 1;
while (n <= m) {
fact *= n;
n++;
}
e += x/ fact;
fact = 1;
x*=xx;
m++;
}
System.out.println("El valor de e^x: " + e);
}
}
Instrucción de selección múltiple switch
package semana6;
public class SeleccionSwitch {
System.out.println("Dame un valor del 1 al 5 ");
int valor = entrada.nextInt();
switch (valor) {
case 1:
System.out.println("El valor fue uno");
break;
case 2:
System.out.println("El valor fue dos");
break;
case 3:
System.out.println("El valor fue tres");
break;
case 4:
System.out.println("El valor fue cuatro");
break;
case 5:
System.out.println("El valor fue cinco");
break;
default:
System.out.println("fuera del rango");
break;
}
} Ing. Miguel Angel Sánchez Hernández
}
package semana6;
System.out.println("Dame una vocal ");
char valor = entrada.next().charAt(0);
switch (valor) {
case 'a':
System.out.println("La vocal fue a");
break;
case 'e':
System.out.println("La vocal fue e");
break;
case 'i':
System.out.println("La vocal fue i");
break;
case 'o':
System.out.println("La vocal fue o");
break;
case 'u':
System.out.println("La vocal fue u");
break;
default:
System.out.println("no fue vocal");
break;
}
}
}
//version de jse 1.7 en adelante
package semana6;
System.out.println("Dame una cadena");
String valor = entrada.nextLine();
switch (valor) {
case “Hola”:
case “hola”:
case “HOLA”:
System.out.println(“La cadena es Hola");
break;
case “Java”:
case “JAVA”:
case “java”:
System.out.println("La cadena es Java");
break;
default:
System.out.println(“cadena no valida");
break;
}
}
}

Sentencia if .. else
Permite que un programa tomar una decisión para ejecutar una acción u
otra.
if (condicion){
}else{
}
Ejemplo:
public class Control {
int a=20,b=10;
if(a>b){
System.out.println("a mayor que b");
}else{
System.out.println("b mayor que a");
}
}
}
Sentencia else if
Permite que un programa tomar una decisión para ejecutar una acción u
otra, pero con una secuencia de if anidado.
if (condicion){
}else if (condicion){
}else if (condicion){
}
.
.
else{
}

public class Control {
int a=20;
if(a == 10){
System.out.println("a es 10");
}else if (a==20){
}else if (a==30){
}else{
System.out.println("No esta en el rago permitido");
}
}
}

Arreglos
Un arreglo es un grupo de variables (llamados elementos o componentes) que

contienen valores, todos del mismo tipo.
subíndice
Nombre del
Arr[0]=23
arreglo
Arr[1]=45
Arr[2]=34
Arr[3]=56
int[ ] Arr=new int[4]

o
int Arr[ ]=new int[4]

Inicializar un arreglo
int arr[ ]={23,34,56,677,765,45}

String arr[ ]={“Norte”,”Sur”,”Este”,”Oeste”}
Arreglos bidimensionales
int[ ][ ] arr=new int[2][2];
(0,0) (0,1)
(1,0) (1,1)

package semana6;
public class Arreglos {
String[] arr={"Norte","Sur","Este","Oeste"};
int[][] arr2={{1,2,3},{3,4}};
int[] arr3=new int[10];
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=0;i<arr2.length;i++){
for(int j=0;j<arr2[i].length;j++){
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
arr3[i]=i;
}
System.out.print(arr3[i]+" ");
}
}
}
¿Piensa en Objetos?
Como hemos venido trabajando nosotros pensamos que un programa es una

lista de instrucciones que le estamos indicando como hacer las cosas.
Ahora en Programación Orientada a Objetos (POO) cambiamos la forma de

pensar, nosotros ahora tenemos un conjunto de objetos que dialogan entre ellos
atreves de mensajes para resolver diferentes tareas programadas.

Conceptos Básicas en POO
Los conceptos que tenemos que tener claro para la POO son objetos, clases,
mensajes y métodos.
Objetos
En la programación estructurada se compone tradicionalmente de funciones y

datos, pero en POO se ocupara solamente Objetos, podemos decir que un
objeto es una encapsulación genérica de datos y los procedimientos para
manipularlos, es decir un objeto es una entidad que contendrá atributos
particulares, los datos(variables) , y una forma para operar con ellos(métodos).
Con esto podemos decir que los métodos definirán su comportamiento y la

manipulación de las variables nos proporcionan su estado.

Mensajes
A la hora de correr un programa orientado a objetos, los objetos están

interpretando y recibiendo mensajes de otros objetos, estos mensajes se
asocian con los métodos.
Métodos
Estos métodos son los que describen el comportamiento, y se escriben en las

clases.
Clases
Es una plantilla para crear objetos, en ella vamos a incluir los atributos (datos) y
los métodos (comportamiento). Cuando se crea un objeto a partir de una clase
se dice que el objeto es un ejemplar de la clase.

Lenguaje Unificado de Modelado UML
El modelo o modelado de objetos describe los conceptos principales de la

orientación a objetos, que son estructuras estáticas y sus relaciones.
Estructuras estáticas: son los objetos y clases lo cuales están compuestos de

atributos y operaciones.
Relaciones: Son las ligas y asociaciones entre los objetos y clases.

Atributos
Los atributos definen la estructura de una clase y de sus correspondientes
objetos.
Ejemplo: Automóvil: color, modelo.
Los atributos corresponden a sustantivos y sus valores pueden ser

sustantivos o adjetivos.
Ejemplo: Persona.
nombre: Rebeca sustantivo
edad: 21 sustantivo
color:rosa adjetivo
Dentro de una clase los nombres de los atributos deben ser únicos
(aunque puede aparecer el mismo nombre de atributos en diferentes
clases).
Ejemplo: Persona, Compañía pueden tener un atributo dirección

cada uno de ellos, pero no puede existir más de uno en cada clase.

Métodos
Los métodos se aplican a todos los objetos de una clase particular. Dichas
métodos pueden ser una acción ejecutada por el objeto o sobre el objeto.
Ejemplo: Pelota: arrojar, atrapar.

Ventana: reflejar.
Las métodos deben ser únicas dentro de una misma clase, aunque no
necesariamente en la misma clase.
Ejemplo: Casa, Carro tienen ambos el método compra, son métodos

iguales sobre la misma clase.
No se debe utilizar el mismo nombre en el métodos que tengan un

significado totalmente diferente.
Ejemplo: el método invertir para una clase de Figura y una clase que
maneja matrices. (invertirFigura,invertirMatrix).

Declaración de la Clase en Java y en UML
<clase_declaración>::=
<modificador> class <nombre>{
<atributo_declaración>
<constructores_declaracion>
<métodos_declaracion>
}
public class ClaseUno{

atributos; características
métodos();
comportamientos
}

package fes.aragon.semanados.clases;
public class Estudiante {
private long numeroCuenta;
private String nombre;
private String apellidoPaterno;
private String apellidoMaterno;
private long telefono;
private String direccion;
public Estudiante(){
numeroCuenta=00;
nombre="sin nombre";
apellidoPaterno="Sin apellido paterno";
apellidoMaterno="Sin apellido materno";
telefono=00;
direccion="Sin direccion";
}
public long getNumeroCuenta() {
return numeroCuenta;
}
public void setNumeroCuenta(long numeroCuenta) {

this.numeroCuenta = numeroCuenta;
}
package fes.aragon.semanados.inicio;
import fes.aragon.semanados.clases.Estudiante;
public class PruebaEstudiante {
Estudiante alumnoUno=new Estudiante();
alumnoUno.setNumeroCuenta(12355);
alumnoUno.setNombre("Miguel Angel");
alumnoUno.setApellidoPaterno("Sanchez");
alumnoUno.setApellidoMaterno("Hernandez");
alumnoUno.setTelefono(46523);
alumnoUno.setDireccion("AV. Siempre Viva");
}
}

Desplegar el estado de los campos del objeto alumnoUno
package pruebas4;
import semana4.Estudiante;
public class PruebaEstudiante {
Estudiante alumnoUno=new Estudiante();
alumnoUno.setNumeroCuenta(12355);
alumnoUno.setNombre("Miguel Angel");
alumnoUno.setApellidoPaterno("Sanchez");
alumnoUno.setApellidoMaterno("Hernandez");
alumnoUno.setTelefono(46523);
alumnoUno.setDireccion("AV. Siempre Viva");
System.out.println("Numero Cuenta: "+alumnoUno.getNumeroCuenta());
System.out.println("Nombre: "+alumnoUno.getNombre());
System.out.println("Apelldo Paterno: "+alumnoUno.getApellidoPaterno());
System.out.println("Apellido Materno:"+alumnoUno.getApellidoMaterno());
System.out.println("Telefono: "+alumnoUno.getTelefono());
System.out.println("Direccion: "+alumnoUno.getDireccion());
}
}

Arreglo del tipo de dato abstracto que creamos nosotros
Ocupa la clase Estudiante ocuparemos para crear un arreglo del tipo de

dato Estudiante.
public class Pruebas {
public static void main(String[] arg){
Estudiante[] alumno= new Estudiante[3];
alumno[0]=new Estudiante(1,"Pedro","Ramirez",”Garrido”,0,”s/n”);
alumno[1]=new Estudiante(2,"Roberto","Fernandez",”Trejo”0,”s/n”);
alumno[2]=new Estudiante(3,"Jorge","Lara",”Mara”,0,”s/n”);
//vercion 1.5 JDK en adelante
for(Estudiante e:alumno){
System.out.println(e.getNombre());
}
//verciones anteriores
for(int i=0;i<alumno.length;i++){
System.out.println(alumno[i].getNombre());
}
}
}

Encapsulación
La encapsulación es una técnica que nos permitirá ocultar los detalles de un

objeto, con esto estamos previniendo que no manipulen al objeto atreves de
operaciones no definidas. Las principales razones son para:
1.- Mantener a salvo el comportamiento y representación de los objetos.
2.- Poder modificar de una manera fácil el objeto ajustándonos a mejores de

los algoritmos ocupados o nuevas tecnologías de software.

Abstracción
Es la idea de la representación de un objeto, localizando sus características y

acciones del mismo. Podemos representar objetos simples o complicados.
Entonces podemos decir, que la abstracción nos localiza los detalles de sus
características y acciones para poder generar y manipular los objetos.
Tomando los conceptos de objeto, encapsulación y abstracción afirmamos lo

siguiente:
En POO la encapsulación y abstracción da como resultado un objeto siendo,

este la unidad fundamental en POO.

Declaración de atributos
<atributo_declaración>::=
<modificador> <tipo> <nombre> [=<valor_por_defecto]
<tipos>::= byte|short|int|long|char|float|double|boolean|<nombre_de_clase>

Declaración de métodos
<método_declaración>::=
<modificador> <tipo_de_retorno> <nombre>(<parametros>){
<sentencias>
}
<parametros>::=<tipo_de_parametro> <nombre_del_parametro> ,
<tipo_de_parametro>::=
byte|short|int|long|char|float|double|boolean|<nombre_de_clase>

Datos Primitivos en Java
Enteros
Tipo Rango Bits
byte -128 127 8 bits
short -32768 32767 16 bits
int -2147483648 2147483647 32 bits
long -9223372036854775808 9223372036854775807 64 bits
Decimales
Tipo Rango Bits
float 1.4E-45 3.4028235E38 4 bytes
double 4.9E-324 1.7976931348623157E308 8 bytes

Tipo char
Este se utiliza para almacenar un carácter único, este ocupa 2 bytes para
almacenar el código Unicode del carácter, los primeros caracteres hasta el 128,
son iguales al código ASCII (American Standard Code for Information Interchange
— Código Estándar Estadounidense para el Intercambio de Información)).
Algunos caracteres en java tienen un significado, para poderlos representar

ocupamos el carácter de escape \, seguido por el carácter que nos indica el
significado del carácter de escape.
Secuencia Significado
\t Tabulación
\b Retroceso
\n Salto de línea
\r Retorno de carro
\f Salto de página
\’ Comilla simple
\” Comilla doble
\\ Barra invertida
Tipo boolean
Representa dos estados verdadero/falso, sus valores son true o false.

Conversiones de tipo
Esto consiste en transformar un valor en otro tipo, si nosotros hacemos una
conversión de un tipos superior a inferior puede haber perdida de información,
por ejemplo de un double a long.

Composición
Ahora sabemos que una clase puede tener referencias de objetos de otras
clases como miembros a esto lo llamamos composición. Su representación en
UML es la siguiente.

Agregación
Es lo mismo que la composición solo con la diferencia que la referencia de los
objetos pueden estar asociados a otras clases, por lo que el objeto puede
existir independiente de la clase.

Ensamblados
Los ensamblados en particular la agregación y la composición son formas

especiales de asociación entre un todo y sus partes.
La agregación, sus partes en el ensamblado pueden aparecer múltiples veces

en el mismo.
En la composición las partes del ensamblado no pueden ser compartidas

entre ensamblados.

Ejemplos
• Una red de computadoras se puede considerar un ensamblado, donde las

computadoras son sus componentes. Este es un ejemplo de agregación.
• Un automóvil esta constituido por motor, carrocería, llantas etc. Esta es

una composición, ya que un motor del automóvil no puede ser
compartido por otro.

• El ensamblado tiene propiedades de transición. Si A es parte de B y B es
parte de C, entonces A es parte de C.
• Es anti simétrico. Si A es parte de B, entonces B no es parte de A.
• Se puede usar la frase “parte-de” o “consiste-de” o “tiene, además

algunas operaciones o atributos se pueden propagar a sus componentes.

Ensamblado(Agregación) Componente
Ensamblado(Composición) Componente

* *
Pais Ciudad Casa
Ejemplo de ensamblado de agregación
Automovil
1
4
1
Carrocería Motor
Ruedas
Ejemplo de ensamblado de composición

Universidad 1 * División 1 * Departamento
Estudiante
Ejemplo de ensamblado de composición con agregación

La clase String
Esta clase fue echa para manejar un conjunto de caracteres, pertenece al
paquete java.lang, nos proporciona métodos para manejar caracteres
individuales, comparar cadenas, buscar y extraer subcadenas, copiar y
convertirlas a minúsculas o a mayúsculas.

Métodos de String
Método Descripción
String(String valor) Es el constructor y devuelve un objeto de tipo String.
String toString() Retorna un objeto String del mensaje de toString.
String concat(String str) Retorna un objeto String en donde se le concatena otro
String.
int compareTo(String str) Compara lexicográficamente el String con el parámetro
que es del mismo tipo, y devuelve un entero que:
< 0 si el String que recibe el mensaje es menor que str
= 0 si el String que recibe el mensaje es igual que str
> 0 si el String que recibe el mensaje es mayor que str
Si diferencia entre mayúsculas y minúsculas.
int lentg() Devuelve un entero, que es el numero de caracteres
Unicode
String toLowerCase() Devuelve un String con la conversión de la cadena a
minúsculas.
String toUpperCase() Devuelve un String con la conversión de la cadena a
miyúsculas.

String trim() Retorna un String, eliminado los espacios en
blanco al principio y al final del objeto String.
Boolean startsWith(String prefijo) Devuelve un true si el prefijo esta al inicio del
objeto String.
Boolean endsWith(String prefijo) Devuelve un true si el prefijo esta al final del
objeto String.
String substring(int inicio,int final) Retorna un objeto de tipo String que es la
subcadena del objeto String, tomando en cuenta
el indice inicial y final del objeto String.
char CharAt(int indice) Devuelve el carácter Unicode de la posición del
índice de el objeto de tipo String.
int indexOf(char car) Retorna el índice de la primera ocurrencia del
carácter en el objeto String.
int indexOf(String str) Retorna el índice de la primera ocurrencia de la
subcadena en el objeto String.
String replace(char car,char ncar) Devuelve un String, en donde se reemplaza
todas las ocurrencias de car con el ncar.
static String valueOf(tipo dato) Retorna un String, no necesita un objeto para se
invocado, los tipos pueden ser los tipos
primitivos de java y Object.
char[] toCharArray() Devuelve una matriz de caracteres, tomando el
objeto String.
byte[] getBytes() Retorna una matriz de bytes partiendo del
objeto String.

Caracteres ASCII
for (char c = 'a'; c <= 'z'; c++) { caracter=‘M’+(‘a’-’A’); int[] tabla=new int[‘z’-’a’+1]
System.out.print(c + " "); tabla[‘f’-’a’]++;
}

Problemas
1.- Escribir un programa que escriba una tabla del código ASCII
2.- Escribir un programa que dé como resultado la frecuencia con la que
aparecen las letras, partiendo de una cadena que proporcione el usuario, no
hay diferencia si hay mayúsculas o minúsculas.
3.-Realizar un programa que lea una cadena de n caracteres e imprima el
resultado que se obtiene cada vez que se realice una rotación de un carácter a
la derecha sobre dicha cadena. El proceso finaliza cuado se haya obtenido
nuevamente la cadena de caracteres original. Por ejemplo,
FES SFE ESF FES

Crear una clase ConjuntoEntero. Cada objeto ConjuntoEntero puede almacenar en el
rango de 0 a 100. El conjunto se representa mediante un arreglo de valores boolean. El
elemento del arreglo a[ i ] es true si el entero i se encuentra en el conjunto. El elemento
del arreglo a[ j ] es false si el entero j no se encuentra dentro del conjunto. El constructor
sin argumentos inicializara el arreglo como vació es decir que todos sus elementos son
false, se deben hacer las siguientes métodos:
1.-Unión, se debe crear un tercer conjunto que sea la unión entre dos conjuntos.
2.-Intersección, se debe crear un tercer conjunto que sea la intersección entre dos
conjuntos.
3.-insertarElemento.
4.-eliminarElemento.
5.-esIgualA.
6.-imprimirElementos, debe devolver los elementos separados por especio.

La herencia es la reutilización de software en la que las clases se crean absorbiendo
los campos y métodos de una clase existente, logrando así crear nuevas clases con
mejores capacidades, o con modificaciones en las capacidades ya existentes.
La clase existente se le conoce como superclase, y la nueva clase se conoce como

subclase. Una vez creada cada subclase puede convertirse en superclase de
futuras subclases.

La subclase representa un grupo más especializado de objetos,
generalmente una subclase exhibe los comportamientos de su superclase
junto con comportamientos adicionales específicos de esta subclase.
La superclase directa es la superclase a partir de la cual la subclase hereda en

forma explicita. Una superclase indirecta se hereda de dos o más niveles
arriba en la jerarquía de clases, lo cual define las relaciones de herencia
entre las clases. En java la jerarquía de clases empieza con la clase Object.

Java ocupa la herencia simple (una clase se deriva de una superclase), no
soporta herencia múltiple ( una clase se deriva de más de una superclase).
La relación “es un” representa a la herencia, por ejemplo “un auto es un

vehiculo”, por lo que la relación “tiene un” representa a la composición, que es
cuando un objeto contiene uno o más referencias de objetos como miembros.
Por ejemplo “un auto tiene un volante”.
Figura
FiguraBidimensional FiguraTridimensional
Circulo Cuadrado Triangulo Esfera Cubo Tetraedro

Campos protected
Los campos public de una clase son accesibles en cualquier parte en donde el
programa tenga referencia al objeto de esa clase, o de sus subclases.
Los campos private de una clase son accesibles sólo en los métodos de la clase.
“Estos nos se heredan”.
Los campos protected de una superclase pueden ser utilizados por los métodos de
esa superclase, y por los métodos de cualquier clase que se derive de esa
superclase y por los métodos de otras clases en el mismo paquete.

public class Punto { public class Circulo extends Punto {
protected int x; private double radio;
protected int y; public Circulo() {
public Punto() { //la llamada implícita del constructor Punto
//la llamada implícita del constructor object //ocurre aquí
//ocurre aquí }
} public Circulo(int X,int Y,double radio){
public Punto(int x,int y){ //la llamada implícita del constructor Punto
//la llamada implícita del constructor object //ocurre aquí
//ocurre aquí x=X;
this.setX(x); this.y=Y;
this.setY(y); setRadio(radio);
} }
public int getX() { public double getRadio() {
return x; return radio;
} }
public void setX(int x) { public void setRadio(double radio) {
this.x = x; this.radio = (radio<0.0?0.0:radio);
} }
public int getY() { public double getDiametro(){
return y; return (2*radio);
} }
public void setY(int y) { public double getCircunferencia(){
this.y = y; return (Math.PI*getDiametro());
} }
public String toString(){ public double getArea(){
return ("("+x+","+y+")"); return (Math.PI*Math.pow(radio,2));
} }
} public String toString(){
return ("Centro: ("+x+","+y+") Radio:" + radio);
}
}
import java.text.DecimalFormat;
public class Prueba {
Circulo a=new Circulo(10,19,30);
System.out.println("X= "+a.getX());
System.out.println("Y= "+a.getY());
//llamada implicita a toString
System.out.println(a);
//llamada explicita a toString
System.out.println(a.toString());
a.setRadio(10);
System.out.println(a);
//cambiar los valores a 2 digitos
DecimalFormat digitos=new DecimalFormat("0.00");
System.out.println("Diametro: "+digitos.format(a.getDiametro()));
System.out.println("Circunferencia: "+digitos.format(a.getCircunferencia()));
System.out.println("Area: "+digitos.format(a.getArea()));
}
}

Los campos protected generan dos problemas:
1.- Un objeto de la subclase no tiene que llamar a un método para establecer valores
al campo protected, por lo que podemos caer en el error de asignarle un valor
invalido al campo (si se hereda de Circulo, y radio es protected, la sublcase le puede
dar un valor negativo a radio, rompiendo así con la lógica de estructura de la
superclase).
2.- Los métodos de la subclase pueden llegar a escribirse con una alta dependencia a
la subclase, en la practica las subclases deben valerse por si solas con solo los
servicios de las superclases. Por que si no pasa esto se dice que el software es frágil
ya que un pequeño cambio en la superclase afectaría a la subclase.

Se recomienda que los campos protected, de una superclase se cambien a
private y se generen los métodos set,get para poder cambiar sus valores, así
se cambia la superclase, no llegue a afectar a la subclase.
Use el modificador de acceso protected cuando una superclase deba

proporcionar un servicio( un método) sólo a sus subclases y no a otras.

Los métodos de una subclase pueden referirse a los miembros public y protected que
se heredan de la superclase con solo utilizar el nombre del campo o método. Pero
cuando una subclase necesita sobrescribir a un método de la superclase se ocupa la
palabra super y un punto(.) seguido del método a sobrescribir.

public class Circulo extends Punto {
public class Punto { private double radio;
private int x; public Circulo() {
private int y; //la llamada implícita del constructor Punto
public Punto() { //ocurre aquí
//la llamada implícita del constructor object }
//ocurre aquí public Circulo(int X,int Y,double radio){
} //la llamada explícita del constructor Punto
public Punto(int x,int y){ //ocurre aquí
//la llamada implícita del constructor object super(X,Y);
//ocurre aquí setRadio(radio);
this.setX(x); }
this.setY(y); public double getRadio() {
} return radio;
public int getX() { }
return x; public void setRadio(double radio) {
} this.radio = (radio<0.0?0.0:radio);
public void setX(int x) { }
this.x = x; public double getDiametro(){
} return (2*radio);
public int getY() { }
return y; public double getCircunferencia(){
} return (Math.PI*getDiametro());
public void setY(int y) { }
this.y = y; public double getArea(){
} return (Math.PI*Math.pow(radio,2));
public String toString(){ }
return ("("+getX()+","+getY()+")"); public String toString(){
} return ("Centro: " +super.toString()+ " Radio: " + getRadio());
} }
}
public class Prueba {
Circulo a=new Circulo(10,19,30);
System.out.println("X= "+a.getX());
System.out.println("Y= "+a.getY());
System.out.println(a.toString());
// se puede hacer esto
//a.x=30;
//cambiar los valores a 2 digitos
DecimalFormat digitos=new DecimalFormat("0.00");
System.out.println("Diametro: "+digitos.format(a.getDiametro()));
System.out.println("Circunferencia: "+digitos.format(a.getCircunferencia()));
System.out.println("Area: "+digitos.format(a.getArea()));
}
}

Programa para calcular los puntos de la circunferencia
public class Punto {
private int x;
private int y;
public Punto() {
//la llamada implícita del constructor object
//ocurre aquí
}
public Punto(int x,int y){
//la llamada implícita del constructor object
//ocurre aquí
this.setX(x);
this.setY(y);
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String toString(){
return ("("+getX()+","+getY()+")");
}
}

import java.util.ArrayList;
public class Circulo extends Punto{
private double radio;
private ArrayList<Punto> puntosCircuferencia=new
ArrayList<Punto>();
public Circulo() { public double getCircunferencia(){
} return (Math.PI*getDiametro());
public Circulo(int X,int Y,double radio){
x=X;
}
this.y=Y; public double getArea(){
setRadio(radio); return (Math.PI*Math.pow(radio,2));
this.calcularPuntos(); }
} public String toString(){
return ("Centro: ("+x+","+y+") Radio:" + radio);
public double getRadio() {
return radio;
}
}
public void setRadio(double radio) { public ArrayList<Punto> getPuntosCircuferencia() {
this.radio = (radio<0.0?0.0:radio); return puntosCircuferencia;
} }
public double getDiametro(){ private void calcularPuntos(){
return (2*radio);
}
double radianes=Math.PI/180;
for(int i=1;i<=360;i++){
double gradoRadianes=i*radianes;
Continua int x=this.x+((int)(this.radio* Math.cos((gradoRadianes))));
int y=this.y+((int)(this.radio* Math.sin((gradoRadianes))));
//System.out.println(x + " "+ y);
Punto punto=new Punto(x, y);
this.puntosCircuferencia.add(punto);
}
}
Ing. Miguel}Angel Sánchez Hernández
import fes.aragon.Circulo;
import fes.aragon.Punto;
public class Calculos {
Circulo circulo=new Circulo(10, 10, 4);
for(Punto salida:circulo.getPuntosCircuferencia()){
System.out.println(salida.toString());
}
}
}

Asignaciones permitidas entre los objetos de la superclase y subclase
Un objeto de la subclase también es un objeto de la superclase, ya que la subclase

contiene todos los campos y métodos de la superclase, pero la subclase pude
contener miembros adicionales exclusivos. Por esta razón hacer una referencia de
la superclase a una variable objeto de subclase no se permite sin una conversión
explícita de tipos.

Hay cuatro maneras de asignar referencias de superclase y subclase
1.- La asignación de un referencia de superclase a una variable de tipo superclase es

simple y directa.
2.- La asignación de un referencia de subclase a una variable de tipo subclase es

simple y directa.
3.- La asignación de la referencia de un objeto de la subclase a una variable de tipo

superclase es segura, ya que el objeto de la subclase es un objeto de la superclase.
Pero solo se pueden invocar los métodos de la superclase, si se quieren llamar los
métodos de la subclase el compilador marca error.
4.- Si se asigna la referencia de un objeto de superclase a una variable de tipo

subclase se produce un error de compilación, para evitarlo la referencia a la
superclase debe convertirse en el tipo subclase de manera explicita.

Punto punto=new Punto(10,20);
Circulo circulo=new Circulo(10,30,23);
Punto ref=circulo;
System.out.println("Llamada: "+ ref.toString());
//System.out.println("Diametro: "+ ref.getDiametro());
//4.-errores de asignar la referencia de la superclase a la variable
//de objeto de tipo subclase
//Punto punto2=new Punto(2,2);
//Circulo circulo2;
//circulo2=punto;
if(ref instanceof Punto){
Circulo ref2=(Circulo)ref;
System.out.println("Diametro: "+ref2.getDiametro());

Polimorfismo es la capacidad que tienen los objetos de una clase de
responder al mismo mensaje o evento en función de los parámetros
utilizados durante su invocación
Este nos permitirá programar en forma general en vez de forma especifica,

ya que nos permite escribir programas que procesan objetos de clases que
formen parte de la misma jerarquía de clases como si fueran todos objetos
de sus superclases.
El término polimorfismo es también conocido como

'Sobrecarga de parámetros' ya que las características de los objetos
permiten aceptar distintos parámetros para un mismo método
(diferentes implementaciones) generalmente con comportamientos
distintos e independientes para cada una de ellas

Hay ocasiones, que se necesitan crear clases en donde no se puedan sacar
instancias de objetos, a estas clases las llamaremos clases abstractas, estas se
ocupan como superclases en la jerarquía de herencias, por lo que las llamaremos
superclases abstractas.
Las clases abstractas son genéricas como para crear objetos ya que estas, no están
completas y las encargadas de declarar las partes faltantes son las subclases, y
estas son las encargadas de instanciar los objetos y se llaman clases concretas.

Se ocupa la palabra reservada abstract para crear una clase abstracta, estas
normalmente tienen uno o más métodos abstractos (los métodos static no
pueden ser abstractos). Un método abstracto es un método con la palabra clave
asbtract.
Los métodos abstractos actúan como reservas de espacio para los métodos que
se implementaran en las subclases, cuando se hereda de una clase abstracta, se
tienen dos opciones, se deja sin definir algunos o todos los métodos abstractos,
entonces la subclase hay que marcarla como abstracta también, o se definen
todos los métodos y ya no se declara abstracta.

Figura
Punto
Circulo
Cilindro
obtenerArea obtenerVolumen obtenerNombre toString
Figura 0.0 0.0 abstract Implem.
Punto 0.0 0.0 “Punto” [x,y]
Circulo Centro=x,y
Pi*r^2 0.0 “Circulo”
Radio=r
Centro=x,y
Cilindro
2pir^2+2pirh Pir^2h “Cilindro” Radio=r
Altura=h

public class Punto extends Figura{
public abstract class Figura extends Object { private int x;
public double getArea(){ private int y;
return 0.0; public Punto() {
} }
public double getVolumen(){ public Punto(int x,int y){
return 0.0; setX(x);
} setY(y);
public abstract String getNombre(); }
} public int getX() {
return x;
}
this.x = x;
}
public int getY() {
return y;
}
this.y = y;
}
return "["+x+","+y+"]";
}
public String getNombre() {
return "Punto";
}
} Hernández
Ing. Miguel Angel Sánchez
public Circulo() {
}
public Circulo(int valorx,int valory,double radio){
super(valorx,valory);
setRadio(radio);
}
return radio;
}
public void setRadio(double radio) {
this.radio = radio;
}
public double getDiametro(){
return 2*radio;
}
public double getCircuferencia(){
return Math.PI*getDiametro();
}
public double getArea(){
return Math.PI*Math.pow(radio,2);
}
//no podemos accesar a las variables privadas,por eso ocupamos super
return "Centro =["+super.getX()+","+super.getY()+"]; Radio= "+radio;
//return "Centro ="+super.toString()+"; Radio= "+radio;
}
public String getNombre(){
return "Circulo";
}
}
public class Cilindro extends Circulo{
private double altura;
public Cilindro() {
}
public Cilindro(int x,int y,double radio,double altura){
super(x,y,radio);
setAltura(altura);
}
public double getAltura() {
return altura;
}
public void setAltura(double altura) {
this.altura = altura;
}
return (2*super.getArea()+super.getCircuferencia()*getAltura());
}
public double getVolumen(){
return (super.getArea()*getAltura());
}
return "Cilindro";
}
return super.toString()+"; Altura= "+getAltura();
}
}

public class principal {
DecimalFormat dosDigitos=new DecimalFormat("0.00");
Circulo circulo=new Circulo(22,3,3.5);
Cilindro cilindro=new Cilindro(20,30,3.3,10.75);
Figura[] arreglo=new Figura[3];
arreglo[0]=punto;
arreglo[1]=circulo;
arreglo[2]=cilindro;
for(int i=0;i<arreglo.length;i++){
System.out.println(arreglo[i].toString());
System.out.println("Nombre: "+arreglo[i].getNombre());
System.out.println("Area: "+dosDigitos.format(arreglo[i].getArea()));
System.out.println("Volumen: "+dosDigitos.format(arreglo[i].getVolumen()));
}
}
}

Interfaces
En Java, una interfaz no es otra cosa que un conjunto de requisitos que deben
satisfacer las clases que se ajusten a esa interfaz.
“Si su clase satisface una determinada interfaz, entonces yo realizare ese

servicio”
Todos los métodos de la interfaz son automáticamente public, por esta razón no
se escribe necesariamente public a los métodos de una interfaz.
La interfaz nunca tiene campos, y los métodos nunca se implementan en la

interfaz, este trabajo le tocan a las clases que vayan a implementar esta interfaz,
para crearlas se utiliza la palabra reservada interface.

Para hacer que una clase implemente una interfaz, se hace dos cosas
1.- Se declara que la clase tiene intención de implementar la interfaz

public class Demo implements Base
2.- Se proporcionan definiciones para todos los métodos de la interfaz.

Se sobrescriben los métodos de la interfaz

Propiedades de la interfaces
Las interfaces no son clases, por lo que no se puede utilizar el operador new para
crear un ejemplar de una interfaz
X=new Base(); ///error
Pero se pueden declarar variables de tipo interfaz.

Base X;
Esta variable interfaz tiene que referirse a un objeto del tipo de una clase que
implementa la interfaz.
x=new Demo() //valido, si Demo implementa a la
//interfaz Base

Comprobar con instanceof si un objeto de una clase determinada
implementa la interfaz.
if(Objeto instanceof Base)
Se pueden construir jerarquías de clases logrando así extender interfaces.
Public interface Movil{

void mover(int x,int y);
}
Public interface ConMotor extends Movil{

{
double consumo();
}

No se pueden poner campos y métodos estáticos en una interfaz, pero si se
pude poner constantes.
Public interface Motor extends Movil{

boolean MOTOR_A_PASO=true;
boolean SERVO_MOTOR=true;
}
Algunas interfaces definen constantes y no métodos( Se vera en la parte de

gráficos de Swing).

Interfaces y clases abstractas
Cuando se utiliza una clase abstracta que expresa un propiedad genérica, solo se
puede extender una clase, de esa clase abstracta, es decir solo se puede heredar
de una clase (superclase directa).
Evitando poder heredar de una segunda clase.
public Clase2 extends Clase1,Clase0 //ERROR
Pero con la interfaz si se puede implementar un o mas interfaces, en C++ se la

llama Herencia múltiple, pero en Java se toma sus beneficios de la herencia
múltiple y se deja la sintaxis compleja de C++.
public Clase2 extends Clase3 implements Clase0,Clase001

public class Punto extends Object implements Figura{
private int x;
private int y;
public interface Figura { public Punto() {
}
public double getArea(); public Punto(int x,int y){
public double getVolumen(); setX(x);
setY(y);
public String getNombre(); }
} public int getX() {
return x;
}
this.x = x;
}
public int getY() {
return y;
}
this.y = y;
}
return "["+x+","+y+"]";
}
public String getNombre() {
return "Punto";
}
return 0.0;
}
public double getVolumen() {
return 0.0;
}
Ing. Miguel Angel }Sánchez Hernández
public Circulo() {
}
public Circulo(int valorx,int valory,double radio){
super(valorx,valory);
setRadio(radio);
}

return radio;
}
public void setRadio(double radio) {

this.radio = radio;
}
public double getDiametro(){
return 2*radio;
}
public double getCircuferencia(){
return Math.PI*getDiametro();
}
return Math.PI*Math.pow(radio,2);
}
return "Centro =["+super.getX()+","+super.getY()+"]; Radio= "+radio;
}
return "Circulo";
}
}
public class Cilindro extends Circulo{
private double altura;
public Cilindro() {
}
public Cilindro(int x,int y,double radio,double altura){
super(x,y,radio);
setAltura(altura);
}
public double getAltura() {

return altura;
}
public void setAltura(double altura) {

this.altura = altura;
}
return (2*super.getArea()+super.getCircuferencia()*getAltura());
}
public double getVolumen(){
return (super.getArea()*getAltura());
}
return "Cilindro";
}
return super.toString()+"; Altura= "+getAltura();
}
public class principal {
DecimalFormat dosDigitos=new DecimalFormat("0.00");
Circulo circulo=new Circulo(22,3,3.5);
Cilindro cilindro=new Cilindro(20,30,3.3,10.75);
Figura[] arreglo=new Figura[3];
arreglo[0]=punto;
arreglo[1]=circulo;
arreglo[2]=cilindro;
for(int i=0;i<arreglo.length;i++){
System.out.println("Nombre: "+arreglo[i].getNombre());
System.out.println("Area: "+dosDigitos.format(arreglo[i].getArea()));
System.out.println("Volumen: "+dosDigitos.format(arreglo[i].getVolumen()));
}
}

Que nos ofrece Swing
•Swing, posee un conjunto de elementos de interfaz de usuario rico y

cómodo.
•Tiene pocas dependencias de la plataforma subyacente, por lo que es

menos proclive a tener defectos de una u otra plataforma
•Ofrece una experiencia de usuario coherente entre platraformas
Por lo que cumple el lema de sun “Write Once, Run Anywhere”.

Creación de un marco
La ventana de nivel superior (lo que esta dentro de otra ventana), recibe el
nombre de marco en Java, la biblioteca AWT posee una clase llamada Frame,
en donde se pueden sacar este tipo de ventanas, JFrame que se extiende de
Frame sirve para hacer lo mismo y es parte de Swing. Este es uno de los
pocos componentes que no se pintan, si no que sus adorno (botones, barra
de titulo, iconos y demás) van a ser dibujados por el sistema de ventanas del
usuario y no por Swing.

import javax.swing.*;
public class Marcos extends JFrame
{
private static final int ANCHURA=300;
private static final int ALTURA=200;
public Marcos()
{
setSize(ANCHURA,ALTURA);
}
}
public class PruebaMarco
{
Marcos ap=new Marcos();
ap.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ap.setVisible(true);
}
}

public class Marco extends JFrame
{
private static final int ANCHURA=300;
private static final int ALTURA=200;
public Marco()
{
setSize(ANCHURA,ALTURA);
}
Marco ap=new Marco();
ap.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ap.setVisible(true);
}
}

Object
Component
Container
JComponent Windows
JPanel Frame
JFrame

package Marcos;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.Properties;
import javax.swing.JFrame;
public class Marco1 extends JFrame

{
public Marco1() {
//dimenciones de la pantalla
Toolkit herram=Toolkit.getDefaultToolkit();
Dimension tamanoPanta=herram.getScreenSize();
int altura=tamanoPanta.height;
int anchura=tamanoPanta.width;
this.setSize(anchura/2,altura/2);
this.setLocation(anchura/4,altura/4);
Image img=herram.getImage("icono.png");
this.setIconImage(img);
this.setTitle("Progamando con Swing");
}

import Marcos.Marco1;
public class Principal01
{
Marco1 app=new Marco1();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
app.setVisible(true);
}
}

Laminas
Las laminas sirven para dibujar componentes sobre ellas, para luego incorporarlo a
un marco.
Una buena practica de programación es trabajar sobre laminas y no sobre los

marcos, ya que los marcos están diseñados para ser contendedores de
componentes como barras de menú y otros elementos.

import java.awt.*;
public class Marco2 extends JFrame
{
public Marco2(){
setTitle("Ocupando Swing");
setSize(300,200);
Lamina1 lamina=new Lamina1();
add(lamina);
}
} import java.awt.*;
public class Lamina1 extends JPanel
{
public void paintComponent(Graphics g){
super.paintComponent(g);
g.drawString("Ocupando Swing",10,100);
}
}

public class Principal02
{
}
}

Ocupar la clase en donde se calculo los puntos de las circunferencia, y crear un
programa en donde se pinten los puntos de la circunferencia con los valores que le
asignes al objeto de Circulo.
Nota: para dibujar los puntos ocupa draw.Rect(x,y,1,1), en donde los 1 indican el
ancho y alto del rectángulo.

Manejo de eventos en Java
Los programas que manejan un GUI deben manejar eventos, en Java se hace de
la siguiente manera:
Fuente de eventos: botones, barras de desplazamientos, marcos, etc.
Oyentes de eventos: cualquier objeto que implemente la interfaz adecuada para

el evento.
Esto es un modelo de delegación de eventos.

Las fuentes de eventos poseen métodos que nos permiten registrar los
oyentes de eventos. Cuando se produce un evento en la fuente, ésta envía
una notificación del evento a todos los objetos que estén registrados para
ese evento.
Un botón puede enviar objetos ActionEvent, mientras que una ventana

puede enviar eventos WindowEvent.

En resumen el esquema funciona de la siguiente manera:
•Un objeto oyente es un ejemplar de una clase que implementa una interfaz
especial denominada interfaz oyente.
•Una fuente de eventos es un objeto en que se pueden registrar

objetos oyentes y enviar a esos objetos otros objetos de eventos.
•La fuente de eventos envía objetos de evento a todos los oyentes registrados
en ella cuando se produce un evento.
•Los objetos oyentes utilizaran entonces la información contenida en el objeto

de evento para determinar su reacción frente al evento

package fes.aragon.swing;
import Laminas.Lamina2;
public class Marco3 extends JFrame{
public Marco3() {
this.setTitle("Acciones");
this.setSize(300,200);
this.add(lamina);
}
}

import java.awt.*;
import java.awt.event.*;
public class Lamina2 extends JPanel{
public Lamina2() {
//se crean las fuente de eventos (botones)
JButton botonAmarillo=new JButton("Amarillo");
JButton botonAzul=new JButton("Azul");
JButton botonRojo=new JButton("Rojo");
//se añaden los botones a la lamina
add(botonAmarillo);
add(botonAzul);
add(botonRojo);
//se crean las acciones de botones
AccionColor accionAmarillo=new AccionColor(Color.YELLOW);
AccionColor accionAzul=new AccionColor(Color.BLUE);
AccionColor accionRojo=new AccionColor(Color.RED);
//se asocian los oyentes de eventos con los botones
botonAmarillo.addActionListener(accionAmarillo);
botonAzul.addActionListener(accionAzul);
botonRojo.addActionListener(accionRojo);
}
private class AccionColor implements ActionListener{
private Color colorFondo;
public AccionColor(Color c){
colorFondo=c;
}
public void actionPerformed(ActionEvent e) {
setBackground(colorFondo);
}
}
package fes.aragon.pruebas;
import Marcos.Marco3;
public class Principal3 {
public static void main(String[] args){
}
}

Como modificarías el programa anterior para dibujar un circulo de altura y
anchura de 50, y que se encuentre en la posición 100,100; Además que se agregue
un botón en la lamina que reduzca el circulo a altura y anchura con 2.

private int reducir=50;
public Lamina2() {
JButton botonAmarillo=new JButton("Amarillo");
JButton botonAzul=new JButton("Azul");
JButton botonRojo=new JButton("Rojo");
JButton botonReducir=new JButton("Reducir");
add(botonAmarillo);
add(botonAzul);
add(botonRojo);
add(botonReducir);
//se crean las acciones de botones
AccionColor accionAmarillo=new AccionColor(Color.YELLOW);
AccionColor accionAzul=new AccionColor(Color.BLUE);
AccionColor accionRojo=new AccionColor(Color.RED);
AccionReducir accionReducir=new AccionReducir();
botonAmarillo.addActionListener(accionAmarillo);
botonAzul.addActionListener(accionAzul);
botonRojo.addActionListener(accionRojo);
botonReducir.addActionListener(accionReducir);
}
//sigue abajo

private class AccionColor implements ActionListener{
private Color colorFondo;
public AccionColor(Color c){
colorFondo=c;
}
setBackground(colorFondo);
}
}
private class AccionReducir implements ActionListener{
reducir=2;
repaint();
}
}
@Override
protected void paintComponent(Graphics arg0) {
// TODO Auto-generated method stub
super.paintComponent(arg0);
arg0.drawOval(100, 100, reducir, reducir);
}
}

Modifica el código anterior para que le puedas agregar otro botón el cual es el
encargado de regresar al circulo a su tamaño de 50.

Crear oyente de eventos sin clases internas
Algunos programadores no les gusta trabajar con clases internas por lo que
optan buscar a los componentes que se modifican como resultado de un
evento, e implementan la interfaz ActionListener que compartirán dichos
componentes.
Por ejemplo, se crean tres botones y se crea un único oyente de eventos para
los tres botones, por lo que el método actionPerformed tiene que determinar
en que botón se hizo clic.

El método getSource de la clase EventObject, la superclase de todas las
demás clases de eventos, nos proporciona el origen de cualquier evento. La
fuente de eventos es el objeto que ha generado el evento y ha modificado al
oyente, este es una manera fácil de poder controlar los eventos, pero se
vuelve muy engorrosa cuando se tienen una gran cantidad de elementos en
la interfaz de usuario.

import java.awt.Color;
import java.awt.event.*;
public class Lamina3 extends JPanel implements ActionListener{
private JButton botonAmarillo=new JButton("Amarillo");
private JButton botonAzul=new JButton("Azul");
private JButton botonRojo=new JButton("Rojo");
public Lamina3() {
add(botonAmarillo);
add(botonAzul);
add(botonRojo);
botonAmarillo.addActionListener(this);
botonAzul.addActionListener(this);
botonRojo.addActionListener(this);
}
public void actionPerformed(ActionEvent actionEvent) {
Object origen= actionEvent.getSource();
if(origen==botonAmarillo){
this.setBackground(Color.YELLOW);
}
else if(origen==botonAzul){
this.setBackground(Color.BLUE);
}
else{
this.setBackground(Color.RED);
}
}
}
public Marco3() {
this.add(lamina);
}
}

Nota: algunos programadores utilizan el método getActionCommand de la
clase ActionEvent que proporciona una cadena con el nombre de la fuente de
eventos que proporciono el evento.
Public void actionPerformed(ActionEvent evento){
String origen=evento.getActionCommand;
if(orden.equals(“Amarillo”))…..;
else if(orden.equals(“Azul”))….;
else if(orden.equals(“Rojo”))….;
}
Esto es peligroso ya que si declaramos a un botón como “rojo” y lo intentamos

encontrar en el evento a través de la cadena “Rojo”, nunca se obtendrá el
resultado deseado para ese evento. Además si se desea utilizar
internacionalización se tendría también que cambiar el método
actionPerformed.

Modifica el código que no ocupa las clases internas para que pueda reducir y
ampliar el circulo como el de clases internas.

Evento de Ratón
Cuando el usuario hace clic en un botón del ratón, se invocan tres métodos oyentes,
mousePressed: cuando se pulsa por primera vez.
mouseReleased: cuando se suelta el botón del ratón
mouseClicked: si se realiza el clic completo (presionar y soltar el botón).
Podemos ignorar los otros si solo nos interesa el clic, podemos obtener las coordenadas
a travez de getX() o getY() del argumento que se pasa del tipo MouseEvent, o podemos
obtener un objeto Point que nos regresa dichas coordenadas.

import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.Jpanel;
public class Lamina4 extends JPanel {
private Point punto = new Point(0, 0);
public Lamina4() {
EventoRaton eventoRaton = new EventoRaton();
this.addMouseListener(eventoRaton);
}
private class EventoRaton extends MouseAdapter {
@Override
public void mouseClicked(MouseEvent e) {
super.mouseClicked(e);
punto = e.getPoint();
repaint();
}
}
@Override
protected void paintComponent(Graphics arg0) {
super.paintComponent(arg0);
arg0.drawString(punto.x + " " + punto.y, punto.x, punto.y);
}
}

public Marco3() {
this.add(lamina);
}
}

Eventos de Teclado
Cuando se pulsa y se suelta una tecla se genera el método KeyEvent, si es pulsada el

método que captura este evento es keyPressed y cuando se suela el método que
captura el evento es keyReleased, que estan en la interfaz KeyListener, si se quiere
saber solo la tecla que a sido pulsada a través de su equivalente en carácter es el
método keyTyped.
Java distingue entre los caracteres y los códigos de teclas virtuales, por ejemplo una
cosa es el carácter a y la tecla pulsada a, ya que esta la consideramos como virtual,
para saber los códigos correspondientes de las teclas virtuales les indicamos a travez
del prefijo VK, así si queremos hacer con la tecla a seria VK_A, aquí cabe notar que no
importa si pulsan a o A ya que no existe código para distinguir de mayúsculas y
minúsculas en teclas virtuales ya que el teclado no tiene tecla especial para la a
minúscula.

import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.Jpanel;
private char tipoTecla;
private String tipoMensaje="";
public Lamina5(){
EventoTeclado evento=new EventoTeclado();
this.addKeyListener(evento);
}
private class EventoTeclado implements KeyListener{
@Override
public void keyPressed(KeyEvent arg0) {
int codigoTeclaVirtual=arg0.getKeyCode();
if(codigoTeclaVirtual==KeyEvent.VK_UP){
tipoMensaje="Tecla arriba: ";
tipoTecla=arg0.getKeyChar();
}
if(codigoTeclaVirtual==KeyEvent.VK_F1){
tipoMensaje="Tecla f1: ";
}
repaint();
}

@Override
public void keyReleased(KeyEvent arg0) {
}
@Override
public void keyTyped(KeyEvent arg0) {
tipoMensaje="Caracter de la tecla: ";
repaint();
}
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawString(tipoMensaje + tipoTecla, 50, 50);
}

public Marco3() {
this.add(lamina);
lamina.setFocusable(true);
}
}

Acceso al Disco
(paquete java.io)

Los archivos y directorios del disco se representan de forma lógica en las
aplicaciones de Java como objetos de la clase File. Solo sirve para obtener
información sobre los archivos y directorios. Ejemplos
File f=new File(“datos.txt”);

File f2=new File(“../Demo/Gato/Salto”);

Lectura de archivos de texto
Si solo se quiere recuperar cadenas de caracteres de un archivo, se ocupa

las clases FileReader y BufferedReader, ejemplo de sus constructores.
FileReader(String ruta);
FileReader(File archivo);
BufferedReader(FileReader entrada);

try{
File f=new File(System.getProperty("user.dir")+"/dat/informacion");
FileReader fr=new FileReader(f);
BufferedReader buff=new BufferedReader(fr);
String cad;
while((cad=buff.readLine())!=null){
System.out.println(cad);
}
}
catch(FileNotFoundException ex){
ex.printStackTrace();
} catch(IOException ex){
}
}

Escritura de archivos de Texto
Para escribir en un archivo se ocupa las clases FileWriter y PrintWriter, con el

primero nos permite tener el acceso del archivo en modo de escritura sus
constructores son:
FileWriter(String ruta,boolean apertura)

FileWriter(File archivo,boolean apertura)
El segundo parámetro indicamos si se añaden los datos en el contenido

existente (true) o se sobreescribirán en este.

La escritura se realiza como si escribiéramos en pantalla una vez creado el
objeto con FileWriter, la manera de ocuparlo es la siguiente:
FileWriter fes=new FileWriter(“archivo.txt”)

PrintWriter fr=new PrintWriter(fes);

try {
File f=new File(System.getProperty("user.dir")+"/dat/Datos");
FileWriter fw=new FileWriter(f,true);
PrintWriter salida=new PrintWriter(fw);
salida.println("Salida de Datos");
salida.println("32");
salida.close();
}
catch(FileNotFoundException ex ){
}
catch(IOException ex){
}
}

Programa que primero lee el contenido de un archivo, y después captura lo que se
escribe en la consola y se presiona enter, y termina hasta que recibe en la cadena de
entrada un carácter de @.
Nota: Debe crear una carpeta que se llame “datos”, en el directorio donde se
encuentre su proyecto, e incluir un archivo de texto que se llame archivo1.txt. Para
agregar texto al archivo en la consola introduzca lo que desee y presione enter, si
desea terminar con la ejecución del programa en la consola agregue el carácter @ y
presione enter.

package archivos;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class ArchivoTexto {
public StringBuffer leerArchivo() {
try {
File archivo = new File(System.getProperty("user.dir") + "/datos/archivo1.txt");
if (archivo.exists()) {
FileReader fr = new FileReader(archivo);
BufferedReader buffer = new BufferedReader(fr);
String cadenas = new String();
StringBuffer datos = new StringBuffer();
while ((cadenas = buffer.readLine()) != null) {
datos.append(cadenas + "\n");
}
fr.close();
return datos;
} else {
System.out.println("Archivo no se encuentra");
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
public void escribirArchivo(String datos) {
try {
File archivo = new File(System.getProperty("user.dir") + "/datos/archivo2.txt");
FileWriter fr = new FileWriter(archivo, true);
PrintWriter salida = new PrintWriter(fr);
salida.println(datos);
salida.close();
}
}

ArchivoTexto ap = new ArchivoTexto();
System.out.println(System.getProperty("user.dir"));
StringBuffer datos = ap.leerArchivo();
System.out.println(datos);
String teclado;
do {
teclado = entrada.nextLine();
ap.escribirArchivo(teclado);
} while (!teclado.contains("@"));
}
Escritura de Datos primitivos en Java
Para escribir datos primitivos en un archivo tenemos dos clases

FileOutputStream y DataOutputStream.
FileOutputStream(File archivo,boolean apertura)

FileOutputStream(String path,boolean apertura)
DataOutputStream(FileOutputStream fr);
Esta ultima clase proporciona métodos para escribir datos en un archivo con
el siguiente formato.
void writexx(xxdatos)
Siendo xx el nombre del dato primitivo.

public class Primitivos {
try {
FileOutputStream fs=new
FileOutputStream(System.getProperty("user.dir")+"/dat/primitivos");
DataOutputStream salida=new DataOutputStream(fs);
salida.writeUTF("Cadena utf");
salida.writeInt(1234);
salida.writeDouble(34.45);
salida.close();
} catch (FileNotFoundException e) {
}
}
}

Lectura de Datos primitivos en Java
Para la lectura de los datos primitivos almacenados en un archivo

tenemos FileInputStream y DataInputStream, este ultimo dispone de
métodos readXxx() donde Xxx es el tipo de dato primitivo que queremos
recuperar.

public class LecturaPrimitivos {
String utf;
int entero;
double real;
try {
FileInputStream fs=new FileInputStream(System.getProperty("user.dir")+
"/dat/primitivos");
DataInputStream entrada=new DataInputStream(fs);
utf=entrada.readUTF();
entero=entrada.readInt();
real=entrada.readDouble();
entrada.close();
System.out.println("Cadena UTF: "+ utf +"\n"+
"Entero: "+ entero + "\n"+
"Real: "+ real + "\n");
} catch (FileNotFoundException e) {
}
}
Escritura y Lectura de objetos en un Archivo
La serialización de un objeto consiste en obtener una secuencia de bytes

que represente el estado de dicho objeto. Esta secuencia puede utilizarse
de varias maneras (puede enviarse a través de la red, guardarse en un archivo
para su uso posterior, utilizarse para recomponer el objeto original, etc.)

public class Persona implements Serializable {
private String name;
private int edad;
public Persona(String nom,int ed){

name=nom;
edad=ed;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
}
Escritura de objetos en un archivo
Esta se realiza a través de ObjectOutputStream, y se necesita tener un

FileOutputStream asociado con el archivo donde se realiza la escritura, se tiene el
método writeObject(Object obj) para escritura del objeto en disco.

try {
File f=new File(System.getProperty("user.dir")+"/dat/datos2");
FileOutputStream fw=new FileOutputStream(f,true);
ObjectOutputStream es=new ObjectOutputStream(fw);
es.writeObject(new Persona("Londres",1989));
es.close();
}
}
}
}

Lectura de objetos en un archivo
Se tiene que utilizar un objeto de ObjectInputStream para la recuperación de los

objetos almacenas en disco, se dispone del siguiente método que es readObject(),
para poder realizar esta tarea.

try {
File f=new File(System.getProperty("user.dir")+"/dat/datos2");
FileInputStream fw=new FileInputStream(f);
ObjectInputStream es=new ObjectInputStream(fw);
Persona per=(Persona)es.readObject();
System.out.println(per.getName());
System.out.println(per.getEdad());
es.close();
}
}
}
catch(ClassNotFoundException ex){
}
}

Clases de envoltorio
Java nos proporciona una clase que representa los 8 tipos de datos primitivos
que ocupa, ofreciéndonos lo siguiente:
• Encapsular un dato básico

• Conversión de cadena a tipo básico
Byte,Short,Character,Integer,Long,Float,Double y Boolean todas ellas se

encuentran en java.lang

Autoboxing/Unboxing
Consiste en la encapsulación automática de un dato básico a un objeto

envoltorio.En versiones anteriores a 1.5
int p=5;
Integer n=new Integer(p);
Utilizando autoboxing
int p=5;
Integer n=p;
Para obtener un dato básico de un objeto envoltorio, se necesitaba utilizar

xxValue() donde xx representa el dato básico a obtener, ahora solo se ocupa el
unboxing
int a=n

El Paquete java.util
Expresiones Regulares
Es una combinación de caracteres que necesitamos que tenga una combinación

particular por ejemplo.
“J2[SEM]E”
“J2SE” “J2ME” “J2EE”
Para definir un patrón ocuparemos la clase Pattern, y para la búsqueda de

coincidencias ocupamos la clase Matcher y sus métodos. Se encuentran en el
paquete java.util.regex.

Caracteres utilizados en la construcción de
expresiones regulares
[BFWE] indica que pueden aparecer cualquiera de los caracteres

especificados.
[A-M] letras entre la A a la M
[^CG] cualquier letra menos C y G
Caracteres Especiales
Cuantificadores
Carácter Función
Símbolo Función
Representa La expresión puede
. cualquier + aparecer una o más
carácter veces
La expresión puede
\d Del 0 al 9
? aparecer ninguna o
una sola vez
Espacio en
\s La expresión puede
blanco
* aparecer cualquier
Un carácter número de veces
\w
(letra o número)

Scanner en=new Scanner(System.in);
String patron1="\\d*";
String patron2="\\w+\\_?\\w+@\\w+\\.\\w+";
System.out.println("Registra la cadena: ");
String cadena=en.nextLine();
Pattern p1=Pattern.compile(patron1);
Pattern p2=Pattern.compile(patron2);
Matcher m1=p1.matcher(cadena);
Matcher m2=p2.matcher(cadena);
if(m1.matches()){
System.out.println("Numero correcto");
}
if(m2.matches()){
System.out.println("Correo correcto");
}
}

Colecciones
Una colección es un objeto que almacena un conjunto de referencia de otros
objetos, es decir es una arreglo de objetos.
El paquete java.util tiene un amplio conjunto de clases para la creación y

tratamiento de colecciones, las operaciones que ofrecen son:
•Añadir objetos a la colección.

•Eliminar objetos de colección.
•Obtener un objeto de la colección.
•Localizar un objeto en la colección.
•Iterar a través de una colección.

índice
ArrayList Objetos La excepción ClassCastException surge cuando
se recuperara un objeto de otro tipo que se
1 espera, esto se nota en el tiempo de ejecución.
2
3
.
.
. Métodos
boolean add(Object)
void add(int indice, Object obj)
Object get(int indice)
Object remove(int indice)
void clear()
int indexOf(Object o)
int size()

ArrayList colec=new ArrayList();
int[] ar={34,756,23,65};
for(int e: ar){
colec.add(e);//autoboxing Integer.valueOf(e)
}
colec.add("String dentro de Integer");
for(Object e: colec){
if(e instanceof Integer){
/*unboxing Integer i=(Integer)e;
*i.intValue()*/
System.out.println(e);
}
else{
System.out.println((String)e);
}
}
System.out.println(colec.indexOf(new Integer(23)));
}

Clase Hashtable
Representa una colección de objetos basada en claves, no es como ArrayList

que se basa en un índice numérico para encontrar el objeto, aquí la clave es la
que identifica al objeto, esta clave puede ser cualquier tipo de objeto.
claves
Hashtable Objetos
1 Object put(Object clave,Object valor)

2 boolean containsKey(Object key)
3 Object get(Object key)
. Object remove(Object key)
. int size()
. Enumeration key()

Hashtable co1=new Hashtable();
co1.put("1","Programacion Estructurada");
System.out.println("Antes se llamaba: "+
co1.put("1","Programacion Orientada a Objetos"));
System.out.println("Ahora se llama: "+co1.get("1"));
}

Interfaz Enumeration
Al no estar basada en índices Hashtable no puede utilizar un for para

recorrer su objetos, esto se logra a través de una de un objeto
enumeration que implementa la interfaz java.util.Enumeration, con este
objeto podemos recorrer una colección de objetos asociados y acceder
a cada uno de ellos, un objeto Enumeration lo podemos ver como un
puntero que apunta a cada uno de los elementos de una colección
Colección
Objeto
Enumeration

Se tiene los siguientes métodos
Object nextElement()
boolean hasMoreElements()
Hashtable col=new Hashtable();
Integer clave;
String valor;
col.put(1,"Uno");
col.put(2,"Dos");
col.put(3,"tres");
Enumeration e=col.keys();
while(e.hasMoreElements()){
clave=(Integer)e.nextElement();
valor=(String)col.get(clave);
System.out.println(valor);
}
}
Como las colecciones gestionan los objetos a través del Object, cada vez que
recuperamos un objeto de la colección, es necesario realizar un refundición
explícita al tipo especifico del objeto que se espera.
ArrayList lista=new ArrayList();

lista.add(“Entrada1”);
.
.
String dato=(String)lista.get(0);
System.out.println(dato.length());

ArrayList lista=new ArrayList();
lista.add(“Entrada1”);
lista.add(new Integer(30));//compila correctamente
.
.
for(inti=0;i<lista.size();i++){
String s=(String)lista.get(i); //compila bien
//pero cuando valga i=1 genera un
//ClassCastException
System.out.println(s);
}

Utilizar genéricos con Colecciones
Se especifica al compilador el tipo especifico que se guardara en la

colección las ventajas que se tienen son:
•En tiempo de compilación si se quiere insertar un objeto del tipo

que no se indico provoca un error.
•No se necesita realizar una conversión explicita para recuperar el

dato.
ArrayList<String> lista=new ArrayList<String>();

Hashtable<String,Persona> tabla;

Clase ObjetosColecc
private Hashtable <String,Persona> tabla=new Hashtable<String, Persona>();

public void abrir(){
try{
File f=new File(System.getProperty("user.dir")+"/Archivos/nombres");
if(f.exists()){
FileOutputStream fs = new FileOutputStream(f);
ObjectOutputStream sal=new ObjectOutputStream(fs);
tabla.put("A1",new Persona("Miguel",32));
tabla.put("A2",new Persona("Jose",31));
sal.writeObject(tabla);
sal.close();
}
} catch (FileNotFoundException ex) {
} catch (IOException ex) {
}
}

public void Lectura(){
String d=null;
try{
File f=new File(System.getProperty("user.dir")+"/Archivos/nombres");
FileInputStream fs=new FileInputStream(f);
ObjectInputStream ent=new ObjectInputStream(fs);
tabla=(Hashtable)ent.readObject();
ent.close();
Enumeration e=tabla.keys();
while(e.hasMoreElements()){
d=(String)e.nextElement();
Persona per=tabla.get(d);
System.out.println(per.getName());
System.out.println(per.getEdad());
}
} catch(ClassNotFoundException ex){
} catch(IOException ex){
}
}

ObjetosColecc app=new ObjetosColecc();
app.abrir();
app.Lectura();
}

PDF Curso PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PDF Curso PDF

Cargado por

Copyright:

Formatos disponibles

Repaso de ciclos, estructuras de control y arreglos

public class Ciclos {

public class Ciclos {

public class Ciclos {

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Un arreglo es un grupo de variables (llamados elementos o componentes) que

int[ ] Arr=new int[4]

Ing. Miguel Angel Sánchez Hernández

int arr[ ]={23,34,56,677,765,45}

int[ ][ ] arr=new int[2][2];

Ing. Miguel Angel Sánchez Hernández

Como hemos venido trabajando nosotros pensamos que un programa es una

Ahora en Programación Orientada a Objetos (POO) cambiamos la forma de

Ing. Miguel Angel Sánchez Hernández

En la programación estructurada se compone tradicionalmente de funciones y

Con esto podemos decir que los métodos definirán su comportamiento y la

Ing. Miguel Angel Sánchez Hernández

A la hora de correr un programa orientado a objetos, los objetos están

Estos métodos son los que describen el comportamiento, y se escriben en las

Ing. Miguel Angel Sánchez Hernández

El modelo o modelado de objetos describe los conceptos principales de la

Estructuras estáticas: son los objetos y clases lo cuales están compuestos de

Relaciones: Son las ligas y asociaciones entre los objetos y clases.

Ing. Miguel Angel Sánchez Hernández

Los atributos corresponden a sustantivos y sus valores pueden ser

Ejemplo: Persona, Compañía pueden tener un atributo dirección

Ing. Miguel Angel Sánchez Hernández

Ejemplo: Pelota: arrojar, atrapar.

Ejemplo: Casa, Carro tienen ambos el método compra, son métodos

No se debe utilizar el mismo nombre en el métodos que tengan un

Ing. Miguel Angel Sánchez Hernández

public class ClaseUno{

Ing. Miguel Angel Sánchez Hernández

public void setNumeroCuenta(long numeroCuenta) {

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ocupa la clase Estudiante ocuparemos para crear un arreglo del tipo de

Ing. Miguel Angel Sánchez Hernández

La encapsulación es una técnica que nos permitirá ocultar los detalles de un

1.- Mantener a salvo el comportamiento y representación de los objetos.

2.- Poder modificar de una manera fácil el objeto ajustándonos a mejores de

Ing. Miguel Angel Sánchez Hernández

Es la idea de la representación de un objeto, localizando sus características y

Tomando los conceptos de objeto, encapsulación y abstracción afirmamos lo

En POO la encapsulación y abstracción da como resultado un objeto siendo,

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Algunos caracteres en java tienen un significado, para poderlos representar

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Ing. Miguel Angel Sánchez Hernández

Los ensamblados en particular la agregación y la composición son formas

La agregación, sus partes en el ensamblado pueden aparecer múltiples veces

En la composición las partes del ensamblado no pueden ser compartidas

Ing. Miguel Angel Sánchez Hernández

• Una red de computadoras se puede considerar un ensamblado, donde las