Como Programar en Java: Ejercicio 5.18

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase que calcula el interes compuesto.
 * Ejercicio 5.18
 * @author LorettoTG
 * @author Deitel - Base tomada de su libro.
 * @version 1.0
 */
public class InteresCompuestoEnteros {
     /**
     * 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
         */
        int monto;
        /**
         * Monto inicial los dos ultimos son los decimales
         */
        int principal = 100000;
        /**
         * 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 = (int) (principal * Math.pow(1.0 + (tasa / 100), anio));

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

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 5.12

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase que calcula el producto de los números impares del 1 al 15.
 * Ejercicio 5.12
 * @author LorettoTG
 * @version 1.0
 */
public class ProductoImpares {
    /**
     * Método encargado de calcular el producto de los números impares
     * que están presentes del 1 al 15.
     */
    public void calcularProducto() {
        int contador = 0;
        int resultado = 1;
        for (contador = 1; contador <= 15; contador++) {
            if ((contador % 2) != 0) {
                resultado *= contador;
            }
        }
        System.out.println("El producto de los números impares es: "
                + 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.
        ProductoImpares productoImpares = new ProductoImpares();
        productoImpares.calcularProducto();
    }
}

Como Programar en Java: Ejercicio 5.11

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase que encuentra el menor de varios enteros.
 * Ejercicio 5.11
 * @author LorettoTG
 * @version 1.0
 */
public class MenorEntero {
    /**
     * Método encargado de obtener el menor de
     * los enteros, el primer entero introducido
     * será el numero de enteros que se permiten
     * introducir.
     */
    public void encontrarMenor() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        System.out.println("Deme el número de enteros que introducira");
        int numeroDeEnteros = entrada.nextInt();
        int contador = 1;
        int numero = 0;
        int menor = 0;

        for (contador = 1; contador <= numeroDeEnteros; contador++) {
            System.out.println("Deme un entero: ");
            numero = entrada.nextInt();

            //Si es el primer número introducido
            //el menor será este.
            if (contador == 1) {
                menor = numero;
            }

            //Si el numero es menor al menor entonces
            //menor sera el numero.
            if (numero < menor) {
                menor = numero;
            }
        }

        System.out.println("El menor es: " + menor);
    }

    /**
     * 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.
        MenorEntero menorEntero = new MenorEntero();
        menorEntero.encontrarMenor();
    }
}

Como Programar en Java: Ejercicio 5.2

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

/*
 * Paquete que contiene los ejercicios respecto
 * al capitulo cinco de Como Programar en Java Septima Edicion.
 */
package com.jlm.ccb.ejercicios.capitulocinco;

import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * Clase encargada de imprimir rectángulos de distintos tamaños dependiendo
 * de la cantidad que el usuario ingrese.
 * Ejercicio 5.2
 * @author LorettoTG
 * @version 1.0
 */
public class Barras extends JPanel {
    /**
     * Las clases que implementan este interfaz son susceptibles de ser
     * serializadas (es decir, las instancias de estas clases pueden
     * guardarse y leerse en/de disco -o cualquier otro dispositivo de
     * entrada/salida-). Al serializar lo que sucede es que los atributos
     * del objeto se convierten en cadenas de bytes y se guardan en el
     * disco. Para leer un objeto, se leen las cadenas de bytes y se
     * reconstruye el objeto a partir de ellos. Imagina que tienes una
     * aplicación que serializa en disco una serie de objetos al cerrarse
     * y los lee en la siguiente ejecución para mantener los valores que
     * tenían antes. El campo serialVersionUID es el número de versión de
     * la clase. Cuando el objeto es serializado lo primero que hace es
     * escribir el serialVersionUID. Si al leer el objeto se detecta que
     * el valor del serialVersionUID guardado no coincide con el actual se
     * lanza una exception InvalidClassException, de modo que el programador
     * puede tratar la excepción de manera adecuada. Para que este mecanismo
     * funcione bien, el programador debe proveer el campo private static
     * final long serialVersionUID en todas las clases que implementen
     * Serializable y en todas las subclases de ellas. El valor es
     * indiferente, pero debes actualizarlo cada vez que modificas tu  clase
     * añadiendo o quitando atributos.
     */
    private static final long serialVersionUID = 1L;

    private int tamano = 0;

    /**
     * Constructor de Barras.
     * @param tamano int Tamaño de la barra.
     */
    public Barras(int tamano) {
        this.tamano = tamano;
    }

    /**
     * Método encargado de pintar círculos concéntricos
     * a partir del centro del JPanel con radios mayores de
     * 10 pixeles en 10 pixeles.
     * @param g Objeto Graphics encapsula la información de estado
     * necesaria para realizar las operaciones básicas que soporta
     * Java
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawRect(10, 10, tamano, 10);
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //Obtiene el tamaño del rectángulo.
        String entrada = JOptionPane.showInputDialog("Tamaño del rectángulo: ");

        //Convierte la entrada en un int.
        int tamano = Integer.parseInt(entrada);

        //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.
        Barras barras = new Barras(tamano);

        //Crea un nuevo objeto JFrame
        JFrame aplicacion = new JFrame();

        //Indicamos que la operacion default para
        //cerrar sera EXIT_ON_CLOSE
        aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //Agregando el panel al marco
        aplicacion.add(barras);
        //Establece el tamaño del marco
        aplicacion.setSize(300, 300);
        //Poniendo su propiedad Visible en verdadera
        aplicacion.setVisible(true);
    }
}

Como Programar en Java: Ejercicio 5.1

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.awt.Graphics;

import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * Clase encargada de pintar 10 circulos concéntricos.
 * Ejercicio 5.1
 * @author LorettoTG
 * @version 1.0
 */
public class CirculosDiez extends JPanel {
    /**
     * Las clases que implementan este interfaz son susceptibles de ser
     * serializadas (es decir, las instancias de estas clases pueden
     * guardarse y leerse en/de disco -o cualquier otro dispositivo de
     * entrada/salida-). Al serializar lo que sucede es que los atributos
     * del objeto se convierten en cadenas de bytes y se guardan en el
     * disco. Para leer un objeto, se leen las cadenas de bytes y se
     * reconstruye el objeto a partir de ellos. Imagina que tienes una
     * aplicación que serializa en disco una serie de objetos al cerrarse
     * y los lee en la siguiente ejecución para mantener los valores que
     * tenían antes. El campo serialVersionUID es el número de versión de
     * la clase. Cuando el objeto es serializado lo primero que hace es
     * escribir el serialVersionUID. Si al leer el objeto se detecta que
     * el valor del serialVersionUID guardado no coincide con el actual se
     * lanza una exception InvalidClassException, de modo que el programador
     * puede tratar la excepción de manera adecuada. Para que este mecanismo
     * funcione bien, el programador debe proveer el campo private static
     * final long serialVersionUID en todas las clases que implementen
     * Serializable y en todas las subclases de ellas. El valor es
     * indiferente, pero debes actualizarlo cada vez que modificas tu  clase
     * añadiendo o quitando atributos.
     */
    private static final long serialVersionUID = 1L;

    private static final int ITERACIONES = 10;

    private static final int LADO_CUADRADO = 20;

    private static final int DESPLAZAMIENTO = 10;
    /**
     * Método encargado de pintar circulos concéntricos
     * a partir del centro del JPanel con radios mayores de
     * 10 pixeles en 10 pixeles.
     * @param g Objeto Graphics encapsula la información de estado
     * necesaria para realizar las operaciones basicas que soporta
     * Java
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        //Obteniendo el ancho
        int ancho = getWidth() / 2;
        //Obteniendo la altura
        int altura = getHeight() / 2;

        //Ciclo para pintar 10 circulos
        for (int i = 0; i < ITERACIONES; i++) {
            //El punto centrico en x menos 5x(i+1) unidades
            //El punto centrico en y menos 5x(i+1) unidades
            //Esto para ir desplazando las esquinas de los
            //rectangulos que conformar el circulo del centro
            //hacia la esquina superior izquierda y el larcho
            //y ancho lo vamos incrementando.
            g.drawOval(ancho - (DESPLAZAMIENTO * (i + 1)),
                    altura - (DESPLAZAMIENTO * (i + 1)),
                    LADO_CUADRADO + i * LADO_CUADRADO,
                    LADO_CUADRADO + i * LADO_CUADRADO);
        }
    }

    /**
     * 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.
        CirculosDiez panel = new CirculosDiez();

        //Crea un nuevo objeto JFrame
        JFrame aplicacion = new JFrame();

        //Indicamos que la operacion default para
        //cerrar sera EXIT_ON_CLOSE
        aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //Agregando el panel al marco
        aplicacion.add(panel);
        //Establece el tamaño del marco
        aplicacion.setSize(300, 300);
        //Poniendo su propiedad Visible en verdadera
        aplicacion.setVisible(true);
    }
}

Como Programar en Java: Ejercicio 2.29

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase encargada de imprimir cuadrados
 * huevos con un lado mayor o igual a 1 unidad
 * y menor o igual a 20 unidades.
 * Ejercicio 4.29
 * @author LorettoTG
 * @version 1.0
 */
public class Cuadrado {
    /**
     * Método encargado de imprimir cuadrados huecos
     * con tamaño de sus lados de 1-20 unidades.
     */
    public void imprimirCuadrado() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        System.out.println("Deme el lado del cuadrado: ");
        int lado = entrada.nextInt();

        if ((lado >= 1) && (lado <= 20)) {
            int renglon = 1;
            int columna = 1;
            //En el caso del ciclo while: Primero se evalúa 
            //la condición de entrada si es verdadera ejecuta 
            //las sentencias en su cuerpo, luego vuelve a
            //verificar la condición de entrada y hasta que 
            //sea falsa sale del ciclo.
            while (renglon <= lado) {
                columna = 1;
                while (columna <= lado) {
                    if ((renglon == 1) || (renglon == lado)) {
                        System.out.print("*");
                    } else {
                        if ((columna == 1) || (columna == lado)) {
                            System.out.print("*");
                        } else {
                            System.out.print(" ");
                        }
                    }
                    columna++;
                }
                System.out.println();
                renglon++;
            }
        } else {
            System.out.println("El tamaño no se puede procesar.");
        }
    }

    /**
     * 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.
        Cuadrado cuadrado = new Cuadrado();
        cuadrado.imprimirCuadrado();
    }
}

Como Programar en Java: Ejercicio 4.23

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase encargada de obtener los dos enteros más grandes
 * de un conjunto de 10 enteros.
 * Ejercicio 4.23
 * @author LorettoTG
 * @version 1.0
 */
public class DosMasGrandes {
    /**
     * Método encargado de obtener los dos enteros mas
     * grandes de un conjunto de 10 enteros.
     */
    public void calcularGrandes() {
        /**
         * Contiene el contador del ciclo while.
         */
        int contador = 0;

        /**
         * Contiene el entero introducido por el usuario.
         */
        int numero = 0;

        /**
         * Contiene el mayor de los enteros introducidos por
         * el usuario.
         */
        int mayor = 0;

        /**
         * Contiene el segundo entero mayor de los enteros
         * introducidos por el usuario.
         */
        int segundoMayor = 0;

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

        //En el caso del ciclo while: Primero se evalúa la condición 
        //de entrada si es verdadera ejecuta las sentencias en su
        //cuerpo, luego vuelve a verificar la condición de entrada 
        //y hasta que sea falsa sale del ciclo.
        while (contador < 10) {
            System.out.print("\nDame un entero: ");
            numero = entrada.nextInt();

            //Si entra en numero > mayor inmediatamente el segundoMayor
            //se le asigna lo que tenía el mayor puesto que este deja de
            //ser el mayor.
            if (numero > mayor) {
                segundoMayor = mayor;
                mayor = numero;
            } else if (numero > segundoMayor) {
                segundoMayor = numero;
            }
            contador++;
        }

        System.out.println("\nEl entero más grande es: " + mayor
                + " y el segundo más grande es: " + segundoMayor);
    }

    /**
     * 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.
        DosMasGrandes dosMasGrandes = new DosMasGrandes();
        dosMasGrandes.calcularGrandes();
    }
}

Como Programar en Java: Ejercicio 4.21

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase encargada de buscar el entero más grande de 10 enteros
 * introducidos por el usuario.
 * Ejercicio 4.21
 * @author LorettoTG
 * @version 1.0
 */
public class ElMasGrande {
    /**
     * Método encargado de recibir 10 enteros y buscar el mayor
     * de ellos.
     */
    public void buscarMayor() {
        /**
         * Contiene el contador del ciclo while
         */
        int contador = 0;

        /**
         * Contiene el entero introducido por el usuario
         */
        int numero = 0;

        /**
         * Contiene el mayor de los enteros introducidos por
         * el usuario
         */
        int mayor = 0;

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

        //En el caso del ciclo while: Primero se evalúa 
        //la condición de entrada si es verdadera ejecuta las 
        //sentencias en su cuerpo, luego vuelve a verificar la 
        //condición de entrada y hasta que sea falsa sale del ciclo.
        while (contador < 10) {
            System.out.print("\nDame un entero: ");
            numero = entrada.nextInt();

            if (numero > mayor) {
                mayor = numero;
            }
            contador++;
        }

        System.out.println("\nEl entero más grande es: " + mayor);
    }

    /**
     * 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.
        ElMasGrande elMasGrande = new ElMasGrande();
        elMasGrande.buscarMayor();
    }
}