Como Programar en Java: Ejercicio 5.20

Aquí esta el ejercicio 5.20 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de calcular aproximaciones
 * al número PI.
 * Ejercicio 5.20
 * @author LorettoTG
 * @version 1.0
 */
public class AproximacionesPI {
    /**
     * Método encargado de calcular als aproximaciones
     * a la constante matematica PI.
     * @param terminos int con el numero de terminos a
     * calcular.
     * @return resultado double con la aproximacion a PI.
     */
    public double aproximar(int terminos) {
        double resultado = 4.0;
        for (int contador = 2; contador <= terminos; contador++) {
            resultado += (4.0 / ((contador * 2) - 1))
                            * Math.pow(-1, contador - 1);
        }
        return resultado;
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //El operador new es el encargado de crear instancias de
        //una clase, es decir los objetos que tienen las características
        //de la clase. El operador new de Java es capaz de reservar la
        //memoria para un objeto de este tipo sabiendo los atributos que
        //tiene según la definición de la clase.
        AproximacionesPI pi = new AproximacionesPI();

        for (int contador = 1; contador <= 9999; contador++) {
            System.out.printf("%05d  %20.15f\n",
                    contador, pi.aproximar(contador));
        }
    }
}

Como Programar en Java: Ejercicio 5.17

Aquí esta el ejercicio 5.17 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de calcular el valor total de venta
 * de todos los productos vendidos.
 * Ejercicio 5.17
 * @author LorettoTG
 * @version 1.0
 */
public class Almacen {
    /**
     * Método encargad de calcular el valor total de
     * venta de todos los productos vendidos.
     * @return resultado double con el total de la venta.
     */
    public double calcular() {
        /**
         * Contiene el total de la venta.
         */
        double resultado = 0.0;
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        /**
         * Contiene el numero del producto.
         */
        int numeroProducto = 0;

        do {
            System.out.println("Deme el numero del producto: ");
            numeroProducto = entrada.nextInt();

            switch (numeroProducto) {
            case 0:
                break;
            case 1:
                resultado += cantidad() * 2.98;
                break;
            case 2:
                resultado += cantidad() * 4.5;
                break;
            case 3:
                resultado += cantidad() * 9.98;
                break;
            case 4:
                resultado += cantidad() * 4.49;
                break;
            case 5:
                resultado += cantidad() * 6.87;
                break;
            default:
                System.out.println("No es un producto valido");
            }
        } while (numeroProducto != 0);

        return resultado;
    }

    /**
     * Método encargado de verificar que la cantidad que
     * da el usuario sea mayor a cero.
     * @return cantidad int con la cantidad validada.
     */
    private int cantidad() {
        /**
         * Contiene la cantidad que se vendio de un producto.
         */
        int cantidad = 0;
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        while (true) {
            System.out.println("Deme la cantidad vendida del producto: ");
            cantidad = entrada.nextInt();
            if (cantidad > 0) {
                return cantidad;
            } else {
                System.out.println("Escriba una cantidad mayor a cero.");
            }
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //El operador new es el encargado de crear instancias de
        //una clase, es decir los objetos que tienen las caracteristicas
        //de la clase. El operador new de Java es capaz de reservar la
        //memoria para un objeto de este tipo sabiendo los atributos que
        //tiene según la definición de la clase.
        Almacen almacen = new Almacen();

        //%.2f indica que espera un double y que tendra en el area de
        //decimales solo dos digitos.
        System.out.printf("El total de ventas es: %.2f", almacen.calcular());
    }
}

Como Programar en Java: Ejercicio 5.14

Aquí esta el ejercicio 5.14 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase que calcula el interes compuesto.
 * Ejercicio 5.14
 * @author LorettoTG
 * @author Deitel - Base tomada de su libro.
 * @version 1.0
 */
public class InteresCompuesto {
    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String args[]) {
        /**
         * Monto que se deposita al final del periodo - año
         */
        double monto;
        /**
         * Monto inicial
         */
        double principal = 1000.0;
        /**
         * La tasa de interés.
         */
        double tasa;

        for (tasa = 5; tasa <= 10; tasa++) {
            System.out.println("Con tasa de interes del " + tasa + "%.");
            //Se muestra el encabezado de la tabla.
            System.out.printf("%s%20s\n", "Anio", "Monto en deposito");

            //calcula el monto en deposito para cada uno de diez años
            for (int anio = 1; anio <= 10; anio++) {
                //calcula el nuevo monto para el año especificado
                monto = principal * Math.pow(1.0 + (tasa / 100), anio);

                // muestra el año y el monto
                System.out.printf("%4d%,20.2f\n", anio, monto);
            }
            System.out.printf("\n\n");
        }
    }
}

Como Programar en Java: Ejercicio 4.17

Aquí esta el ejercicio 4.17 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase que lleva el registro de kilómetros por litro
 * que tiene un conductor.
 * Ejercicio 4.17
 * @author LorettoTG
 * @version 1.0
 */
public class Conductores {

    /**
     * Calcula y muestra los kilómetros conducidos y los litros
     * usados por cada reabastecimiento, e imprime el total de
     * kilómetros por litro obtenidos en todos los reabastecimientos
     * hasta ese punto.
     */
    public void calcularKmLitro() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        /**
         * Contiene los kilómetros para ese reabastecimiento.
         */
        double kilometros = 0;
        /**
         * Contiene los litros para ese reabastecimiento.
         */
        double litros = 0;
        /**
         * Contiene el total de kilómetros de la ruta.
         */
        double totalKilometros = 0;
        /**
         * Contiene el total de litros de la ruta.
         */
        double totalLitros = 0;

        System.out.println("Deme el número de kilómetros recorridos: ");
        kilometros = entrada.nextDouble();

        //Ciclo while que se detiene hasta que el kilometraje sea menor
        //a cero.
        while(kilometros > 0) {
            System.out.println("Deme el número de litros usados: ");
            litros = entrada.nextDouble();

            totalKilometros += kilometros;
            totalLitros += litros;

            System.out.println("Kilometros-Litros para este "
                    + "reabastecimiento: " + kilometros / litros);

            System.out.println("Kilometros-Litros para todo "
                    + "el recorrido: " + totalKilometros / totalLitros);

            System.out.println(
                    "Deme el número de kilómetros recorridos: ");
            kilometros = entrada.nextDouble();
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        Conductores conductor = new Conductores();
        conductor.calcularKmLitro();
    }
}

Como Programar en Java: Ejercicio 4.18

Aquí esta el ejercicio 4.18 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase que contiene los datos de un cliente.
 * Ejercicio 4.18
 * @author LorettoTG
 * @version 1.0
 *
 */
public class Cliente {
    /**
     * Contiene el número de cuenta.
     */
    int cuenta;
    /**
     * Contiene el saldo al inicio del mes.
     */
    double saldoInicio;
    /**
     * Contiene el total de todos los artículos cargados
     * por el cliente en el mes.
     */
    double totalArticulos;
    /**
     * Contiene el total de todos los créditos aplicados
     * a la cuenta del cliente en el mes.
     */
    double totalCreditos;
    /**
     * Contiene el límite de crédito permitido.
     */
    double limiteCredito;

    /**
     * Método que calcula el nuevo saldo con la siguiente
     * formula =saldo inicial + cargos - créditos
     * @param saldoInicio double con el total de todos los
     * artículos cargados por el cliente en el mes.
     * @param totalArticulos double con el total de todos
     * los créditos aplicados a la cuenta del cliente en el mes.
     * @param totalCreditos double con el límite de crédito
     * permitido.
     */
    public void calcularSaldo(double saldoInicio, 
            double totalArticulos, double totalCreditos) {
        double nuevoSaldo = saldoInicio + totalArticulos - totalCreditos;
        System.out.println("Su nuevo saldo es: " + nuevoSaldo);
        if (nuevoSaldo > limiteCredito) {
            System.out.println("Se excedió el límite de su crédito");
        }
    }

    /**
     * Este es un getter que obtiene el cuenta.
     * @return el cuenta int.
     */
    public int getCuenta() {
        return cuenta;
    }
    /**
     * Este es un setter que asigna el cuenta.
     * @param cuenta de tipo int el cuenta a asignar.
     */
    public void setCuenta(int cuenta) {
        this.cuenta = cuenta;
    }
    /**
     * Este es un getter que obtiene el saldoInicio.
     * @return el saldoInicio double.
     */
    public double getSaldoInicio() {
        return saldoInicio;
    }
    /**
     * Este es un setter que asigna el saldoInicio.
     * @param saldoInicio de tipo double el 
     * saldoInicio a asignar.
     */
    public void setSaldoInicio(double saldoInicio) {
        this.saldoInicio = saldoInicio;
    }
    /**
     * Este es un getter que obtiene el totalArticulos.
     * @return el totalArticulos double.
     */
    public double getTotalArticulos() {
        return totalArticulos;
    }
    /**
     * Este es un setter que asigna el totalArticulos.
     * @param totalArticulos de tipo double el 
     * totalArticulos a asignar.
     */
    public void setTotalArticulos(double totalArticulos) {
        this.totalArticulos = totalArticulos;
    }
    /**
     * Este es un getter que obtiene el totalCreditos.
     * @return el totalCreditos double.
     */
    public double getTotalCreditos() {
        return totalCreditos;
    }
    /**
     * Este es un setter que asigna el totalCreditos.
     * @param totalCreditos de tipo double el 
     * totalCreditos a asignar.
     */
    public void setTotalCreditos(double totalCreditos) {
        this.totalCreditos = totalCreditos;
    }
    /**
     * Este es un getter que obtiene el limiteCredito.
     * @return el limiteCredito double.
     */
    public double getLimiteCredito() {
        return limiteCredito;
    }
    /**
     * Este es un setter que asigna el limiteCredito.
     * @param limiteCredito de tipo double 
     * el limiteCredito a asignar.
     */
    public void setLimiteCredito(double limiteCredito) {
        this.limiteCredito = limiteCredito;
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        Cliente cliente = new Cliente();
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        System.out.println("Deme el numero de cuenta: ");
        cliente.setCuenta(entrada.nextInt());

        System.out.println("Deme el saldo al inicio del mes: ");
        cliente.setSaldoInicio(entrada.nextDouble());

        System.out.println("Deme el total de todos los articulos: ");
        cliente.setTotalArticulos(entrada.nextDouble());

        System.out.println("Deme el total de creditos: ");
        cliente.setTotalCreditos(entrada.nextDouble());

        System.out.println("Deme el límite de crédito: ");
        cliente.setLimiteCredito(entrada.nextDouble());

        cliente.calcularSaldo(cliente.getSaldoInicio(),
                cliente.getTotalArticulos(), cliente.getTotalCreditos());
    }
}

Como Programar en Java: Ejercicio 3.13

Aquí esta el ejercicio 3.13 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo3;

/**
 * Objeto que una ferretería podría utilizar para
 * representar una factura para un artículo vendido
 * en la tienda.
 * Ejercicio 3.13
 * @author LorettoTG
 * @version 1.0
 *
 */
public class Factura {
    /**
     * Contiene el número de la pieza.
     */
    String numeroPieza = "";
    /**
     * Contiene la descripción de la pieza.
     */
    String descripcionPieza = "";
    /**
     * Contiene la cantidad de artículos de ese
     * tipo que se van a comprar.
     */
    int cantidadPieza = 0;
    /**
     * Contiene el precio de la pieza.
     */
    double precioPieza = 0;

    /**
     * Constructor de Factura que inicializa el numero de
     * la pieza, la descripción de la pieza, la cantidad
     * de esa pieza y el precio de la pieza. Si la cantidad de
     * las piezas es menor a cero, la establece en cero, si el
     * precio por pieza es menor a cero lo establece en cero.
     * @param numeroPieza String con el número de la pieza.
     * @param descripcionPieza String con la descripción de la pieza.
     * @param cantidadPieza int con la cantidad de artículos de ese
     * tipo que se van a comprar.
     * @param precioPieza double con el precio de la pieza.
     */
    public Factura(String numeroPieza, String descripcionPieza,
            int cantidadPieza, double precioPieza) {
        this.numeroPieza = numeroPieza;
        this.descripcionPieza = descripcionPieza;
        if (cantidadPieza < 0) {
            this.cantidadPieza = 0;
        } else {
            this.cantidadPieza = cantidadPieza;
        }
        if (precioPieza < 0) {
            this.precioPieza = 0.0;
        } else {
            this.precioPieza = precioPieza;
        }
    }

    /**
     * Este es un getter que obtiene el numeroPieza.
     * @return el numeroPieza String.
     */
    public String getNumeroPieza() {
        return numeroPieza;
    }

    /**
     * Este es un setter que asigna el numeroPieza.
     * @param numeroPieza de tipo String el numeroPieza a asignar.
     */
    public void setNumeroPieza(String numeroPieza) {
        this.numeroPieza = numeroPieza;
    }

    /**
     * Este es un getter que obtiene el descripcionPieza.
     * @return el descripcionPieza String.
     */
    public String getDescripcionPieza() {
        return descripcionPieza;
    }

    /**
     * Este es un setter que asigna el descripcionPieza.
     * @param descripcionPieza de tipo String el descripcionPieza a asignar.
     */
    public void setDescripcionPieza(String descripcionPieza) {
        this.descripcionPieza = descripcionPieza;
    }

    /**
     * Este es un getter que obtiene el cantidadPieza.
     * @return el cantidadPieza int.
     */
    public int getCantidadPieza() {
        return cantidadPieza;
    }

    /**
     * Este es un setter que asigna el cantidadPieza.
     * @param cantidadPieza de tipo int el cantidadPieza a asignar.
     */
    public void setCantidadPieza(int cantidadPieza) {
        this.cantidadPieza = cantidadPieza;
    }

    /**
     * Este es un getter que obtiene el precioPieza.
     * @return el precioPieza double.
     */
    public double getPrecioPieza() {
        return precioPieza;
    }

    /**
     * Este es un setter que asigna el precioPieza.
     * @param precioPieza de tipo double el precioPieza a asignar.
     */
    public void setPrecioPieza(double precioPieza) {
        this.precioPieza = precioPieza;
    }

    /**
     * Método que obtiene el monto de la factura, multiplica
     * la cantidad de piezas por el precio de la pieza.
     * @return resultado double con el monto de la factura.
     */
    public double obtenerMontoFactura() {
        double resultado = 0.0;
        resultado = getCantidadPieza() * getPrecioPieza();
        return resultado;
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        Factura factura = new Factura("15478", "Tornillo", 100, 5.021);
        System.out.println("Monto de la factura: " + factura.obtenerMontoFactura());

        factura = new Factura("14444", "clavo", -1, 100);
        System.out.println("Monto de la factura: " + factura.obtenerMontoFactura());

        factura = new Factura("14544", "tuerca", 10, -100);
        System.out.println("Monto de la factura: " + factura.obtenerMontoFactura());

        factura = new Factura("123456", "Foco", -10, -781);
        System.out.println("Monto de la factura: " + factura.obtenerMontoFactura());
    }
}

Como Programar en Java: Ejercicio 3.12

Esta noche les traigo el ejercicio 3.12 del libro Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo3;

import java.util.Scanner;

/**
 * Clase encargada de generar métodos comunes a una
 * cuenta como sus miembros que utiliza.
 * Ejercicio 3.12
 * @author LorettoTG
 * @version 1.0
 */
public class Cuenta {
    private double saldo = 0.0;

    /**
     * Constructor de Cuenta que inicializa el saldo,
     * si el saldo es menor a 0 lo inicializa con cero.
     * @param saldo double con el saldo de la cuenta.
     */
    public Cuenta(double saldo){
        if( saldo > 0.0 ){
            this.saldo = saldo;
        }
    }

    /**
     * Método que abona alguna cantidad a este saldo.
     * @param monto double Con la cantidad a sumar al saldo.
     */
    public void abonar(double monto) {
        saldo = saldo + monto;
    }

    /**
     * Método que retira alguna cantidad a esta cuenta el saldo.
     * @param monto double Con la cantidad a restar al saldo.
     */
    public void retirar(double monto) {
        if(monto > saldo) {
            System.out.println("El monto a cargar excede el "
                + "saldo de la cuenta");
        } else {
            saldo = saldo - monto;
        }
    }

    /**
     * Método que obtiene el saldo
     * @return saldo double con el saldo de esta cuenta.
     */
    public double getSaldo(){
        return saldo;
    }



    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        Cuenta cuenta = new Cuenta( 50.00 );

        System.out.printf("Saldo de cuenta: $%.2f\n",
                cuenta.getSaldo());

        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        System.out.println("Escriba el monto a depositar de la cuenta: ");
        double monto = entrada.nextDouble();
        System.out.printf("\nsumando %.2f al saldo de cuenta\n\n", monto);
        cuenta.abonar(monto);

        System.out.println("Escriba el monto a retirar de la cuenta");
        monto = entrada.nextDouble();
        System.out.printf("\nretirando %.2f de la cuenta\n\n", monto);
        cuenta.retirar(monto);

        System.out.println("Saldo en la cuenta: " + cuenta.getSaldo());

    }
}