Problema 1. Escribir un programa para calcular el perímetro de una circunferencia siguiendo el diálogo:

radio?__ perímetro=Nº Solución 1. Con programa ad-hoc class Programa{ static public void main(String[]args) throws IOException { double r=U.readDouble(“radio?”); U.println(“perímetro=” + 2*Math.PI*r); } }

Solución 2. Con clase para circunferencias class Circunferencia{ private double r; public Circunferencia(double x){ if(x<=0) U.abortar(“radio<=0”); r=x; } public double perimetro(){ return 2*Math.PI*r; } } class Programa{ static public void main(String[]args) throws IOException{ Circunferencia c=new Circunferencia( U.readDouble(“radio?”)); U.println(“perímetro=” + c.perimetro()); } }

Problema 2. Calcular el área y el perímetro de un círculo Solución 1. Modificar clase Circunferencia agregando método área Solución 2. Usar (y escribir) nueva clase Circulo que:

extienda la clase Circunferencia con método área herede las otras componentes (datos y métodos).

U.println(“Calcular área y perímetro de círculo”); Circulo c=new Circulo(U.readDouble(“radio?”));

//uso de método de clase Circulo U.println(“área=”+c.area()); //uso de método heredado de clase Circunferencia U.println(“perímetro=”+c.perimetro());

//clase base o superior class Circunferencia{ protected double r;//visible en clase y extensiones public Circunferencia(double x){ r=x; if(r<=0) U.abortar(“radio<=0”); } public double perimetro(){ return 2*Math.PI*r; } } //clase extendida o derivada class Circulo extends Circunferencia{ public double area(){ return Math.PI*r*r; } public Circulo(double x){//constructor super(x);//invocar ctor de clase superior } }

class Circulo extends Circunferencia

Circunferencia

perimetro

Circunferencia radio

Circulo

area

Circulo

Problema 3. Calcular área y perímetro de un círculo o un cuadrado Circulo(1) o Cuadrado(2)? __ radio?__ o lado?__ area=Nº perimetro=Nº Programa: int n=U.readInt(“Circulo(1) o Cuadrado(2)?”); if(n==1){ Circulo c=new Circulo(U.readDouble(“radio?”)); U.println(“area=”+c.area()); U.println(“perimetro=”+c.perimetro()); }else if(n==2){ Cuadrado c=new Cuadrado(U.readDouble(“lado?”)); U.println(“area=”+c.area()); U.println(“perimetro=”+c.perimetro()); }else U.abortar(“debe ser 1 o 2”);

Solución 1. Con clases independientesclass Circulo{protected double r;public Circulo(double x){ r=x; if(r<=0) U.abortar(“radio<=0”);}public double area(){return Math.PI*r*r;}public double perimetro(){return 2*Math.PI*r;}} class Cuadrado{protected double a;public Cuadrado x){ a=x; if(a<=0) U.abortar(“lado<=0”);}public double area(){return a*a;}public double perimetro(){return 4*a;}}

Solución 2. Con jerarquía de clasesclass Figura{protected double x;public Figura(double x){ this.x=x; if(x<=0) U.abortar(“<=0”);}} class Circulo extends Figura{public Circulo(double x){super(x);}public double area(){return Math.PI*x*x;}public double perimetro(){return 2*Math.PI*x;}} class Cuadrado extends Figura{public Cuadrado(double x){super(x);}public double area(){return x*x;}public double perimetro(){return 4*x;}}

Solución 3. Con métodos ficticios (redefinidos en extensiones) class Figura{ protected double x; public Figura(double x){ this.x=x; if(x<=0) U.abortar(“<=0”); } public double area(){return 0;} public double perimetro(){return 0;} } Corolario. Programa usuario más breve Figura f; switch( U.readInt(“Circulo(1) o Cuadrado(2)?”) ){ case 1: f=new Circulo(U.readDouble(“radio?”)); break; case 2: f=new Cuadrado(U.readDouble(“lado?”)); break; default: U.abortar(“1 o 2”); } U.println(“area=”+f.area()); U.println(“perimetro=”+f.perimetro());

Enlace Dinámico (dynamic binding) f=new Circulo(…); f=new Cuadrado(…); referencia a objeto de clase Figura puede apuntar también a objetos de

clase extendidas Circulo y Cuadrado objeto de clase extendida es un objeto de clase base (círculos y

cuadrados son figuras) f.area() si f apunta a un objeto de clase Cuadrado, se invoca método area de clase Cuadrado Circulo , se invoca método area de clase Circulo x objeto clase Cuadrado

f referencia clase x objeto clase

Figura Circulo

Solución 4: Con clase abstracta que obliga a redefinir métodos

abstract class Figura{protected double x;public Figura(double x){ this.x=x; if(x<=0) U.abortar(“debe ser >0”);}abstract public double area();abstract public double perimetro();}Notas•no permite crear objetos, no admite new Figura()•debe tener al menos un método abstracto:

abstract encabezamiento;•obliga a clases extendidas a redefinir métodos abstractos•permite definir otras figuras

class Rectangulo extends Figura{protected double y;public Rectangulo(double x,double y){ super(x); this.y=y; if(y<=0) U.abortar(“<=0”);}public double area(){return x*y;}public double perimetro(){return 2*(x+y);}} class Triangulo extends Figura{protected double y,z;public Triangulo(double x,double y,double z){ super(x); this.y=y; this.z=z; if(y<=0 || z<=0 || x+y<=z || x+z<=y || y+z<=x) U.abortar(“no forman triangulo”);}public double perimetro(){return x+y+z;}public double area(){ double s=(x+y+z)/2; return Math.sqrt(s*(s-x)*(s-y)*(s-z));}}

Problema . Escriba la clase abstracta Cuerpo y las clases extendidas Cubo, Esfera y Caja para el siguiente programa que permite calcular el volumen y el área de un cubo, una esfera, o una caja (paralelepípedo)

Cuerpo c; switch(U.readInt(“Cubo(1),Esfera(2),o Caja(3)?”)) { case 1: c=new Cubo(U.readDouble(“lado?”)); break; case 2: c=new Esfera(U.readDouble(“radio?”)); break; case 3: c=new Caja(U.readDouble(“largo?”), U.readDouble(“ancho?”), U.readDouble(“alto?”)); break; default: U.abortar(“1, 2 o 3”); } U.println(“volumen=” + c.volumen()); U.println(“area=” + c.area());

Nota. El área de la esfera es 4r2 y el volumen es 4/3r3

abstract class Cuerpo{ protected double x; public Cuerpo(double x){ this.x=x; if(x<=0) U.abortar(“<=0”); } abstract double area(); abstract double volumen(); } class Esfera extends Cuerpo{ public Esfera(double x){super(x);} public double area(){return 4*Math.PI*x*x;} public double volumen(){return Math.PI*x*x*x*4/3;} } class Cubo extends Cuerpo{ public Cubo(double x){super(x);} public double area(){return 6*x*x;} public double volumen(){return x*x*x;} }

class Caja extends Cuerpo{ protected double y, z; public Caja(double x,double y,double z){ super(x); this.y=y; this.z=z; if(y<=0 || z<=0) U.abortar(“<=0”); } public double area(){ return 2*(x*y + x*z + y*z); } public double volumen(){ return x*y*z; } } Nota. Un cubo es también una caja class Cubo extends Caja{ public Cubo(double x){super(x,x,x);} }

Solución 2. Con interface clase base abstracta sólo con métodos implicitamente abstractos sin datos interface Cuerpo { public double area(); public double volumen(); }

class Esfera implements Cuerpo{ protected double r; public Esfera(double x){r=x;} public double area(){ return 4*Math.PI*r*r; } public double volumen(){ return Math.PI*r*r*r*4/3; } } class Cubo implements Cuerpo{ protected double a; public Cubo(double x){a=x;} public double area(){return 6*a*a;} public double volumen(){return a*a*a;} }

class Caja implements Cuerpo{ protected double l,a,h;//largo, ancho y altura public Caja(double x,double y,double z){ l=x; a=y; h=z; if(x<=0 || y<=0 || z<=0) U.abortar(“<=0”); } public double area(){ return 2*(l*a + l*h + a*h); } public double volumen(){ return l*a*h; } } Nota. Un cubo es también una caja class Cubo extends Caja{ public Cubo(double x){super(x,x,x);} }

Object: clase raíz de toda la jerarquía de herencia de Java class Object { //entrega la dir del objeto en memoria //en la forma “NombreClase@nºhexadecimal” (base 16) public String toString(){ return ...; } //entrega true sólo si es el mismo objeto public boolean equals(Object x){ return this==x;//compara referencias } ...//otros métodos }

Toda clase extiende (implícita o explicitamente) a Object class Fraccion extends Object{ protected int a, b; ... //redefinición de métodos de clase Object public String toString(){ return a+”/”+b; } public boolean equals(Object x){ Fraccion f=(Fraccion)x; //casting return a*f.b == b*f.a;//compara objetos } }

casting para considerar x como Fraccion error si x no es de clase Fraccion (o extensión)

Métodos genéricos (aplicables a objetos de distintas clases) //invertir n objetos de arreglo x static public void invertir(Object[]x,int n){ for(int i=0; i<n/2; ++i) intercambiar(x,i,n-i-1); } //intercambiar x[i] con x[j] static public void intercambiar(Object[]x,int i,int j){ Object aux=x[i]; x[i]=x[j]; x[j]=aux; } //mostrar un arreglo de objetos static public void mostrar(Object[]x){ for(int i=0; i<x.length; ++i) U.println(x[i].toString()); } si toString no existe en clase de x[i], se hereda de clase Object se puede escribir sólo U.println(x[i]);

Uso de métodos genéricos //para arreglo de strings String[]s={“C”,”B”,”A”,”B”,”C”}; mostrar(s);invertir(s,s.length);mostrar(s); //para arreglo de fracciones Fraccion[]f={new Fraccion(), new Fraccion(1,2), new Fraccion(“123/4567”), new Fraccion(5)}; mostrar(f);invertir(f,f.length);mostrar(f); //para arreglo heterogeneo Object[]a={“A”,new Fraccion(1/2),”B”}; mostrar(a);invertir(a,a.length);mostrar(a);

Búsqueda (de un objeto en un arreglo de objetos) //buscar objeto x en arreglo y de n objetos //entregar índice de 1ªaparición (–1 si no está) static public int indice(Object x,Object[]y,int n){ for(int i=0; i<n; ++i) if(y[i].equals(x)) return i; return –1; } Uso indice(“A”,s,s.length) entrega 2 indice(new Fraccion(2,4),f,f.length) entrega 1 puesto que f[1] es new Fraccion(1,2) indice(“A”,a,a.length) entrega 0

Comparable: Interface predefinida para clases que admiten comparar objetos interface Comparable{ public int compareTo(Object x); } class Fraccion implements Comparable{ ... //redefinición de compareTo de Comparable public int compareTo(Object x){ Fraccion f=(Fraccion)x; return a*f.b – b*f.a; } } Nota clase String extiende Object e implementa Comparable

Problema. Ordenar un arreglo de n objetos (comparables) encabezamiento static public void ordenar(Comparable[]x,int n) Invocación (ejemplos) String[]s={...}; Fraccion[]f={...}; ordenar(s,s.length); ordenar(f,f.length); Situación inicial: arreglo desordenado Situación final: arreglo ordenado

Solución 1. Algoritmo de selección y reemplazo/intercambio Repetir n veces seleccionar el menor intercambiar menor con el primero ¿situación intermedia (invariante)? ip im ip: índice del primero (de los que aún están desordenados) im: índice del menor (entre los desordenados) Si se intercambia x[ip] con x[im] y se avanza ip, entonces la invariante se restablece (mantiene)

static public void ordenar(Comparable[]x,int n){ //repetir n veces for(int ip=0; ip<n; ++ip)//para ip=0,...,n-1 { //seleccionar el (indice del) menor int im=ip; for(int i=ip+1; i<n; ++i) if(x[i].compareTo(x[im])<0) im=i; //intercambiar menor con el primero intercambiar(x,im,ip); } } Algoritmo O(n2) las n iteraciones realizan n-1, n-2, ..., 1 comparaciones total de comparaciones: i, para i=1,...,n-1=n(n-1)/2=n2/2 - n/2 orden de magnitud: n2 ej, si n=100, se realizan del orden de 10.000 comparaciones

Búsqueda secuencial para arreglo ordenado: O(n), pero peor caso realiza en promedio n/2 (y no n) comparaciones int indice(Comparable x,Comparable[]y,int ip,int iu){ //recorrer todos los índices (de 1º a último) for(int i=ip; i<=iu; ++i){ //si y[i]=x, devolver índice i int c=y[i].compareTo(x); if(c==0) return i; //si y[i]>x, no está (pq y está ordenado) if(c>0) break; } return –1; } recursivamente if(ip>iu) return –1; int c=y[ip].compareTo(x); if(c==0) return ip; return c>0? -1: indice(x,y,ip+1,iu);

Problema. Programar el algoritmo de búsqueda binaria (para buscar eficientemente en arreglo ordenado)

encabezamiento static public int indice( Comparable x,Comparable[]y,int ip,int iu) ¿algoritmo? Comparar x con elemento que está en la mitad del arreglo y Si son iguales, devolver índice de mitad Si x es menor, buscar en primera mitad del arreglo (descartando segunda mitad) Si x es mayor, buscar en segunda mitad del arreglo

(descartando primera mitad) Repetir mientras queden elementos. Devolver –1 si x no está en arreglo y.

static public int indice (Comparable x,Comparable[]y,int ip,int iu){ //repetir mientras queden elementos while(ip<=iu){ //comparar x con elemento que está en la mitad

int im=(ip+iu)/2; //indice del medio int c=x.compareTo(y[im]); //si son iguales, devolver índice de mitad if(c==0) return im; //si x es menor, buscar en 1ª mitad del arreglo if(c<0) iu=im–1;//”subir” índice del último //si x es mayor, buscar en 2ª mitad del arreglo else ip=im+1;//”bajar” índice del primero } //devolver –1 si x no está en arreglo y. return –1; }

Ejemplo de uso: static public void main(String[]args){ String[]mes={“abril”,...,”septiembre”}; String[]month={“april”,..., “september”}; int i=indice(args[0],mes,0,mes.length-1); U.println( i<0? “mes incorrecto”: month[i]); } invocación java TraducirMes mayo may java TraducirMes martes mes incorrecto