Como Programar en Java: Ejercicio 4.30

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase encargada de analizar un entero de 5
 * dígitos e indicar si es o no es palíndromo.
 * Ejercicio 4.30
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PalindromoNumero {
    /**
     * Método encargado de analizar si el numero es
     * o no es un palíndromo, existen mejores formas
     * de realizarlo pero debemos utilizar lo
     * aprendido hasta este momento.
     */
    public void analizar() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);
        System.out.println("Deme el entero de 5 digitos: ");
        int entero = entrada.nextInt();

        //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 ((entero < 9999) || (entero > 100000)) {
            System.out.println("No es un entero de 5 digitos");
            System.out.println("Deme el entero de 5 digitos: ");
            entero = entrada.nextInt();
        }

        //Si el primer dígito es igual al ultimo dígito
        if ((entero / 10000) == (entero % 10)) {
            //Se quita el primer dígito
            entero = entero % 10000;
            //Se quita el ultimo dígito
            entero = entero / 10;
            if ((entero / 100) == (entero % 10)) {
                System.out.println("Es un palíndromo");
            } else {
                System.out.println("No es un palíndromo");
            }
        } else {
            System.out.println("No es un palíndromo");
        }
    }

    /**
     * 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.
        PalindromoNumero palindromo = new PalindromoNumero();
        palindromo.analizar();
    }
}

Como Programar en Java: Ejercicio 4.1 B

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.awt.Graphics;

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

/**
 * Objeto que crea un panel con una figura.
 * Ejercicio 4.1 B
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PanelDibujoCuatroEsquinas 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;
    /**
     * Dibuja desde la esquina superior izquierda líneas
     * para formar una especie de triángulo en la parte
     * superior izquierda.
     */
    public void paintComponent( Graphics g ) {
        //Lo primero que debemos hacer es llamar a paintComponent
        //para asegurar que el panel se muestre correctamente
        super.paintComponent( g );

        //Obtenemos la anchura total
        int anchura = getWidth();
        //Obtenemos la altura total
        int altura = getHeight();

        //Obtenemos el desplazamiento en x
        int moverEnX = anchura / 15;

        //Obtenemos el desplazamiento en y
        int moverEnY = altura / 15;

        //Un ciclo que dibuja líneas a partir de la esquina superior
        //izquierda, de donde se quedan esas líneas a la esquina inferior
        //derecha, líneas a partir de la esquina superior derecha, de donde
        //se quedan esas líneas a la esquina inferior izquierda.
        for ( int i = 0; i <= 15; i++) {
            g.drawLine( 0, 0, moverEnX * i, altura - (moverEnY * i));
            g.drawLine( moverEnX * i, altura - (moverEnY * i), anchura, altura);
            g.drawLine( anchura, 0, (anchura - moverEnX * i), altura - (moverEnY * i));
            g.drawLine( (anchura - moverEnX * i), altura - (moverEnY * i), 0, altura);
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main( String args[] ) {
        //Crea un objeto PanelDibujoEsquina que contendrá
        //el dibujo
        PanelDibujoCuatroEsquinas panel = new PanelDibujoCuatroEsquinas();

        //Crea un objeto JFrame que contiene el marco
        //donde estará el panel
        JFrame aplicacion = new JFrame();

        //Establece lo que hará el marco al salir
        aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        //Agrega el panel al marco creado
        aplicacion.add( panel );
        //Asignamos el tamaño del marco
        aplicacion.setSize( 200, 200 );
        //Asignamos a la propiedad visible true
        aplicacion.setVisible( true );
    }
}

Como Programar en Java: Ejercicio 4.2 B

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.awt.Graphics;

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

/**
 * Objeto que crea un panel con una figura.
 * Ejercicio 4.2 B
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PanelDibujoCuatroEsquinasAbajo 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;
    /**
     * Dibuja desde la esquina superior izquierda líneas
     * para formar una especie de triángulo en la parte
     * superior izquierda.
     */
    public void paintComponent( Graphics g ) {
        //Lo primero que debemos hacer es llamar a paintComponent
        //para asegurar que el panel se muestre correctamente
        super.paintComponent( g );

        //Obtenemos la anchura total
        int anchura = getWidth();
        //Obtenemos la altura total
        int altura = getHeight();

        //Obtenemos el desplazamiento en x
        int moverEnX = anchura / 15;

        //Obtenemos el desplazamiento en y
        int moverEnY = altura / 15;

        //Un ciclo que dibuja líneas a partir de la esquina superior
        //izquierda, de donde se quedan esas líneas a la esquina inferior
        //derecha, líneas a partir de la esquina superior derecha, de donde
        //se quedan esas líneas a la esquina inferior izquierda.
        for ( int i = 0; i <= 15; i++) {
            g.drawLine(0, moverEnY * i, moverEnX * (i+1), altura);
            g.drawLine(anchura, moverEnY * i, anchura - moverEnX * (i+1), altura);
            g.drawLine(0, altura - moverEnY * i, moverEnX * (i+1), 0);
            g.drawLine(anchura, altura - moverEnY * i, anchura - moverEnX * (i+1), 0);
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main( String args[] ) {
        //Crea un objeto PanelDibujoEsquina que contendrá
        //el dibujo
        PanelDibujoCuatroEsquinasAbajo panel = new PanelDibujoCuatroEsquinasAbajo();

        //Crea un objeto JFrame que contiene el marco
        //donde estará el panel
        JFrame aplicacion = new JFrame();

        //Establece lo que hará el marco al salir
        aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        //Agrega el panel al marco creado
        aplicacion.add( panel );
        //Asignamos el tamaño del marco
        aplicacion.setSize( 200, 200 );
        //Asignamos a la propiedad visible true
        aplicacion.setVisible( true );
    }
}

Como Programar en Java: Ejercicio 4.1 A

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.awt.Graphics;

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

/**
 * Objeto que crea un panel con una figura.
 * Ejercicio 4.1 A
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PanelDibujoEsquina 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;
    /**
     * Dibuja desde la esquina superior izquierda líneas
     * para formar una especie de triángulo en la parte
     * superior izquierda.
     */
    public void paintComponent( Graphics g ) {
        //Lo primero que debemos hacer es llamar a paintComponent
        //para asegurar que el panel se muestre correctamente
        super.paintComponent( g );

        //Obtenemos la anchura total
        int anchura = getWidth();
        //Obtenemos la altura total
        int altura = getHeight();

        //Obtenemos el desplazamiento en x
        int moverEnX = anchura / 15;

        //Obtenemos el desplazamiento en y
        int moverEnY = altura / 15;

        //Un ciclo que dibuja líneas a partir de la esquina superior
        //izquierda
        for ( int i = 0; i <= 15; i++) {
            g.drawLine( 0, 0, moverEnX * i, altura - (moverEnY * i));
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main( String args[] ) {
        //Crea un objeto PanelDibujoEsquina que contendrá
        //el dibujo
        PanelDibujoEsquina panel = new PanelDibujoEsquina();

        //Crea un objeto JFrame que contiene el marco
        //donde estará el panel
        JFrame aplicacion = new JFrame();

        //Establece lo que hará el marco al salir
        aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        //Agrega el panel al marco creado
        aplicacion.add( panel );
        //Asignamos el tamaño del marco
        aplicacion.setSize( 200, 200 );
        //Asignamos a la propiedad visible true
        aplicacion.setVisible( true );
    }
}

Como Programar en Java: Ejercicio 4.2 A

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.awt.Graphics;

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

/**
 * Objeto que crea un panel con una figura.
 * Ejercicio 4.2 A
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PanelDibujoEsquinaAbajo 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;
    /**
     * Dibuja desde la esquina superior izquierda líneas
     * para formar una especie de triángulo en la parte
     * superior izquierda.
     */
    public void paintComponent( Graphics g ) {
        //Lo primero que debemos hacer es llamar a paintComponent
        //para asegurar que el panel se muestre correctamente
        super.paintComponent( g );

        //Obtenemos la anchura total
        int anchura = getWidth();
        //Obtenemos la altura total
        int altura = getHeight();

        //Obtenemos el desplazamiento en x
        int moverEnX = anchura / 15;

        //Obtenemos el desplazamiento en y
        int moverEnY = altura / 15;

        //Un ciclo que dibuja líneas a partir de la esquina superior
        //izquierda, de donde se quedan esas líneas a la esquina inferior
        //derecha, líneas a partir de la esquina superior derecha, de donde
        //se quedan esas líneas a la esquina inferior izquierda.
        for ( int i = 0; i <= 15; i++) {
            g.drawLine(0, moverEnY * i, moverEnX * (i+1), altura);
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main( String args[] ) {
        //Crea un objeto PanelDibujoEsquina que contendrá
        //el dibujo
        PanelDibujoEsquinaAbajo panel = new PanelDibujoEsquinaAbajo();

        //Crea un objeto JFrame que contiene el marco
        //donde estará el panel
        JFrame aplicacion = new JFrame();

        //Establece lo que hará el marco al salir
        aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        //Agrega el panel al marco creado
        aplicacion.add( panel );
        //Asignamos el tamaño del marco
        aplicacion.setSize( 200, 200 );
        //Asignamos a la propiedad visible true
        aplicacion.setVisible( true );
    }
}

Como Programar en Java: Ejercicio 4.20

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

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase que se encarga de calcular el sueldo
 * bruto de tres empleados.
 * Ejercicio 4.20
 * @author LorettoTG
 * @version 1.0
 */
public class SueldoBruto {
    /**
     * Método encargado de realizar el calculo del sueldo.
     * La empresa paga la cuota normal en las primeras 40 horas
     * de trabajo de cada empleado, y paga cuota y media en
     * todas las horas trabajadas que excedan de 40.
     */
    public void calcularSueldo() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        /**
         * Contiene el contador para los tres empleados.
         */
        int contador = 0;
        /**
         * Contiene las horas trabajadas por los empleados.
         */
        int horas = 0;
        /**
         * Contiene el sueldo por hora trabajada.
         */
        double tarifa = 0.0;
        /**
         * Contiene el sueldo total del empleado.
         */
        double sueldo = 0.0;

        //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 < 3) {
            System.out.println("Las horas trabajadas del empleado "
                    + (contador + 1) + ": ");
            horas = entrada.nextInt();
            System.out.println("La tarifa por hora: ");
            tarifa = entrada.nextDouble();

            if ( horas <= 40 ) {
                sueldo = horas * tarifa;
            } else {
                sueldo = (40 * tarifa) + (horas-40) * (tarifa*1.5) ;
            }

            System.out.println("El sueldo del empleado " + (contador + 1)
                    + " es: " + sueldo);

            contador++;
        }
    }

    /**
     * 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.
        SueldoBruto sueldoBruto = new SueldoBruto();
        sueldoBruto.calcularSueldo();
    }
}

Como Programar en Java: Ejercicio 4.22

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

package com.jlm.ccb.ejercicios.capitulo4;

/**
 * Clase encargada de imprimir una tabla
 * con el siguiente encabezado.
 * N    10*N    100*N    1000*N
 * Ejercicio 4.22
 * @author LorettoTG
 * @version 1.0
 */
public class Tabla10N {
    /**
     * Método encargado de realizar el ciclo
     * para la impresión de la tabla.
     */
    public void imprimirTabla() {
        /**
         * Contiene el contador del ciclo while
         */
        int contador = 1;

        System.out.println("N     10*N   100*N   1000*N");
        //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 <= 5) {
            System.out.printf("%d     %d     %d     %d\n",
                    contador, contador*10, contador*100, contador*1000);
            contador++;
        }
    }

    /**
     * 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.
        Tabla10N tabla = new Tabla10N();
        tabla.imprimirTabla();
    }
}