Informe Poo

E.P.N
Programacion Orientada a Objetos

Proyecto del Segundo Bimestre

Nombre: JAIME GUZMAN
Fecha: 12/Ene/2010

Se desea desarrollar una aplicación para administrar los puertos del Ecuador, cada uno de los puertos tiene su nombre, una persona administrador
(cédula, nombre, sueldo) y una ciudad de origen (código, nombre y una persona alcalde)
Los puertos almacenan varios contenedores que llegan al país, ellos registran una placa, el peso en toneladas, un precio base por tonelada, un resumen
del contenido y una persona que es el dueño del contenedor.
Los contenedores pueden ser públicos o privados. Los contenedores públicos contienen un porcentaje de exoneración sobre el precio del contenedor
(el precio se calcula multiplicando un precio base de tonelada por el número de toneladas del contenedor).
El precio del contenedor público se calcula descontando el porcentaje de descuento del precio base. El precio del contenedor privado se calcula
sumando el precio base del contenedor por el número de toneladas más un recargo por cantidad de toneladas, esta cantidad de recargo se incrementa en
uno por cada 10 toneladas de peso.
El puerto debe registrar la cantidad de contenedores que existen actualmente en él, y un indicador de pago (cancelado o adeudado).
Se requieren los siguientes informes:
1. Un listado de todos los contenedores con los nombres de los propietarios.
2. Un listado de las placas de los contenedores públicos y privados del puerto.
3. Un total de pagos recibidos por cada puerto.
4. Un total de pagos recibidos por todos los puertos del país.
5. El gobierno desea conocer un listado de todos los contenedores públicos que se encuentran en todos los puertos del país.
6. El gobierno también desea conocer cuánto recibirá de ingresos por los contenedores privados que han ingresado al país.
7. Un listado de todas las cédulas y nombres de los propietarios de los contenedores que adeudan al puerto.
Implementar el ingreso, eliminación y actualización de los contenedores además de las siguientes consultas:
1. Si existe un contenedor y buscarlo por placa
2. Cuáles son los contenedores de un determinado propietario
3. Cuáles son los contenedores existentes en un puerto dado
Realizar un menú para manipular la aplicación y desarrollar los pasos para el diseño de un diagrama de clases.

CLASE APLICACION AplicacionPuerto.java

package puertoEcuador;
import java.io.*;
public class AplicacionPuerto {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

double precioBase= 0;
double arancel = 0;
double descuento = 0;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

CiudadOrigen ciudad = new CiudadOrigen("001","Quito",new Persona("141234234123","alcalde"));
Puerto puerto = new Puerto(new PersonaAdministrador("1721489407","David Guzman",123),ciudad,"Puerto SanBlas");

for(;;){

try{
System.out.println("Ingrese una opcion: n 1 Para setear impuestos y descuentos n 2 Para ingresar a la aplicacionn"+
"3 para buscar por placan 4 para buscar por propietarion 5 para enlistar los contenedoresn");
switch(Integer.parseInt(br.readLine())) {
case 1: {
System.out.println("Ingrese impuestos y descuentos n");
System.out.println("Ingrese el precio base para contenedor[dolares]: n");
precioBase = Double.parseDouble(br.readLine());
System.out.println("Ingrese el descuento para contenedor publico [%]: n");
descuento = Double.parseDouble(br.readLine());
System.out.println("Ingrese el arancel para contenedor privado [dolar/tonelada]: n");
arancel = Double.parseDouble(br.readLine());
break;
}
case 2: {
System.out.println("Ingrese la opcion:n 1 añadir un contenedorn 2 eliminar un contenedorn ");
switch(Integer.parseInt(br.readLine())) {
case 1:{
System.out.println("INGRESAR UN CONTENDEDOR n");
System.out.println(" Presione P para ingesar un contenedor publico" +
" n T para ingresar un contenedor privado");
String opcion = br.readLine();
if(opcion.equals("t") || opcion.equals("T")){

System.out.println("Ingrese un contenedor con el formato:n NOMBRE_DEL_PROPIETARIO;" +
"CEDULA_DEL_PROPIETARIO;PAGADO
(true/false);PESO;PLACA;RESUMEN_DE_CONTENIDOn ");
puerto.addContenedorPrivado(br.readLine(), precioBase, arancel);
}
else if(opcion.equals("p") || opcion.equals("P")) {

System.out.println("Ingrese un contenedor con el formato:n NOMBRE_DEL_PROPIETARIO;" +
"CEDULA_DEL_PROPIETARIO;PAGADO(true/false);PESO;PLACA;RESUMEN_DE_CONTENIDOn ");
puerto.addContenedorPublico(br.readLine(), precioBase, descuento);
}
break;
}
case 2 : {
System.out.println("ELIMINAR UN CONTENDEDOR n Ingrese la placa: n");
puerto.eliminarContenedorPublico(puerto.buscarContenedorPlaca(br.readLine()));
System.out.println("Se ha eliminado correctamente n");
break;
}
case 3 : {
System.out.println("BUSCAR UN CONTENDEDOR n Ingrese la placa: n");
Object o = puerto.buscarContenedorPlaca(br.readLine());
if(o instanceof ContenedorPublico) {
ContenedorPublico aux = (ContenedorPublico)o;
System.out.println(aux.listarParamDeContenedoresPublicos());
}else if(o instanceof ContenedorPrivado) {
ContenedorPrivado aux = (ContenedorPrivado)o;
System.out.println(aux.listarParamDeContenedoresPrivados());
}break;
}
case 4: {
System.out.println("BUSCAR UN CONTENDEDOR n Ingrese el nombre del propietario: n");
Object o = puerto.buscarContenedorNombre(br.readLine());
System.out.println(aux.listarParamDeContenedoresPublicos());
}else if(o instanceof ContenedorPrivado) {
System.out.println(aux.listarParamDeContenedoresPrivados());
}break;
}
case 5: {
System.out.println("ENLISTAR CONTENDEDORES n");
System.out.println(puerto.contenedoresDelPuerto());
break;

}case 6: {
String nombre = null;
String cedula = null;
boolean estado = false;
double peso =0;
String resumen = null;
System.out.println("ACTUALIZAR UN CONTENEDORn Ingrese la placa");
String placa = br.readLine();
System.out.println("Cambiar nombre y/n:n");
if(br.readLine().equals("y")) {
System.out.println("Ingrese nombre: n");
nombre = br.readLine();
}
System.out.println("Cambiar cedulay/n:n");
System.out.println("Ingrese cedula: n");
cedula = br.readLine();
}
System.out.println("Poner en pagado y/n:n");
estado = true;
}
System.out.println("Cambiar peso y/n:n");
System.out.println("Ingrese peso: n");
peso = Integer.parseInt(br.readLine());
}
System.out.println("Cambiar resumen y/n:n");
System.out.println("Ingrese resumen: n");
resumen = br.readLine();
}
puerto.actualizarContenedorPlaca(placa, nombre, cedula, estado, peso, resumen);
break;
}
default: {
System.out.println("No es una opcion validan");
break;
}
}
break;
}
default: {
System.out.println("No es una opcion valida n");
}
}

}catch(IOException e) {
System.out.println(e.getMessage());
}catch(MyException e) {
System.out.println(e.getMessage());
}catch(NumberFormatException e) {
System.out.println("Error en el ingreso " + e.getMessage());
}

}

}

}

CLASE PUERTO Puerto.java


import java.util.*;
/**
* La clase define objetos del tipo <code>Puerto</code>
*
* @author davidGuzman
* @version 1.0
*/
public class Puerto {

String nombre;
CiudadOrigen ciudadOrigen;
PersonaAdministrador administrador;

/*Contiene los contenedores publicos del puerto*/
ArrayList<ContenedorPublico> contenedoresPublicos;

/*Contiene los contenedores privados del puerto*/
ArrayList<ContenedorPrivado> contenedoresPrivados;

/**
* Constructor con los siguientes parametros
*
* @param administrador
* @param ciudadOrigen
* @param nombre
*/
public Puerto(PersonaAdministrador administrador,
CiudadOrigen ciudadOrigen, String nombre) {

this.administrador = administrador;
this.ciudadOrigen = ciudadOrigen;
this.nombre = nombre;
contenedoresPublicos = new ArrayList<ContenedorPublico>();
contenedoresPrivados = new ArrayList<ContenedorPrivado>();
}

/**
* @return the nombre
*/
public String getNombre() {

return nombre;
}

/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {

}

/**
* El metodo calcula la cantidad de contenedores existentes en el
* arrayList de <code>Contenedor</code>
*
* @return cantidadContenedores
*/
public int calcularCantidadDeContenedores() {

int cantidadContenedores=0;
for(Iterator<ContenedorPublico>i = contenedoresPublicos.iterator(); i.hasNext(); ) {

cantidadContenedores++;
}

for(Iterator<ContenedorPrivado>i = contenedoresPrivados.iterator(); i.hasNext(); ) {

cantidadContenedores++;
}

return cantidadContenedores;
}

/**
* El metodo lista la placa del contenedor, la cedula del propietario
* y el nombre del propietario
*
* @return String
*/
public String listarContenedorPropietario() {

String contenedorDueño = new String();
for(Iterator<ContenedorPublico>i = contenedoresPublicos.iterator(); i.hasNext();) {

contenedorDueño += i.next().toStringContenedorPropietario();
}
for(Iterator<ContenedorPrivado>i = contenedoresPrivados.iterator(); i.hasNext();){

contenedorDueño+= i.next().toStringContenedorPropietario();
}
return contenedorDueño;
}

/**
* El metodo retorna un String con el numero de placa
* de cada contenedor añadiendo un retorno de carro
*
* @return String placas
*/
public String listarPlacas() {

String placas = new String();

placas+= "Placa publico: "+i.next().placa + "n";
}
for(Iterator<ContenedorPrivado>i = contenedoresPrivados.iterator(); i.hasNext();) {

placas+= "Placa privado: "+i.next().placa + "n";
}
return placas;

}

/**
* El metodo calcula el total de pagos realizados en el puerto
* sumando el precio total de cada contenedor
*
* @return pagos
*/
public double calcularTotalPagosxPuerto() {

double pagos=0;

ContenedorPublico aux = i.next();
if(aux.estadoContenedor) {
pagos+= aux.calcularPrecioTotal();
}

}
ContenedorPrivado aux = i.next();
}
}
return pagos;
}

/**
* El metodo devuelve una lista de los contenedores publicos
*
* @return contenedores es un String con la placa, peso, precio del contenedor
*/
public String listarContenedoresPublicos() {

String contenedores = new String();
for(Iterator<ContenedorPublico>i=contenedoresPublicos.iterator();i.hasNext();) {
contenedores += "placa: "+aux.placa+" "+"peso: "+aux.peso+" "+"Precio total: "+aux.calcularPrecioTotal()+"n";
}
return contenedores;
}

/**
* El metodo calcula el total de pagos realizados en el puerto
* sumando el precio total de cada contenedor privado

*
* @return pagos
*/
public double calcularIngresosContenedoresPrivados() {

double pagos=0;
}
}
return pagos;
}

/**
* El metodo hace una lista en un String de las personas que
* adeudan un contenedor mas la placa del contenedor
*
* @return deudores String to
*/
public String nombresDeudores() {
String deudores = new String();
deudores += "Nombre: "+aux.propietario.nombre +" "+"Placa: "+aux.placa +"n";
}
}
deudores += "Nombre: "+aux.propietario.nombre +" "+"Placa: "+aux.placa +"n";
}
}
return deudores;
}

/**
* El metodo hace una lista en un String de las personas que
* adeudan un contenedor mas la placa del contenedor
*
* @return deudores String to
*/
public String cedulasDeudores() {

String deudores = new String();
deudores += "Cedula: "+aux.propietario.cedula +" "+"Placa: "+aux.placa +"n";
}
}
deudores += "Cedula: "+aux.propietario.cedula +" "+"Placa: "+aux.placa +"n";
}
}
return deudores;
}

/**
* El metodo añade un contenedor, tomando como parametros un string
* al cual se lo separa en tokens para tener los atributos de un objeto
* de la clase <code>ContenedorPublico</code>
*
* @param contenedor es un String que será separado
* @param precioxTon
* @param exoneracion
* @throws MyException
* @throws NumberFormatException
*/
public void addContenedorPublico(String contenedor, double precioxTon, double exoneracion) throws MyException,NumberFormatException {

StringTokenizer stk = new StringTokenizer(contenedor,";");

if(stk.countTokens()==6) {

Persona persona = new Persona(stk.nextToken(),stk.nextToken());
String aux = stk.nextToken();
if(!aux.equals("true")&&!aux.equals("false")){

throw new MyException("Error en el ingreso de estado de contenedor debe ser true o false");
}else {
ContenedorPublico cp = new
ContenedorPublico(persona,Boolean.parseBoolean(aux),Double.parseDouble(stk.nextToken()),stk.nextToken(),stk.nextToken(),precioxTon,exoneracion);
if(!existeContenedor(cp)) {
contenedoresPublicos.add(cp);
}else {
throw new MyException("Error el contenedor ya existe");
}

}

}else {
throw new MyException("Error en el ingreso de delimitadores");
}

}

/**
* El metodo añade un contenedor, tomando como parametros un string
* al cual se lo separa en tokens para tener los atributos de un objeto
* de la clase <code>ContenedorPrivado</code>
*
* @param contenedor es un String que será separado
* @param precioxTon
* @param recargoxTon
* @throws NumberFormatException
*/
public void addContenedorPrivado(String contenedor, double precioxTon, double recargoxTon) throws MyException,NumberFormatException {

StringTokenizer stk = new StringTokenizer(contenedor,";");

if(stk.countTokens()==6) {

Persona persona = new Persona(stk.nextToken(),stk.nextToken());
String aux = stk.nextToken();
if(!aux.equals("true")&&!aux.equals("false")){

throw new MyException("Error en el ingreso de estado de contenedor debe ser true o false");
}else {
ContenedorPrivado cp = new
ContenedorPrivado(persona,Boolean.parseBoolean(aux),Double.parseDouble(stk.nextToken()),stk.nextToken(),stk.nextToken(),precioxTon,recargoxTon);
if(!existeContenedor(cp)) {
contenedoresPrivados.add(cp);
}else {
throw new MyException("El contenedor ya existe");
}

}

}else {
throw new MyException("Error en el ingreso de delimitadores");
}
}

/**
* El metodo comprueba si un objeto tiene alguna correspondencia
* con un contenedor ya sea publico o privado
*
* @param o objeto a ser comprobado a traves de coincidiencia de la placa
* @return boolean true para confirmar la existencia de un contenedor
*/
public boolean existeContenedor(Object o) {

if(o instanceof ContenedorPublico || o instanceof ContenedorPrivado) {
if(aux.placa.equals(i.next().placa)) {
return true;
}
}
return true;
}
}
}
else if(o instanceof ContenedorPrivado) {
return true;
}
}
return true;
}
}
}
}return false;
}

/**
* EL metodo elimina un contenedor verificando si este existe
*
* @param o es un objeto de la clase <code>Object</code>
*/
public void eliminarContenedorPublico(Object o) throws MyException {

if(existeContenedor(o)) {

contenedoresPublicos.remove(o);
contenedoresPrivados.remove(o);
}else {
throw new MyException("No existe el contenedor");
}
}

/**
* El metodo busca un contendor por su placa y lo devuelve
*
* @param placaBuscada
* @return
*/
public Object buscarContenedorPlaca(String placaBuscada) {

if(aux.placa.equals(placaBuscada)) {
return aux;
}
}

return aux;
}
}
return null;
}

/**
* El metodo busca un contenedor por el nombre de su propietario y lo devuelve
*
* @param nombre es el nombre del propietario del contenedor
* @return Object
*/
public Object buscarContenedorNombre(String nombre) {

if(aux.propietario.nombre.equals(nombre)) {
return aux;

}
}

if(aux.propietario.nombre.equals(nombre)) {
return aux;
}
}
return null;
}

/**
* El metodo busca un contendor por su placa y lo devuelve
*
* @param placaBuscada
* @return
*/
public void actualizarContenedorPlaca(String placaBuscada,String nombre,
String cedula,boolean estado, double peso,
String resumen) {

if(nombre!=null){
aux.propietario.setNombre(nombre);
}else if(cedula!=null) {
aux.propietario.setCedula(cedula);
}else if(estado==true || estado==false) {
aux.setEstadoContenedor(estado);
}else if(peso!=0) {
aux.setPeso(peso);
}else if(resumen!=null) {
aux.setResumen(resumen);
}
}
}

if(nombre!=null){
aux.propietario.setNombre(nombre);
}else if(cedula!=null) {
aux.propietario.setCedula(cedula);

}else if(estado==true || estado==false) {
aux.setEstadoContenedor(estado);
}else if(peso!=0) {
aux.setPeso(peso);
}else if(resumen!=null) {
aux.setResumen(resumen);
}

}
}
}

/**
* Devuelve un String con todos los contenedores existentes
*
* @return String
*/
public String contenedoresDelPuerto() {

String cp = new String();
ContenedorPublico con = i.next();
cp+= con.toStringContenedorPropietario()+ con.listarParamDeContenedoresPublicos()+"n";
}

ContenedorPrivado con = i.next();
cp+= con.toStringContenedorPropietario() + con.listarParamDeContenedoresPrivados()+"n";
}
return "Puerto: "+this.nombre+ "n" + cp;
}
}

CLASE CIUDAD ORIGEN CiudadOrigen.java


/**
* La clase define objetos del tipo <code>CiudadOrigen</code>
*
* @version 1.0
*/
public class CiudadOrigen {

/* Atributo que define el codigo de una ciudad*/
private String codigo;

/* Atributo que define el nombre de una ciudad*/
public String nombre;

Persona alcalde;

/**
* Constructor por default
*/
public CiudadOrigen() {

}

/**
* Constructor con tres campos
*
* @param codigo contiene el campo para el atributo <code>codigo</code>
* @param nombre contiene el campo para el atributo <code>nombre</code>
* @param alcalde objeto de la clase <code>Person</code>
*/
public CiudadOrigen(String codigo, String nombre, Persona alcalde) {

this.codigo = codigo;
this.alcalde = alcalde;
}

/**
* Constructor copia
*
* @param nuevaCiudad objeto de la clase <code>CiudadOrigen</code>
*/

public CiudadOrigen(CiudadOrigen nuevaCiudad) {

this.codigo = nuevaCiudad.codigo;
this.nombre = nuevaCiudad.nombre;
this.alcalde = nuevaCiudad.alcalde;
}

/**
* Retorna el campo <code>codigo</code>
*
* @return codigo campo que contiene el atributo <code>codigo</code>
*/
public String getCodigo() {

return codigo;
}

/**
* Metodo que setea el campo <code>codigo</code>
*
* @param codigo contiene el campo para el atributo <code>codigo</code>
*/
public void setCodigo(String codigo) {

this.codigo = codigo;
}

/**
* Retorna el campo <code>nombre</code>
*
* @return nombre campo que contiene el atributo <code>codigo</code>
*/

return nombre;
}

/**
* Metodo que setea el campo <code>nombre</code>
*
* @param nombre contiene el campo para el atributo <code>nombre</code>
*/

}

/**
* @return the alcalde
*/
public Persona getAlcalde() {

return alcalde;
}

/**
* @param alcalde the alcalde to set
*/
public void setAlcalde(Persona alcalde) {

this.alcalde = alcalde;
}

}

CLASE Contenedor Contenedor.java


/**
* La clase define objetos del tipo <code>Contenedor</code>
*
* @version 1.0
*/
public class Contenedor {

/*campo que contiene la placa del contenedor*/
protected String placa;

protected double peso;
protected double precioBasexTonelada;
/*campo que contiene el resumen del contenido del contenedor*/
public String resumen;

/*Atributo que define el estado de un contenedor true=pagado false=adeudado*/
protected boolean estadoContenedor;

Persona propietario;

/**

* Constructor con parametros de la clase <code>Contenedor</code>
*
* @param estadoContenedor
* @param peso
* @param placa
* @param precioBasexTonelada
* @param resumen
* @param propietario
*/
public Contenedor(boolean estadoContenedor, double peso, String placa,
double precioBasexTonelada, String resumen, Persona propietario) {

this.estadoContenedor = estadoContenedor;
this.peso = peso;
this.placa = placa;
this.precioBasexTonelada = precioBasexTonelada;
this.resumen = resumen;
this.propietario = propietario;
}

/**
*/
public Contenedor() {

}

/**
* Constructor tipo copia
*
* @param contenedor objeto de la clase <code>Contenedor</code>
*/
public Contenedor(Contenedor contenedor) {

this.placa = contenedor.placa;
this.peso = contenedor.peso;
this.precioBasexTonelada = contenedor.precioBasexTonelada;
this.resumen = contenedor.resumen;
this.estadoContenedor = contenedor.estadoContenedor;
this.propietario = contenedor.propietario;
}

/**
* @return the placa
*/
public String getPlaca() {

return placa;
}

/**
* @param placa the placa to set
*/
public void setPlaca(String placa) {

this.placa = placa;
}

/**
* @return the peso
*/
public double getPeso() {

return peso;
}

/**
* @param peso the peso to set
*/
public void setPeso(double peso) {

this.peso = peso;
}

/**
* @return the precioBasexTonelada
*/
public double getPrecioBasexTonelada() {

return precioBasexTonelada;
}

/**
* @param precioBasexTonelada the precioBasexTonelada to set
*/
public void setPrecioBasexTonelada(double precioBasexTonelada) {

this.precioBasexTonelada = precioBasexTonelada;
}

/**
* @return the resumen

*/
public String getResumen() {

return resumen;
}

/**
* @param resumen the resumen to set
*/
public void setResumen(String resumen) {

this.resumen = resumen;
}

/**
* @return the estadoContenedor
*/
public boolean getEstadoContenedor() {

return estadoContenedor;
}

/**
* @param estadoContenedor the estadoContenedor to set
*/
public void setEstadoContenedor(boolean estadoContenedor) {

this.estadoContenedor = estadoContenedor;
}

/**
* @return the propietario
*/
public Persona getPropietario() {

return propietario;
}

/**
* @param propietario the propietario to set
*/
public void setPropietario(Persona propietario) {

this.propietario = propietario;
}

/**
* El metodo calcula el precio base de un contenedor de
* la clase <code>Contenedor</code>
*
* @return precioBase es el precio que se paga por cada tonelada
*/
public double calcularPrecioBase() {

return this.peso*this.precioBasexTonelada;
}

/**
* El metodo devuelve un string con la placa del contenedor
* y la informacion del propietario
*
* @return String
*/
public String toStringContenedorPropietario() {

return this.placa + " " + this.propietario.getCedula() + " " + this.propietario.getNombre()+ "n";
}
}

CLASE CONTENEDOR PUBLICO ContenedorPublico.java


/**
* La clase define objetos del tipo <code>ContenedorPublico</code>
*
* @version 1.0
*/
public class ContenedorPublico extends Contenedor {

/*Porcentaje de exoneracion es un atributo que se da en tanto por ciento*/
private double porcentajeExoneracion;

/**
* @return the porcentajeExoneracion
*/
public double getPorcentajeExoneracion() {

return porcentajeExoneracion;
}

/**
* @param porcentajeExoneracion the porcentajeExoneracion to set
*/
public void setPorcentajeExoneracion(double porcentajeExoneracion) {

this.porcentajeExoneracion = porcentajeExoneracion;
}

/**
* Constructor con los siguientes campos:
*
* @param peso
* @param placa
* @param resumen
* @param porcentajeExoneracion
*/
public ContenedorPublico(Persona propietario, boolean estadoContenedor, double peso,
String placa, String resumen,double precioBasexTonelada,
double porcentajeExoneracion) {
super(estadoContenedor, peso, placa, precioBasexTonelada, resumen,
propietario);
this.porcentajeExoneracion = porcentajeExoneracion;
}

/**
* Metodo que calcula el precio total que se pagara por un contenedor
* del tipo <code>ContenedorPublico</code>
*
* @return precioTotal es el precio total que se pagara por el contenedor
* publico incluido el porcentaje de exoneración.
*/
public double calcularPrecioTotal() {

return super.calcularPrecioBase()-(super.calcularPrecioBase()*this.porcentajeExoneracion/100);
}

/**
* Metodo que lista en un String todos los atribuots de un contenedor
* publico
*
* @return String parametros de <code>ContenedorPublico</code>
*/
public String listarParamDeContenedoresPublicos() {

return "Placa: "+ super.placa + " Peso: "+ super.peso + " resumen: "+super.resumen + " Pagado: "+super.estadoContenedor + " Precio total:
"+calcularPrecioTotal();
}

}

CLASE CONTENEDOR Privado ContenedorPrivado.java


/**
* La clase define objetos del tipo <code>ContenedorPrivado</code>
*
* @version 1.0
*/
public class ContenedorPrivado extends Contenedor {

private double recargoxTonelada;

/**
* @return the porcentajeRecargoxTonelada
*/
public double getPorcentajeRecargoxTonelada() {

return recargoxTonelada;
}

/**
* @param porcentajeRecargoxTonelada the porcentajeRecargoxTonelada to set
*/
public void setPorcentajeRecargoxTonelada(double recargoxTonelada) {

this.recargoxTonelada = recargoxTonelada;
}

/**
* Constructor con los siguientes parametros:
*
* @param peso
* @param placa
* @param resumen

* @param recargoxTonelada
*/
public ContenedorPrivado(Persona propietario, boolean estadoContenedor, double peso,
String placa, String resumen, double precioBasexTonelada,
double recargoxTonelada) {
super(estadoContenedor, peso, placa, precioBasexTonelada, resumen,
propietario);
this.recargoxTonelada = recargoxTonelada;
}

/**
* Metodo que calcula el valor del recargo en dolares
*
* @return recargo valor del recargo en dolares/tonelada
*/
public double calcularRecargo() {

for(int n=0; n<=super.peso ; n+=10) {

this.recargoxTonelada+=1;
}

return recargoxTonelada;
}

/**
* Metodo que calcula el precio total de un contenedor de la clase
* <code>Contenedor</code>
*
* @return precioTotal es el precio incluido el recargo, en dolares.
*/
public double calcularPrecioTotal() {

return super.calcularPrecioBase()+ this.calcularRecargo()*super.peso;
}

/**
* Metodo que lista en un String todos los atribuots de un contenedor
* privado
*
* @return String parametros de <code>ContenedorPrivado</code>
*/
public String listarParamDeContenedoresPrivados() {

return "Placa: "+ super.placa + " Peso: "+ super.peso + " resumen: "+super.resumen + " Pagado: "+super.estadoContenedor + " Precio total:
"+calcularPrecioTotal();

}
}

CLASE exception MyException.java


/**
* La clase define objetos del tipo <code>MyException</code>
*
* @version 1.0
*/
public class MyException extends Exception {

/**
*
*/
private static final long serialVersionUID = 1L;

public MyException(String msg) {
super(msg);
}

}

CLASE PERSONA Persona.java


/**
* La clase define objetos del tipo <code>Persona</code>
*
* @version 1.0
*/
public class Persona {

protected String cedula;
protected String nombre;

/**
* @return the cedula
*/

public String getCedula() {

return cedula;
}

/**
* @param cedula the cedula to set
*/
public void setCedula(String cedula) {

this.cedula = cedula;
}

/**
* @return the nombre
*/

return nombre;
}

/**
* @param nombre the nombre to set
*/

}

/**
* Constructor con dos parametros
*
* @param cedula
* @param nombre
*/
public Persona(String nombre, String cedula) {

this.cedula = cedula;
}

/**
*/
public Persona() {

}

/**
* Constructor tipo copia
*
* @param persona objeto de la clase <code>Persona</code>
*/
public Persona(Persona persona) {

this.cedula = persona.cedula;
this.nombre = persona.nombre;
}

}

CLASE PERSONA ADMINISTRADOR PersonaAdministrador.java


/**
* La clase define objetos del tipo <code>PersonaAdministrador</code>
*
* @version 1.0
*/
public class PersonaAdministrador extends Persona {

private double sueldo;

/**
* @return the sueldo
*/
public double getSueldo() {

return sueldo;
}

/**
* @param sueldo the sueldo to set
*/
public void setSueldo(double sueldo) {

this.sueldo = sueldo;

}

/**
* Constructor de la clase <code>PersonaAdministrador</code>
*
* @param cedula
* @param nombre
* @param sueldo
*/
public PersonaAdministrador(String cedula, String nombre, double sueldo) {
super(cedula, nombre);
this.sueldo = sueldo;
}
}

Informe Poo

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (20)

Similar to Informe Poo

Similar to Informe Poo (20)

Recently uploaded

Recently uploaded (20)

Informe Poo