DULCE * Clase que representa un dulce de la tienda de dulces */ public class Dulce { // ----------------------------------------------------------------// Atributos // ----------------------------------------------------------------/** * El nombre del

dulce */ // TODO: Declarar el atributo que modela el nombre del dulce private String nombre; /** * La cantidad de dulce en el inventario */ // TODO: Declarar el atributo que modela la cantidad del dulce private int cantidad; /** * El peso en gramos del dulce */ private int pesoGramos; /** * El precio del dulce por unidad */ private int precio; // ----------------------------------------------------------------// Constructores // ----------------------------------------------------------------/** * Constructor de la clase, se encarga de crear un nuevo dulce segn los parmetros * @param nombreN El nombre del dulce - nombreN != null * @param cantidadC La cantidad del dulce en inventario cantidadC > 0 * @param peso El peso del dulce en gramos - peso > 0 * @param precioP El precio del dulce - precioP > 0 * */ public Dulce( String nombreN, int cantidadC, int peso, int precioP ) { // // TODO: Inicializa los atributos con los valores dados como parmetro nombre = nombreN; cantidad = cantidadC; pesoGramos = peso; precio = precioP; } // ----------------------------------------------------------------// Mtodos // ----------------------------------------------------------------/** * Devuelve el nombre del dulce * @return Nombre del dulce

*/ public String darNombre( ) { // // TODO: Completar segn la documentacin del mtodo return nombre; } /** * Devuelve la cantidad del dulce en inventario * @return La cantidad del dulce en inventario */ public int darCantidad( ) { // // TODO: Completar segn la documentacin del mtodo return cantidad; } /** * Devuelve el peso en gramos del dulce * @return El peso en gramos del dulce */ public int darPesoGramos( ) { return pesoGramos; } /** * Devuelve el precio del dulce por unidad * @return El precio del dulce por unidad */ public int darPrecio( ) { return precio; } /** * Se agregan dulces al inventario, por lo tanto su cantidad aumenta en la cantidad recibida por parmetro<br /> * <b> post:</b> Se agrega la cantidad dada en el parmetro, a la cantidad del dulce * @param cantidadN La nueva cantidad - cantidadN > 0 */ public void comprarDulces( int cantidadN ) { // // TODO: Completar segn la documentacin del mtodo cantidad += cantidadN; } /** * Vende una cantidad de dulces dada por parmetro, por lo tanto su cantidad disminuye en la cantidad recibida por parmetro<br /> * <b> post:</b> Se disminuye la cantidad del dulce en la cantidad dada en el parmetro * @param cantidadV La cantidad a vender - cantidad > 0

* @return Devuelve el costo de la venta. El costo es calculado multiplicando el precio del dulce por la cantidad vendida */ public int venderDulces( int cantidadV ) { // // TODO: Completar segn la documentacin del mtodo cantidad -= cantidadV; return precio * cantidadV; } } TIENDADULCES /** * Clase que representa una tienda de dulces */ public class TiendaDulces { // ----------------------------------------------------------------// Constantes // ----------------------------------------------------------------/** * Constante para el nombre del dulce 1 */ public static final String NOMBRE_DULCE_1 = "Chocolatina"; /** * Constante para el nombre del dulce 2 */ public static final String NOMBRE_DULCE_2 = "Gomita"; // // TODO: Declarar la constante NOMBRE_DULCE_3, inicializarlo en "Caramelo" y documentar public static final String NOMBRE_DULCE_3= "Caramelo"; // // TODO: Declarar la constante NOMBRE_DULCE_4, inicializarlo en "Chicle" y documentar public static final String NOMBRE_DULCE_4= "Chicle"; // ----------------------------------------------------------------// Atributos // ----------------------------------------------------------------/** * Dulce 1 */ private Dulce dulce1; /** * Dulce 2 */ private Dulce dulce2; /** * Dulce 3 */

private Dulce dulce3; /** * Dulce 4 */ // TODO: Declarar el atributo que modela el dulce 4 private Dulce dulce4; // ----------------------------------------------------------------// Constructores // ----------------------------------------------------------------/** * Constructor de la clase TiendaDulces. <br> * <b> post:</b> Se crean cuatro dulces con los siguientes valores: <br> * dulce1: Nombre: Chocolatina, Cantidad: 30, Peso: 30, Precio: 200 <br> * dulce2: Nombre: Gomita, Cantidad: 100, Peso: 5, Precio: 50 <br> * dulce3: Nombre: Chicle, Cantidad: 60, Peso: 25, Precio: 250 <br> * dulce4: Nombre: Caramelo, Cantidad: 20, Peso: 10, Precio: 500 <br> * */ public TiendaDulces( ) { dulce1 = new Dulce( TiendaDulces.NOMBRE_DULCE_1, 30, 30, 200 ); dulce2 = new Dulce( TiendaDulces.NOMBRE_DULCE_2, 100, 5, 50 ); // // TODO: Inicializar el atributo dulce3 con la informacin dada en la documentacin dulce3 = new Dulce(TiendaDulces.NOMBRE_DULCE_3, 60,25,250); // // TODO: Inicializar el atributo dulce4 con la informacin dada en la documentacin dulce4 = new Dulce(TiendaDulces.NOMBRE_DULCE_4, 20,10,500); } // ----------------------------------------------------------------// Mtodos // ----------------------------------------------------------------/** * Devuelve el dulce 1 * @return El dulce 1 */ public Dulce darDulce1( ) { return dulce1; } /** * Devuelve el dulce 2 * @return El dulce 2 */ public Dulce darDulce2( ) { return dulce2; } /** * Devuelve el dulce 3 * @return El dulce 3

*/ public Dulce darDulce3( ) { // // TODO: Complete el mtodo segn la documentacin return dulce3; } /** * Devuelve el dulce 4 * @return El dulce 4 */ public Dulce darDulce4( ) { // // TODO: Complete el mtodo segn la documentacin return dulce4; } /** * Devuelve el descuento obtenido dependiendo el peso de la bolsa de dulces <br> * <b> post:</b> Dependiendo del peso recibido por parmetro, retorna el porcentaje del descuento a aplicar:<br> * - Si el peso es menor a 100 g retorna 0<br /> * - Si el peso est entre 100 g y 199 g retorna 0.1<br /> * - Si el peso est entre 200 g y 999 g retorna 0.2<br /> * - Si el peso es igual o superior a 1000 g retorna 0.5<br /> * @param peso El peso de la bolsita de dulces - peso >= 0 * @return El descuento representado en una fraccin de 1 */ public double darDescuento( int peso ) { // // TODO: Complete el mtodo segn la documentacin if (peso < 100) { return 0; } else if (peso >= 100 && peso <= 199) { return 0.1;} else if (peso >= 200 && peso <= 999) {return 0.2; } else {return 0.5;} } /** * Vende una cantidad dada de cada dulce, y calcula el precio total dependiendo de la poltica de descuentos de la tienda<br> * <b> pre:</b> Los dulces se encuentran inicializados <br> * <b> post:</b> Se disminuye la cantidad de cada tipo de dulce de la de la tienda segn la cantidad vendida en la bolsita, y <br /> * dependiendo del peso de los dulces vendidos en la bolsita, se obtiene un descuento aplicable al precio de venta: <br /> * entre 100 g y 199 g hay 10% de descuento, entre 200 g y 999 g hay 20% de descuento y ms 1000 g = 50% de descuento. * @param cantDulce1 La cantidad del dulce 1 a vender - cantDulce1 >= 0 * @param cantDulce2 La cantidad del dulce 2 a vender - cantDulce2 >= 0 * @param cantDulce3 La cantidad del dulce 3 a vender - cantDulce3 >= 0 * @param cantDulce4 La cantidad del dulce 4 a vender - cantDulce4 >= 0 * @return El costo de la bolsita de dulces aplicando el descuento

*/ public double venderBolsita( int cantDulce1, int cantDulce2, int cantDulce3, int cantDulce4 ) { double costo = 0; costo += dulce1.venderDulces(cantDulce1); costo += dulce2.venderDulces(cantDulce2); costo += dulce3.venderDulces(cantDulce3); costo += dulce4.venderDulces(cantDulce4);

int peso = 0; peso += cantDulce1* dulce1.darPesoGramos(); peso += cantDulce2* dulce2.darPesoGramos(); peso += cantDulce3* dulce3.darPesoGramos(); peso += cantDulce4* dulce4.darPesoGramos(); return costo - (costo * darDescuento(peso));

// // TODO: Complete el mtodo segn la documentacin } /** * Devuelve el peso de un dulce dado su nombre y cantidad<br> * <b> pre:</b> Los dulces se encuentran inicializados <br> * @param nombre Nombre del dulce - nombre != null * @param cantidad Cantidad del dulce para calcular el peso - cantidad >= 0 * @return El peso del dulce dado, segn la cantidad solicitada */ public int darPeso( String nombre, int cantidad ) { return darDulce(nombre).darPesoGramos()*cantidad;

/** * Compra una cantidad especifica del dulce con el nombre dado <br> * <b> pre: </b> los dulces se encuentran inicializados <br> * <b> post:</b> se aumento la cantidad del dulce con el nombre dado, en la cantidad recibida por parmetro * @param nombre El nombre del dulce a comprar - nombre != null * @param cantidad La cantidad de dulce a comprar - cantidad > 0 */ public void comprarDulce( String nombre, int cantidad ) { darDulce(nombre).comprarDulces(cantidad);

} /** * Devuelve el dulce con el nombre dado por parmetro <br> * <b> pre: </b> los dulces estn inicializados

* @param nombre El nombre del dulce - nombre != null * @return El dulce con el nombre dado, null si no existe */ public Dulce darDulce( String nombre ) { if (dulce1.darNombre().equals(nombre)) {return dulce1; } else if (dulce2.darNombre().equals(nombre)) {return dulce2;} else if (dulce3.darNombre() .equals(nombre)) {return dulce3;} else {return dulce4; }

if (division1 < division2 && division1 < division3 && division1 < division4 ) return dulce1; else if (division2 < division1 && division2 < division3 && division2 < division4 ) return dulce2; else if (division3 < division1 && division3 < division2 && division3 < division4 ) return dulce3; else return dulce4;

* Clase que representa la embarcacin del capitn Morgan. * */ public class BarcoPirata { // --------------------------------------------------------------------// Constantes // --------------------------------------------------------------------/** * Carga mxima soportada por el barco. */ public static final int CARGA_MAXIMA = 20000; // --------------------------------------------------------------------// Atributos // --------------------------------------------------------------------/** * Nombre del barco */ private String nombre; /** * Carga 1 del barco */ private Carga carga1; // TODO // Declarar los atributos para modelar las dems cargas. // Por cada carga adicionar su comentario de documentacin. /** * Carga 2 del barco */ private Carga carga2; /** * Carga 3 del barco */ private Carga carga3; /** * Carga 4 del barco */ private Carga carga4; // --------------------------------------------------------------------// Constructores // --------------------------------------------------------------------/** * Crea un barco llamado El Pirata sin carga incial */ public BarcoPirata( ) { nombre = "El Pirata"; // TODO // Iniciar las cargas del barco. Al crear el barco No se tiene ninguna carga embarcada carga1 = null; carga2 = null;

} } /** * Devuelve el total de dulces en la tienda. Es la suma de la cantidad de cada uno de los cuatro dulces que maneja la tienda. <br> * <b> pre: </b> Todos los dulces se encuentran inicializados * @return El total de dulces en la tienda */ public int darTotalDulces( ) { // ----------------------------------------------------------------// Puntos de Extensin // ----------------------------------------------------------------/** * Mtodo para la extensin 1 * @return respuesta1 */ public String metodo1( ) { return "Respuesta 1"; } /** * Mtodo para la extensin2 * @return respuesta2 */ public String metodo2( ) { return "Respuesta 2"; } } BARCO PIRATA Barcopirata /** * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~ * $Id: BarcoPirata.java,v 1.5 2006/07/18 20:55:58 da-romer Exp $ * Universidad de los Andes (Bogot - Colombia) * Departamento de Ingeniera de Sistemas y Computacin * Licenciado bajo el esquema Academic Free License version 2.1 * * Proyecto Cupi2 (http://cupi2.uniandes.edu.co) * Ejercicio: n2_barcoPirata * Autor: Jorge Hernandez - 30/10/2005 * Modificado por: Milena Vela - Mar 10 2006 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~ */ package uniandes.cupi2.barcoPirata.mundo; /**

return (dulce1.darCantidad()+dulce2.darCantidad()+dulce3.darCantidad()+dulce4.dar Cantidad()); } /** * Verifica si la cantidad del dulce con el nombre dado, es mayor o igual a la cantidad recibida. <br> * <b> pre: </b> los dulces se encuentran inicializados * @param cant La cantidad de dulce a verificar - cant > 0 * @param nombre El nombre del dulce a verificar la cantidad * @return True si el dulce a verificar tiene la cantidad disponible dada, False de lo contrario */ public boolean verificarCantidad(String nombre, int cant) { return darDulce(nombre).darCantidad() >= cant ; } /** * Retorna el dulce ms econmico <br> * <b> pre: </b> los dulces se encuentran inicializados <br> * @return El dulce ms econmico cuya relacin costo/peso es la mnima entre los dulces de toda la tienda */ public Dulce darEconomico( ) { double division1 = dulce1.darPrecio() / dulce1.darPesoGramos(); double division2 = dulce2.darPrecio() / dulce2.darPesoGramos(); double division3 = dulce3.darPrecio() / dulce3.darPesoGramos(); double division4 = dulce4.darPrecio() / dulce4.darPesoGramos();

carga3 = null; carga4 = null; } // --------------------------------------------------------------------// Mtodos // --------------------------------------------------------------------/** * Vacia el barco de todas sus cargas para comenzar un nuevo viaje */ public void descargarBarco( ) { carga1 = null; // TODO // Descarga el resto de cargas del barco carga2 = null; carga3 = null; carga4 = null; } /** * Suma el peso de todas las cargas embarcadas y lo retorna. <br> * @return el peso total cargado en el barco. */ public double darCargaTotal( ) { double peso = 0; // TODO // Completar el mtodo segn la documentacin // El peso de una carga embarcada depende de su nmero de cajas y del peso de cada caja if (carga1 != null) { peso += carga1.darPesoCaja() * carga1.darNumeroCajas(); } if (carga2 != null) { peso += carga2.darPesoCaja() * carga2.darNumeroCajas(); } if (carga3!=null) { peso+=carga3.darPesoCaja()*carga3.darNumeroCajas(); } if (carga4!=null) { peso+=carga4.darPesoCaja()*carga4.darNumeroCajas(); } return peso; } /** * Devuelve la primera carga * @return carga 1 */

public Carga darCarga1( ) { return carga1; } /** * Devuelve la segunda carga * @return carga 2 */ public Carga darCarga2( ) { return carga2; } public Carga darCarga3( ) { // TODO // Completar el mtodo segn la documentacin return carga3; } /** * Devuelve la tercera carga * @return carga 3 */ public Carga darCarga4( ) { // TODO // Completar el mtodo segn la documentacin return carga4; } /** * Devuelve la cuarta carga * @return carga 4 */ // TODO // Construir el mtodo (signatura y cuerpo) segn la documentacin

} // caso en el que la segunda carga exista y sea incompatible if( carga2 != null && carga2.darTipoCarga( ) == Carga.CARGA_PELIGROSA ) { cumple = false; } // caso en el que la tercera carga exista y sea incompatible if( carga3 != null && carga3.darTipoCarga( ) == Carga.CARGA_PELIGROSA ) { cumple = false; } // caso en el que la cuarta carga exista y sea incompatible if( carga4 != null && carga4.darTipoCarga( ) == Carga.CARGA_PELIGROSA ) { cumple = false; } } if( tipo == Carga.CARGA_PELIGROSA ) { // caso en el que la primera carga exista y sea incompatible if( carga1 != null && carga1.darTipoCarga( ) == Carga.CARGA_PERECEDERA ) { cumple = false; } // caso en el que la segunda carga exista y sea incompatible if( carga2 != null && carga2.darTipoCarga( ) == Carga.CARGA_PERECEDERA ) { cumple = false; } // caso en el que la tercera carga exista y sea incompatible if( carga3 != null && carga3.darTipoCarga( ) == Carga.CARGA_PERECEDERA ) { cumple = false; } // caso en el que la cuarta carga exista y sea incompatible if( carga4 != null && carga4.darTipoCarga( ) == Carga.CARGA_PERECEDERA ) { cumple = false; } } // TODO // Completar el caso en el que la carga es de tipo PELIGROSA return cumple; } /** * Verifica si se puede o no zarpar. Se puede zarpar siempre y cuando la carga total del barco sea superior a 12000 kilogramos o si hay ms de una carga embarcada. * @return true si se puede zarpar, false en caso contrario

/** * Informa si la carga a embarcar es compatible con otros tipos de carga previamente embarcados. * @param tipo de la carga por verificar si se puede agregar o no segn las condiciones de sanidad * @return true si la carga cumple con las condiciones sanitarias, false en caso contrario. */ public boolean cumpleCondicionesSanitarias( int tipo ) { boolean cumple = true; // caso en el que la carga sea PERECEDERA if( tipo == Carga.CARGA_PERECEDERA ) { // caso en el que la primera carga exista y sea incompatible if( carga1 != null && carga1.darTipoCarga( ) == Carga.CARGA_PELIGROSA ) { cumple = false;

*/ public boolean puedeZarpar( ) { boolean partir= false; if (darCargaTotal()>12000) { partir=true; } else { if (carga1!=null) { if (carga2!=null ||carga3!=null ||carga4!=null) { partir=true; } } if (carga2!=null) { if (carga1!=null ||carga3!=null ||carga4!=null) { partir=true; } } if (carga3!=null) { if (carga2!=null ||carga1!=null ||carga4!=null) { partir=true; } } if (carga4!=null) { if (carga2!=null ||carga3!=null ||carga1!=null) { partir=true; } }

* Verifica que el cliente de la carga que viene por parmetro no haya embarcado otra carga previamente. * @param cliente Nombre del dueo de la carga * @return true si NO hay cargas embarcadas del cliente, false de lo contrario. */ public boolean esCargaUnicaCliente( String cliente ) { boolean unica=true; if (carga1!=null) { if (carga1.darNombreCliente().equals(cliente)) { unica=false; } } if (carga2!=null) { if (carga2.darNombreCliente().equals(cliente)) { unica=false; } } if (carga3!=null) { if (carga3.darNombreCliente().equals(cliente)) { unica=false; } } if (carga4!=null) { if (carga4.darNombreCliente().equals(cliente)) { unica=false; } } return unica;

// TODO // Si la carga4 esta embarcada verificar que no pertenece al cliente // Si si pertenece al cliente ya NO se puede embarcar otra carga para este cliente } /** * Verifica que el peso de la nueva carga que entra como parmetro junto con las cargas previamente embarcadas en el barco No exceda la capacidad de carga del barco. * @param numeroCajas Nmero de cajas de la carga * @param pesoCaja Peso de cada una de las cajas de la carga * @return true si se puede agregar esta carga al barco, false en caso contrario. */ public boolean sePuedeEmbarcar( int numeroCajas, double pesoCaja ) { boolean sePuede = true; // se verifica que la carga no sea demasiado pesada double pesoCarga = ( numeroCajas * pesoCaja ); if( pesoCarga + darCargaTotal( ) > CARGA_MAXIMA ) { sePuede = false; } return sePuede; } /** * Ingresa la carga que entra como parmetro realizando las siguientes verificaciones: <br> * 1. El peso de la carga no supera la capacidad del barco <br> * 2. La carga cumple con las condiciones de sanidad <br> * 3. El cliente dueo de la carga no ha adicionado una carga previamente. <br> * Si las tres condiciones anteriores se cumplen se agrega la carga, de lo contrario, no es posible agregar la carga. <br> * @param numeroCarga El nmero de la carga que se va a asignar. Valores posibles 1, 2, 3 o 4 segn la carga a embarcar. * @param numeroCajas Nmero de cajas de la carga * @param peso Peso de cada una de las cajas de la carga * @param tipo Tipo de la carga * @param cliente Nombre del dueo de la carga * @return true si se pudo agregar la carga, false en caso contrario. */ public boolean cargarBarco( int numeroCarga, int numeroCajas, double peso, String cliente, int tipo ) { boolean sePudo = true; // se verifica que la carga no supere la capacidad del barco if( !sePuedeEmbarcar( numeroCajas, peso ) ) { sePudo = false; } else { if (!cumpleCondicionesSanitarias(tipo)) {

} return partir; // TODO // Completar el mtodo segn la documentacin } /**

// TODO // Si la carga1 esta embarcada verificar que no pertenece al cliente // Si si pertenece al cliente ya NO se puede embarcar otra carga para este cliente // TODO // Si la carga2 esta embarcada verificar que no pertenece al cliente // Si si pertenece al cliente ya NO se puede embarcar otra carga para este cliente // TODO // Si la carga3 esta embarcada verificar que no pertenece al cliente // Si si pertenece al cliente ya NO se puede embarcar otra carga para este cliente

sePudo=false; } else { if (!esCargaUnicaCliente(cliente)) { sePudo=false; } switch (numeroCarga) { case 1: carga1=new Carga(numeroCajas, peso, cliente, tipo); break; case 2: carga2=new Carga(numeroCajas, peso, cliente, tipo); break; case 3: carga3=new Carga(numeroCajas, peso, cliente, tipo); break; case 4: carga4=new Carga(numeroCajas, peso, cliente, tipo); break; default: break; } } // TODO // Completa las verificaciones de Condiciones Sanitarias y de Carga Unica del cliente // Si todas las verificaciones son exitosas se puede embarcar la carga que ingresa como parmetro // Segn el caso se da el valor a sePudo. } return sePudo; } // ----------------------------------------------------------------// Puntos de Extensin // ----------------------------------------------------------------/** * Mtodo para la extensin 1 * @return Respuesta de la extensin 1 */ public String metodo1( ) { return "Respuesta 1"; } /** * Mtodo para la extensin 2 * @return Respuesta de la extensin 2 */ public String metodo2( ) { }

return "Respuesta 2"; } Carga /** * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~ * $Id: Carga.java,v 1.2 2006/06/02 20:14:56 f-vela Exp $ * Universidad de los Andes (Bogot - Colombia) * Departamento de Ingeniera de Sistemas y Computacin * Licenciado bajo el esquema Academic Free License version 2.1 * * Proyecto Cupi2 (http://cupi2.uniandes.edu.co) * Ejercicio: n2_barcoPirata * Autor: Jorge Hernandez - 30/10/2005 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~ */ package uniandes.cupi2.barcoPirata.mundo; /** * Esta clase representa una carga del barco pirata. */ public class Carga { // --------------------------------------------------------------------// Constantes // --------------------------------------------------------------------/** * Tipo de carga peligrosa */ public static final int CARGA_PELIGROSA = 1; /** * Tipo de carga perecedera */ // TODO // Dar el valor entero (int) al tipo de carga PERECEDERA public static final int CARGA_PERECEDERA = 2; /** * Tipo de carga no perecedera */ // TODO // Definir la constante (int) para el tipo de carga NO PERECEDERA public static final int CARGA_NO_PERECEDERA = 3; // --------------------------------------------------------------------// Atributos // --------------------------------------------------------------------/** * Nombre del cliente */ // TODO // Definir el atributo para el nombre del cliente (String)

private String nombreCliente;

/** * Nmero de cajas de la carga */ private int numeroCajas; /** * Peso de cada caja de la carga */ private double pesoCaja; /** * Tipo de la carga */ // TODO // Definir el atributo para el tipo de carga a transportar (int) private int tipoCarga; // --------------------------------------------------------------------// Constructores // --------------------------------------------------------------------/** * Constructor de la clase carga <br> * <b>post</b>: se ha creado una nueva carga<br> * @param cajas : es el nmero de cajas de la carga * @param peso : es el peso de cada caja de la carga * @param cliente : es el nombre del cliente dueo de la carga * @param tipo : es el tipo de carga */ public Carga( int cajas, double peso, String cliente, int tipo ) { numeroCajas = cajas; // TODO // Completar el mtodo de construccin de un objeto pesoCaja = peso; nombreCliente = cliente; tipoCarga = tipo; } // --------------------------------------------------------------------// Mtodos // --------------------------------------------------------------------/** * Retorna el peso de cada caja que hay en la carga * @return peso de cada caja de la carga */ public double darPesoCaja( ) { return pesoCaja; } /** * Retorna el nombre del cliente dueo de la carga * @return nombre del cliente */

public String darNombreCliente( ) { // TODO // retornar el nombre del cliente return nombreCliente;

} /** * Retorna el nmero de cajas de la carga * @return nmero de cajas que hay en la carga */ // TODO // Construir el mtodo (signatura y cuerpo) segn la documentacin public int darNumeroCajas( ) { return numeroCajas; } /** * Retorna el tipo de carga * @return tipo de carga */ public int darTipoCarga( ) { // TODO // retornar el tipo de carga return tipoCarga;

} }