Instituto Tecnológico de Culiacán

Programación Orientada a Objetos

Dr. Clemente García Gerardo

Objetivo del curso

El estudiante aprenderá tópicos avanzados de programación orientada a objetos (POO) y su implementación por medio de un lenguaje de programación, que sirvan como base para cursos posteriores donde se desarrollarán sistemas computacionales.

Relación con otras asignaturas

POO

Fundamentos de Programación

Estructura de Datos

ADOO

Semestre actualSemestre anterior Próximo semestre

Aprendizajes requeridos

• Comprender la estructura de control de flujo

• Crear y manipular datos primitivos

• Contar con la capacidad de abstracción para analizar un problema y realizar el planteamiento de la solución mediante el uso de técnicas básicas del análisis y diseño orientado a objetos.

• Tener la habilidad para desarrollar algoritmos que representen el comportamiento de los objetos involucrados en la solución del problema

Aportación al perfil del egresado

Aplica la POO en la solución de problemas reales que impliquen el desarrollo de software.

Contenido

Unidad 1. Arreglos unidimensionales y multidimensionales

1.1 Conceptos básicos

1.2 Operaciones

1.3 Aplicaciones

Unidad 2. Métodos y mensajes

2.1 Concepto de método

2.2 Declaración de método

2.3 Llamada de métodos (mensaje)

2.4 Tipos de métodos

2.5 Pase de argumentos

2.6 Devolución de un valor desde el método

Contenido

Unidad 3. Constructor y Destructor

3.1 Conceptos

3.2 Declaración

3.3 Aplicaciones

3.4 Tipos de constructores y destructores

Unidad 4. Sobrecarga

4.1 Sobrecarga de métodos

4.2 Sobrecarga de operadores

Contenido

Unidad 5. Herencia

5.1 Introducción

5.2 Herencia simple

5.3 Herencia múltiple

5.4 Clase base y clase derivada

5.5 Parte protegida

5.6 Redefinición de los miembros de la clase derivada

5.7 Clases virtuales y visibilidad

5.8 Constructores y destructores en las clases derivadas

Contenido

Unidad 6. Polimorfismo y reutilización

6.1 Concepto de polimorfismo

6.2 Clases abstractas

6.3 Definición de interfaz

6.4 Implementación de un interfaz

6.5 Reutilización de la definición de una interfaz

6.6 Definición y creación de paquetes / librería

6.7 Reutilización de la clases de un paquete/librería

6.8 Clases genéricas (plantillas)

Contenido

Unidad 7. Excepciones

7.1 Definición

7.2 Gestión de excepciones

Unidad 8. Flujos y archivos

8.1 Introducción

8.2 Archivos de Texto

8.3 Archivos Binarios

8.4 Manipulación de archivos

8.5 Aplicaciones

Criterios de Evaluación

Tres parciales 60 %

Tareas 30 %

Proyectos 10 %

-------

100 %

Nivelación, sólo presentarán aquellos alumnos que hayan alcanzado por lo menos un 50% de calificación

Bobliografía

1. Taylor DavidObject Orient information systems, planning

and implementations.Ed. Wiley, Canada2. Herbert SchildtFundamentos de Programación en Java 2McGrawHill3. Luis Joyanes AguilarProgramación en Java, McGrawHill

Bibliografía

Programación en Java 2

Luis Joyanes Aguilar

McGrawHill

www.javasoft.com

www.javaworld.com

www.prenhall.com/deitel

Métodos

La clase consta de dos elementos principales; atributos y métodos

Problema

Se desea que se elabore un programa java que permita leer una serie de número (1-10) y reporte una tabla de frecuencia de cada número.

Orientación a Objetos

Vivimos en un mundo de objetos. Estos objetos existen en la naturaleza, en entidades hechas por el hombre, en los negocios y en los productos que usamos. Pueden ser clasificados, descritos, organizados, combinados, manipulados y creados. Por eso no es sorprendente que se proponga una visión orientada a objetos para la creación de software de computadora, una abstracción que modela el mundo de forma tal que nos ayuda a entenderlo y gobernarlo mejor.

La orientación a objetos puede describirse como el conjunto de disciplinas que desarrollan y modelan software que facilitan la construcción de sistemas complejos a partir de componentes.

El término orientado a objetos significa que el software se organiza como una colección de objetos que contienen tanto estructuras de datos como comportamiento.

Orientación a Objetos

Bicicleta

Tam.del cuadro Tam. De la rueda marchas material

Cambiar marcha() mover() reparar()

Se hace una abstracción que resulta en

OBJETOS BICICLETA

Orientación a Objetos

El atractivo intuitivo de la orientación a objetos es que proporciona conceptos y herramientas con las cuales se modela y representa el mundo real tan fielmente como sea posible. Estos conceptos y herramientas orientados a objetos son tecnologías que permiten que los problemas del mundo real sean expresados de modo fácil y natural.

Orientación a Objetos

La primera vez que se propuso un enfoque orientado a objetos para el desarrollo de software fue a finales de los años sesenta. Sin embargo, las tecnologías de objetos han necesitado casi veinte años para llegar a ser ampliamente usadas. Durante los años 90, la ingeniería del software orientada a objetos se convirtió en el paradigma de elección para muchos productores de software y para un creciente número de sistemas de información y profesionales de la ingeniería.

Orientación a Objetos

Programación Orientada a Objetos (POO)

La POO es un método de desarrollo de software, donde los programas están organizados como una colección cooperativa de objetos, donde cada uno representa una instancia de una clase, y cuyas clases son miembros de una jerarquía de clases unidas vía hereditario.

La POO es una tecnología para el diseño y desarrollo de programas que incorpora varios mecanismos sofisticados y eficientes que proveen un marco de organización para el desarrollo de proyectos de programación complejos y de gran tamaño.

Conceptos de POO

ClaseDescripción de un grupo de objetos con propiedades similares, comportamiento comunes y semántica común.

AtributoCaracterística de una clase.

Objeto- Es una instancia especifica de una clase. -Es una unidad con datos encapsulados, que pueden ser accesados por un conjunto de métodos de interfaz.

Variables de instanciaDatos asociados con cada instancia de una clase. Cada instancia mantiene un conjunto de distinto de variables.

MensajeEs el proceso de invocar una operación sobre un objeto, en respuesta a un mensaje se ejecuta en el objeto el método correspondiente.

MétodoUnidad de código declarada dentro de una clase y utilizada para acceder las variables de instancia del objeto.

Java características de OO

Abstracción de datos: • acto de representar las características escenciales de una entidad sin incluir detalles no necesarios.•Es el concepto de combinar la definición de tipos de datos y ocultación de datos.

Polimorfismo:• Literalmente significa “múltiples formas”• Es la capacidad para una clase derivada de una antecesora utilicen un mismo método de forma diferente.

Herencia:• Es el mecanismo por medio del que se pueden definir clases a partir de clases ya existente.

•Generecidad:• Técnica para definir componentes de programa que tiene más de una interpretación dependiendo de los tipos de argumentos.

Clases Java

Class Ejemplo { // Definición de atributo Alcance tipo Nombre; -- private, protected, public

//Definición de métodos

}

Vehiculo

Terrestre Acuatico

BarcoAnfibioAutomovil

Recursividad

Recursividad

La recursividad (recursión) es aquella propiedad que posee un método para llamarse a si mismo (recursividad directa) o bien a través de otro método (recursividad indirecta). La recursividad es usada para resolver problemas en términos de si mismo. Las siguientes clases java muestran los dos tipos de recursividad.

Recursividad

Los dos ejemplos anteriores muestran la recursividad en sus dos variantes (directa e indirecta). Estos métodos recursivos nunca terminan su ejecución correctamente ya que siempre se esta ejecutando el llamado recursivo.

Estos métodos terminarán la ejecución con error de stack overflow. Para evitar este error en un método recursivo se deben considerar los siguientes casos:

Caso(s) Base o Trivial: Condición o condiciones que permiten al método finalizar su ejecución.

Caso(s) Recursivos: Auto llamado del método.

class ejemplo

{ public void imprime(int n)

{ if (n==0) //Caso base

return;

System.out.println(n);

imprime(n-1);

System.out.println(“…”+n);

}

}

Recursividad

ejemplo Obj=new ejemplo();

Obj.imprime(5);

n Condición imprime recursividad imprime

5 5==0 no 5 Imprime(5-1)

4 4==0 no 4 Imprime(4-1)

3 3==0 no 3 Imprime(3-1)

2 2==0 no 2 Imprime(2-1)

1 1==0 no 1 Imprime(1-1)

0 0==0 si Fin ejecución

D1

D2

D3

D4

D5

D6

D7

D7 5

Dir n

D7 4

D7 3

D7 2

D7 1

5

4

3

2

1

class ejemplo

{ public void imprime(int n)

{ if (n==0) //Caso base

return;

System.out.println(n);

imprime(n-1);

System.out.println(“…”+n);

}

}

Recursividad

ejemplo Obj;

Obj.imprime(5);

n Condición imprime recursividad imprime

5 5==0 no 5 Imprime(5-1)

4 4==0 no 4 Imprime(4-1)

3 3==0 no 3 Imprime(3-1)

2 2==0 no 2 Imprime(2-1)

1 1==0 no 1 Imprime(1-1)

0 0==0 si Fin ejecución

D1

D2

D3

D4

D5

D6

D7

D7 5

Dir n

D7 4

D7 3

D7 2

D7 1

5

4

3

2

1

…1

…2

…3

…4

…5

…1

…2

…3

…4

…5

Recursividad

public long eleva(long x,long y){

if ( y = = 0) return 1;

if ( y = = 1) return x;

if(y%2==0) return eleva(x*x,y/2);

return eleva(x*x,y/2) * x;

}

La función de Ackermann, utilizada en la teoría de la computación, es una función recursiva que toma dos números naturales como argumentos y devuelve un número natural.

Recursividad

public int ackerman(int M, int N) { if(M == 0) return N + 1; if (N == 0) return ackerman(M-1,1); return ackerman(M-1,ackerman(M,N-1)); }

Obj.ackerman(3,2)

• Los paquetes (package) es la forma que tiene Java de agrupar clases e interfaces que tienen cierta relación.

Paquetes

• Un paquete es un archivo especial que contiene las declaraciones de clases con sus métodos.

Algunos paquetes predefinidos en Java:

java.lang Contienen las clases que son el núcleo de java (System, String, Integer, Math…). El compilador siempre incorpora este paquete.

java.io Contiene clases utilizadas para entrada salida (BufferReader, FileInputStream,…)

java.util Contiene diversas clases de utilidad (Random, StringTockenizer---)

java.appletJava.awt

Contienen clases para crear applets e interfaces gráficos.

Todo desarrollador de Java puede crear sus propios paquetes. Suponga que tenemos la siguiente clase ya desarrollada.

Paquetes

class Recursiva { public static long Fib(int n) { if(n==1 || n==2) return 1; return Fib(n-1)+Fib(n-2); } public static long Fact(int n){ if(n==0) return 1; if(n==1) return 1; return n * Fact(n-1); } }

Paquete

package Rutinas;public class Recursiva { public static long Fib(int n) { if(n==1 || n==2) return 1; return Fib(n-1)+Fib(n-2); } public static long Fact(int n){ if(n==0) return 1; if(n==1) return 1; return n * Fact(n-1); } }

Nombre de carpeta, que esta definida dentro de la carpeta donde elabora sus programas.

La declaración import permite especificar las clases de los paquetes que se van a utilizar en el programa.

import Rutinas.Recursiva;

Paquetes

import Rutinas.Recursiva;class AplRecursiva{ public static void main(String [] a) { Recursiva Obj=new Recursiva(); System.out.println("el 8 fib= "+Obj.Fib(8)); System.out.println("el 8 fact= "+Obj.Fact(8));

}}

El manejar paquetes permite evitar la colisión de nombres en software.

Paquetes

Esta colisión de nombres se da cuando dos clases llevan el mismo nombre y ambas requieren ser utilizadas dentro de un programa en particular. Empleando paquetes se garantiza que el nombre de la clase sea único.

package Paquete1;public class A{ private int x; protected int y; public A(){ this(1,2); } public A(int x,int y) { this.x=x; this.y=y; } public void Imprime() { System.out.println(x+" "+y); }}

package Paquete2;public class A{ private int d1; protected int d2; public A() { this(1,2); } public A(int x,int y) { d1=x;d2=y; } public void Imprime() { System.out.println(d1+"-"+d2+"=" +(d1-d2)); }}

Paquetes

import Paquete1.*;import Paquete2.*;class AplMismaClase{ public static void main(String[]a) {

A Obj = new A();A Obj1 = new A();

Obj.Imprime();Obj1.Imprime();

}}

Error, la clase A es ambigua, ya que existe en ambos

paquetes.

import Paquete1.*;import Paquete2.*;class AplMismaClase{ public static void main(String[]a) { Paquete1.A Obj = new Paquete1.A();

Paquete2.A Obj1 = new Paquete2.A(); Obj.Imprime();

Obj1.Imprime(); }}

La reutilización de código en la programación orientada a objetos es una característica que la hacen poderosa. Esto es posible gracias a la agregación (composición) y a la herencia.

La agregación, la herencia y las interfaces

La agregación (composición). Es la creación de una clase usando otra(s) clase(s) para definir atributos.

class Nombre { private String ApPaterno; private String ApMaterno; private String Nombre1; private String Nombre2; public Nombre(String Nom, String Ap1,String Ap2) { Nombre1=Nom; ApPaterno=Ap1;ApMaterno=Ap2; } public Nombre(String Nom1, String Nom2, String Ap1,String Ap2) { Nombre1=Nom1; Nombre2=Nom2; ApPaterno=Ap1;ApMaterno=Ap2; }}

Sobrecargado de métodos

¿Existe agregación en esta clase?

class Persona { private Nombre NomPropio; private char Sexo; private Reloj Swatch; public Persona() { NomPropio=new Nombre(“Juan”,”Lopez”,”Garcia”); Swatch=new Reloj(6,5,18); } public Persona (Nombre Nom1, char Sexo, Reloj R) { NomPropio=Nom1; Swatch=R; this.Sexo=Sexo; }public String toString() { return "Datos genelaes :\n"+NomPropio.toString()+"\nTiempo reloj: "+Swatch.toString(); }}

AgregaciónDefinición de la clase Persona

class AplPersona { public static void main(String [] a) { Persona Obj=new Persona(new Nombre(“Juan”;”Lopez”;”Miguel”),’M’,new Reloj(5,6,7)); System.out.println("Primer Person \n"+Obj); System.out.println("Segunda Persona \n"+Obj1); }}

Agregación

La herencia es el mecanismo por medio del cual los desarrolladores en Java pueden construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas).

Herencia

El mecanismo conocido con el nombre de herencia permite reutilizar clases. Se crea una nueva clase que extiende la funcionalidad de una clase existente sin tener que reescribir el código asociado a está última.

Trabajador

Empleado

Auditor

Clase base o super clase

SubclaseEspecialización de Trabajador

Clase genérica que sirve para encapsular datos como nombre, dirección, número de IMSS.

Clase especializada para representar empleado que tienen nómina mensual. Encapsula datos como salario anual e impuestos.1

Clase especializada para representar empleado que cobran por horas. Encapsula horas y trifa por hora.

Herencia

Trabajador

-Nombre-

Direccion-NoIMSS

+toString

Empleado-Nombre

-Direccion-NoIMSS-Sueldo

-Impuesto

+toString

Auditor-Nombre

-Direccion-NoIMSS-Horas-Tarifa

+toString

Las clases Empleado y Auditor contienen los atributos y operaciones que la definen y heredan de Trabajador.

Atributos heredados, no todos pueden ser accedidos por los métodos propios de la subclase.

Atributos propios todos pueden ser accedidos por los métodos propios de la subclase.

¿Qué determina si un atributo o método heredado esta disponible a los métodos de la subcalse?

!El modificador definido!

public está accesible desde todas las clases.Protected está accesible sólo dentro de su clase y subclases.private esta accesible sólo dentro de su clase.

Sintaxis usada en java para implementar herencia

Herencia

class Subclase extends claseBase {// Definición de atributos y métodos propios}

Un ejemplo.

Herencia

class Animal{ public void Respirar() { System.out.println(“RESPIRA”); }}

classAplAnimal { public static void main() { Pez Nemo=new Pez(); SOP(Nemo.Respirar()); }}

class Pez extends Animal { public void Respirar() { System.out.println(“***Burbujear***”); }}

¿Qué método responde a este mensaje?

¿este método se le puede enviar un mensaje?

Polimorfismo

este método puede invocar al Respirar de la clase Animal usando la palabra reservada

super

Java usa la palabra reservada super para referirse a miembros de la superclase.

Herencia

super() se invoca el constructor de la superclase.super.Metodo() invoca al método de la superclase.Cuando utilice el super() en el constructor de la subclase éste debe aparecer como primer instrucción del constructor de la subclase.

Elabore las clases java que se requieran para representar el siguiente diagrama UML

Herencia

Pago

ImporteFecha

Credito

FolioAutorizacionIdEstablecimiento

Contado

TipoMonedaImporte entregoCotizacion

Cheque

IdBancoIdCuenta

Herencia significa especialización

Herencia vs Agregación

Agregación significa una relación del tipo “tener un” entre clases.1. Cuando la clase contenida no existe independientemente de

la clase que la contiene (contenido físico) se denomina agregación. Los objetos contenidos dependen del padre, ejemplo Mano-Dedos, si cortas la mano se mueren los dedos.

2. Cuando la clase contenida existe independientemente de la clase que la contiene se denomina agregación por referencia. Los objetos contenidos no dependen del padre, ejemplo Perro - Pulgas, si matas el perro viven las pulgas

Una subclase especializa sus atributos y métodos a través de la herencia y puede agregar más atributos y métodos según se requiera (logrando hacer la subclase más restrictiva, más especial).

Clases abstractas

Una clase abstracta, es una clase de la que no se puede crear objetos, ya que suelen representar conceptos generales.

¿Cómo se declara una clase abstracta?

abstract class Nombre {

//atributos y métodos

}

Un método abstracto no se desarrolla su cuerpo en la clase donde se declara su firma. El cuerpo será desarrollado en alguna de las subclases.

abstract class Nombre { public abstract void Met1(); public void Met2() {…………..}}

Una clase abstracta se declarada con la palabra reservada abstract como prefijo en la cabecera de la clase.

En una clase abstracta se pueden definir métodos abstractos.

abstract class a{public abstract void Met1();

}

public class Abstracta{public static void main(String []a){

a Obj = new a();}

}

Clases abstractas

Error, no se puede instanciar de una clase abstracta.

Clases abstractas

abstract class a{ public abstract void Met1() { System.out.println(“….”); } }public class Abstracta{ public static void main(String []a){ a Obj = new a(); }}

Error, un método abstracto no puede tener desarrollado el cuerpo en la clase abstracta.

Clases abstractas

abstract class a{ public abstract void Met1() ; }class b extends a { public void Met2() {“++metodo 2++”;}}public class Abstracta{ public static void main(String []a){ b Obj = new b(); }}

Error, la clase b no es abstracta y no redefine el Met1.

Clases abstractas

abstract class a{ public abstract void Met1() ; }abstract class b extends a { public void Met2() { System.out.println("+++metodo2"); }}class c extends b{ public void Met1(){ System.out.println("**** redifinido +++"); }}public class Abstracta{ public static void main(String []a){ c Obj = new c(); Obj.Met1(); }}

Clase abstracta, método abstracto

Herencia, subclase abstracta, superclase abstracta, no se redefine el Met1 que es abstracto.

Herencia, subclase no abstracta, superclase abstracta, se redefine el Met1 no se define abstracto.

Clases, métodos y atributos finalAlgunas ocasiones es conveniente que un método no sea redefinido en un subclase o incluso que una clase completa no pueda ser extendida(que no pueda se utilizada para que se herede de ella). Esto lo podemos implementar apoyandonos con la cláusula final.

El compilador es más eficiente con difiniciones final por que no buscará estás clases y métodos al tratar herencia.

final class Nombre { … Métodos y atributos}

class Nombre { public final void Met1() { …. }}

class Nombre { private final int a=8; public final void Met1() { …. }}

Una clase final no puede ser superclase en la definición de

herencia.

InterfacesJava incorpora interface, que permite declarar un conjunto de constantes y de firmas (cabeceras) de métodos abstractos.

interface Nombre { // constante tipoDato Nombre = valor ; // Firmas métodos TipoRegresa Nombre (Parámetros);}

interface Barco { // constante int MaxDias=30 ; // Firmas métodos void Alarma(); void MsgAuxilio();}

Actua como un atributo final

Actua como un método abstracto

La interfaz especifica el comportamiento común que tiene un conjunto de clases. Dicho compportamiento tiene que ser implementado en cada una de las clases.

Interfaces¿Cómo lograr la implementación de una interfaz?

Se utiliza una sintaxis similar a la derivación de una clase, con la palabra reservada implements en lugar de extends.

class NombreClase implements NombreInterfaz[,NombreInterfaz2,…] { // Definición de atributos // Definición de los métodos de la clase // Definición de los métodos de la interfaz}

La clase que implementa una interfaz tiene que desarrollar el código de cada uno de los métodos de la interfaz, de no hacerlo, la clase se convierte en clase abstracta y entonces debe declararse abstract.

Interfacesinterface a{ int Maximo=8; void Met1(); }

class b implements a { public void Met2() { System.out.println(“Maximo "+Maximo); }}public class AplInterface{ public static void main(String []a){ b Obj = new b(); Obj.Met2(); }}

Error, la clase b no redefine el método Met1 y no es una clase abstracta……Solución defina el método o defina la clase abstracta.

Interfaces, un ejemplointerface Barco{ void Alarma(); void MsgAuxilio(String a); }

class BarcoPasaje implements Barco { private int Eslora; private int NoCamas; public BarcoPasaje() { Eslora=200; NoCamas=88; } public void Alarma(){ System.out.println(“****Alarma Barco Pasajeros”); } public void MsgAuxilio(String a) { Alarma(); System.out.println(“!!! SOS SOS !!!!”+a); } }

Interfaces, un ejemplo

class PortaAvion implements Barco { private int NoAviones; private int NoTripulacion; public PortaAvion() { NoAviones=50; NoTripulacion=150; } public void Alarma(){ System.out.println(“****Marineros a sus puestos *****”); } public void MsgAuxilio(String a) { Alarma(); System.out.println(“!!! SOS SOS !!!!”+a); } }

Interfaces

Las interfaces se pueden organizar en forma jerárquica, de tal forma que los métodos se heredan de una interfaz a la descendente.

interface a{ int Maximo=8; void Met1(); }

interface a1 extends a { void Met2(); }

interface a2 extends a { void Met3(); }

interface a3 extends a1, a2 { void Met3(); }

Interfaces

En una herencia múltiple, los identificadores de algunos métodos o atributos pueden coincidir en la clase que hereda, provocando una colisión

interface a{ float Maximo=8; void Met1(); } interface aa extends a{ void Met1(); }interface bb extends a { void Met1();}class h implements aa,bb{ public void Met1(){ System.out.print("Maximo="+Maximo); }}public class AplInterfaceMultiple{ public static void main(String []a){ h Obj = new h(); Obj.Met1(); }}

Alerta, posible colisión de atributo

Reglas que establece Java para resolver colisiones.

Excepciones

El diseño y escritura de clases y métodos es una tarea difícil y delicada, por ello es necesario manejar los errores que se produzcan con la mayor eficiencia.Analice la ejecución del siguiente código java.

import java.util.*;class Excepcion0{ public static void Metodo1(Scanner In){ int Edad; System.out.print("Proporcione su edad "); Edad=In.nextInt(); }

En este código no existe error de compilación. Pero qué sucede si durante la ejecución el usuario introduce como edad

la palabra CIEN.Exception in thread "main" java.util.InputMismatchExceptionat java.util.Scanner.throwFor(Scanner.java:840)at java.util.Scanner.next(Scanner.java:1461)at java.util.Scanner.nextInt(Scanner.java:2091)at java.util.Scanner.nextInt(Scanner.java:2050)at Excepcion0.Metodo1(Excepcion0.java:7)at Excepcion0.main(Excepcion0.java:30)

Excepciones

public static void main(String [] arg){ Scanner In=new Scanner(System.in); Metodo1(In);

}}

public static void Metodo2(){ String Str=“ 2123"; int Numero=Integer.parseInt(Str); System.out.println("Numero= "+Numero); }

public static void Metodo3(int n){ System.out.println(n); Metodo3(n-1); }

public static float Metodo4(int n){ int Numero=0; float r=n/Numero; return r; }

Metodo2(); Metodo3(100); Metodo4(200);

En este código no existe error de compilación. Pero qué sucede cuando Java intenta convertir una cadena (con caracteres no numéricos) a un valor

numérico.Exception in thread "main" java.lang.NumberFormatException: For input string: " 2123“ at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)at java.lang.Integer.parseInt(Integer.java:449)at java.lang.Integer.parseInt(Integer.java:499)at Excepcion0.Metodo2(Excepcion0.java:11)at Excepcion0.main(Excepcion0.java:31)

En este código no existe error de compilación. Pero qué sucede con la recursividad?.

Exception in thread "main" java.lang.StackOverflowErrorat sun.nio.cs.SingleByteEncoder.encodeArrayLoop(SingleByteEncoder.java:91)at sun.nio.cs.SingleByteEncoder.encodeLoop(SingleByteEncoder.java:130)at java.nio.charset.CharsetEncoder.encode(CharsetEncoder.java:544)at sun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:252)at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:106)at java.io.OutputStreamWriter.write(OutputStreamWriter.java:190)at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:111)

En este código no existe error de compilación. Pero qué sucede con la división?.

Exception in thread "main" java.lang.ArithmeticException: / by zeroat Excepcion0.Metodo4(Excepcion0.java:22)at Excepcion0.main(Excepcion0.java:34)

Java incluye un mecanismo de manejo de excepciones que está soportado por el lenguaje.

Excepciones

Una excepción es un error del programa que ocurre en tiempo de ejecuciónUna excepción se “levanta” (del inglés raise) en caso de un error e indica una condición anormal que no se debe presentar durante la ejecución del programa.

¿Qué es un excepción?

import java.util.*;class Excepcion0{ public static void Metodo1(Scanner In){ int Edad; System.out.print("Proporcione su edad "); try { Edad=In.nextInt(); } catch (Exception ex) { System.out.println(“ *** se presentó un error en la admisión de datos***” ); return; } }}

Cuando se introduzca valores que no representan enteros se lanzará una excepción, transfiriéndose el flujo del

programa al manejador catch.

• Cuando se produce una excepción dentro de un método Java, éste crea un objeto que contiene información sobre la excepción y lo pasa al código llamador.• La rutina receptora de la excepción es responsable de reaccionar a tal evento inesperado.• Cuando creamos un objeto para la excepción y lo pasamos al código llamador decimos que lanzamos una excepción (Throw an exception)• Si el método llamador no tiene un manejador de la excepción se busca hacia atrás en la pila de llamados anidados hasta encontrarlo.• Decimos que el manejador atrapa la excepción (catch the exception)

El mecanismo de manejo de excepciones en Java utiliza cinco palabras reservadas: try, catch, throw, throws y finally.

Excepciones

Excepciones

try, establece un bloque de instrucciones para detectar excepciones

catch, un manejador para capturar excepciones de los bloques try

throw, una expresión para levantar (raise) excepciones

throws, indica las excepciones que puede elevar un método

finally, bloque opcional situado después de los catch de un try..

Excepciones

try { instrucciones}catch (tipoexcepción) { instrucciones}

catch (tipoexcepción){ instrucciones}

•••

finally { instrucciones}

Cuando se declara un bloque try puede existir uno o mas manejadores catch.

El manejador finally es opcional, cuando se declara siempre se ejecuta, haya o no haya excepciones.

Puede existir un bloque try sin manejadores catch pero con el manejador finally.

class EjemploExcepcion { public static void main(String [] arg) { Scanner in=new Scanner(System.in); int num=0; int [] v; System.out.print("Proporcione Edad"); num=in.readInt(in); try { v=new int[num]; v[40]=8; float d=num / (num-1) ; } catch(ArithmeticException e) { System.out.println("divison entre cero“); } catch(IndexOutOfBoundsException e) { System.out.println("subindice fuera de rango"); return; } catch(NegativeArraySizeException e) { System.out.println("intentó crear un vector con valor negativo"); System.exit(1); } finally { System.out.println("....instrucciones del ffinally.."); } System.out.print (“continua con las instrucciones”); }}

Excepciones

En el bloque de este catch no existe una instrucción que finalice el programa, lo que permitirá que se ejecute las instrucciones del finally y continúe la ejecución después del finally.En el bloque de este catch existe una return que finaliza la ejecución del programa, lo que permitirá que sólo se ejecute las instrucciones del finally.En el bloque de este catch existe una System.exit(1) que finaliza la ejecución del programa (incluso sale del java), lo que provoca que el cuerpo del finally no se ejecute.

ExcepcionesClases de excepciones definidas en Java.

Object

Throwable

Error Exception

Throwable es la clase base de las excepciones que deriva de la superclase Object.

Las excepciones de tipo Error son generadas por el sistema, se puede decir que se trata de errores irrecuperables. Ejemplo salir de la memoria.

De la clase Exception derivan clases de las que se instancian objetos (excepciones) para ser lanzadas (throw) que pueden ser capturados por los catch .

catch (StackOverflowError e){ System.out.println("Pila llena"); }

ExcepcionesLanzamiento de excepciones propias.

La sentencia throw levanta una excepción. throw Objeto; donde objeto debe ser un objeto de una clase deriva de Exception.

class MiEx extends Exception { public MiEx() { super(); } public MiEx(String Cadena){ super(Cadena); }}

class LanzoExcepcion { public static void main(String [] arg) throws MiEx { int num=0; if(num<=0) throw new MiEx("No maneja numero negativos"); }}

ExcepcionesRecuperándose de una excepción, cuando se introduce un valor fuera del rango establecido.

class LanzoExcepcion { public static int Lee()throws MiEx{ int d; Scanner In=new Scanner(System.in); System.out.print("Edad 1-30 "); try { d=In.nextInt(); if(d<1 || d>30) throw new MiEx(" el rango valido es de 1-30"); } catch (MiEx Obj){ System.out.println("\07\07\07 Proporciono datos fuera de rango"+Obj.getMessage()); return Lee(); } return d;}

import java.util.Scanner;class MiEx extends Exception { public MiEx() { super(); } public MiEx(String Cadena){ super(Cadena); }}

ExcepcionesRecuperándose de una excepción , cuando el número de elementos es mayor a los elementos del vector.

class ExcpMedia extends Exception { public ExcpMedia() { super(); } public ExcpMedia(String Cadena) { super(Cadena); }}

class ExpPerAVG { public static double calculamedia(int num) throws ExcpMedia { double b[]={1.1,1.2,1.3,1.4,1.5}; double media; try { media=avg(b,num); return media; } catch (ExcpMedia msg) { System.out.println("Error "+msg); num=b.length; return avg(b,num); } }

public static void main(String [] arg) throws ExcpMedia { System.out.println("Resultado=" +calculamedia(30)); } }

static double avg(double []v,int n) throws ExcpMedia { if (n>v.length) throw new ExcpMedia(“Elementos > que tamaño del vector"); double sum=0; for(int i=0;i<n;i++) sum=sum+v[i]; return sum/n; }

Flujos y Archivos

Un archivo es un grupo de datos estructurados que son almacenados en algún medio y pueden ser usados por diferentes aplicaciones. Los archivos tienen como finalidad guardar datos de forma permanente para que otra aplicación pueda usarlos.

Los archivo también denominados ficheros (file); es una colección de información (datos relacionados entre sí), localizada o almacenada como una unidad en alguna parte de la computadora.

¿Qué son archivos?

Características de los archivos

1. Independencia de las informaciones respecto de los programas.2. La información almacenada es permanente.3. Un archivo puede ser accedido por distintos programas en

distintos momentos.4. Gran capacidad de almacenamiento.

Flujos y Archivos

Almacenamiento de archivos

Texto:

Un archivo de texto se considera una secuencia de caracteres ASCII divididos en líneas, cada línea termina con un carácter de nueva línea (\n), el que se convierte en CR+LF (retorno de carro/salto de línea).

Binario:

Un archivo binario se considera una secuencia de bytes.

Si deseamos almacenar 25678 en un archivo texto se graba la cadena 25678 que requiere 5 bytes, en un archivo binario requiere dos bytes (el almacenamiento lo hace en binario).

Flujos y ArchivosOrganización de archivos

La organización de un archivo define la forma en la que los registros se disponen sobre el soporte de almacenamiento

En general se consideran tres tipos de organizaciones:

Organización secuencial

Un archivo de organización secuencial es una sucesión de registros almacenados consecutivamente sobre el soporte externo, de tal forma que para acceder al registro n, es obligatorio por los n-1 registros que le preceden.

Organización directa (o aleatoria)

Un archivo es de acceso directo cuando cualquier registro es directamente accesible mediante la especificación de un índice que da la posición del registro con respecto al origen del archivo.

Flujos y Archivos

El manejo de archivos en Java se hace mediante el concepto de flujo (stream). Los flujos conducen los datos entre el programa y los dispositivos externos (disco duro)

Programa Archivo

Establecer flujo

El programa no puede trabajar con el archivo

ÉxitoNO

SI

El programa puede manipular el archivo a

tráves del flujo.

Flujos y Archivos

import java.io.*;class AplFA0 { public static void main(String [] a){ int c; try {

FileInputStream F=new FileInputStream("AplFA0.java");

while ( ( c= F.read() ) != -1){ System.out.print((char)c);

} } catch (Exception e){

System.out.println("El flujo no se estableció, verifique si el archivo existe"); } }}

Estableciendo el flujo

Manipulando el archivo a través del flujo

En este paquete se encuentran todas las clases stream necesarias para dar E/S a nuestro programas

Flujos y Archivos

InputStream OutputStream

FileInputStream ByteArrayInputStream PipeInputStream SequenceInputStream StringBufferInputStream FilterInputStream

FileOutputStream ByteArrayOutputStrem PipeOutputStream FilterOutputStream

Los flujos de datos pueden clasificarse en flujos de entrada (InputStream) y flujos de salida (OutputStream). Java declara dos clases que derivan directamente de Object.

Object

InputStream OutputStream

Clases abstractas

Flujos y ArchivosArchivos de acceso directo (aleatorio).

Un archivo es de acceso aleatorio cuando cualquier registro es directamente accesible mediante la especificación de un índice, que da la posición del registro con respecto al inicio del archivo.

1 200 S 100.55

2 100 S 234.89

3 250 C 12.99

4 200 S 1526.77

5 100 C 1897.77

6 150 S 156.87

CveEmp

Depto EC Sdo

Suponga que tenemos el siguiente archivo

1 200 S 100.55

2 100 S 234.89

3 250 C 12.99

4 200 S 1526.77

5 100 C 1897.77

6 150 S 156.87

CveEmp

Depto EC Sdo

Se abre el archivo desde una clase JAVA

PunteroPuntero se encuentra antes del primer dato del archivo. De donde se encuentre Puntero puede leer o escribir.

1 200 S 100.55

2 100 S 234.89

3 250 C 12.99

4 200 S 1526.77

5 100 C 1897.77

6 150 S 156.87

CveEmp

Depto EC Sdo

Se desea leer el quinto registro

Puntero

Saltar todos estos bytes

1 200 S 100.55

2 100 S 234.89

3 250 C 12.99

4 200 S 1526.77

5 100 C 1897.77

6 150 S 156.87

CveEmp

Depto EC Sdo

Se desea leer el tercer registro

Puntero

Saltar todos estos byte

Las operaciones que se realizan con un archivo directo son:

CreaciónAltasBajasModificacionesConsultas

Flujos y ArchivosPara el proceso de archivos aleatorios es importante establecer el tipo de datos de cada campo del registro lógico.

CveEmp

Nombre

CveDepto

EdoCivil

int

String

int

Char

4

Max+2

4

2

Los campos de tipo primitivos tiene longitud fija.

Los campos de tipo String se debe especificar el máximo número de caracteres permitidos más dos bytes si lo graba en formato UTF ya que guarda la longitud de la cadena.

Flujos y ArchivosLa clase File

Antes de realizar acciones sobre un Archivo, necesitamos información sobre ese Archivo. La clase File proporciona métodos para conocer propiedades del archivo tales como tamaño, permisos de acceso, última modificación, si existe.Constructores de la clase File:

public File ( String NombreCompleto)

crea un objeto File con el nombre y ruta del archivo pasado como argumento.

public File (String Ruta,String Nombre)

Crea un objeto File con la ruta y nombre del archivo pasado como argumento

public File(File Ruta,String Nombre) Crea un objeto File con un primer argumento File con la ruta y el nombre en el segundo argumento.

Flujos y ArchivosFile MiArchivo=new File(“Datos.Dat”);

Crea un objeto File con el archivo Datos.Dat que se encuentra en la carpeta donde la aplicación se está ejecutando.

File MiArchivo=new File(“c:\\ClasesTec\\POO\\Datos.Dat”);

Crea un objeto File con el archivo Datos.Dat que se encuentra en la carpeta especificada (ruta completa o absoluta).

File MiArchivo=new File(“FlujosArchivos”,“Datos.Dat”);

Crea un objeto File con el archivo Datos.Dat que se encuentra en la ruta relativa FlujosArchivos. Esto significa que la carpeta FlujosArchivos es subcarpeta de donde se esta ejecutando la aplicación.

File Dir=new File(“c:\\ED\\”); File MiArchivo=new File(Dir ,“Datos.Dat”);

Crea un objeto Dir con ruta absoluta y crea un objeto MiArchivo con el archivo Datos.dat que se encuentra en la ruta especificada por el objeto Dir.

Flujos y Archivosimport java.io.*;class InfoArchivo { public static void main( String args[] ) { if( args.length ==0 ) { System.out.println( "Debe indicar un fichero." ); return; } for( int i=0; i < args.length; i++ ) { File f = new File( args[i] ); System.out.println( "Nombre: "+f.getName() ); System.out.println( "Camino: "+f.getPath() ); if( f.exists() ) { System.out.print( f.isFile() ? "Archivo existente " : "No es archivo"); System.out.print( (f.canRead() ? " y se puede Leer" : "" ) ); System.out.print( (f.canWrite() ? " y se puede Escribir" : "" ) ); System.out.println( "." ); System.out.println( "La longitud del fichero son "+ f.length()+" bytes" ); } else System.out.println( "El fichero no existe." ); } } }}

Métodos de la clase File

? Operador terciario. (Evalúa expresión ? Cierto : falso)

Flujos y ArchivosLista de Métodos de la clase File

Nombres de fichero String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo( File nuevoNombre )Comprobaciones boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute()Información general del fichero long lastModified() // regresa en milisegundos long length()Utilierias de directorio boolean mkdir() String[] list()

import java.io.*;import java.util.Date;import java.text.DateFormat;class File1 { public static void main(String [] a){ File Dir=new File("c:\\clemente\\clasestec\\poo\\"); File Arch=new File(Dir,"AplBarco.java");

System.out.println( "ultima modificacion milisegundos: "+Arch.lastModified() );

Date Fecha=new Date(Arch.lastModified()); System.out.println( "ultima modificacion : "+Fecha );

String cadenaFecha =DateFormat.getDateTimeInstance().format(Arch.lastModified()); System.out.println( "ultima modificacion formateada : "+cadenaFecha ); }}

Flujos y Archivos

Flujos y ArchivosLa clase RandomAccessFileLa clase RandomAccessFile es la base para crear los objetos de tipo fichero de acceso directo.

Constructores de la clase RandomAccessFile

public RandomAccessFile(String NombreArchivo, String Modo)

Donde NombreArchivo es el nombre al que quedará ligado el objeto que se cree con esta clase. El argumento Modo es la forma de apertura en que estará disponible el archivo.

public RandomAccessFile(File Archivo, String Modo)

Donde Archivo es un objeto File que se creó con la ruta y nombre del archivo. El argumento Modo es la forma de apertura en que estará disponible el archivo.

Modo Descripción

“r”Apertura para lectura, si intenta escribir genera una excepción IOException

“rw”“rws”“rwd”

Apertura para lectura y escritura. Si el archivo no existe lo crea.

Flujos y Archivosimport java.io.*;import java.util.*;class ArchDirecto1 { public static String Ajusta(String Nom,int Ancho){ for(int i=0;Nom.length()<Ancho;i++) Nom=Nom+" "; return Nom; } public static void main( String args[] ) throws IOException { Random R = new Random(); String [] V={"Raul","Aurora","Porfirio","Alejandro","Bertha","Sofia","Oscar","Serapio","Daniela","Marisol"}; File F=new File("Clientes.dat"); RandomAccessFile Arch= new RandomAccessFile( F,"rw" ); String Nombre; int Codigo; long Edad; double Estatura; Codigo=0; for(int i=0 ;i<10;i++){ Codigo++; Nombre=V[R.nextInt(10)]; Nombre=Ajusta(Nombre,20); Edad=R.nextInt(1000)+1; Estatura=R.nextInt(1)+1+R.nextFloat(); System.out.println(Nombre.length()+" "+V[3].length()); Arch.writeInt(Codigo); Arch.writeUTF(Nombre); Arch.writeLong(Edad); Arch.writeDouble(Estatura); } Arch.close(); }}

Flujos y Archivos

Si en los archivos de acceso directo trata de leer más información de la almacenada (más allá del fin del archivo) se lanza un excepción del tipo EOFException si existe un problema de lectura IOException.

Métodos de la clase RandomAccessFile

length() regresa el número de bytes que esta formado el archivo

seek(No bytes) mueve el puntero la cantidad de bytes especificados, iniciando siempre desde el inicio del archivo.

getFilePointer() regresa la posición actual del puntero del archivo, que representa el número de bytes desde el inicio del archivo hasta la posición actual.

Manejo de String

Definición de una variable.

String Nombre;Nombre=Valor;

String Nombre=“valor”;

String Nombre=new String(“Valor”);

Para obtener el número de caracteres de la cadena, use el método length.

int largo=Nombre.length();

Para comparar dos string.

if (Nom1.equals(Nom2))

If (Nom1==Nom2)

Manejo de String

Para sabes si Cad1 es mayor, menor o igual a Cad2, utilice el método compareTo.

Sintaxis Cad1.compareTo(Cad2), este método regresa como resultado un valor numérico entero, posibles valores negativo, cero, positivo.

if ( Cad1.compareTo(Cad2)==0) { // Son iguales}

if ( Cad1.compareTo(Cad2)>0) { SOP(Cad1 +” es mayor que “+Cad2);}

if ( Cad1.compareTo(Cad2)<0) { SOP(Cad1 +” es menor que “+Cad2);}

El contenido en mayúscula y minúsculas aquí importa.

Manejo de String

Para sabes si Cad1 igual a Cad2, ignorando mayúsculas y minúsculas, utilice el método equalsIgnoreCase.

Sintaxis Cad1.equalsIgnoreCase(Cad2).

String Nom1="ana";String Nom2="aNA";

// Ignorando las mayúsculas if(Nom1.equalsIgnoreCase(Nom2) ) System.out.println(“Si son igual en contenido ");

elseSystem.out.println(“ NO son igual en contenido ");

Manejo de String

// Buscar una subString en un String String Nom1="El atomo es el adecuado para esta situacón"; String Nom2=“adecuado”;

if (Nom1.indexOf(Nom2)>=0) System.out.println("Inica en la pisicion "+Nom1.indexOf(Nom2)); else System.out.println("No es substring, posicion regresa "+Nom1.indexOf(Nom2));

//Buscar un substring en una cadena del final al inicio if (Nom1.lastIndexOf(Nom2)>=0) System.out.println("Inica en la pisicion "+Nom1.lastIndexOf(Nom2)); else System.out.println("No es substring, posicion regresa "+Nom1.lastIndexOf(Nom2));

Manejo de String

Para copiar una parte del String a otro String utilice el metodo

substring(Posicioninicial, Cuantos);

System.out.println("Copiando con el substring");

for(int i=0; i < Nom1.length(); i++) { Nom2=Nom1.substring(0,i+1); //posicion inicial, cuantos System.out.println(Nom2); }

Nom2=Nom1.substring(0); // copia todo

System.out.println("Copiado con el substring todos \n"+Nom2);

Manejo de String

Para obtener un carácter de una cadena, utilice el método charAt(poscaracter)

El método charAt permite obtener un carácter de una cadena, tiene como parámetro el índice (posición) del carácter a obtener. El índice del primer carácter es 0, del último carácter es la length()-1.

String Texto=“Instituto”;for( int i=0 ; i< Texto.length() ; i++) System.out.print(Texto.charAt(i));

Para obtener un arreglo de caracteres, utilice el método getChars()

public Void getChars(int p, int n, char [] c, int x)

p Índice del primer carácter de la cadena a copiar

n Representa el número de caracteres a copiar

c Es el arreglo donde se copiaran los caracteres

x Representa el índice del arreglo a partir de donde se almacenarán.

Manejo de String

Para eliminar los blancos que están al inicio y/o final de una cadena, utilice el método trim().

String NvoTexto=Texto.trim(); System.out.println(NvoTexto);

Texto=" 12345 "; int Num=Integer.parseInt(Texto.trim()); System.out.println(Num);

Para remplazar la ocurrencia de un carácter por otro caracter, utilice el método replace.

replace(CaracterViejo,CaracterNuevo)

Texto="a.b.c.d.e.."; NvoTexto=Texto.replace('.','*'); System.out.println("Texto original "+Texto); System.out.println("Texto original "+NvoTexto);

Tablas Hash

Una tablas Hash es una estructura que asocia Claves con valores, se basa en un algoritmo de cálculo para convertir claves.

Para la creación de una tabla Hash se puede con uno de los siguientes constructores.

public Hashtable()public Hashtable(int CapacidadInicial)public Hashtable(int CapacidadInicial, float LoadFactor)

Tablas Hashimport java.util.*;class HashNumeros{ public static void main(String [] arg){ // definir una tabla Hash Hashtable Numeros = new Hashtable(); // Agregar información Numeros.put("1","Uno"); Numeros.put("2","Dos"); Numeros.put("3","Tres"); //Obtener el conjunto de claves Enumeration e =Numeros.keys(); // Recorrer la lista while (e.hasMoreElements()) { // Obtengo la clave String clave = (String) e.nextElement(); // Obtengo la información asociada a esa clave String valor = (String) Numeros.get(clave); System.out.println(" id : " + clave + " nombre = " + valor); } Numeros.clear(); //limpia la tabla hash