figuras en java.pdf

8/17/2019 figuras en java.pdf

1/18

Paolo Rosso Grupos: 2B+ENG - ETSIA

EDA2004/2005

//clase abstracta YA QUE tiene al menos un método abstracto

//No se puede hacer new Figura();

import java.text.*;

//Para el formateo de los double en toString

public abstract class Figura {

//Atributos

protected double dim1;

protected double dim2; protected String nombre;

El ejemplo de las Figuras


EDA2004/2005

//Métodos

//constructor que UNICAMENTE puede ser invocado por la

//subclases; podemos crear (new) objetos de las clases

// Circulo, Rectangulo o Cuadrado, PERO NO Figura

public Figura( double dim1 , double dim2, String nombre){

this.dim1 = dim1;

this.dim2 = dim2;

this.nombre = nombre;

}

// Métodos abstractos: comunes, pero con IMPLEMENTACIÓN

//especializada: NO TIENEN CUERPO y a su cabecera sigue ";"

public abstract double area( );

public abstract double perimetro( );


2/18


EDA2004/2005

// Métodos NO abstractos y finales: se heredan SIN sobrescritura// el area es double, la imprimo con formato

final public String toString(){

// creación de la variable numConFormato;

NumberFormat numConFormato = NumberFormat.getInstance();

numConFormato.setMinimumFractionDigits(2);

numConFormato.setMaximumFractionDigits(2);

return ("\t"+this.nombre+" con area\t"+numConFormato.format(this.area())+"\n");

}

final public boolean menorQue( Figura fig){

return this.area() < fig.area();

}

}//Fin de la clase abstracta Figura


EDA2004/2005

public class Circulo extends Figura {

public Circulo( double radio ) {

super(radio, radio, "Circulo");

}

public double area( ){

return Math.PI * super.dim1 * super.dim1;

}

public double perimetro( ){

return 2 * Math.PI * super.dim1;

}

}// fin de la clase Circulo


3/18


EDA2004/2005

public class Rectangulo extends Figura {

public Rectangulo( double alto, double ancho ){

super(alto , ancho, "Rectangulo" );

}

public double area( ) {

return super.dim1 * super.dim2;

}

public double perimetro( ) {

return 2 * ( super.dim1 + super.dim2 );}

}


EDA2004/2005

public class Cuadrado extends Rectangulo {

// como hereda de Rectangulo, no hace falta definir en ella

// perimetro o area.

public Cuadrado( double lado ) {

// recordar que hereda de Rectangulo

super( lado, lado );

//cuando se ejecuta, el nombre del Cuadrado es Rectangulo

// ¿Qué podemos hacer para modificar el nombre y poner Cuadrado?

super.nombre="Cuadrado";

}

}// fin de la clase Cuadrado


4/18


EDA2004/2005

//Trabajamos con una colección (array) de 3 figuras que seleen de pantalla:

// * Mostrarlas por pantalla

// * Calcular el área de toda la colección

// * Ordenarlas por área (con Inserción Directa) UTILIZANDOun método genérico

import java.io.*;

// Para el formateo de los double en el método que obtiene el

// área total

import java.text.*;

//para utilizar el método genérico deOrdenacion insercionDirecta

import Miscelanea.Ordenacion;


EDA2004/2005

public class TestFigura{

private static BufferedReader teclado;

private static Figura leerFigura() t hr ows I OExc ept i on {

String tipo="";

Figura instanciaLeida = null;

do {

System.out.println("\nIntroduzca Circulo o Rectangulo o

Cuadrado");

tipo = teclado.readLine();

} while (!tipo.equals("Circulo") && !tipo.equals("Rectangulo")

&& !tipo.equals("Cuadrado") );


5/18


EDA2004/2005

switch (tipo.charAt(0)) {

case 'C':{System.out.println("\nPara leer Circulo,introduzca el radio");

double radio = leerDouble();

instanciaLeida = new Circulo(radio);} break;

case 'R': {System.out.println("\nPara leer Rectangulo,introduzca EN LINEAS SEPARADAS Alto y Ancho");

double alto = leerDouble();

double ancho = leerDouble();

instanciaLeida = new Rectangulo(alto , ancho);} break;

case 'S': {System.out.println("\nPara leer Cuadrado,introduzca el lado");

double lado = leerDouble();

instanciaLeida = new Cuadrado(lado);} break;

} //fin del switch

return instanciaLeida;

}// fin de leerFigura


EDA2004/2005

private static int leerEntero() t hr ows IOException { boolean hayerror=true;int num=0;

do {t r y {System.out.print("\nIntroduzca el numero de figuras: ");

num = Integer.parseInt(teclado.readLine());hayerror=false;}

c a t c h ( NumberFormatException eUnchecked){// intento de convertir una cadena que no tiene el formato adecuada// en un determinado tipo numérico// catch: captura excepciones (un objeto throwable; ej. eUnchecked)

System.out.println("Atento: no has tecleado un entero");}

} while (hayerror);return num;

} // fin de leerEntero;


6/18


EDA2004/2005

private static double leerDouble() throws IOException {

boolean hayerror=true;double num=0.0;

do{

t r y {

num = new Double(teclado.readLine()).doubleValue();

hayerror=false;

}

c a t c h ( NumberFormatException eUnchecked){

System.out.println("Atento: no has tecleado un double")

}

} while (hayerror);return num;

} // fin de leerDouble;


EDA2004/2005

public static double AreaFiguras( Figura conjunto[ ] ){double total = 0;for( int i = 0; i < conjunto.length ; i++ ){

if( conjunto[ i ] != null )total += conjunto[ i ].area( );

}

return total;}

public static void muestraFiguras( Figura conjunto[ ] ){for( int i = 0; i < conjunto.length ; i++ )

System.out.print((conjunto[ i ]) );System.out.println();

}


7/18


EDA2004/2005

public static void ordenarFigurasPorArea( Figura conjunto[ ] ){for( int i = 1; i < conjunto.length ; i++ ) {

Figura figAInsertar = conjunto[i];int posIns = i ;// Búsqueda del lugar de insercion ordenada;// desplazar mientras NO se encuentre

for( ; posIns > 0 &&figAInsertar.menorQue(conjunto[posIns-1]) ; posIns--)

conjunto[posIns] = conjunto[posIns - 1];

// Insercion en posInsconjunto[posIns] = figAInsertar;

}

}//fin de ordenarFigurasPorArea

//OJO: MODIFICACIONES **************************************// No hace falta implementar un nuevo código de Inserción Directa que// ordene Figuras por area. Basta con reutilizar el código genérico// de Inserción Directa de la clase, también genérica, Ordenación


EDA2004/2005

public static void main( String [ ] args ) {// Lectura desde teclado:// (1) del numero de figuras de la colección y

// (2) de las figuras del array de Figura's colección.// Atentos a las IOExcepction y NumberFormatException

t r y {teclado = new BufferedReader(new InputStreamReader(System.in));int numLeido =0;int numFiguras = leerEntero();

// representación con arrayFigura coleccion[ ] = new Figura[numFiguras];

//Lectura de las numFiguras: se controla el NumberFormatExceptionfor ( int i=0 ; i < numFiguras ; i++) {

Figura instancia = leerFigura();coleccion[ i ] = instancia;

}System.out.println( "\nColeccion de Figuras que se maneja"); muestraFiguras( coleccion );


8/18


EDA2004/2005

...// creacion de la variable numConFormato; NumberFormat numConFormato = NumberFormat.getInstance();

numConFormato.setMinimumFractionDigits(2);numConFormato.setMaximumFractionDigits(2);System.out.println( "\nArea de todas las figuras = " +

numConFormato.format(AreaFiguras(coleccion)));

// Eliminada al implementar Compar abl e :ordenarFigurasPorArea(coleccion);// Se substituye por la llamada al método insercionDirecta, estático// y genérico de la clase, también genérica, Ordenacion/* Ordenacion.insercionDirecta(coleccion);*/// Alternativamente, sin la directiva import Miscelanea.Ordenacion

// Miscelanea.Ordenacion.insercionDirecta(coleccion);System.out.println( "\nColeccion de Figuras ordenadas por area"); muestraFiguras( coleccion );

}c a t c h (IOException electura) {

System.out.println("Problema con Input: "+electura);}

} //fin del main}//fin del test


EDA2004/2005

Herencia: clase derivada

n Hereda atributos y métodos de la clase base

n Puede añadir nuevos atributos y métodos

n Puede sobrescribir métodos de la clase base

n Debe definir su(s) propio(s) constructor(es)

Regla de visibilidad:

n Privado/private: sólo para los métodos de la clase base, NO para lasclases derivadas

n Protegido/protected: privado excepto para las clases derivadas (+ lasdel mismo paquete/package)

Clases derivadas y regla de visibilidad


9/18


EDA2004/2005


public Circulo( double radio ) {super(radio, radio, "Circulo");

}

public double area( ){

return Math.PI * super.dim1 * super.dim1;

}

public double perimetro( ){

return 2 * Math.PI * super.dim1;

}

}// fin de la clase Circulo


EDA2004/2005

Método abstracto:n Declarado pero no implementadon Definido en una clase derivada

Clase abstracta:n Clase con un(os) método(s) abstracto(s)

n No se pueden crear objetos (concretos) de la clase (abstracta)n Su constructor utilizado desde la(s) clase(s) derivada(s)

public abstract class Figura {//Atributos protected double dim1; protected double dim2; protected String nombre;

public abstract double area( );

public abstract double perimetro( );

...}

Métodos y clases abstractas


10/18


EDA2004/2005

Método final:

n

Permanece invariante (no se puede sobrescribir)n La llamada al método se resuelve a tiempo de compilación y No

en tiempo de ejecución (tipado estático)

final public boolean menorQue( Figura fig){

return this.area() < fig.area();

}

Clase final:

n NO puede ser extendida

n Todos los métodos son finales

public final class Integer extends Number implements Comparable {

...

}

Métodos y clases finales


EDA2004/2005

Interfaz:

n Clase abstracta que contiene sólo

n Métodos abstractos ( public abstract)

n Constantes ( public static final)

public interface Comparable {// NO hay atributos

public int compareTo( Object o );

}

public class Number implements Comparable {

...

}

Interfaces


11/18


EDA2004/2005

Herencia múltiple:n NO soportada directamente

n Con interfaces

public class Tablahash implements Comparable, Hashable {

...

}

Ejercicio.

clase Estudiante, clase Empleado: clase EstudianteEmpleado

Interfaces y herencia múltiple


EDA2004/2005

Programación genérica: a partir de la herencia

package Miscelanea;// Clase Ordenacion: contiene todos losmétodosde ordenación de un array estudiados// hasta la fecha, estáticos, PERO implementadoscomo genéricos. public class Ordenacion { public static void insercionDirecta( Obj e c t secuencia[ ] ){

for( int i = 1; i < secuencia.length ; i++ ) {Comparable elemAInsertar =(Comparable)secuencia[i];int posIns = i ;// Búsqueda del lugar de insercion ordenada;// desplazar mientras NO se encuentrefor( ; posIns > 0 &&elemAInsertar.compareTo((Comparable)secuencia[posIns-1]) == -1;

posIns--)secuencia[posIns] = secuencia[posIns - 1];// Insercion en posInssecuencia[posIns] = elemAInsertar;

}}//fin de insercionDirecta sobre un array de Comparable

}

Programación Genérica


12/18


EDA2004/2005

public abstract class Figura implements Comparable {//Atributos protected double dim1; protected double dim2; protected String nombre;

//Métodos: véase antes//OJO: MODIFICACIONES**********************************************// 1.- ya NO hace falta definir menorQue: se implementa Comparable

/*final public boolean menorQue( Figura fig){return this.area() < fig.area(); }*/

// 2.- compareTo es el único método del interface Comparable.

public int compareTo( Object o ) {// Object: superclase definida en java.lang

Figura laotraFigura = (Figura) o;// conversión de restricción (casting): operador de conversión

double diff = this.area( ) - laotraFigura.area( );if( diff == 0 ) return 0;

else if( diff < 0 ) return -1;else return 1;

}


EDA2004/2005

Polimorfismo (comprobación tipos en tiempo de compilación)+enlace dinámico (tipado dinámico)

n Conversión de ampliación:

referencia a superclase = referencia clase derivadan Conversión de restricción: viceversa, con casting/* Diferencia entre DECLARACION de una referencia e INSTANCIACION de un

objeto al que se refiere la referencia */

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

Rectangulo rect = new Rectangulo(2,3);System.out.println("Area del rectangulo:\t "+rect.toString());Circulo circ= new Circulo(2);System.out.println("Area del circulo:\t "+circ.toString());

Figura fig;fig=rect; // conversión de ampliaciónSystem.out.println("Area de la figura rectangulo:"+fig.toString());fig=circ;System.out.println("Area de la figura circulo: "+fig.toString());

}

}

Polimorfismo y enlace dinámico


13/18


EDA2004/2005

//Comprobación de tipado dinámico: operador instanceof public class Prueba3{

public static void main(String args[]){Figura frect = new Rectangulo(2,3);Figura fcirc1= new Circulo(2);Figura fcirc2= new Circulo(4);Figura coleccion[] = new Figura [3] ;coleccion[0] = frect;coleccion[1] = fcirc1;coleccion[2] = fcirc2;System.out.println("¿cuantos circulos hay en la coleccion?");

int numcirculos=0;for( int i = 0; i < coleccion.length ; i++ ){

Figura fig= coleccion[i];if (fig instanceof Circulo) {

System.out.println( fig.toString()); numcirculos++;

}}System.out.println("Hay "+numcirculos+" circulos");

}}


EDA2004/2005

//Para representación enlazada de una secuencia de figuras:atributo ENLACE public abstract class Figura {

//Atributos protected double dim1; protected double dim2; protected String nombre;// NUEVO ATRIBUTO para poder enlazar PRIVADO (se añade consultora)

private Figura sig;//Métodos: véase antes//constructor que UNICAMENTE puede ser invocado por la subclases

public Figura(double dim1,double dim2,String nombre, Figura sig){this.dim1 = dim1; this.dim2 = dim2; this.nombre = nombre;this.sig = sig;

}//Consultora del atributo sig public Figura siguiente(){

return (this.sig);}

}

Representación enlazada


14/18


EDA2004/2005


public Circulo( double radio, Figura sig ) {

super(radio, radio, "Circulo", sig);

}

...

}

public class Rectangulo extends Figura {

public Rectangulo( double alto, double ancho, Figura sig ){

super(alto , ancho, "Rectangulo", sig);

}...

}


EDA2004/2005

public class Prueba3{

public static void main(String args[]){

//Construcción de una colección

//Inicialización: colección ENLAZADA vacía

Figura coleccion = null;

//Inserción en cabeza de figuras diversascoleccion = new Rectangulo(2,3,coleccion);

coleccion = new Circulo(4,coleccion);

coleccion = new Circulo(2,coleccion);

coleccion = new Cuadrado(2,coleccion);

// ¿ Quién es el último de la coleccion ?: Recorrido de la coleccion

// ENLAZADA para mostrar el orden de inserción en cabeza

System.out.println("Coleccion figuras, en orden de creacion");

for( Figura i = coleccion; i != null ; i = i.siguiente())

System.out.print( i.toString());


15/18


EDA2004/2005

... System.out.println("¿cuantos circulos hay en la coleccion?");

int numcirculos=0;

for( Figura i = coleccion; i != null ; i = i.siguiente() ){

Figura fig= i;

if (fig instanceof Circulo) {

System.out.print( fig.toString());

numcirculos++;

}

}

System.out.println("Hay "+numcirculos+" circulos");

}}


EDA2004/2005

Excepción:

n Condición anormal/excepcional durante la ejecución de un

segmento de código

n Objeto (Throwable)java.lang.Object

java.lang.Throwable

java.lang.Exception

subclases de Excepción: e.g. IOException NumberFormatException

que se envía al causante de la excepción que puede:n No tratarla (el sistema da un error)

n No tratarla pero propagarla/lanzarla: throws

(throws: al final de la cabecera del método)

n Después de intentar (try) ejecutar el segmento de código,

capturarla (catch) y tratarla; finalmente, se pueden ejecutar las

instrucciones asociadas a la cláusula finally: try-catch-finally

Excepciones


16/18


EDA2004/2005

Excepción de usuario:

n Excepción propia: se define como clase derivada de dela clase Exception

n Para generar una excepción propia, se crea un objeto dela misma: new

n Para lanzarla: throw (sin ‘s’ final...)

Excepciones de usuario


EDA2004/2005

public class ExcepcionVectorLleno extends Exception {

public vectorLleno (String mensaje){

super(mensaje);}

}

public class vector { private int valores[] private int num;

public vector (int talla) {valores=new int[talla]; num=0;} public void anyadir (int el) t hr ows ExcepcionVectorLleno{

if (num==valores.length)t hr ow new ExcepcionVectorLleno(“Error: el vector está lleno”);

valores[num++]=el;}

}


17/18


EDA2004/2005

try {

...}

catch (Exception e) { // capturo

System.out.println(“La excepción “+e+” puede ser capturaday vuelta a lanzar: como muy tarde deberá ser tratada en el main que no podrá propagarla (throws en la cabecera) nicapturarla (catch) y volverla a lanzar (throw)”);

t hr ow (e); // vuelvo a lanzar

}


EDA2004/2005

public class ExcepcionItemNoValido extends Exception{

public ExcepcionItemNoValido(String mensaje){

super(mensaje);

}

}

public class ExcepcionItemRepetido extends Exception{

public ExcepcionItemRepetido(String mensaje){

super(mensaje);

}

}

public class ExcepcionAgendaLlena extends Exception{

public ExcepcionAgendaLlena(String mensaje){

super(mensaje);

}

}

Excepciones:El ejemplo de la clase agenda


18/18


EDA2004/2005

public class Agenda {static final int MaxItems = 250;

private int numElem; private itemAgenda secuenciaItem[]; public Agenda (){secuenciaItem = new itemAgenda[MaxItems]; numElem= 0;} public void anyadirItem (itemAgenda item) throws ExcepcionAgendaLlena,

ExcepcionItemNoValido, ExcepcionItemRepetido {if(item != null){

if (numElem >= MaxItems)throw new ExcepcionAgendaLlena("Error: no hay más sitio");

if (item.telefono().length() != 9 || item.nombre().length() > 40|| item.nombre().charAt(0) == 0)throw new ExcepcionItemNoValido("Error: : item \""+item+"\“incorrecto");

itemAgenda l = recuperarPorTelefono(item.telefono());if (l != null)

throw new ExcepcionItemRepetido("Error: el teléfono del item \""+item+"\" ya existe");

secuenciaItem [numElem++] = item;}

} // otros métodos }


EDA2004/2005

public class Prueba{

static void main (String args[]){

System.out.println("Prueba de creación de una agenda:\n");

Agenda a = new Agenda();

itemAgenda item;

try {

item = new itemAgenda("1004","Atencion Clientes");

a.anyadirItem(item);

} catch (ExcepcionAgendaLlena e) {System.out.println(e);}catch (ExcepcionItemNoValido e){System.out.println(e);}catch (ExcepcionItemRepetido e){System.out.println(e);}

// etc.

}

}

figuras en java.pdf

Documents