Como Programar en Java: Ejercicio 5.29

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

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

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

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