Programación, Desarrollo, Ingeniería de Software, Frameworks, &c

Cómo subir un archivo al servidor usando JSP

2011-11-17T08:38:00.001-08:00

En este corto tutorial expondré cómo subir un archivo a un servidor Tomcat, usando JSP.

Primero que todo el formulario (form.html):

A continuación el script JSP (uploadFile.jsp):

[Nota: Recuerden añadir estas librerías a directorio_instalación_tomcatX/lib/:

commons-fileupload-1.2.2.jar
commons-io-2.1.jar

Las librerías las pueden descargar desde aquí: commons-fileupload-x.x.x.jar commons-io-x.x.jar

Además, no olviden reiniciar el servidor Web Tomcat.

]

¿Es recomendado el uso de Mapa de Imágenes?

2011-11-07T06:37:00.000-08:00

Esta vez quiero hablerles sobre el uso de mapas de imágenes en sitios Web:

¿Es recomendado su uso?

Hace unos días dediqué ocasión para leer acerca de las mejores prácticas para acelerar el proceso de carga de un sitio Web, y me he encontrado con una consideración importante para reducir el número de peticiones (requests, en inglés) tipo HTTP. Vale la pena discutir sobre este aspecto, ya que hoy por hoy, son muchos los aspectos a considerar cuando diseñamos, implementamos una aplicación Web.

A pesar de que existen herramientas que automatizan este proceso, en casos específicos, debemos hacerlo a mano, pues con esto ganamos mayor control sobre lo que estamos programando, y en lo que se refiere a mapas de imágenes hay alternativas más apropiadas para llevar a cabo esta tarea, pero desde mi experiencia, puedo decir que:

El uso de mapas de imágenes obstaculiza la accesibilidad.
Es propenso a errores, debido al uso de coordenadas para su ubicación o definición.
El abánico de clientes Web es enorme, lo que acrecenta la posibilidad de casos de incompatibilidad.

¿Qué piensan uds. sobre este aspecto sobre el rendimiento de un sitio Web?

Instalación de Zend Server CE en Ubuntu 10.04

2010-10-04T17:32:00.000-07:00

Como he había escrito en un post anterior, estoy haciendo énfasis en el aprendizaje, desarrollo e implementación de tecnologías en la nube.

Entonces, a partir de ahora se inicia la entrega de diferentes guías, tutoriales, descargas, &c.

Y es así, que para esta ocasión me he tomado un poco de tiempo para explicar el proceso de instalación automático de Zend Server Community Edition (CE) para Linux:

Descargar el script de instalación (disponible en RPM/DEB) desde aquí.
Descomprimir el archivo recién descargado.
Ingresar al contenido del directorio descomprimido. Y ejecutar uno de los siguientes comandos:
- Para PHP 5.2: sudo install_zs.sh 5.2 ce
- Para PHP 5.3: sudo install_zs.sh 5.3 ce
Una vez finalice la instalación podemos ingresar al administrador Web de Zend Server, así:
- Modo seguro: https://localhost:10082/ZendServer
- Modo normal: http://localhost:10081/ZendServer/

Bueno, eso corresponde a la instalación de ZS. Espero que esto les sea de gran ayuda.

Adicinal: dejo el link oficial de la comunidad de Zend.

Conceptos básicos de Programación y Diseño

2010-10-03T15:18:00.001-07:00

Programación: La base de la programación es la lógica binaria; hay una forma correcta e incorrecta para implementar un algoritmo dado.

Diseño: La base del diseño es cómo su cerebro interpreta lo que el ve; y dado que no todos interpretan las cosas de la misma manera, es imposible decir que si algo es correcto o incorrecto.

openindiana la alternative verdaderamente OpensSource de OpenSolaris

2010-09-27T08:49:00.001-07:00

Como es sábido por la comunidad Open Source, OpenSolaris ya no recibirá atención por parte de Oracle (quién adquirió Sun Microsystems e hizo que se descontinuará el desarrollo del Sistema Operativo anteriormente nombrado), con lo cual muchos usuarios del dicho SO se ve afectada por esta situación.

Y claro, la comunidad inquietada, precisamente el grupo OpenIndiana que gracias al aporte de muchos usuarios ha proyectado el desarrollo de un sistema operativo basado en OpenSolaris. A continuación algunas imágenes de lo que será esta distribución GNU/Linux:

Estaré atento a nuevas noticias acerca de OpenIndiana para mantenerlos informados. Hasta pronto.

2010-09-24T10:07:00.001-07:00

"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"

A Timeless Way of Building - Christopher Alexander

Transición

2010-09-24T09:46:00.001-07:00

En Java México han publicado un corto artículo que habla sobre los problemas que evitan que Java sea usado como plataforma de desarrollo en empresas. Al iniciar, se menciona sobre lo que se considera Java hoy en día, quiénes son las personas que más lo están usando, etc.

Más...

Algunos conceptos sobre patrones e IS

2010-09-21T06:10:00.001-07:00

“Cada patrón describe un problema que ocurre una y otra vez en nuestro entorno, para describir después el núcleo de la solución a ese problema, de tal manera que esa solución pueda ser usada más de un millón de veces sin hacerlo siquiera dos veces de la misma forma” [Alexander - A Pattern Language Towns/Building/Construction]

Concepto de patrón de diseño:

"Una arquitectura orientada a objetos bien estructurada está llena de patrones. La calidad de un sistema orientado a objetos se mide por la atención que los diseñadores han prestado a las colaboraciones entre sus objetos. Los patrones conducen a arquitecturas más pequeñas, más simples y más comprensibles". [Grady Booch]

Los patrones de diseño son descripciones de clases cuyas instancias colaboran entre sí. Cada patrón es adecuado para ser adaptado a un cierto tipo de problema. Para describir un caso debemos especificar:

Nombre
Propósito o finalidad
Sinónimos (otros nombres por los que puede ser conocido)
Problema al que es aplicable
Estructura (diagrama de clases)
Participantes (responsabilidad de cada clase)
Colaboraciones (diagrama de interacciones)
Implementación (consejos, notas y ejemplos)
Otros patrones con los que está relacionado

[Extraído desde: Design Patterns - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides]

Hacia la Web...

2010-09-19T18:33:00.001-07:00

Continuará...

Test de Personalidad de Programador

2010-09-18T22:21:00.001-07:00

En el siguiente enlace: http://www.doolwind.com/blog/programmer-personality-test/ me encontrado con un interesante test que mide la personalidad de un programador.

Entre las preguntas que se hayan en el test son:

¿En qué invierte la mayor parte de su tiempo?
¿Quién es el mejor programador?
¿Cuál es la mejor manera de programar?
El lenguaje 'perfecto' será:
¿Cuál es la mejor implementación?

Este test, puede ser útil para comprender cómo nos comportamos durante el desarrollo de una aplicación o sistema, cuales son nuestras habilidades más sobresalientes, y cómo, en qué estamos fallando.

Edito: aquí hay otro!

Código spaghetti!

2010-09-18T20:00:00.001-07:00

Hablemos un poco del famoso código spaghetti:

El código spaghetti se distingue por ser un código tiende a utilizar instrucciones u órdenes que llevan a confundir durante su lectura (bueno por parte del programador) y que en un programa extenso hace que sea ilegible y de díficil comprensión.

Características específicas del código spaghetti: mucho GOTOs, excepciones, hilos, y construcciones de decisión sin una estructura bien definida:

miremos el primer ejemplo: http://paste.ubuntu.com/496233/ [Wikipedia2010]

Para un programador principiante, este un código de díficil interpretación.

Ahora el mismo programa, pero en un lenguaje de programación estructurado: http://paste.ubuntu.com/496234/ [Wikipedia2010]

Como podemos observar, los lenguajes de programación actuales han cambiado ese enfoque antíquisimo de forma radical, lo que permite que haya más personas que puedan escribir programas sin conocimientos profesionales.

Más información: aquí

Copiar & pegar en-línea

2010-09-18T08:24:00.000-07:00

Pastebin de Ubuntu es una gran utilidad alojada en la nube, que nos permite pegar cualquier texto (plano) o código fuente de cualquier lenguaje de programación (la lista es bastante extensa), por ejemplo: ActionScript, C++, C#, CSS, Erlang, HTML, Java, JavaScript, MySQL, Perl, SQL, XML, entre otros más.

Aquí dejo un ejemplo:

Desde este enlace puede consultar el código y descarglo. Esto quiere decir que por cada texto que peguemos en Ubuntu Pastebin, nos proporcionar un enlace para poder compartirlo con otros e inclusive descargarlo: http://paste.ubuntu.com/485447/

Aplicaciones Web vs Aplicaciones de Escritorio

2010-09-18T07:25:00.001-07:00

Podemos fácilmente distinguir entre una aplicación Web y una aplicación de Escritorio: esta última se caracteriza por llevar a cabo casi la totalidad de operaciones de negocios, la seguridad impera en este modo, debido a que el equipo donde se encuentra instalada puede contar con diferentes mecanismos de defense frente a virus, troyanos, software espía, &c; el rendimiento y velocidad de procesamiento son también un punto a favor, dado que de forma local aprovecha (si es que el desarrollador de la aplicación lo ha considerado) los recursos de máquina de forma eficiente y eficaz...

Ahora, con respecto a las aplicaciones Web, éstas tienen muchos puntos a favor, como por ejemplo la administración centralizada, el despliegue se puede realizar en un 1/4 del tiempo que toma una aplicación de Escritorio en instalarle en equipos cliente. Por otro lado, sigue el paradigma de multiplataforma, ya que a través de un único navegador es capaz de acceder a la aplicación como tal y llevar operaciones como si se tratará de una apliación más instalada en el equipo local. Sus usuarios pueden acceder (siempre que se haya concedido este permiso) desde cualquier otra máquina que no se la propia suya.

Para quienes estén interesados en leer más acerca de este asunto, a continuación dejo un enlace donde hay información más concreta:

aquí: Web Applications vs Desktop Applications

WTFs/m.

2010-07-07T07:33:00.000-07:00

Leadership and Software Teams: Some Thoughts

2010-06-24T11:37:00.000-07:00

Leadership and Software Teams: Some Thoughts

¿Qué es la deuda tecnológica? « Código Comestible

2010-06-18T05:31:00.000-07:00

¿Qué es la deuda tecnológica? « Código Comestible

¿Os habéis encontrado alguna vez con código mal escrito que es difícil de mantener y más difícil de reutilizar? Apuesto a que sí.

Ese código muchas veces no es chapucero porque el programador no sepa hacerlo mejor, sino porque se ha hecho con prisas y sin preocuparse en que ese código pueda extenderse con facilidad en el futuro. Se ahorra tiempo, por ejemplo, en técnicas como los test unitarios que mejoran considerablemente la calidad del código.

Cuando uno se ve forzado a trabajar con una base de código muy mal escrita, los proyectos acaban tardando mucho más de lo necesario. Lo que podíamos haber hecho en dos días acaba tardando diez. O cuarenta. Todo es mucho más complicado porque tenemos que enfrentarnos a las problemas que nos presenta el código legado.

Para explicar las consecuencias del código hecho con prisas Ward Cunningham acuñó el término deuda tecnológica. Hacer código de mala calidad a toda prisa, es como pedir un crédito: puede que obtengamos un beneficio a corto plazo pero si tenemos que seguir desarrollando ese código, tarde o temprano tendremos que pagar todo el tiempo que nos habíamos ahorrado y los intereses. Refactorizar código mal escrito es siempre más difícil que escribirlo bien desde el principio.

A veces la deuda tecnológica tiene sentido. Puede que tengamos que terminar un producto antes que un competidor, o puede que si no terminamos pronto perdamos una gran oportunidad de negocio. En ese caso, la deuda tecnológica tiene el mismo sentido que la deuda financiera: incurrimos en algo de deuda para obtener unos beneficios tan grandes que compensan de sobra el pago de los intereses.

Sin embargo, la deuda tecnológica, como la financiera, también tiene un aspecto muy peligroso: recurrir a la deuda es una manera muy sencilla de tapar los problemas que tiene nuestro negocio. Entra dinero y crea la ilusión de que el negocio sigue funcionando, aunque en realidad sólo hemos aplazado los problemas al tiempo que los empeoramos.

Con la deuda tecnológica pasa lo mismo. Hacer constantemente chapuzas puede dar la sensación de que los proyectos avanzan. Sin embargo, al poco tiempo acabamos con una maraña de código inmantenible; lo que debería ser muy sencillo se convierte en complicado y los desarrollos avanzan cada vez más despacio.

Es porque todo nuestro esfuerzo se invierte en pagar los intereses de la deuda tecnológica.

Larry Ellison critica fuertemente a Jonathan Schwartz

2010-05-20T13:05:00.000-07:00

Larry Ellison critica fuertemente a Jonathan Schwartz

Aplicacion Con Acceso a Bases de Datos Java MySql y Patrones de Diseño Parte 4

2010-05-20T12:56:00.000-07:00

Aplicacion Con Acceso a Bases de Datos Java MySql y Patrones de Diseño Parte 4

Anti Pattern

2010-05-20T09:35:00.000-07:00

Anti Pattern

Ch03-01: Ejercicio del ejemplo de GUI y gráficos

2010-03-08T08:44:00.000-08:00

3.1 (Extra) Modifique el programa de suma en la figura 2.7 para usar la entrada y salida basadas en cuadro de diálogo con los métodos de la clase JOptionPane. Como el método showInputDialog devuelve un objeto String, debe coonvertir el objeto String que introduce el suario a un int para usarlo en los cálculos. El método


Integer.parseInt( String s )

toma un argumento String que representa a un entero (por ejemplo, el resultado de JOptionPane.showInputDialog) y devuelve el valor como un int.

El método parseInt es un método static de la clase Integer (del page java.lang). Observe que si el objeto String no contiene un entero válido, el programa terminará con un error.

Solución:


import javax.swing.JOptionPane;

public class Ch03_DialogoSuma
{
   public static void main( String args[] )
   {

      // Solicitud y obtención del primer número entero como un objeto String
      String numero1 = JOptionPane.showInputDialog( "Escriba el primer número entero: " );

      // Conversión de tipo String a tipo Int del primer número entero
      int num1 = Integer.parseInt( numero1 );

      // Solicitud y obtención del segundo número entero con un objeto String
      String numero2 = JOptionPane.showInputDialog( "Escriba el segundo número entero: " );

      // Conversión de tipo String a tipo Int del segundo número entero
      int num2 = Integer.parseInt( numero2 );

      // Crear el mensaje con formato
      String mensaje = String.format( "La suma: %d + %d = %d" , num1, num2 , ( num1 + num2 ) );

      // Visualizar resultados en una diálogo de mensaje
      JOptionPane.showMessageDialog( null, mensaje );
   } // fin de main
} ///:~

Conclusiones:

El manejo de fechas en un programa de Java es importante, pues permite el control de ciertos elementos sobre el programa.

Se pueden crear métodos ayudantes para mostrar mensajes al usuario de la aplicación y evitar la fatiga.

Ch03-15: Clase Fecha

2010-03-08T08:26:00.000-08:00

3.15 Cree un clase llamada Fecha, que incluya tres piezas de información como variables de incnacia -un mes (tipo int), un día (tipo int) y un año (tipo int). Su clase debe tener un constructor que inicialice las tres variables de instancia, y debe asumir que los valores que se proporcionan son correctos.

Proporcione un método establecer y un método obtener para cada variable de instancia. Proporcione un método mostrarFecha, que muestre el mes, día y año, separados por barras diagionales (/). Escriba una aplicación de prueba llamada PruebaFecha, que demuestre las capacidades de cada Fecha.

Solución:


public class Ch03_Fecha
{
   // Variables de instancia (o piezas de información)
   private int dia; // Día del año (formato numérico)
   private int mes; // Mes del año (formato numérico)
   private int annio; // Mes del año

   // Constructor para inicializar las variables de instancia
   public Ch03_Fecha( int pMes , int pDia , int pAnnio )
   {
      // Validación para el mes
      if( pMes > 0 )
      {
         if( pMes <= 12 )
         {
            mes = pMes;
         }
      }

      // Validación para el día
      if( pDia > 0 )
      {
         if( pDia <= 31 )
         {
            dia = pDia;
         }
      }

      // Validacion para el annio
      if( pAnnio >= 1929 )
      {
         if( pAnnio <= 2029 )
         {
            annio = pAnnio;
         }
      }
   } // Fin del constructor

   // Método para establecer el mes
   public void establecerMes( int pMes )
   {
      if( pMes > 0 )
      {
         if( pMes <=31 )
         {
            mes = pMes;
         }
      }
   }

   // Método para obtener el mes
   public int obtenerMes()
   {
      return mes;
   }

   // Método para establecer el día
   public void establecerDia( int pDia )
   {
      if( pDia > 0)
      {
         if( pDia <= 31 )
         {
            dia = pDia;
         }
      }
   }

   // Método para obtener el día
   public int obtenerDia()
   {
      return dia;
   }

   // Método para establecer el año
   public void establecerAnnio( int pAnnio )
   {
      if( pAnnio >= 1929 )
      {
         if ( pAnnio <= 2029 )
         {
            annio = pAnnio;
         }
      }
   }

   // Método para obtener el año
   public int obtenerAnnio()
   {
      return annio;
   }

   // Método para mostrar la fecha en formato mm / dd / aaaa
   public void mostrarFecha()
   {
      System.out.print( "\nFecha seleccionada: " );
      System.out.printf( "\n %d / %d / %d " , obtenerMes() , obtenerDia() , obtenerAnnio() );
   } // fin del método mostrarFecha
} ///:~

Clase que prueba las capacidades de la clase Fecha:


// Importar la clase 'Scanner'
import java.util.Scanner;

public class Ch03_PruebaFecha
{
   // El método main inicia y finaliza la ejecución de la aplicación
   public static void main( String args[] )
   {
      // Variables receptoras de los valores introducidos por el usuario del programa
      int dia; // Día en formato numérico
      int mes; // Mes en formato numérico
      int annio;

      // Instanciamiento de un objeto de clase Ch03_Fecha con valores iniciales
      Ch03_Fecha fecha = new Ch03_Fecha( 5 , 21 , 2009 );

      // Ver fecha
      fecha.mostrarFecha();

      // Solicitud y obtención de datos por parte del usuario
      // Crea un objeto Scanner para obtener datos desde la entrada estándar
      Scanner entrada = new Scanner( System.in );

      // Mes
      System.out.print( "\nEscriba el número del mes: " );
      mes = entrada.nextInt();
      fecha.establecerMes( mes );

      // Día
      System.out.print( "\nEscriba el número del día: " );
      dia = entrada.nextInt();
      fecha.establecerDia( dia );

      // Año
      System.out.print( "\nEscriba el año: " );
      annio = entrada.nextInt();
      fecha.establecerAnnio( annio );

      // Mostrar fecha
      fecha.mostrarFecha();

      System.out.println();
      System.out.println();
   } // fin de main
} ///:~

Conclusiones:

Ch03-14 - Clase Empleado

2010-03-07T06:01:00.000-08:00

3.14 Cree un clase llamada Empleado, que incluya tres piezas de información como variables de instancia: un primer nombre (tipo String), un apellido paterno (tipo String) y un salario mensual (double). Su clase debe tener un constructor que inicialice las tres variables de instancia.

Proporcione un método establecer y un método obtener para cada variable de instancia. Si el salario mensual no es positivo, establézcalo a 0.0.

Escriba una apl.icación de prueba llamada PruebaEmpleado, que demuestre las capacidades de cada Empleado. Cree dos objetos Empleado y muestre el salario anual de cada objeto. Después, proporcione a cada Empleado un aumento del 10% y muestre el slario anual de cada Empleado otra vez.

Solución:


public class Ch03_Empleado
{
   //Variables de instancia
   private String nombre; // Nombre del empleado
   private String apellido; // Apellido del empleado
   private double salarioMensual; //Salario mensual del empleado

   // Constructor para inicializar las vars. de instancia
   public Ch03_Empleado( String pNombre , String pApellido , double pSalarioMensual )
   {
      // Asignación de los valores de los parámetros a las variables de instancia
      nombre = pNombre;
      apellido = pApellido;
      if( pSalarioMensual > 0.0 )
      {
         salarioMensual = pSalarioMensual;
      }
   } // Fin del constructor

   // Método establecer para el nombre del empleado
   public void establecerNombre( String pNombre )
   {
      nombre = pNombre;
   }

   // Método para obtener el nombre del empleado
   public String obtenerNombre()
   {
      return nombre;
   }

   // Método para establecer el epellido del empleado
   public void establecerApellido( String pApellido )
   {
      apellido = pApellido;
   }

   // Método para obtener el apellido del empleado
   public String obtenerApellido()
   {
      return apellido;
   }

   // Método para establecer el sueldo del empleado
   public void establecerSalarioMensual( double salario )
   {
      if( salario < 0.0 )
      {
         System.out.print( "\nEl salario escrito no es válido." );
         return;
      }
      salarioMensual = salario;
   }

   // Método para obtener el salario mensual de un empleado
   public double obtenerSalarioMensual()
   {
      return salarioMensual;
   }

   // Método para calcular el salario anual de un empleado
   public double obtenerSalarioAnual()
   {
      return obtenerSalarioMensual() * 12;
   }

   // Método para incrementar el 10% sobre el sueldo anual del empleado
   public double obtenerAumento()
   {
      return obtenerSalarioAnual() * 1.10;
   }

   // Método que muestra resumen de la información relativa al empleado
   public void mostrarResumen()
   {
      System.out.printf( "\nSu nombre es: %s" , obtenerNombre() );
      System.out.printf( "\nSu apellido es: %s" , obtenerApellido() );
      System.out.printf( "\nSu salario mensual es: %f" , obtenerSalarioMensual() );
      System.out.printf( "\nSu salario anual sin incremento es: %f" , obtenerSalarioAnual() );
      System.out.printf( "\nSu salario anual con incremento es: %f" , obtenerAumento() );
   } // fin del método mostrarResumen
} ///:~

Clase que prueba las capacidades de la clase Factura:


// Importar la clase 'Scanner'
import java.util.Scanner;

public class Ch03_PruebaEmpleado
{
// El método main inicia y finaliza la ejecución de la aplicación
public static void main( String args[] )
{
   // Variables receptoras de valores introducidos por el usuario del programa
   String nombre; // Nombre del empleado
   String apellido; // Apellido del empleado
   double salario; // Salario mensual del empleado

   // Instacimiento de dos objetos con valores iniciales
   Ch03_Empleado empleado1 = new Ch03_Empleado( "Zhen" , "Gholz" , 800 );
   Ch03_Empleado empleado2 = new Ch03_Empleado( "Larz" , "Binz" , -900 );

   // Solicitud y obtención de los del empleado1
   // Crear un objeto Scanner que admita la entrada de valores de la ventana de comandos
   Scanner entrada = new Scanner( System.in );

   System.out.print( "\nSolicitud y recepción de los datos del empleado1" );

   // Nombre
   System.out.print( "\nEscriba su nombre: " );
   nombre = entrada.nextLine();
   empleado1.establecerNombre( nombre );

   // Apellido
   System.out.print( "\nEscriba su apellido: " );
   apellido = entrada.nextLine();
   empleado1.establecerApellido( apellido );

   // Salario
   System.out.print( "\nEscriba su salario mensual: " );
   salario = entrada.nextDouble();
   empleado1.establecerSalarioMensual( salario );

   // Muestra el resumen del empleado1
   System.out.print( "\nResumen para empleado1: " );
   empleado1.mostrarResumen();

   System.out.println( "\n\nSolicitud y recepción de los datos del empleado2" );

   // Nombre
   System.out.print( "\nEscriba su nombre: " );
   nombre = entrada.nextLine();
   empleado2.establecerNombre( nombre );

   // Apellido
   System.out.print( "\nEscriba su apellido: " );
   apellido = entrada.nextLine();
   empleado2.establecerApellido( apellido );

   // Salario
   System.out.print( "\nEscriba su salario mensual: " );
   salario = entrada.nextDouble();
   empleado2.establecerSalarioMensual( salario );

   // Muestra el resumen del empleado1
   System.out.print( "\nResumen para empleado2: " );
   empleado2.mostrarResumen();

   System.out.println();
} // Fin del método main
} ///:~

Conclusiones:

Cada Empleado conserva los valores correspondientes a sus variables de instancia (atributos). El cambio de estado de un objeto, en esta problema, no afecta la estabilidad del otro, por lo tanto se está haciendo uso correcto del paradigma orientado a objetos.

A medida que van surgiendo cambios, es decir, cada vez que se realiza una acción sobre los objetos estos se van moldeando a los mensajes recibidos por otros objetos de esta misma clase u otra.

Programación a Bajo Nivel

2010-02-13T04:24:00.000-08:00

Ch03-13: La Clase Factura

2009-11-30T08:32:00.000-08:00

3.13 Cree una clase llamada Factura, que una ferretería podría utilizar para representar una factura para un artículo vendido en la tienda.

Una Factura debe incluir cuatro piezas de información como variables de instancia: un número de pieza (tipo String), la descripción de pieza (tipo String), la cantidad de artículos de ese tipo que se van a comprar (tipo int) y el precio por artículo (double).

Su clase debe tener un constructor que inicialice las cuatro variables de instancia. Proporcione un método establecer y un método obtener para cada variable de instancia.

Además, proporcione un método llamada obtenerMontoFactura, que calcule el monto de la facture (es decir, que multiplique la cantidad por el precio por artículo). y después devuelva ese monto como un valor double. Si la cantidad no es positiva, debe establecer en 0. (cero) .

Si el precio por artículo no es positivo, debe establecer a 0.0.

Escriba una aplicación de prueba llamada PruebaFacture, que demuestra las capacidades de la clase Factura.

Solución:


public class Ch03_Factura
{
   // Variables de instancia
   private String numDePieza; // Número de la pieza
   private String descPieza; // Descripción de la pieza
   private int qtyArticulo; // Cantidad del artículo
   private double vlrArticulo; // Valor del artículo

   // Constructur personalizado
   public Ch03_Factura( String pNumDePieza , String pDescPieza , int pQtyArticulo , double pVlrArticulo )
   {
      // Asignación de los valores de los parámetros a las vars. de inst.
      numDePieza = pNumDePieza;
      descPieza = pDescPieza;
      if( pQtyArticulo > 0 )
      {
         qtyArticulo = pQtyArticulo;
      }
      if( pVlrArticulo > 0.0 )
      {
         vlrArticulo = pVlrArticulo;
      }
   } // Fin del constructor de la clase

   // Método establecer para número de la pieza
   public void establecerNumDePieza( String pNumDePieza )
   {
      numDePieza = pNumDePieza;
   }

   // Método obtener para número de la pieza
   public String obtenerNumDePieza()
   {
      return numDePieza;
   }

   // Método para establecer la descripción de la pieza
   public void establecerDescPieza( String pDescPieza )
   {
      descPieza = pDescPieza;
   }

   // Método para obtener la descripción de la pieza
   public String obtenerDescPieza()
   {
      return descPieza;
   }

   // Método para establecer la cantidad de artículo
   public void establecerQtyArticulo( int pQtyArticulo )
   {
      qtyArticulo = pQtyArticulo;
   }

   // Método para obtener la cantidad de artículo
   public int obtenerQtyArticulo()
   {
      return qtyArticulo;
   }

   // Método para establecer valor del artículo
   public void establecerVlrArticulo( double pVlrArticulo )
   {
      vlrArticulo = pVlrArticulo;
   }

   // Método para obtener el valor del artículo
   public double obtenerVlrArticulo()
   {
      return vlrArticulo;
   }

   // Método Obtener Monto Factura
   public void obtenerMontoFactura()
   {
      // Comprobación de que no hayan cantidad negativas
      if( obtenerQtyArticulo() < 0 )
      {
         qtyArticulo = 0;
      }

      if( obtenerVlrArticulo() < 0.0 )
      {
         vlrArticulo = 0.0;
      }

      System.out.printf( "\n ********** FERRETERÍA **********" );
      System.out.printf( "\n ***** Factura *****\n\n" );
      System.out.printf( "Número de pieza: %s" , obtenerNumDePieza() );
      System.out.printf( "\nDescripción de la pieza: %s" , obtenerDescPieza() );
      System.out.printf( "\nCantidad del artículo: %d" , obtenerQtyArticulo() );
      System.out.printf( "\nValor unitario del artículo: %f" , obtenerVlrArticulo() );

      //Totalizar el monto de la compra
      System.out.printf( "\n\nEl total a pagar es: %f" , ( obtenerQtyArticulo() * obtenerVlrArticulo() ) );
   } // fin de main
} ///:~

Clase que prueba las capacidades de la clase Factura:


// Importar la clase 'Scanner'
import java.util.Scanner;

public class Ch03_PruebaFactura
{
  // El método main inicia y finaliza la ejecución de la aplicación
  public static void main( String args[] )
  {
     // Variables
     String cadena; // Número y descripción de la pieza
     int cantidad; // Cantidad del artículo
     double valor; // Valor del artículo

     // Constructor personalizado. Creación de un objeto inicializando sus
     // variables de instancia
     Ch03_Factura factura = new Ch03_Factura( "0" , "Ninguna" , 0 , 0.0 );

     // Mostrar el estado actual de los atributos del objeto 'factura'
     System.out.printf( "\nNúmero de pieza: %s" , factura.obtenerNumDePieza() );
     System.out.printf( "\nDescripción de la pieza: %s" , factura.obtenerDescPieza() );
     System.out.printf( "\nCantidad del artículo: %d" , factura.obtenerQtyArticulo() );
     System.out.printf( "\nValor unitario del artículo: %f" , factura.obtenerVlrArticulo() );

     // Solicitud y obtención de los datos
     // Creación de un objeto de tipo 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Número de pieza
     System.out.print( "\nEscriba el número de pieza: " );
     cadena = entrada.nextLine();
     factura.establecerNumDePieza( cadena );

     //Descripción de la pieza
     System.out.print( "\nEscriba la descripción de la pieza: " );
     cadena = entrada.nextLine();
     factura.establecerDescPieza( cadena );

     // Cantidad del artículo
     System.out.print( "\nEscriba la cantidad del artículo: " );
     cantidad = entrada.nextInt();
     factura.establecerQtyArticulo( cantidad );

     // Valor del artículo
     System.out.print( "\nEscriba el valor del artículo: " );
     valor = entrada.nextDouble();
     factura.establecerVlrArticulo( valor );

     // Mostrar el monto de la factura
     factura.obtenerMontoFactura();

     System.out.println();
     System.out.println();
    
  } // fin de main
} ///:~

Conclusiones:

Nuevamente podemos observar que los método establecer y obtener, incrementan la estababilidad del programa.

Por lo general, se suelen usar variables de instancia, por ejemplo qtyArtciculo, que llevan antepuesto un prefijo en inglés, en este caso 'qty' para hacer referenciar a 'quantity' que es lo mismo que 'cantidad' en español.

Ch03-11: Clase Cuenta

2009-11-30T08:18:00.000-08:00

3.12 Modifique la clase Cuenta para proporcionar un método llamada cargar, que retir dinero de un objeto Cuenta.

Asegure que el monto a cargar no exceda el saldo de Cuenta. Si lo hace, el saldo debe permanecer sin cambio y el método debe imprimer un mensaje que indique "El monto a cargar excede el saldo de la cuenta".

Modifique la clase PruebaCuenta para probar el método cargar.

Solución:


public class Ch03_Cuenta2
{
   // Variable de instancia
   private double saldo;

   // Constructor explícito de la clase
   public Ch03_Cuenta2( double monto )
   {
      if( monto > 0.0 ) // Comprueba que la cantidad pasada sea mayor que cero
      {
         saldo = monto;
      }
   }

   // Método para establecer (depositar) un monto
   public void establecerAbono( double monto )
   {
      saldo = saldo + monto;
   }

   // Método para obtener el saldo
   public void obtenerSaldo()
   {
      System.out.printf( "\nEl saldo actual de su cuenta es: %f" , saldo );
   }

   // Método para realizar (establecer) un retiro (cargar)
   public void cargar( double monto )
   {
      if( saldo - monto < 0.0 )
      {
         System.out.print( "\nEl monto a cargar excede el saldo de la cuenta." );
         return;
      }

      saldo = saldo - monto;
   } // Fin del método cargar

} // Fin de la clase Ch03_Cuenta2

La clase de prueba:


// Importar la clase 'Scanner'
import java.util.Scanner;

public class Ch03_PruebaCuenta2
{
  // El método main inicia y finaliza la ejecución de la aplicación
  public static void main( String args[] )
  {
     double monto;

     // Instanciamiento e inicialización de un objeto de clase Ch03_Cuenta2
     Ch03_Cuenta2 cuenta = new Ch03_Cuenta2( 50 );

     // Consultar el saldo del objeto almacenado en la variable cuenta
     cuenta.obtenerSaldo();

     // Realizar un depósito
     // Creación de un objeto 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Solicitud y obtención del monto a depositar
     System.out.print( "\nEscriba el monto a depositar: " );
     monto = entrada.nextDouble();
     cuenta.establecerAbono( monto );

     // Consultar el saldo actual del objeto cuenta
     cuenta.obtenerSaldo();

     // Realizar un retiro (carga)
     // Solicitud y obtención del monto a cargar del usuario de la ventana de comandos
     System.out.print( "\nDigite el monto a retirar: " );
     monto = entrada.nextDouble();
     cuenta.cargar( monto );

     // Mostrar el saldo actual
     cuenta.obtenerSaldo();

     System.out.println();

  } // Fin del método 'main'

} // Fin de la clase 'Ch03_PruebaCuenta2'

Conclusiones:

Los métodos establecer ayudan a que los datos que ingresa el usuario a través de uno de los medios de flujo de entrada se validen antes de almacenarse en una o más variables de instancia. Esto ayuda a que los datos mantengan consistencia durante el tiempo de ejecución .

El programador siempre debe considerar estas excepciones que pueden ocurrir durante la ejecución del programa. Más adelante se presentarán problemas resueltos acerca de las Excepciones.

Ch03-11: Libro Calificaciones

2009-11-30T08:04:00.000-08:00

3.11 Modifique la clase LibroCalificaciones de la siguiente manera:

Incluya una segunda variable de instancia String, que represente el nombre del instructor del curso.
Proporcione un método establecer para modificar el nombre del instructor, y un método obtener para obtener el nombre.
Modifique el constructor para especificar dos parámetros: uno para el nombre del curso y otro para el nombre del instructor.
Modifique el método mostrarMensaje, de tal forma que primero imprima el mensaje de bienvenida y el nombre del curso, y que después imprima "Este curso es presentado por: ", seguido del nombre del instructor.

Use su clase modificada en una aplicación de prueba que demuestra las nueva cpacidades de la clase.

Solución:



// Declaración de clase
public class Ch03_LibroCalificaciones5
{
  // Variables de instancia
  private String nombreDelCurso;
  private String nombreDelInstructor;
 
  // Constructor inicialización de variables de instancia
  public Ch03_LibroCalificaciones5( String curso, String nombre )
  {
     // Asigna a la var. de inst. nombreDelCurso el valor del parámetro curso
     nombreDelCurso = curso;
     // Asigna a la var. de inst. nombreDelInstructor el valor del parámetro nombre
     nombreDelInstructor = nombre;
  } // Fin del constructor

  // Método establecer nombre del curso
  public void establecerNombreDelCurso( String curso )
  {
     nombreDelCurso = curso;
  }

  // Método obtener el nombre del curso
  public String obtenerNombreDelCurso()
  {
     return nombreDelCurso;
  }

  // Método establecer nombre del instructor
  public void establecerNombreDelInstructor( String nombre )
  {
     nombreDelInstructor = nombre;
  }

  // Método obtener nombre del instructor
  public String obtenerNombreDelInstructor()
  {
     return nombreDelInstructor;
  }

  // Método mostrar mensaje
  public void mostrarMensaje()
  {
     System.out.printf( "\nBienvenido al Libro de Calificaciones para: %s" , obtenerNombreDelCurso() );
     System.out.printf( "\nEste curso es presentado por: %s\n" , obtenerNombreDelInstructor() );
  }

} // fin de la clase LibroCalificaciones

La clase de prueba:



import java.util.Scanner;

public class Ch03_PruebaLibroCalificaciones5
{
  // El método main inicia y finaliza la ejecucación de la aplicación
  public static void main( String args[] )
  {
     String nombre;
     String curso;
    
     // Instanciamiento de un objeto Ch03_LibroCalificaciones5
     Ch03_LibroCalificaciones5 miLibroCalificaciones = new Ch03_LibroCalificaciones5( "CS101 - Introducción a la programación en Java" , "Bakunin" );
    
     // Visualizar el estado de los atributos del obtjeto
     miLibroCalificaciones.mostrarMensaje();
    
     // Crear un objeto de clase 'Scanner'
     Scanner entrada = new Scanner( System.in );
    
     // Solicitud y obtención de los datos del usuario
     System.out.print( "\nDigite el nombre del curo: " ); // Indicador
     curso = entrada.nextLine(); // Lee una línea de texto y devuelve un objeto String
     miLibroCalificaciones.establecerNombreDelCurso( curso );

     System.out.print( "Digite el nombre del instructor: " );
     nombre = entrada.nextLine(); // Lee una línea de texto
     miLibroCalificaciones.establecerNombreDelInstructor( nombre );

     // Visualización del estado de los atributos del objeto
     miLibroCalificaciones.mostrarMensaje();

  } // fin del método 'main'

} // Fin de la clase Ch03_PruebaLibroCalificaciones5

Conclusiones:

Los método establecer (también conocidos como métodos mutadores) y los métodos obtener (o métodos de consulta) permiten establecer o modificar el valor de una o más variables de instancias de una clase. Por otro lado, los métodos obtener obtienen información acerca del contenido de una variable de instancia.

Comentario

2009-11-19T04:52:00.000-08:00

Quiero hacer la siguiente entrada con el idea de invitar a aquellas personas que visitan este blog, a que comenten acerca de los códigos que se publican. Básicamente, como ya lo había dicho antes, el propósito es crear un ambiente de participación (proponer mejores soluciones a las hechas por mí mismo, tratar de simplificar (optimizar) el código fuente expuesto de los problemas resueltos, etc.).

Además, quiero aprovechar esta entrada para aclarar que el contenido publicado está bajo los criterios de Creative Commons. Y sigue los siguientes tipos de licencia:

Reconocimiento - No Comercial

Para terminar con esta entrada, para el próximo mes (diciembre), me encargaré de publicar con mayor frecuencia contenido para este blog: desde material bibliográfico (atribuyendo autorías) hasta noticias acerca de la evolución de la plataforma Java.

Be Free. Be GNU/Linux.

Ch02-31: Cuadrados y Cubos

2009-11-19T04:42:00.000-08:00

2.26 Utilizando sólo las técnicas de programación que aprendió en este capítulo, escriba una aplicación que calcule los cuadrados y cubos de los números del 0 al 10, y que imprima los valores resultantes en formato de tabla, como se muestra a continuación. [Nota: Este programa no requiere de ningún tipo de entrada por parte del usuario].

Solución:


import java.util.Scanner;

// Declaración de clase
public class Ch02_TableroDamas
{
// Clase definida por el programador
public class Ch02_CuadradoCubo
{
 // Método de clase
 public static void main( String[] args )
 {
    System.out.printf( "\n Número\tCuadrado\tCubo" );
    System.out.printf( "\n %d\t     %d\t       %d", 0 , ( 0 * 0 ) , ( 0 * 0 * 0 ) );
    System.out.printf( "\n %d\t     %d\t       %d", 1 , ( 1 * 1 ) , ( 1 * 1 * 1 ) );
    System.out.printf( "\n %d\t     %d\t       %d", 2 , ( 2 * 2 ) , ( 2 * 2 * 2 ) );
    System.out.printf( "\n %d\t     %d\t       %d", 3 , ( 3 * 3 ) , ( 3 * 3 * 3 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 4 , ( 4 * 4 ) , ( 4 * 4 * 4 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 5 , ( 5 * 5 ) , ( 5 * 5 * 5 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 6 , ( 6 * 6 ) , ( 6 * 6 * 6 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 7 , ( 7 * 7 ) , ( 7 * 7 * 7 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 8 , ( 8 * 8 ) , ( 8 * 8 * 8 ) );
    System.out.printf( "\n %d\t     %d\t      %d", 9 , ( 9 * 9 ) , ( 9 * 9 * 9 ) );
    System.out.printf( "\n %d\t    %d\t     %d\n", 10 , ( 10 * 10 ) , ( 10 * 10 * 10 ) );

    // Salida
    System.exit(0);
 } // Fin del método de clase
} // Fin de la clase definida por el programador

Conclusiones:

El uso de los especificadores de formato proporcionan un medio idóneo para mostrar información tabulada.

Los paréntesis redundantes, es decir, signos de agrupación que ayudan a identificar de forma fácil y directa el resultado que se pretende obtener a través de la expresión.

Ch02-30: Separar dígitos

2009-11-12T04:31:00.001-08:00

2.29 Escriba una aplicación que reciba del usuario un número compuesto por cinco dígitos, que separe ese número en sus dígitos individuales y los imprima, cada uno separado de los demás por tres espacios

Por ejemplo, si el usuario escribe el número 42339, el programa debe imprimir:

4 2 3 3 9

Suponga que el usuario escribe el número correcto de dígitos. ¿Qué ocurre cuando ejecuta el programa y escribe un número con más de cingo dígitos? ¿Qué ocurre cuando ejecuta el programa y escribe un número con menos de cinco dígitos? [Sugerencia: es posible hacer este ejercicio con las técnicas que aprendió en este capítulo. Necesita utilizar los operadores de división y residuo para "seleccionar" cada dígito].

Solución:


import java.util.Scanner;

// Clase definida por el programador
public class Ch02_SepararDigitos
{
   // Método de clase
   public static void main( String[] args )
   {
      int num; // Almacena el número digitado por el usuario
      int temp; // Almacena cocientes y residuos
      int dM; // Decenas de mil
      int uM; // Unidades de mil
      int cen; // Centenas
      int dec; // Decenas
      int uni; // Unidades

      // Instanciar un objeto de tipo 'Scanner'
      Scanner entrada = new Scanner( System.in );

      // Solicitud y obtención del número
      System.out.print( "Digite un número entero de 5 dígitos: " );
      num = entrada.nextInt();

      if( num >= 10000 )
      {
         if( num <= 99999)
         {
            dM = num / 10000;
            temp = num % 10000;
            uM = temp / 1000;
            temp = temp % 1000;
            cen = temp / 100;
            temp = temp % 100;
            dec = temp / 10;
            temp = temp % 10;
            uni = temp;

            // Visualización de resultados
            System.out.printf( "\n%d   %d   %d   %d   %d\n", dM, uM, cen, dec, uni);
         } // fin de if
      } // fin de if
      // Salida
      System.exit(0);
   } // fin de main
} ///:~

Conclusiones:

El uso de los operadores aritméticos cociente( / ) y residuo ( % ) permiten desarrollar de manera directa y simple el problema propuesto. La clave de la solución se encuentre en la instrucción if anidado.

Ch02-29: Moldeado (casting) de tipos

2009-11-12T04:10:00.000-08:00

2.28 He aquí otro adelanto. En este capítulo (2), aprendió acerca de los enteros y el tipo int. Java puede también representar letras en mayúsculas y una considerable variedad de símbolos especiales. Cada carácter tiene su correspondiente representación entera. El conjunto de caracteres que utiliza una computadora, y las correspondientes representaciones enteras de estos caracteres, se conocen como el conjunto de caracteres de esa computadora.

Usted puede indicar un valor de carácter en un programa con sólo encerrar ese carácter entre comillas sencillas (o simples), como en 'A'.

Usted puede determinar el equivalente entero de un carácter si antepone a ese carácter la palabra (int), como en

( int ) 'A'

Esta forma se conoce como operador de conversión de tipo. [...]. La siguiente instrucción imprime un carácter y su equivalente entero:


System.out.printf( "El carácter %c tiene el valor %d\n" , 'A' , ( ( int ) ) 'A' ) );

Cuando se ejecuta esta instrucción, muestra el carácter A y el valor 65 (del conjunto de caracteres conocido como Unicode) como parte de la cadena. Observe que el especificador de formato %c es un receptáculo para un carácter (en este caso, el carácter 'A').

Utilizando instrucciones similares a la mostrada anteriormente en este ejercicio, escriba una aplicación que muestre los equivalentes enteros de algunas letras en mayúsculas, en minúsculas, dígitos y símbolos especiales.

Muestre los equivalentes enteros de los siguientes caracteres: A B C a b c 0 1 2 $ * + / y el carácter en blanco.

Solución:


import java.util.Scanner;

// Clase definida por el programador
public class Ch02_ConversionTipos
{
// Método de clase
public static void main( String[] args )
{

   System.out.printf( "El carácter %c tiene el valor %d.\n", 'A' , ( (int) 'A' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", 'B' , ( (int) 'B' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", 'C' , ( (int) 'C' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", 'a' , ( (int) 'a' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", 'b' , ( (int) 'b' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", 'c' , ( (int) 'c' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '0' , ( (int) '0' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '1' , ( (int) '1' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '2' , ( (int) '2' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '$' , ( (int) '$' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '+' , ( (int) '+' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", '/' , ( (int) '/' ) );
   System.out.printf( "El carácter %c tiene el valor %d.\n", ' ' , ( (int) ' ' ) );

   // Salida
   System.exit(0);  
} // fin de main
} ///:~

Conclusiones:

Este tipo de problema juega un papel importante en el desarrollo de problemas posterios, pues para determinadas representaciones, en muchas ocasiones es idóneo represntar los datos en un formato mas adecuado para la solución que se persigue.

El especificador de formato %c funciona un receptáculo de caracteres encerrados entre comillas simples.

Ch02-28: Circulo

2009-11-10T05:03:00.000-08:00

2.27 He aquí un adelanto. En este capítulo (2), aprendió sobre los enteros y el tipo int. Java también puede representar números de punto flotante que contienen puntos decimales, como 3.14159. Escriba una aplicación que reciba del usuario el radio de un círculo como un entero, y que imprima el diámetro, la circunferencia y el área del círculo mediante el uso del valor de punto flotante 3.14159 para π.

Use las técnicas aprendidas en este capítulo. [Nota: también puede utilizar la constante predefinida Math.PI para el valor de π. Esta constante es más precsia que el valor 3.14159. La clase Math se define en el paquete java.lang. Las clases en este paquete se importan de manera automática, por lo que no se necesita importar la clase Math mediante la instrucción import para usarla].

Use las siguientes fórmulas (r es el radio):

diámetro = 2r
circunferencia = 2πr
área = πr^2

No almacene los resultados de cálculo en una variable. En vez de ello, especifique cada cálculo como el valor que se imprimirá en una instrucción System.out.print. Obserque que los valores producidos por los cálculos del área y la circunferencia son números de punto flotante. Dichos valores pueden imprimirse con el especificaodr de formato %f en una instraucción System.out.printf.

Solución:


import java.util.Scanner;

// Declaración de clase definida por el programador
public class Ch02_Circulo
{
  // Método de clase o método estático
  public static void main( String[] args )
  {
     int radio; // Almacena el radio del círculo

     // Instanciar un objeto de tipo 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Solicitud y obtención del radio del círculo
     System.out.print( "Digite el radio del círculo: ");
     radio = entrada.nextInt();

     // Visualización de resultados
     //Diámetro
     System.out.printf("\nEl diametro del círculo es: %d.", ( 2 * radio ) );

     // Circunferencia
     System.out.printf( "\nLa circunferencia del círculo es: %f.", ( 2 * Math.PI * radio ) );

     // Área
     System.out.printf( "\nEl área del círculo es: %f.\n", ( Math.PI * radio * radio ) );

     // Salida normal
     System.exit(0);

  } // fin del método main
} ///:~

Conclusiones:

El uso del método println del objeto out de la clase System juego el papel principal en la solución de este problema.

El especificador de formato %f facilita la presentacion de numeros de punto flotante a traves del metodo printf.

Ch02-27 Tablero damas

2009-11-10T04:57:00.001-08:00

2.26 Escriba una aplicación que muestre un patrón de tablero de damas, como se muestra a continuación.

Solución:


import java.util.Scanner;

// Declaración de clase
public class Ch02_TableroDamas
{
  // El método 'main' inicia la ejecución de la aplicación en Java
  public static void main( String[] args )
  {
     System.out.println(" * * * * * * * *");
     System.out.println("  * * * * * * * *");
     System.out.println(" * * * * * * * *");
     System.out.println("  * * * * * * * *");
     System.out.println(" * * * * * * * *");
     System.out.println("  * * * * * * * *");
     System.out.println(" * * * * * * * *");
     System.out.println("  * * * * * * * *");

     System.exit(0);
  } // Fin del método 'main'
} ///:~

Conclusiones:

El uso del método println del objeto out de la clase System juego el papel principal en la solución de este problema.

Se ha tenido en cuenta el espaciado de inicio de línea para lograr el patrón que se muestra en la imagen superior de esta entrada.

Ch02-26 Múltiplos

2009-11-10T04:47:00.000-08:00

2.26 Escriba una aplicación que lea dos enteros, determine si el primero es un múltiplo del segeundo e imprima el resultado. [Sugerencia: use el operador residuo].

Solución:


import java.util.Scanner;

// Declaración de clase
public class Ch02_Multiplo
{
  // El método 'main' inicia la ejecución de la aplición en Java
  public static void main( String[] args )
  {
     // Variables
     int numero1;
     int numero2;

     // Instanciación de un objeto de clase 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Solicitud y obtención de los datos
     System.out.print( "Digite el primer entero: " );
     numero1 = entrada.nextInt();

     System.out.print( "Digite el segundo entero: " );
     numero2 = entrada.nextInt();

     // Determinar si el primer entero es múltiplo del segundo entero
     if( numero1 % numero2 == 0 )
     {
        System.out.printf( "\n%d es múltiplo de %d.", numero1, numero2 );
     }

     System.exit(0);

  } // Fin del método 'main'
} ///:~

Conclusiones:

Como se puede observar en el código fuente de la solución al problema planteado se destaca el sudo del operador residuo (%) para determinar si un número es múltiplo de otro. El método exit (línea 29) recibe como parámetro un entero (en caso de ser un número distinto de cero (0), quiere decir que el programa ha termina de una forma anormal).

Ch02-25 Par o impar

2009-11-06T07:07:00.000-08:00

2.25 Escriba una aplicación que lea un entero y que determine e imprima si es impar o par. [Sugerencia: use el operador residuo. Un número par es un múltiplo de 2. Cualquier múltiplo de 2 deja un residuo de 0 (cero) cuando se divide entre 2.

Solución:


import java.util.Scanner;

// Declaración de clase
public class Ch02_ParOImpar
{
  // El método 'main' inicia la ejecución de la aplicación en Java
  public static void main( String[] args )
  {
     // Variables
     int numero;

     // Instanciación de un objeto de clase 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Solicitud y obtención del número entero
     System.out.print( "Digite un número entero: " );
     numero = entrada.nextInt();

     // Determinar si es par o impar
     if( numero % 2 == 0 )
     {
        System.out.printf("\n%d es par.\n", numero );
     }

     if( numero % 2 != 0 )
     {
        System.out.printf("\n%d es impar.\n", numero );
     }

     // Salida
     System.exit(0);

  } // fin de main
} ///:~

Conclusiones:

En la solución de este problema se destaca el uso del operador % (residuo, resto, módulo o modulus) para determinar si el número que introdujo el usuario es par o impar.

Ch02-24 Mayor y menor 5 enteros

2009-11-06T05:11:00.000-08:00

2.24 Escriba una aplicación que lea cinco enteros y que determine e imprima los enteros mayor y menor en el grupo. Use solamente las técnicas de programación que aprendió en este capítulo.

Solución:


import java.util.Scanner;
// Declaración de clase
public class Ch02_Comparar5Enteros
{
  // El método main inicia la ejecución de la aplicación
  public static void main( String[] args )
  {
     // Variables
     int num1; // Primer entero
     int num2; // Segundo entero
     int num3; // Tercer entero
     int num4; // Cuarto entero
     int num5; // Quinto entero
     int menor; // Número entero menor del grupo
     int mayor; // Número entero mayor del grupo

     // Instanciación (creación) de un objeto de clase 'Scanner'
     Scanner entrada;
     entrada = new Scanner( System.in );

     // Solicitud y obtención de los datos (números enteros)
     System.out.printf( "Digite el primer número entero: ");
     num1 = entrada.nextInt();

     System.out.print( "Digite el segundo número entero: " );
     num2 = entrada.nextInt();

     System.out.print( "Digite el tercer número entero: " );
     num3 = entrada.nextInt();

     System.out.print( "Digite el cuarto número entero: " );
     num4 = entrada.nextInt();

     System.out.print( "Digite el quinto número entero: " );
     num5 = entrada.nextInt();

     // Asignación temporal
     menor = num1;
     mayor = num5;

     // Determinar el número menor del grupo de los 5 enteros
     if( num2 < menor =" num2;" menor =" num3;" menor =" num4;" menor =" num5;"> mayor )
     {
        mayor = num1;
     }

     if( num2 > mayor )
     {
        mayor = num2;
     }

     if( num3 > mayor )
     {
        mayor = num3;
     }

     if( num4 > mayor )
     {
        mayor = num4;
     }

     // Visualización (mostrar) resultados
     System.out.printf( "\nEl menor de: %d, %d, %d, %d y %d es %d\n", num1,num2,num3,num4,num5,menor);
     System.out.printf( "El mayor de: %d, %d, %d, %d y %d es %d\n", num1,num2,num3,num4,num5,mayor);

  } // fin de main
} ///:~

Conclusiones:

Cómo puede observarse la solución a este problema es muy sencilla. Para agilizar la entrada de datos se usó un objeto de la clase Scanner (entrada).

Por otro lado, aquí se demuestra cómo formatear la salida a través del método static printf.

Ch02-18 Figuras planas

2009-11-05T04:04:00.001-08:00

2.18 Escriba una aplicación que muestre un cuadro, un óvalo, una flecha y un diamante usando asteriscos (*). Como se muestra a continuación:

Solución:


// Declaración de clase
public class Ch02_Figuras
{
// El método 'main' inicia la ejecución de la aplicación
public static void main( String[] args)
{

   System.out.printf( "*********\t***\t  *\t  *\n");
   System.out.printf( "*       *     *       *      ***        * *\n");
   System.out.printf( "*       *    *         *    *****      *   *\n");
   System.out.printf( "*       *    *         *      *       *     *\n");
   System.out.printf( "*       *    *         *      *      *       *\n");
   System.out.printf( "*       *    *         *      *       *     *\n");
   System.out.printf( "*       *    *         *      *        *   *\n");
   System.out.printf( "*       *     *       *       *         * *\n");
   System.out.printf( "*********\t***          *\t  *\n");

} // Fin del método 'main'

} // Fin de la declaración del cuerpo de la clase 'Ch02_Figuras'

Conclusiones:

La salida estándar permite la salida de figuras planas formadas por carácteres del conjunto UNICODE.

El uso de caracteres especiales como: \t y \n (tabulación y nueva línea, respectivamente) facilitan la solución a este problema.

Ch02-17 Promedio Entero

2009-10-27T08:04:00.000-07:00

2.17 Escriba una aplicación que reciba tres enteros del usuario y muestre la suma, promedio, producto, menor y mayor de esos números. [Nota: el cálculo del promedio en este ejercicio debe resultar en una representación entera del promedio. Por lo tanto, si la suma de los valores es 7, el promedio debe ser 2, no 2.3333...].

Solución:


import java.util.Scanner; // importa la clase Scanner

public class Ch02_PromedioEntero
{
/** inicia y finaliza la ejecución de la aplicación */
public static void main( String[] args )
{
 // crea un objeto Scanner
 Scanner teclado = new Scanner( System.in );

 // declara tres variables de tipo entero
 int num1, num2, num3;

 // solicita y guarda el primer número
 System.out.print( "Escriba el primer número: " );
 num1 = teclado.nextInt();

 // solicita y guarda el segundo número
 System.out.print( "Escriba el segundo número: " );
 num2 = teclado.nextInt();

 // solicita y guarda el tercer número
 System.out.print( "Escriba el tercer número: " );
 num3 = teclado.nextInt();

 // calcula la suma de los tres números.
 int suma = num1 + num2 + num3;

 System.out.printf( "\n\nSuma: %d + %d + %d = %d\n" , num1 , num2 , num3 , suma );

 // calcula el promedio de los tres números. En este caso solo se trunca la parte entera
 int promedio = suma / 3;

 System.out.printf( "Promedio: %d / 3 = %d\n" , suma , promedio );

 // calcula el producto de los tres números.
 int producto = num1 * num2 * num3;

 System.out.printf( "Producto: %d * %d * %d = %d\n" , num1 , num2 , num3 , producto );

 // determina el menor de los tres números
 if( num1 <> num2 )
 {
    if( num1 > num3 )
    {
       System.out.printf( "Mayor: %d\n" , num1 );
    } // fin de if anidado. Profundidad: 1
    else if( num3 > num2 )
    {
       System.out.printf( "Mayor: %d\n" , num3 );
    } // fin de if anidado. Profundidad: 1
    else
    {
       System.out.printf( "Maor: %d\n" , num2 );
    } // fin de
 } // fin de if
 else
 {
    if( num2 > num3 )
    {
       System.out.printf( "Mayor: %d\n" , num2 );
    } // fin de if anidado. Profundidad: 1
    else
    {
       System.out.printf( "Mayor: %d\n" , num3 );
    } // fin de else anidado. Profundidad: 1
 } // fin de else

 System.out.println( "\n" );

} // fin de main
} ///:~

Conclusiones:

Vale destacar que si se usan valores de naturaleza entero, los valores obtenidos a través de operaciones aritméticas, estos resultarán del mismo tipo.

La solución de este problema, representaq una manera sencilla de obtener el menor y el mayor de un conjunto de tres números enteros, gracias al uso de la construcción condicional if.

Ch02-16: Número Mayor o Números Iguales

2009-10-27T07:42:00.000-07:00

2.16 Escriba una aplicación que pida al usuario que escriba dos enteros, que obtenga los números del usuario y muestre el número más grande, seguido de las palabras "es más grande". Si los números son iguales, imprima el mensaje "Estos números son iguales".

Solución:


import java.util.Scanner;

// Declaración de la clase
public class Ch02_Comparacion
{
// El método 'main' inicia la ejecuación de la aplicación en Java
public static void main( String[] args )
{
  // Variables
  int numero1; // Primer número entero
  int numero2; // Segundo número entero

  // Instanciación de un objeto de tipo 'Scanner'
  Scanner entrada;
  entrada = new Scanner( System.in );

  // Petición de los datos al usuario
  System.out.print( "Digite el pimer número entero: " );
  numero1 = entrada.nextInt();

  System.out.print( "Digite el segundo número entero: " );
  numero2 = entrada.nextInt();

  if( numero1 > numero2)
  {
     System.out.printf( "%d es más grande.\n", numero1 );
  }

  if( numero2 > numero1)
  {
     System.out.printf( "%d es maś grande.\n", numero2 );
  }

  if( numero1 == numero2 )
  {
     System.out.printf( "Estos números son iguales.\n");
  }

  System.exit(0); // Salida

} // Fin del método 'main'

} // Fin de la declaración del cuerpo de la clase

Conclusiones:

En esta solución es importante observar el uso de la palabra reservada (o clave) if para la evaluación de números.

También se hace uso de la clase Scanner para la instanciación de objetos que a través de sus responsabilidades (métodos) permiten la captura de datos a través de la entrada estándar.

E2-15: Suma, producto, diferencia y cociente

2009-10-10T09:42:00.000-07:00

2.15 Escriba una aplicación que pida al usuario que escriba dos números, que obtenga los números del usuario e imprima la suma, producto, diferencia y cociente (división) de los números.

Solución:


import java.util.Scanner;

// Declaración de clase 'Aritmetica'
public class Ch02_Aritmetica
{
  // Método de clase
  public static void main( String[] args )
  {
     // Declaración de variables
     int x; // Primer número entero
     int y; // Segundo número entero
     int suma; // Almacenará el valor obtenido de sumar x e y
     int resta; // Almacenará el valor obtenido de restar x menos y
     int producto; // Almacenará el valor obtenido de multiplicar x por y
     int cociente; // Almacenerá el valor obtenido de dividir x sobre y

     // Instanciación (creación) de un objeto de clase 'Scanner'
     Scanner entrada = new Scanner( System.in );

     // Solicitud de los datos al usuario a través de la entrada estándar
     System.out.print( "Digite el primer número entero: ");
     x = entrada.nextInt();

     System.out.printf( "Digite el segundo número entero: ");
     y = entrada.nextInt();

     // Calcular suma
     suma = x + y;

     // Calcular resta
     resta = x - y;

     // Calcular producto
     producto = x * y;

     // Calcular cociente
     cociente = x / y;

     // Visualización de resultados en la salida estándar (monitor)
     System.out.printf( "La suma de %d + %d = %d\n", x , y , suma );

     System.out.printf( "La diferencia de %d - %d = %d\n", x , y , resta );

     System.out.printf( "El producto de %d * %d = %d\n", x , y , producto );

     System.out.printf( "El cociente de %d / %d = %d\n", x , y , cociente);

     System.exit(0);
  } // fin de main
} ///:~

¿Qué necesitas para empezar a programar?

2009-10-05T19:58:00.000-07:00

Muchas personas que se inician en el mundo de la programación, y que sienten deseo por profundizar en esta área de la Informática tan interesante, suelen preguntarse cuáles son los requisitos esenciales para empezar a programar.

Tiempo
Dedicación
Manuales y libros (los mejores que se puedan conseguir, por ejemplo Cómo Programar en Java de Deitel & Deitel, cualquiera de sus ediciones está bien).
Deseos de superación
Lógica y matemática (todo los conocimientos de estas dos discplinas que puedan adquirir están bien y te hacen un buen programador).
Otras...

Es importante hacer notar que algunos de los requerimientos anteriores pueden variar, pues hay personas que se devuelven en determinados campos con más facilidad que otros.

¿Y los problemas que deben resolverse?

En cuanto más problemas resuelvas de forma concreta y simple mejor será su desempeño. Esto es una garantía hecha por los grandes expertos de la programación. [Nota: En este punto es importante resaltar que cada problema planteado propone un reto para el programador. Eso es lo que hace divertido e interesante programar].

Continuará...

Bienvenidos a Código Fuente Java

2009-09-19T08:50:00.000-07:00

Hoy 19 de septiembre de 2009 decidí iniciar este nuevo blog, con la idea de crear un espacio que ayude aquellos quienes se inician en la programación en Java, y cómo para las personas que tienen experiencia. En la Red hay cientos de sitios dedicados a este tópico, y que realmente representan fuentes de información concretas y fidedignas acerca de la tecnología Java y su respectiva plataforma, que a su vez son altamente valoradas por los visitantes; pero este blog también pretende llegar a ser un lugar interactivo y actualizado.

Objetivo general

El objetivo principal de este weblog es ofrecer códigos fuente de programas propuesto por distintos textos enfocados a la programación en el lenguaje de programación Java.

¿Por qué se escogía Java?

Básicamente por ser un lenguaje de programación robusto, estable, actualizado, multiplaforma, limpio, bien diseñado e implementado, libre, orientado a objetos, su amplia API. Porque Java = C++--.

¿Cuál será el contenido de este blog?

Código fuente de la solución y explicación de problemas planteados y propuestos.
Noticias generales acerca Java.
Tips
Entornos de desarollodo integrados (NetBeans, Eclipse, etc.)
Software Libre
Guías de instalación, configuración, etc.
Otros

¿Cómo se mostrará la información en el blog "Código Fuente Java"?

El código fuente publicado usará la impresora estética de Alexander Gorbashov (Syntax Highlighter). Se adjuntarán imágenes, vídeos, entre otro material relacionado e interesante.

Los comentarios, sugerencias y replicas de los usuarios serán bienvenidos

Se agradecerá a aquellos visitantes que hagan sus comentarios acerca de los códigos fuente noticias, guías, etc.

¿Quién está a cargo de este blog?

Al igual que Ubuntu - Ubuntu y Actualidad, me encargaré también de mantener este blog. Mi nombre es Jhon F. Ortiz O., soy estudiante de Ingeniería de Sistemas, soy entusiasta del Software Libre y la programación en Java (de aquí haya decidido crear un sitio como este).