Cenando con Bytes

Como Programar en Java: Ejercicio 6.34

2011-10-06T21:55:00.000-05:00

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número y arroja un mensaje dependiendo el
 * número de intentos que realizo el usuario.
 * Ejercicio 6.34
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumeroSecreto {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;
        int contador = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
                contador++;
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
                contador++;
            } else {
                contador++;
                System.out.println("FELICIDADES. Adivino el número!");
                if (contador < 10) {
                    System.out.println("O ya sabía ustede el secreto, "
                            + "o tuvo suerte!");
                } else if (contador > 10) {
                    System.out.println("Debería haberlo hecho mejor.");
                } else {
                    System.out.println("Aja! Sabia usted el secreto!");
                }
            }
        }
    }

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

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 6.34

2011-10-06T21:44:00.000-05:00

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número y arroja un mensaje dependiendo el
 * número de intentos que realizo el usuario.
 * Ejercicio 6.34
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumeroSecreto {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;
        int contador = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
                contador++;
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
                contador++;
            } else {
                contador++;
                System.out.println("FELICIDADES. Adivino el número!");
                if (contador < 10) {
                    System.out.println("O ya sabía ustede el secreto, "
                            + "o tuvo suerte!");
                } else if (contador > 10) {
                    System.out.println("Debería haberlo hecho mejor.");
                } else {
                    System.out.println("Aja! Sabia usted el secreto!");
                }
            }
        }
    }

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

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 6.33

2011-10-05T21:43:00.000-05:00

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número.
 * Ejercicio 6.33
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumero {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
            } else {
                System.out.println("FELICIDADES. Adivino el número!");
            }
        }
    }

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

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 5.29

2011-10-02T19:00:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir Twelve Days
 * Ejercicio 5.29
 * @author LorettoTG
 * @version 1.0
 */
public class DoceDias {
    /**
     * MÃ©todo encargado de imprimir la cancion de los
     * doce dias.
     */
    public void imprimir() {
        for (int dia = 1; dia <= 12; dia++) {
            switch(dia) {
            case 1:
                System.out.print("One ");
                imprimirFragmento(dia);
                break;
            case 2:
                System.out.print("Two ");
                imprimirFragmento(dia);
                break;
            case 3:
                System.out.print("Three ");
                imprimirFragmento(dia);
                break;
            case 4:
                System.out.print("Four ");
                imprimirFragmento(dia);
                break;
            case 5:
                System.out.print("Five ");
                imprimirFragmento(dia);
                break;
            case 6:
                System.out.print("Six ");
                imprimirFragmento(dia);
                break;
            case 7:
                System.out.print("Seven ");
                imprimirFragmento(dia);
                break;
            case 8:
                System.out.print("Eight ");
                imprimirFragmento(dia);
                break;
            case 9:
                System.out.print("Nine ");
                imprimirFragmento(dia);
                break;
            case 10:
                System.out.print("Ten ");
                imprimirFragmento(dia);
                break;
            case 11:
                System.out.print("Eleven ");
                imprimirFragmento(dia);
                break;
            case 12:
                System.out.print("Twelve ");
                imprimirFragmento(dia);
                break;
            }
        }
    }

    /**
     * MÃ©todo encargado de imprimir fragmentos de
     * la cancion correspondiente al dÃa.
     * @param dia int Con el fragmento correspondiente
     * al dÃa.
     */
    public void imprimirFragmento(int dia) {
        switch(dia) {
        case 1:
            System.out.println("True Love refers to God");
            break;
        case 2:
            System.out.println("Turtle Doves refers to the Old "
                    + "and New Testaments");
            break;
        case 3:
            System.out.println("French Hens refers to Faith, "
                    + "Hope and Charity, the Theological Virtues");
            break;
        case 4:
            System.out.println("Calling Birds refers to the Four "
                    + "Gospels and/or the Four Evangelists");
            break;
        case 5:
            System.out.println("Golden Rings refers to the first Five "
                    + "Books of the Old Testament, the \"Pentateuch\", "
                    + "which gives the history of man's fall from grace.");
            break;
        case 6:
            System.out.println("Geese A-laying refers to the six days "
                    + "of creation");
            break;
        case 7:
            System.out.println("Swans A-swimming refers to the seven gifts "
                    + "of the Holy Spirit, the sacraments");
            break;
        case 8:
            System.out.println("Maids A-milking refers to the eight "
                    + "beatitudes");
            break;
        case 9:
            System.out.println("Ladies Dancing refers to the nine Fruits of "
                    + "the Holy Spirit");
            break;
        case 10:
            System.out.println("Lords A-leaping refers to the ten "
                    + "commandments");
            break;
        case 11:
            System.out.println("Pipers Piping refers to the eleven "
                    + "faithful apostles");
            break;
        case 12:
            System.out.println("Drummers Drumming refers to the points of "
                    + "doctrine in the Apostle's Creed");
            break;
        }
    }

    /**
     * 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.
        DoceDias doceDias = new DoceDias();
        doceDias.imprimir();
    }
}

Como Programar en Java: Ejercicio 5.27

2011-10-01T17:31:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de simular una salida de un ciclo
 * sin utilizar continue.
 * Ejercicio 5.27
 * @author LorettoTG
 * @version 1.0
 */
public class NoContinue {
    /**
     * Punto de entrada a la clase y a la aplicaciÃ³n.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        for (int cuenta = 1; cuenta <= 10; cuenta++) {
            if (cuenta != 5) {
                System.out.printf("%d ", cuenta);
            }
        }
        System.out.println("\nSe uso continue para omitir imprimir 5");
    }
}

Como Programar en Java: Ejercicio 5.26

2011-09-29T20:03:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de simular una salida de un ciclo
 * sin utilizar break.
 * Ejercicio 5.26
 * @author LorettoTG
 * @version 1.0
 */
public class NoBreak {
    /**
     * Punto de entrada a la clase y a la aplicaciÃ³n.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        int cuenta = 0;

        do {
            cuenta++;
            System.out.printf("%d ", cuenta);
        } while (cuenta != 5);

        System.out.printf("\nSalio del ciclo en cuenta = %d\n", cuenta);
    }
}

Como Programar en Java: Ejercicio 5.25

2011-09-27T22:23:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de imprimir un Rombo
 * con asteriscos.
 * Ejercicio 5.25
 * @author LorettoTG
 * @version 1.0
 */
public class RomboTamano {
    /**
     * MÃ©todo encargado de imprimir un Rombo
     * con asteriscos.
     * @param numero int Con un numero impar, si no
     * fuera impar el metodo lo indicara.
     */
    public void imprimir(int numero) {
        if (numero < 0 || numero > 19) {
            System.out.println("Debe estar entre 1 y 19 el numero.");
        } else {
            if (numero % 2 == 0) {
                System.out.println("No es un nÃºmero impar.");
            } else {
                int media = numero / 2 + 1;
                for (int renglon = 1; renglon <= numero; renglon++) {
                    for (int columna = 1; columna <= numero;
                            columna++) {
                        if (renglon <= media) {
                            if (((media - renglon) < columna)
                                    && (columna < (media + renglon))) {
                                System.out.print('*');
                            } else {
                                System.out.print(' ');
                            }
                        } else {
                            if (((renglon - media) < columna)
                                    && (columna < (media * 2
                                    - (renglon - media)))) {
                                System.out.print('*');
                            } else {
                                System.out.print(' ');
                            }
                        }
                    }
                    System.out.println();
                }
            }
        }
    }

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

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

        System.out.println("Deme un nÃºmero impar: ");
        int numero = entrada.nextInt();
        rombo.imprimir(numero);
    }
}

Como Programar en Java: Ejercicio 5.24

2011-09-26T21:04:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir un Rombo
 * con asteriscos.
 * Ejercicio 5.24
 * @author LorettoTG
 * @version 1.0
 */
public class Rombo {
    /**
     * MÃ©todo encargado de imprimir un Rombo
     * con asteriscos.
     */
    public void imprimir() {
        int media = 9 / 2 + 1;
        for (int renglon = 1; renglon <= 9; renglon++) {
            for (int columna = 1; columna <= 9; columna++) {
                if (renglon <= media) {
                    if (((media - renglon) < columna)
                            && (columna < (media + renglon))) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else {
                    if (((renglon - media) < columna)
                            && (columna < (media * 2 - (renglon - media)))) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                }
            }
            System.out.println();
        }
    }

    /**
     * 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.
        Rombo rombo = new Rombo();
        rombo.imprimir();
    }
}

Como Programar en Java: Ejercicio 5.23

2011-09-25T22:19:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de convertir las siguientes
 * expresiones utilizando leyes de Morgan.
 * !( x < 5 ) && !( y >= 7 )
 * !( x == y ) || !( z != 5 )
 * !( ( x <= 8 ) && ( y > 4 ) )
 * !( ( x > 4 ) || ( y <= 6 ) )
 * Ejercicio 5.23
 * @author LorettoTG
 * @version 1.0
 */
public class LeyesMorgan {
    /**
     * MÃ©todo encargado de convertir algunas condiciones
     * con las leyes de morgan. Si se imprime alguna leyenda
     * de no es cierto quiere decir que las leyes de Morgan
     * no fueron aplicadas correctamente.
     * @param x int Con el primer entero introducido.
     * @param y int Con el segundo entero introducido.
     * @param z int Con el tercer entero introducido.
     */
    public void calcular(int x, int y, int z) {
        if (((!(x < 5) && !(y >= 7)))
                != (((x >= 5) && (y < 7)))) {
            System.out.println("No es cierto 1");
        }


         if (((!(x == y) || !(z != 5)))
                 != ((x != y) || (z == 5))) {
             System.out.println("No es cierto 2");
         }

         if ((!((x <= 8) && (y > 4)))
                 != ((x > 8) || (y <= 4))) {
             System.out.println("No es cierto 3");
         }
         if ((!((x > 4) || (y <= 6)))
                 != ((x <= 4) && (y > 6))) {
             System.out.println("No es cierto 4");
         }
    }

    /**
     * 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.
        LeyesMorgan leyes = new LeyesMorgan();
        for (int x = 1; x <= 10; x++) {
            for (int y = 1; y <= 10; y++) {
                for (int z = 1; z <= 10; z++) {
                    leyes.calcular(x, y, z);
                }
            }
        }

    }
}

Como Programar en Java: Ejercicio 5.22

2011-09-24T14:44:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir diferentes patrones utilizando
 * seguidos.
 * Ejercicio 5.22
 * @author LorettoTG
 * @version 1.0
 */
public class ImprimirAsteriscosAstutos {
    /**
     * MÃ©todo encargado de imprimir 4 diferentes patrones.
     */
    public void imprimirPatrones() {
        for (int renglon = 1; renglon <= 10; renglon++) {
            for (int columna = 1; columna <= 55; columna++) {
                if (columna <= 10) {
                    if (columna <= renglon) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else if (columna > 10 && columna <= 15) {
                    System.out.print(' ');
                } else if (columna > 15 && columna <= 25) {
                    if ((columna - 15) <= (11 - renglon)) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else if (columna > 25 && columna <= 30) {
                    System.out.print(' ');
                } else if (columna > 30 && columna <= 40) {
                    if ((columna - 30) < renglon) {
                        System.out.print(' ');
                    } else {
                        System.out.print('*');
                    }
                } else if (columna > 40 && columna <= 45) {
                    System.out.print(' ');
                } else {
                    if ((columna - 45) <= (10 - renglon)) {
                        System.out.print(' ');
                    } else {
                        System.out.print('*');
                    }
                }
            }
            System.out.println();
        }
    }

    /**
     * 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.
        ImprimirAsteriscosAstutos asteriscos = new ImprimirAsteriscosAstutos();
        asteriscos.imprimirPatrones();
    }
}

Como Programar en Java: Ejercicio 5.21

2011-09-24T14:43:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de calcular los Triples de Pitagoras.
 * Ejercicio 5.21
 * @author LorettoTG
 * @version 1.0
 */
public class TriplesPitagoras {
    /**
     * Método encargado de calcular los Triples de
     * Pitagoras por fuerza bruta en longitudes que van
     * desde 1 hasta 500 unidades.
     */
    public void calcular() {
        /**
         * Contiene la suma de los cuadrados de los dos lados
         * de un triangulo.
         */
        int sumaLados = 0;

        /**
         * Contiene el total de triples de pitagoras.
         */
        int contador = 0;
        for (int lado1 = 1; lado1 <= 500; lado1++) {
            for (int lado2 = 1; lado2 <= 500; lado2++) {
                for (int hipotenusa = 1; hipotenusa <= 500; hipotenusa++) {
                    sumaLados = (lado1 * lado1) + (lado2 * lado2);
                    if ((hipotenusa * hipotenusa) == sumaLados) {
                        System.out.println("Triples de pitÃ¡goras con:\n"
                                + "\tLado 1: " + lado1
                                + "\n\tLado 2: " + lado2
                                + "\n\tHipotenusa: " + hipotenusa);
                        contador++;
                    }
                }
            }
        }
        System.out.println("Existen un total de " + contador
                    + " triples de pitÃ¡goras.");
    }

    /**
     * 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.
        TriplesPitagoras triplesPitagoras = new TriplesPitagoras();
        triplesPitagoras.calcular();
    }
}

Como Programar en Java: Ejercicio 5.20

2011-09-22T21:07:00.000-05:00

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

2011-09-22T21:00:00.000-05:00

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.16

2011-09-21T20:22:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de imprimir barras horizontales.
 * Ejercicio 5.16
 * @author LorettoTG
 * @version 1.0
 */
public class BarrasHorizontales {
    /**
     * MÃ©todo encargado de imprimir una barra horizontal
     * @param numeroAsteriscos int con el nÃºmero de asteriscos
     * a imprimir.
     */
    public void imprimir(int numeroAsteriscos) {
        for (int contador = 1; contador <= numeroAsteriscos; contador++) {
            System.out.print('*');
        }
        System.out.println();
    }

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

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

        /**
         * Contiene el contador para el ciclo.
         */
        int contador = 1;
        /**
         * Contiene el numero ingresado por el usuario.
         */
        int numeroAsteriscos = 0;

        do {
            System.out.print("Deme el primer numero: ");
            numeroAsteriscos = entrada.nextInt();

            if (numeroAsteriscos > 0 && numeroAsteriscos < 30) {
                barras.imprimir(numeroAsteriscos);
                contador++;
            } else {
                System.out.println("Ingrese un numero entre 1 y 30");
            }
        } while (contador <= 5);

    }
}

Como Programar en Java: Ejercicio 5.18

2011-09-21T20:20:00.000-05:00

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.15

2011-09-19T20:13:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir diferentes patrones utilizando
 * solamente:
 * System.out.print('*');
 * System.out.println();
 * Esta instruccion solo se utiliza para los dos ultimos patrones.
 * System.out.print(' ');
 * Ejercicio 5.15
 * @author LorettoTG
 * @version 1.0
 */
public class ImprimirAsteriscos {
    /**
     * MÃ©todo encargado de imprimir 4 diferentes patrones.
     */
    public void imprimirPatrones() {
        System.out.println("Imprime el patron (a)");
        for (int renglon = 1; renglon <= 10; renglon++) {
            for (int columna = 1; columna <= renglon; columna++) {
                System.out.print('*');
            }
            System.out.println();
        }
        System.out.println("\n\nImprime el patron (b)");
        for (int renglon = 10; renglon >= 1; renglon--) {
            for (int columna = 1; columna <= renglon; columna++) {
                System.out.print('*');
            }
            System.out.println();
        }
        System.out.println("\n\nImprime el patron (c)");
        for (int renglon = 1; renglon <= 10; renglon++) {
            for (int columna = 1; columna <= 10; columna++) {
                if (columna < renglon) {
                    System.out.print(' ');
                } else {
                    System.out.print('*');
                }
            }
            System.out.println();
        }
        System.out.println("\n\nImprime el patron (d)");
        for (int renglon = 10; renglon >= 1; renglon--) {
            for (int columna = 1; columna <= 10; columna++) {
                if (columna < renglon) {
                    System.out.print(' ');
                } else {
                    System.out.print('*');
                }
            }
            System.out.println();
        }
    }

    /**
     * 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.
        ImprimirAsteriscos asteriscos = new ImprimirAsteriscos();
        asteriscos.imprimirPatrones();
    }
}

Como Programar en Java: Ejercicio 5.14

2011-09-19T20:10:00.000-05:00

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

2011-09-18T21:24:00.000-05:00

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.13

2011-09-17T16:22:00.000-05:00

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de calcular el factorial.
 * Ejercicio 5.13
 * @author LorettoTG
 * @version 1.0
 *
 */
public class Factorial {
    /**
     * MÃ©todo encargado de calcular el factorial de
     * un nÃºmero positivo utilizando un mÃ©todo iterativo.
     * Si se ingresa un nÃºmero negativo regresara un -1 como
     * resultado.
     * @param entero int Con el entero a calcular su factorial.
     * @return resultado int Con el factorial calculado.
     */
    public int calcularFactorial(int entero) {
        /**
         * Contiene el contador utilizado como condiciÃ³n en el
         * ciclo while para calcular su factorial.
         */
        int contador = 1;
        /**
         * Almacena el resultado del factorial, por ser multiplicaciones
         * lo que se utilizara se inicializa en 1.
         */
        int resultado = 1;

        if (entero >= 0) {
            //Las tres partes del ciclo se encuentran
            //separadas por ; (punto y coma). La primer
            //parte del ciclo especifica valores previo
            //a su inicio. La segunda parte indica la
            //condiciÃ³n de terminaciÃ³n para el ciclo,
            //la cual esta directamente relacionada con
            //los valores iniciales. Finalmente, la
            //Ãºltima parte especifica como serÃ¡n
            //manipulados los valores iniciales en cada
            //iteraciÃ³n del ciclo. Cada parte del ciclo
            //debe incluir al menos un elemento, a la
            //cual es posible agregar otros elementos a
            //partir de una , (coma).
            for (contador = 1; contador <= entero; contador++) {
                resultado = resultado * contador;
            }
            return resultado;
        } else {
            return -1;
        }
    }

    /**
     * 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.
        Factorial factorial = new Factorial();
        int contador = 1;
        //Las tres partes del ciclo se encuentran
        //separadas por ; (punto y coma). La primer
        //parte del ciclo especifica valores previo
        //a su inicio. La segunda parte indica la
        //condiciÃ³n de terminaciÃ³n para el ciclo,
        //la cual esta directamente relacionada con
        //los valores iniciales. Finalmente, la
        //Ãºltima parte especifica como serÃ¡n
        //manipulados los valores iniciales en cada
        //iteraciÃ³n del ciclo. Cada parte del ciclo
        //debe incluir al menos un elemento, a la
        //cual es posible agregar otros elementos a
        //partir de una , (coma).
        for (contador = 1; contador <= 5; contador++) {
            System.out.println(contador + "    "
                + factorial.calcularFactorial(contador));
        }
    }
}

Como Programar en Java: Ejercicio 5.11

2011-09-14T19:20:00.000-05:00

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

2011-09-13T21:34:00.000-05:00

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

2011-09-12T19:49:00.000-05:00

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

2011-09-11T19:31:00.000-05:00

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

2011-09-10T20:04:00.000-05:00

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

2011-09-10T19:57:00.000-05:00

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();
    }
}