Ejercicios NETBEANS 6.5 - NETBEANS 6.8 - NETBEANS 7.1 - NETBEANS 7.2 - NETBEANS 7.3.

Contar Vocales de una Palabra o Texto

2013-04-30T00:25:00.000-07:00

Este ejercicio nos enseñará a contar las vocales de una palabra o texto ingresado.

Crearemos un método llamado aceptar(), en el cual declaramos una variable llamada texto como String, la cual a su vez recibirá el valor que contenga la caja de texto (txtCuenta). también definiremos un contador llamado cuentavocales como int, que como su nombre lo indica, nos contará las vocales de la palabra o texto que ingresemos. Luego recorreremos la palabra o texto, usando el bucle for y trabajaremos con el método length, que nos da la longitud total de la misma. Al usar charAt(), estamos diciendo que nos devuelva el caracter de la posición que estamos recorriendo. De esta manera comprobaremos si el caracter recorrido es una de las vocales (a, e, i, o, u). Luego, presentaremos el resultado en el label (lblRespuesta).

El método limpiar() nos servirá para borrar los contenidos. Por último, llamaremos a nuestros métodos desde sus respectivos botones.

Uso de CheckBox

2013-04-28T21:44:00.003-07:00

Aprenderemos mediante un ejemplo el uso de CheckBox. Elegiremos una o varias carreras y las presentaremos como carreras elegidas.

Crearemos un método llamado carreras(), en el cual declaramos una variable llamada mensaje como String y le asignaremos el valor de cadena "Carreras Elegidas". Para cada jCheckBox llamaremos a la propiedad isSelected, que devuelve true si el componente esta seleccionado, en caso contrario devuelve false. isSelected es la propiedad más usada de un jCheckBox.

Crearemos también un método limpiar(), que limpiará los contenidos para el label (lblRespuesta) y los jCheckBox. A la propiedad setSelected le diremos que nos devuelva false, es decir, que "no nos muestre como seleccionado".

Por último, llamaremos a nuestros métodos creados desde sus respectivos botones.

Area de un Círculo ingresando el Radio

2013-04-26T23:03:00.005-07:00

Calcularemos el área de un círculo de acuerdo al radio ingresado.

Crearemos un método llamado area(), en el que calcularemos el área del círculo de acuerdo al radio ingresado en la caja de texto (txtRadio), cual valor convertiremos a entero usando parseInt, para presentar los cálculos correspondientes en el label (lblRespuesta). El metodo limpiar() nos servirá para borrar los contenidos.

Para terminar, llamaremos a nuestros métodos desde sus respectivos botones.

Minutos a Segundos

2013-04-26T21:40:00.000-07:00

Ejercicio simple en el que ingresaremos un número de minutos y presentaremos su equivalente en segundos.

Crearemos un método llamado convertir(), en el que declaramos dos variables (minutos, segundos) como int. Luego pasaremos el texto ingresado en la caja de texto (txtMinutos) a valor entero, usando parseInt y; haremos los cálculos correspondientes de conversión para presentarlo en el label (lblRespuesta). El método limpiar() nos servirá para borrar los valores para un nuevo cálculo.

Por último, llamaremos a nuestros métodos creados desde sus respectivos botones.

Número a Letras

2013-04-26T19:45:00.000-07:00

En este ejercicio ingresaremos un número en el rango 1-20 y lo presentaremos transformado a letras.

Crearemos un método llamado convertir(), en el cual declaramos una variable llamada numero como int y, haremos uso de la estructura selectiva switch para definir el número ingresado según el rango y dar la respuesta correspondiente en el label (lblRespuesta). En caso el número ingresado se encuentre fuera del rango recibiremos un mensaje. El segundo método es limpiar() que, como ya sabemos nos servirá para borrar contenidos.

Por último, llamaremos a nuestros métodos desde sus respectivos botones.

Aprobado / Desaprobado

2013-04-26T17:19:00.002-07:00

Ingresaremos tres notas para un alumno, calcularemos su promedio y luego mostraremos si está aprobado o desaprobado.

Condición: El alumno aprobará el curso, siempre y cuando su promedio sea mayor o igual a 10.5.

Crearemos dos métodos: notas() y limpiar(). En el primero, pasaremos los datos tomados de las cajas de texto y los pasaremos a un valor entero usando parseInt. Los valores los guardaremos en nuestras variables (nota1, nota2 y nota3 respectivamente) que anteriormente declaramos como enteras (int). Para calcular el promedio, crearemos una variable llamada promedio y será declarada como double. Luego haremos la condicional para determinar si el alumno aprueba o desaprueba el curso y; presentaremos la información en el label (lblRespuesta). Como siempre, el método limpiar(), que nos servirá para borrar el contenido y comenzar un nuevo cálculo.

Por último, llamamos a nuestros métodos creados programando desde sus respectivos botones.

Función Matemática

2013-04-26T16:16:00.000-07:00

En este ejercicio hallaremos el valor de la función x = 5a² + b².

El código para encontrar el valor de esta función es simple. Usaremos los métodos de la clase Math.

Promedio de Notas

2013-04-26T15:36:00.000-07:00

Ejercicio simple en el que aprenderemos a calcular el promedio de cuatro notas ingresadas.

Crearemos un método llamado promedio() con cuatro variables (n1, n2, n3, n4) y las declaramos como int, luego otra variable llamada promedio, la cual será declarada como double. Los valores de las cuatro cajas de texto se pasarán a un valor entero con parseInt, luego haremos el cálculo del promedio sumando todos los valores y dividiéndolos por 4 (que son las notas ingresadas en total). Haremos también otro método llamado limpiar(), que nos servirá para borrar los contenidos para un nuevo cálculo.

Por último, programamos nuestros botones Aceptar y Nuevo respectivamente, para llamar a nuestros métodos creados.

Consumo de Electricidad

2013-04-26T14:07:00.000-07:00

Este ejercicio nos enseñará a hacer los cálculos correspondientes para programar una Factura de Consumo de Electricidad. Trabajaremos también con un combo para clientes sectoriales (A, B, C y D) y hacer los cobros de acuerdo al tipo de cliente elegido. La condición del ejercicio también nos dice que si los Kw consumidos son menores a 100, entonces se aplicará un descuento del 10% al total a pagar. Llamaremos también a la Calculadora de Windows.

Primero vamos a importar el paquete de excepciones (java.io.IOException), que nos servirá para cuando llamemos a la Calculadora de Windows. Como ya se explicó anteriormente usaremos parseInt para convertir los valores ingresados en nuestras cajas de texto a un valor entero.

En nuestro método calculos(), haremos las condicionales para los clientes sectoriales ingresados desde el combo. Entonces: Para el cliente Tipo A, el Precio/Kw será de 0.33; para el cliente Tipo B el Precio/Kw será 0.8; para el cliente Tipo C, el Precio/Kw será 1.5 y; para el cliente Tipo D será 2. Luego haremos los cálculos para el descuento si cumple con la condición (Kw consumidos menores a 100) y; el total, que es el importe menos el descuento, si es que el último existiera.

El método limpiar(), nos servirá para borrar los contenidos y hacer un nuevo cálculo.

Llamaremos a nuestros métodos limpiar() y calculos() desde sus botones respectivos. Programaremos el botón Salir para que cierre el programa y; para terminar, llamaremos a la calculadora programando desde su respectivo botón (btnCalcular).

Sueldos Mayores al Promedio (Vectores)

2013-04-22T15:19:00.000-07:00

Para este ejercicio ingresaremos un número determinado de sueldos, calcularemos el promedio de estos y luego mostraremos: los Sueldos, el Promedio y los Sueldos Mayores al Promedio. Usaremos vectores.

Declararemos una variable P como int y será igual a 6, que es el número total de sueldos que ingresaremos en nuestro arreglo. Crearemos un vector Sueldo que tomará los valores ingresados en P como enteros y; un contador s. Los valores ingresados como texto, los pasaremos a un valor entero usando parseInt dentro de Sueldo(). Crearemos también un método privado llamado agregarDatos(), dentro del cual los datos de Sueldo() serán agregados a nuestro vector Sueldo, que contiene nuestro contador s (Sueldo [s]).

En el método mostrar(), trabajaremos en el JTextArea (taLista) con nuestro vector creado (Sueldo) y condicionaremos los sueldos ingresados para que nos muestre los sueldos totales, el promedio y los sueldos mayores al promedio, como nos lo pide el ejercicio. Luego programamos el botón Mostrar para llamar a nuestro método.

Programaremos dentro del botón Agregar para que cuando ingresemos cada elemento del arreglo, nos muestre un aviso que diga que el sueldo ha sido ingresado. Por último, condicionaremos al mismo botón, para que cuando cumpla la condición de ingreso de elementos, se DESACTIVE.

Uso de Vectores

2013-04-22T13:58:00.000-07:00

Crearemos un arreglo para ingresar hasta 10 países, luego programaremos para desactivar el botón de ingreso y por último mostraremos en un JTextArea los países ingresados.

Declaramos una variable N como int y que será igual a 10, lo cual nos indica en este caso el número total de países que ingresaremos en nuestro arreglo. Luego declaramos nuestro vector pais como String, el cual contendrá los nombres de nuestros países y; por último un contador c. En el método AgregarPais, los datos serán recibidos de dato como String, que luego pasarán a formar parte del vector pais. Dentro de listaPais, trabajaremos con el JTextArea (Talista), que mostrará la lista de nuestros países ingresados.

Programaremos luego el boton Agregar, para que cuando cumpla la condición de ingreso (hasta 10 países) se DESACTIVE. Para terminar, programaremos el botón Mostrar, para que llame a nuestro método listaPais() una vez ingresados todos los elementos del arreglo.

Matrícula de Alumno

2013-04-22T12:55:00.000-07:00

En este ejercicio aprenderemos a trabajar con datos elegidos de dos combos, aplicando los descuentos respectivos sobre la matrícula de acuerdo al turno y la carrera.

Las condiciones para el desarrollo del ejercicio son las siguientes:

Crearemos una clase llamada matriculaalumnos y como podremos apreciar, en ella el trabajo se centra en la variable matricula, la cual declaramos como int y retornará un valor double a r, una vez que se hagan los cálculos correspondientes. Esta nos ayudará en las condicionales de acuerdo al tenor del ejercicio propuesto.

Luego los respectivos get y set para cada variable declarada:

En el método Main de nuestro proyecto, haremos lo siguiente:

Dentro de nuestro formulario crearemos un método limpiarcontroles(), que al ejecutarlo desde el botón Nuevo, nos limpie el contenido del formulario para un nuevo cálculo y; luego programamos dentro del botón Aceptar creando un objeto al que llamaremos oMatriculados, que a su vez trabajará con los contenidos que nos interesan para obtener los resultados que queremos.

Factorial de un Número

2013-04-18T00:14:00.000-07:00

Este ejercicio calculará el factorial de un número ingresado.

El factorial para todo entero positivo n (factorial de n o n factorial) se define como el producto de todos los números enteros positivos desde 1 (es decir, los números naturales) hasta n. Aquí el código:

Como siempre, llamaremos a nuestros métodos creados, desde sus respectivos botones (Aceptar y Nuevo).

Grados Celsius a Farenheit

2013-04-16T22:12:00.000-07:00

Ejercicio sencillo en el que aprenderemos a convertir de grados Celsius a grados Farenheit.

Crearemos dos métodos: aceptar() y nuevo() respectivamente. Para el primero usaremos parseInt, que como ya sabemos, es un método estático que nos ayudará a convertir el contenido de nuestra caja de texto (txtCelsius) a valor entero, luego guardamos el contenido en una variable a, que declaramos como double y hacemos los cálculos necesarios de conversión, guardando el resultado en la variable double llamada result. En el segundo método simplemente limpiaremos los contenidos de la caja de texto (txtCelsius) y el label (lblRespuesta) respectivamente. El código es el siguiente:

Para terminar, llamamos a nuestros métodos creados programando desde los botones Aceptar y Nuevo.

Número Par o Impar

2013-04-16T20:48:00.000-07:00

Ejercicio simple que identifica un número cualquiera como Par o Impar.

Crearemos dos métodos: aceptar() y nuevo() respectivamente. Para el primero usaremos parseInt, que es un método estático y nos ayudará a convertir el contenido de nuestra caja de texto (txtNumero) a valor entero, luego guardamos el contenido en una variable que declaramos como entera (int x) y por último trabajaremos bajo la condicional (if-else) que nos ayudará a decidir si el número es par o impar. En el segundo método simplemente limpiaremos los contenidos de la caja de texto (txtNumero) y el label (lblRespuesta) respectivamente. El código es el siguiente:

Por último, llamaremos a nuestros métodos, programando desde los botones Aceptar y Nuevo respectivamente.

Operaciones Básicas por Consola

2013-04-16T15:45:00.000-07:00

En este ejercicio ingresaremos dos números cualquiera y el sistema nos devolverá las operaciones básicas con esos números. Usaremos System.out.

La programación la haremos dentro del método main de nuestro proyecto. importaremos la clase Scanner (java.util.Scanner), que nos servirá para leer los dos números ingresados. La codificación es como sigue:

Días a Horas por Consola

2013-04-16T14:40:00.000-07:00

En este ejercicio imprimiremos por consola el número de días ingresados, para convertirlos a número de horas. Usaremos System.out.

La programación la haremos dentro del método main de nuestro proyecto. importaremos la clase Scanner (java.util.Scanner), que nos servirá para leer lo que el usuario introduzca a través del teclado. La codificación es como sigue:

Tabla de Multiplicar por Consola

2013-04-16T14:07:00.000-07:00

En este ejercicio, aprenderemos a imprimir por consola usando System.out. Vamos a crear una tabla de multiplicar con cualquier número ingresado.

La programación la haremos dentro del método main de nuestro proyecto. importaremos la clase Scanner (java.util.Scanner), que nos servirá para leer lo que el usuario introduzca a través del teclado. La codificación es como sigue:

Convertir Texto de Minúsculas a Mayúsculas

2013-04-14T19:46:00.000-07:00

Ejercicio simple en el que aprenderemos a cambiar un texto de minúsculas a mayúsculas.

Primero crearemos un método llamado nuevo(), que nos limpiará la caja de texto (txtTexto()) y el label (lblMayuscula()) respectivamente. Luego viene el segundo método, que es aceptar() y que se encargará de cambiar el texto ingresado a mayúsculas usando toUpperCase, que no es más que una función de cadena que devuelve un caracter o texto a mayúsculas.

Luego programamos nuestro botones Aceptar y Nuevo respectivamente, para llamar a nuestros métodos creados. Como vemos, no es cosa del otro mundo. Algo muy simple ¿Verdad?.

Ejecutar el Bloc de Notas de Windows

2013-04-14T16:07:00.002-07:00

Este ejercicio nos enseña cómo ejecutar el Bloc de Notas (Notepad) de Windows desde Netbeans.

Primero vamos a importar el paquete de excepciones, tal como indica la imagen:

Luego programamos nuestro botón (btnBlocnotaswin) con el siguiente código:

Ejecutar la Calculadora de Windows

2013-04-14T15:39:00.000-07:00

Este ejercicio nos enseña cómo ejecutar la calculadora de Windows desde Netbeans.

Primero vamos a importar el paquete de excepciones, tal como indica la imagen:

Luego programamos nuestro botón (btnCalculadora) con el siguiente código:

Número Entero a BINARIO

2013-04-12T21:47:00.001-07:00

En este ejercicio ingresaremos un número entero, para que cuando aceptemos, el programa lo convierta a sistema binario.

Como verán la codificación es muy simple. Crearemos un método llamado busqueda(), que nos hará los cálculos necesarios de conversión y, luego lo llamaremos mediante nuestro boton Calcular (btnCalcular()). Condicionaremos también el entero y diremos que sea menor a 256, caso contrario nos mostrará un mensaje con el texto "INGRESE NUMERO MENOR A 256".

Datos de Trabajador a un JTable (vectores y clases)

2013-04-12T20:12:00.000-07:00

Este ejercicio nos enseña cómo ingresar datos a un JTable. Ingresaremos los datos de un trabajador (DNI, Nombre, Apellidos y Sueldo). Si su sueldo es mayor a 1000, su bonificación será del 10%, caso contrario su bonificación será del 20%. Los datos se agregarán y se presentarán como registros en una Tabla (JTable). Los datos ingresados en minúsculas, se presentarán en mayúsculas.

Crearemos 3 clases (Persona, Trabajador y Traba).Vamos en orden. Aquí la clase Persona:

En nuestra clase Persona, declaramos las variables (dni, nombre, apellido) como private. Luego para cada variable haremos su Get (tomar el valor) y Set (mostrar el valor). Una vez hecho esto, usaremos toUpperCase, que nos ayudará a devolver el texto ingresado en minúsculas para convertirlo en mayúsculas, concatenando (+" "+) los valores ingresados en las cajas de texto de Nombres y Apellidos respectivamente, para presentarlos como uno solo en el JTable.

Ahora nuestra clase Trabajador:

A nuestra clase Trabajador la extenderemos hacia la clase Persona (extends Persona), puesto que también haremos uso de los objetos de esa clase. También leeremos el sueldo y la bonificación, haremos los cálculos correspondientes según el tenor del ejercicio y mostraremos sus respectivos valores.

Ahora la clase Traba:

Creamos un vector llamado Trab, el cual será el "repositorio" de todos los elementos ingresados para agregarlos al JTable.

Luego en nuestro form importaremos nuestras clases y las librerias necesarias. Después crearemos un objeto llamado oTraba. Crearemos también el método verDni(), que nos devolverá un mensaje de error, si es que no se ha ingresado correctamente el DNI.

En nuestro método verSueldo() diremos que nos muestre un mensaje si la caja de texto Sueldo (txtSuel) está vacía. Programaremos también un método limpiar(), que borrará el contenido de las cajas de texto; otro método mostrarTrabajadores(), que nos mostrará los trabajadores en el JTable y; otro método más agregaTrabajadores(), que servirá para agregar los datos ingresados desde las cajas de texto hacia el JTable, con un aviso que nos dirá que los datos han sido guardados.

Luego programaremos la caja de texto DNI (txtDni) en su evento KeyPressed, para que acepte sólo 8 dígitos y al botón Aceptar (btnAceptar), para agregar y mostrar a los trabajadores a través del llamado a nuestros métodos (agregaTrabajadores() y mostrarTrabajadores()) anteriormente creados y; en caso se omita ingresar el sueldo y/o DNI llame a nuestro/s método/s verSueldo() y/o verDni() respectivamente, que nos mostrará un/os mensaje/s para ingresar el/los dato/s.

Por último, programamos el botón Salir (btnSalir) para que cierre el programa y nuevamente la caja de texto DNI (txtDni) ahora en su evento KeyTyped, para que acepte sólo dígitos, además de la caja de texto Sueldo (txtSuel) en su evento KeyTyped para el mismo fin.

Datos Personales a un TextArea (clases)

2013-04-12T15:31:00.000-07:00

En este ejercicio aprenderemos a: Ingresar Datos a un TextArea, Convertir de Minúsculas a Mayúsculas, Ingresar sólo dígitos y exactos de un DNI, en caso contrario nos aparecerá un Mensaje pidiendo un "DNI válido" y no dejará ingresar los datos. Usaremos clases para desarrollar este ejercicio.

Crearemos nuestra clase Persona, dentro de ella declaramos las variables como private. Luego por cada variable haremos su Get (tomar el valor) y Set (mostrar el valor).

Luego usaremos toUpperCase, que nos ayudará a devolver el texto ingresado en minúsculas para convertirlo en mayúsculas, concatenando (+" "+) los valores ingresados en las cajas de texto de Nombres y Apellidos respectivamente.

En nuestro método verDni(), trabajaremos con una condicional if, a la cual diremos que si el tamaño ingresado en txtDni es menor o igual a 7 (dado que un DNI tiene 8 dígitos) nos devuelva un aviso con un mensaje que diga "Ingrese DNI Válido".

En nuestro método aceptar(), crearemos los datos para el objeto a partir de los valores ingresados dentro de nuestras cajas de texto, que luego se mostrarán en el JTextArea (tblLista). También usaremos "\n" para que nos dé un salto y los textos no salgan como uno solo cuando ingresemos un segundo dato.

Programaremos el botón Salir para que cuando demos clic se cierre el programa. En nuestro botón Aceptar usaremos un if y else, para condicionar que si los dígitos ingresados son 8, se ejecuten nuestros métodos aceptar() y limpiar(), en caso contrario se ejecute nuestro método verDni(), el cual nos avisa mediante un mensaje que ingresemos un DNI válido.

Por último, programaremos también nuestro txtDni en sus eventos KeyTyped y Key Pressed respectivamente, para que al momento de tipear no acepte más que sólo dígitos y luego una vez completados (los 8 dígitos), el cursor se ubique en txtNom (Nombre).

Registro de Socios (usando vectores)

2013-04-12T00:31:00.000-07:00

Un buen ejemplo del uso de vectores. En este ejercicio ingresaremos datos de varias personas; como el Nombre, Apellido, Sexo y el Tipo de Socio (Activo, Cesante o Particular), luego realizaremos las consultas de socios por sexo (Masculino o Femenino o Todos los socios ingresados). También podremos filtrarlos por Activos, Cesantes o Particulares.

Mucho Ojo: El método a continuación va a trabajar con los vectores y va a tener que llegar al JTable para que nosotros podamos visualizarlo. Pero el JTable necesita un formato y la data necesita un modelo, para eso llamamos a la clase DefaultTableModel. El modelo lo vamos a llenar fila por fila y necesitaremos pasar todas las filas al modelo, para eso hacemos un ciclo de FOR desde 0 hasta que "i" sea menor al tamaño (size) que es un método que devuelve el tamaño o la cantidad de filas de un vector. Esto quiere decir que si tuvieramos 3 registros (0,1,2) llenos o terminados, entonces pasan al TABLE.

Creamos un método llamado masculino(), que nos filtrará por sexo Masculino.

Al usar Object data y los corchetes diremos que no va a tener un tamaño especifico y elementAt nos sirve para extraer el valor de un elemento del arreglo o vector. Para los métodos femenino(), activos(), cesantes() y particulares() la codificación es casi la misma que masculino().

Ahora programamos el botón Nuevo y le decimos que mientras no se ingrese el primer dato aparezca el texto "Cancelar" en el botón, pero una vez agregado el primer dato aparezca "Nuevo". Habilitamos el botón Guardar (btnGuardar) y luego hacemos que el cursor se sitúe en la caja de texto Nombre (txtNombre.requestFocus).

Luego programamos el botón Guardar para que cuando completemos un registro y lo guardemos nos salga un mensaje de "Socio Registrado". Ponemos además a false el método activarcontroles y btnGuardar. En nuestro btnNuevo haremos mostrar como texto "Nuevo", dado que ya ingresamos un registro.

En el paso siguiente, "llamaremos" a nuestros métodos masculino(), femenino() y listasocio() dentro de su correspondiente botón.

Por último programaremos el combo (cboTipo1) para que en nuestra pestaña Consulta la consulta por Tipo de Socio (Activos, Cesantes o Particulares) nos dé el filtro deseado. Llamaremos por cada ítem a nuestros métodos (activos(), cesantes() y particulares()).