CURSO: PROGRAMACIÓN AVANZADA

PRÁCTICA DE LABORATORIO 05
OBJETIVO: Afianzar los conocimientos del siguiente tema.
 Herencia, clases abstractas, interfaces

PROGRAMAS BASE:

Labo05Anidadas.java

package progavanzada;
public class Labo05Anidadas
{

public Labo05Anidadas()
{

}//Fin del constructor

public String getInformacion()

{
FiguraGeometrica fg = new FiguraGeometrica
(12 , 10, 14, 12);
return "Area del objeto " + fg.getArea() + "\nPerimetro del
objeto: " + fg.getPerimetro()
+ "\nVolumen del objeto: " + fg.getVolumen();
}//Fin de getInformacion

//___________________________________________________
//Clases anidadas

abstract class Geometrica

{//Una clase abstracta también se puede usar como un origen de
variables en las cuales guardar datos y así no tener que
declararlas.
int vAltura, vBase;
int vLado,vAncho;

public Geometrica()
{
vAltura=0;
vBase=0;
vLado=0;
vAncho=0;
}//Fin del constructor

public abstract int fArea(int altura, int base);

}//Fin del class Geometrica

//--------------------------------------------------------------------------------------

class PerimetroArea extends Geometrica

{

public int fArea(int altura, int base)//metodo heredado de Area

{
vAltura = altura;
vBase = base;
return vAltura * vBase;
}//Fin de fArea

public int fPerimetro(int medida_de_un_lado)//Método propio de

esta clase
{
vLado = medida_de_un_lado;
return vLado * 4;
 }

public int fVolumen (int altura, int base, int ancho)

{
vBase = base;
vAltura = altura;
vAncho = ancho;
return vBase * vAltura * vAncho;
}//Fin de fVolumen

}//Fin del class PerimetroArea

//-----------------------------------------------------------------------------------

interface Getters
{
public void setBase(int nueva_base);
public int getBase();
public void setAltura(int nueva_altura);
public int getAltura();
public void setAncho(int nuevo_ancho);
public int getAncho();
public void setLado(int nuevo_lado);
public int getLado();

public int getArea();

public int getPerimetro();
public int getVolumen();
}//Fin de la interface Getters
//-----------------------------------------------------------------------------------

class FiguraGeometrica extends PerimetroArea implements

Getters
{
 //Constructor para cargar todo.
public FiguraGeometrica(int nueva_base, int nueva_altura, int
nuevo_ancho, int nuevo_lado)
{//Cargando todas las propiedades.
setBase(nueva_base);
setAltura(nueva_altura);
setAncho(nuevo_ancho);
setLado(nuevo_lado);
}//Fin del cosntructor

//Implementaciones de la interface Getters

public int getVolumen()

{
return fVolumen (getAltura(), getBase(), getAncho());
}//Fin de getVolumen

public void setBase(int nueva_base)

{
vBase=nueva_base;
}//Fin de setBase
public int getBase(){ return vBase;}//Fin de getBase

public void setAltura(int nueva_altura)

{
vAltura = nueva_altura;
}//Fin de setAltura
public int getAltura(){return vAltura;}//Fin de getAltura

public void setAncho(int nuevo_ancho)

{
vAncho = nuevo_ancho;
}//Fin de setAncho
public int getAncho(){return vAncho;}//Fin de getAncho
 public void setLado(int nuevo_lado)
{
vLado = nuevo_lado;
}//Fin de setLado
public int getLado(){ return vLado;}//Fin de getLado

public int getArea()

{
return fArea(getAltura(), getBase() );
}//Fin de getArea
public int getPerimetro()
{
return fPerimetro (getLado() );
}//Fin de getPerimetro

//*****************************************

//implementaciones de la clase PerimetroArea.

public int fArea(int altura, int base)//metodo heredado de Area

{
return altura * base;
}//Fin de fArea

public int fPerimetro(int medida_de_un_lado)//Metodo propio de

esta clase
{
return medida_de_un_lado * 4;
}

public int fVolumen (int altura, int base, int ancho)

{
return altura * base * ancho;
}//Fin de fVolumen
//*******************************************

}//Fin del class FiguraGeometrica

//___________________________________________________

}//Fin del class Labo05Anidadas

Labo05main.java

package progavanzada;

public class Labo05main {

public static void main(String[] args) {

Labo05Anidadas x = new Labo05Anidadas();
String z = x.getInformacion();
System.out.println(z);
}
}
EJERCICIO:

Defina una clase abstracta aviones, con dos métodos despegar y aterrizar.

Defina una interface vuelos, con dos constantes, una para máxima velocidad 1500 y otra
para mínima velocidad 1000. Además, el método abstracto cinturones.

Defina una clase Boeing747 que sea hija de aviones e implemente la interfase vuelos.
Que tenga como atributos el peso y el estado del aeropuerto. Además, defina los
métodos abstractos heredados. Para poder despegar el peso debe ser menor a 180 y el
aeropuerto debe estar libre. Para poder aterrizar el aeropuerto debe estar libre y la
velocidad menor a 1000. En caso de ser la velocidad mayor a 1000 se debe indicar que
los cinturones deben asegurarse.

Defina una clase Hércules que sea hija de aviones e implemente la interfase vuelos. Que
tenga como atributos el peso y el estado del aeropuerto. Además, defina los métodos
abstractos heredados. Para poder despegar el peso debe ser menor a 160 y el
aeropuerto debe estar libre. Para poder aterrizar el aeropuerto debe estar libre y la
velocidad menor a 1500. En caso de ser la velocidad mayor a 1500 se debe indicar que
los cinturones deben asegurarse.

Para realizar las pruebas defina una clase principal en la que se cree dos aviones, uno
Hércules y otro Boeing; y se pida al usuario que ingrese el peso de cada avión y el estado
del aeropuerto. El usuario determinara si se encuentra volando o por despegar. Si el
avión está volando se deberá ingresar la velocidad. A partir de los datos ingresados hacer
el análisis si puede o no despegar o aterrizar y si se deben o no asegurar los cinturones.