Java + Swing 017. Modo diseño en NetBeans. Juego; números aleatorios. Utilizando Thread y Random.

Ejercicio: Realizar una pequeña aplicación que pueda generar siete números aleatorio y mostrarla. Los números no podrán repetirse.
Diseño de formulario con JFrame.
En la imagen podemos ver el diseño y a un costado los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, va de izquierda a derecha e el diseño. Todos los campos de texto están deshabilitados, esto se hace cambiando la propiedad “enabled”.
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
Creamos los métodos siguientes en el apartado “Fuente”. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
Código Java
private void limpiar(){
//Método para limpiar campos y activar objetos.
//Se carga en el contructor del JFrame y el boton reiniciar.
contador.setText(null);
numUno.setText(null);
numDos.setText(null);
numTres.setText(null);
numCuatro.setText(null);
numCinco.setText(null);
numSeis.setText(null);
numSiete.setText(null);
num.setText(null);
jugar.setEnabled(true);
iniciar.setEnabled(true);
jLabelFinal.setVisible(false);
}
private void iniciar(){
//Variable de clase tipo boolean, para controlar la ejecusión del Thread.
control = true;
//Forma de declarar un Thread.
//El modificador final para mejor control.
final Thread t = new Thread( new Runnable() {
@Override
//Implementamos el método que trae.
public void run() {
//Para generar los números aleatorios utilizamos Random.
Random ran = new Random();
//while para mostrar los números generados.
while (control) {
//Los número generados van del 1 al 20.
//Indicamos 20 + 1 pués los números generados van desde el cero.
int next = (int)(ran.nextDouble() * 20 + 1);
//Los números generados se muestran en "num" un JTextField
num.setText(String.valueOf(next));
try {
Thread.sleep(100);
} catch (Exception e) {

}
//Al cambiar el valor de la variable control se sale del bucle y el Thread.
if (control==false) {
break;
}
}
}
});
//Método que iniciar la ejecusión del Thread.
t.start();
}

private void jugar(){
//Método que se ejcutan con el botón jugar.
control = false;
//La lista de if anidados es para controlar los números repetidos.
try {
if(!"".equals(num.getText())){
if(numUno.getText().isEmpty()){
numUno.setText(num.getText());
contador.setText("1");
}
else{
if(num.getText().equals(numUno.getText())){
iniciar();
jugar();
}
else{
if(numDos.getText().isEmpty()){
numDos.setText(num.getText());
contador.setText("2");
}
else{
if(num.getText().equals(numDos.getText())){
iniciar();
jugar();
}
else{
if(numTres.getText().isEmpty()){
numTres.setText(num.getText());
contador.setText("3");
}
else{
if(num.getText().equals(numTres.getText())){
iniciar();
jugar();
}
else{
if(numCuatro.getText().isEmpty()){
numCuatro.setText(num.getText());
contador.setText("4");
}
else{
if(num.getText().equals(numCuatro.getText())){
iniciar();
jugar();
}
else{
if(numCinco.getText().isEmpty()){
numCinco.setText(num.getText());
contador.setText("5");
}
else{
if(num.getText().equals(numCinco.getText())){
iniciar();
jugar();
}
else{
if(numSeis.getText().isEmpty()){
numSeis.setText(num.getText());
contador.setText("6");
}
else{
if(num.getText().equals(numSeis.getText())){
iniciar();
jugar();
}
else{
if(numSiete.getText().isEmpty()){
numSiete.setText(num.getText());
contador.setText("7");
iniciar.setEnabled(false);
jugar.setEnabled(false);
control = false;
num.setText(null);
jLabelFinal.setVisible(true);
jLabelFinal.setForeground(Color.red);
}
}
}
}
}
}
}
}
}

}
}
}
}
}
else{
iniciar();
jugar();
}

} catch (Exception e) {
System.out.println("Metodo jugar " + e);
}

}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void iniciarActionPerformed(java.awt.event.ActionEvent evt) {                                        
//Método para crear el Thread y llamar sus métodos.
iniciar();
}

private void reiniciarActionPerformed(java.awt.event.ActionEvent evt) {
//Método para limpiar campos y activar objetos.
limpiar();
}

private void jugarActionPerformed(java.awt.event.ActionEvent evt) {
//Método para obtener el número generado y mostrar.
jugar();
}
Por último tenemos el formulario en ejecución.
Observación: Los métodos y el diseño son meramente para práctica y ejemplo, no tienen aplicación funcional y pueden contener errores.

Java básico 054. Función, cálculo de x^y utilizando multiplicación sucesiva.

Ejercicio: Diseñe un programa que lea de teclado dos números enteros (x e y) y escriba en pantalla el resultado de calcular la potencia de x elevado a y (x^y), mediante multiplicaciones sucesivas. Por ejemplo, 2^3 = 2x2x2.
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class MultiSuce {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos dos variable enteras.
int x, y;
//Utilizamos Scanner para capturar datos.
Scanner num = new Scanner(System.in);
//Solicitamos los datos necesarios.
System.out.println("Ingresa la base y el exponenete.");
System.out.print("Base: ");
x = num.nextInt();
System.out.print("Exponente: ");
y = num.nextInt();
//Ejecutamos la función pasándole los argumentos necesarios.
long multSus = multSuc(x, y);
System.out.println("Resultado " + x + "^" + y + " = " + multSus);
}
//Creamos una función con retorno tipo long y dos argumentos tipo enteros.
static long multSuc(int x, int y){
long exp = 1;
//Comprobamos que los datos ingresados no sean ceros.
if(x != 0 && y != 0){
//Utilizamos un bucle for para la multiplicación sucesiva.
//Se hará la multiplicación tantas veces como el exponente ingresado.
for (int i = 1; i <= y; i++) {
//Esto representa exp = exp * x;
exp *= x;
}

}
//Retornamos el resultado.
return exp;
}
}

Java + Swing 016. Modo diseño en NetBeans. Trabajando con JComboBox y jTable.

Ejercicio: Realizar una pequeña aplicación que nos muestre la forma de agregar ítems a un JComboBox y jTable.
Diseño de formulario con JFrame.
En la imagen podemos ver el diseño y a un costado los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, va de izquierda a derecha e el diseño.
Diseño del formulario utilizando JFrame. Como elementos utilizamos “JComboBox”, “Botón”, y “Tabla”.
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
Creamos los métodos siguientes en el apartado “Fuente”. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
Código Java
private void comboUno(){
//Este método nos permite cargar el comboUno.
//Utilizamos el DefaultComboBoxModel para cargar los datos, es una de las
//tantas formas.
jComboBox1.setModel(new DefaultComboBoxModel(new Object[]{
"Monitores","Impresoras","Teclados","CPU","Memoria RAM"
}));
}
private void tableModel(){
//Este metodo configura el DefaultTableModel, nos permite dar forma a la tabla.
jTable1.getColumnModel().getColumn(0).setPreferredWidth(10);
jTable1.getColumnModel().getColumn(1).setPreferredWidth(300);
model = (DefaultTableModel)jTable1.getModel();
model.setNumRows(0);

}
private void agregarTabla(){
//Con este método agregamos datos a la tabla.
if(nombre.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "No hay datos.");
}
else{
//El id de cada fila lo generamos. Es Opcional.
int id = jTable1.getRowCount() + 1;
//Utilizamos el model de la tabla que configuramos en tableModel().
model.addRow(new Object[]{
id,nombre.getText()
});
nombre.setText(null);
}
}
private void arrayTabla(){
//Los datos de la tabla lo pasamos a un Array con este método.
int rowCount = jTable1.getRowCount();
if( rowCount != 0){
//Utilizamos jTable1.getRowCount() para obtener la cantidad de filas
//que será la cantidad de elementos del Array.
String[] nombres = new String[jTable1.getRowCount()];
//Cargamos el Array con los datos de la tabla.
for (int i = 0; i < nombres.length; i++) {
//Utilizamos el getValueAt del model para obtener los datos de la tabla.
//El primer parámetro es la fila, el segundo la columna.
//Las columnas se cuentan desde cero.
nombres[i]= model.getValueAt(i, 1).toString();
}
//Cada vez que ejecutemos el método también limpiamos el ComboBox con removeAllItems().
//De esta forma no se duplican los datos con cada ejecusión.
jComboBox2.removeAllItems();
//Con un for recorremos el Array de String.
for (int i = 0; i < nombres.length; i++) {
String string = nombres[i];
//Utilizamos addItem, para agregar cada ítem del combo.
jComboBox2.addItem(string);
}
}
}
private void eliminarTable(){
//Metodo para remover datos de la tabla.
try {
int selectedRow = jTable1.getSelectedRow();
if(jTable1.getRowCount() > 0){
model.removeRow(selectedRow);
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "No seleccionado para eliminar.");
}
}
private void arrayLista(){
//Metodo similar a la anterior, utilizando Array literal.
String[] dias = {"Lunes","Martes","Miércoles","Jueves","Viernes","Sábado","Domingo"};
jComboBox3.removeAllItems();
for (int i = 0; i < dias.length; i++) {
String string = dias[i];
jComboBox3.addItem(string);
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void cargarUnoActionPerformed(java.awt.event.ActionEvent evt) {                                          
//Evento botón cargarUno.
comboUno();
}

private void agregarTablaActionPerformed(java.awt.event.ActionEvent evt) {
//Evento botón agregarTabla.
agregarTabla();
}

private void cargarDosActionPerformed(java.awt.event.ActionEvent evt) {
//Evento botón cargarDos.
arrayTabla();
}

private void cargarTresActionPerformed(java.awt.event.ActionEvent evt) {
//Evento botón cargarTres.
arrayLista();
}

private void jComboBox1ActionPerformed(java.awt.event.ActionEvent evt) {
//Evento jComboBox1 para obtener datos seleccionados y pasar a un JTextField.
//El try para capturar posibles excepciones.
try {
comboUno.setText(jComboBox1.getSelectedItem().toString());
} catch (Exception e) {
}
}

private void jComboBox2ActionPerformed(java.awt.event.ActionEvent evt) {
//Evento jComboBox2 para obtener datos seleccionados y pasar a un JTextField.
try {
comboDos.setText(jComboBox2.getSelectedItem().toString());
} catch (Exception e) {
}

}

private void jComboBox3ActionPerformed(java.awt.event.ActionEvent evt) {
//Evento jComboBox2 para obtener datos seleccionados y pasar a un JTextField.
try {
comboTres.setText(jComboBox3.getSelectedItem().toString());
} catch (Exception e) {
}

}

private void eliminarFilaActionPerformed(java.awt.event.ActionEvent evt) {
//Evento botón eliminarFila.
eliminarTable();
}
Por último tenemos el formulario en ejecución.

Java básico 053. Función, obtener multiplicación de (m * n) utilizando ciclo.

Ejercicio: Desarrollar una función que lea del teclado dos números enteros y escriba en pantalla el resultado de multiplicar ambos números, teniendo en cuenta que no se permite utilizar la operación de multiplicar (*), por lo que se deberá realizar mediante sumas sucesivas. Por ejemplo, 2 x 3 = 2 + 2 + 2.
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class MultiFor {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos dos variables tipo entero.
int m, n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//Solicitamos los datos.
System.out.println("Introduce dos número enteros (m*n).");
System.out.print("Introduce m: ");
m = num.nextInt();
System.out.print("Introduce n: ");
n = num.nextInt();
//Llamamos a la función que creamos, pasandole los dos parámetros.
int multi = multi(m, n);
//Imprimimos datos.
System.out.println("La multiplicación ("+m+"*"+n+")= "+multi);
}
//Creamos la función con retorno tipo entero y dos parámetros.
static int multi(int m, int n){
int mul = 0;
//Establecemos condición de que (m y n) no sean cero.
if((m != 0) && (n != 0)){
//Utilizamos un for para ejecutar el ciclo de sumas.
for (int i = 0; i < n; i++) {
// += representa (mul = mul + m), solo acorta lo anterior.
mul += m;
}
}
//Retornamos el resultado.
//Si m o n es cero, retornará cero.
return mul;
}
}

Java + Swing 015. Modo diseño en NetBeans. Fecha y Hora con objeto Calendar.

Ejercicio: Desarrollar un formulario con jFrame que permite el manejo de fecha y horas.
Para diseñar el formulario utilizamos un jFrame. Como se ve en la imagen siguiente, es la forma como debe quedar el formulario después de agregar todos los objetos correspondientes. Se indica con marcadores en “rojo” la referencia del objeto con nombre de variable y tipo de objeto. Esto es importante para que coincidan con los métodos que crearemos.
Los objetos que utilizamos en el diseño son: JFormattedTextField, JTextField, JTextArea, JLabel, JButton y el JScrollPane que se agrega de forma automática en caso necesario.
Observación: el indicador (dd/MM/yyyy) significa fecha en formato día/mes/año.
En la imagen siguiente vemos la forma de configurar el “JFormattedTextField”, que es el objeto que se utiliza para controlar la entrada de datos en un formato específico, en este caso “fecha”.
La serie de pasos es la siguiente: (1) seleccionar objeto. (2) acceder a Propiedades o “Properties”. (3) seleccionamos “AbstractFormatterFactory”. (4) indicamos “mascara”. (5) tipo “personal”. (6) marcamos el formato que deberá respetarse. (##/##/####) -- (09/07/2013). (7) Aceptamos los cambios. Esto se aplica solo al objeto “JFormattedTextField”.
Creamos los métodos siguientes en el apartado “Fuente”. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se insertan algunos comentarios para tratar de explicar el funcionamiento de cada método.
Código Java
private String fechaString(Calendar fecha){
//A este método le pasamos un objeto Calendar y la convierte en un String de fecha.
String retorno = null;
//Utilizamos SimpleDateFormat para establecer el formato de la fecha.
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
//Si fecha está vacío retornará null.
if(fecha != null){
//Este proceso permite convertir el Objeto Calendar en un formato de fecha útil.
retorno = sdf.format(fecha.getTime());
}
return retorno;
}
private String horaString(Calendar fecha){
//A este método le pasamos un objeto Calendar y la convierte en un String de hora.
String retorno = null;
//Utilizamos SimpleDateFormat para establecer el formato de la hora.
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
if(fecha != null){
//Este proceso permite convertir el Objeto Calendar en un formato de hora útil.
retorno = sdf.format(fecha.getTime());
}
return retorno;
}
private Calendar fechaCalendar(String fecha){
//A este método le pasamo como parámetro un String con formato fecha específico
//y la convierte en objeto Calendar.
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
//Obtenemos una instancia del objeto Calendar.
Calendar cal = Calendar.getInstance();
//Utilizamos un try para controlar entrada de datos erroneos.
try {
//Hacemos la conversión con este procedimiento.
cal.setTime(sdf.parse(fecha));
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error de formato de fecha: " + e);
}
return cal;
}
private void obtenerFechaUser(){
//Utilizamos este método para obtener la fecha que haya introducido el usuario.
//En este caso desde el JTextField "fechaUser".
String fecha = fechaUser.getText();
//Comprobamos que no este vacío.
if(fecha != null){
//Llamamos a nuestros métodos de más arriba.
Calendar fechaCalendar = fechaCalendar(fecha);
fechaTestD.setText(fechaCalendar.toString());
String fechaString = fechaString(fechaCalendar);
fechaTest.setText(fechaString);
}
}
private void obtenerFechaSistema(){
//Este método permite obtener una instancia del Objeto Calendar, procesarla
//y obtner la fecha y la hora actual.
Calendar cal = Calendar.getInstance();
String fechaString = fechaString(cal);
fechaObtenido.setText(fechaString);
String horaString = horaString(cal);
horaObtenido.setText(horaString);
}
Lo siguiente será agregar los eventos que harán funcionar a nuestro programa. Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la imagen vemos como se indica (1)” setLocationRelativeTo(null);” que nos permitirá centrar el formulario llamándola desde el constructor del jFrame. (2) nos indica el evento que se llama desde el botón “probar”. (3) llamamos al método “obtenerFechaUser();” que habíamos creado. Este método se ejecutará al hacer clic sobre el botón “probar”.
La última imagen nos muestra el jFrame en ejecución. Obs.: En el “JTextArea” imprimimos el Objeto calendar sin procesar, por tanto trae todo lo que incluye el objeto.

Java básico 052. Función, obtener cociente y resto sin utilizar operaciones de división.

Ejercicio: Diseñe un programa que lea del teclado dos números enteros y escriba en pantalla el cociente y resto de la división de ambos números, teniendo en cuenta que no se permite utilizar las operaciones de división y resto (/, %), por lo que se deberá realizar mediante restas sucesivas.
Ejemplo: 7 / 2 = (7 -2 = 5; 5 -2 = 3 ; 3 -2 = 1 =) Cociente = 3 ; Resto = 1.
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class JavaCal {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos dos variables enteras.
int dividendo;
int divisor;
//Utilizamos Scanner para capturar valores desde el teclado.
Scanner num = new Scanner(System.in);
//Utilizamos "try" para controlar posibles errores de entrada de datos.
try {
//Procedemos a capturar los valores.
System.out.print("Ingresa el dividendo: ");
dividendo = num.nextInt();
System.out.print("Ingresa el divisor: ");
divisor = num.nextInt();
//Después de obtener los datos llamamos nuestra función.
calculo(dividendo, divisor);
} catch (Exception e) {
System.out.println("Error de datos: " + e);
}
}
//Creamos nuestra función sin retorno.
//La función requerirá 2 parámetros.
static void calculo(int dividendo, int divisor){
int resto;
int cociente = 0;
//Condición en caso que número sea negativo o cero.
if(divisor <= 0){
System.out.println("No se puede realizar operación.");
}
else{
//Arreglos para mejorar el formato de impresión.
int y = dividendo - divisor;
System.out.println("(" + dividendo + "/" + divisor + ")" );
System.out.print("(" + dividendo + "-" + divisor + "=" + y + ")" );
resto = dividendo;
//Un bucle para realizar los cálculos necesarios.
while (resto >= divisor) {
resto -= divisor;
int var = resto - divisor;
++cociente;
//Por cada ciclo imprimimos los valores intermedios.
if(resto > divisor){
System.out.print("("+ resto + "-" + divisor + "=" + var + ")");
}

}
//Al termina el ciclo nos retorna los valores finales.
System.out.println("\nCociente: " + cociente + " ; " + "Resto: " + resto);
}
}
}

Java básico 051. Función, imprimir un cuadrado hueco utilizando asteriscos “*”.

Ejercicio: Desarrollar una función que lea un número entero de teclado y escriba un cuadrado (hueco) con tantos asteriscos (*) de lado como indique el número leído. Por ejemplo, para un número leído con valor 5, escribirá:
*****
*   *
*   *
*   *
*****
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibuj {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera.");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Anidamos otro for con el mismo proceso.
for (int j = 0; j < n; ++j) {
//Establecemos una condición para que se imprima el "*".
if((i == 0) || (i == n-1) || (j == 0) || (j == n - 1)){
System.out.print(simbolo);
}
else{
System.out.print(" ");
}
}
}
System.out.println();
}
}

Java básico 050. Función, obtener semanas, días y HH:mm:ss de cierta cantidad de segundos.

Ejercicio: Desarrollar una función que lea de teclado una cierta cantidad de segundos y muestre su equivalente en semanas, días, horas, minutos y segundos.
Ejemplo: 2178585 segundos equivalen a [3] semanas, 4 días, 05:09:45.
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionSeg {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Obtenemos los segundos con la función.
int segundos = segundos();
//Obtenemos el resultado.
String calculos = calculos(segundos);
//Imprimimos el resultado.
System.out.println(calculos);

}
static String calculos(int s){
//Declaramos constantes enteros, representan valores absolutos.
final int segMin = 60;
final int minHora = 60;
final int horaDia = 24;
final int diaSemana = 7;
final int segHora = segMin * minHora;
final int segDia = segHora * horaDia;
final int segSemana = segDia * diaSemana;
//Especificamos el valor de cada variable.
int semana = s / segSemana;
//Con el resto seguimos el proceso descendiente.
int resto = s % segSemana;
int dia = resto / segDia;
resto = resto % segDia;
int hora = resto / segHora;
String horaS = hora + "";
//Un pequeño arreglo para mostrar formato HH:mm:ss.
if(hora < 10)horaS = "0" + horaS;
resto = resto % segHora;
int minuto = resto / segMin;
String minutoS = minuto + "";
if(minuto < 10)minutoS = "0" + minutoS;
int segundo = resto % segMin;
String segundoS = segundo + "";
if(segundo < 10)segundoS = "0" + segundoS;
//Almacenamos todo el resultado en un String usando concatenación.
String res = (s + " segundos representan " + "[" + semana + "]" + " semanas "
+ "[" + dia + "]" + " días y " + horaS +":" + minutoS + ":" + segundoS );
//Retornamos ese valor.
return res;
}
//Utilizamos una función para capturar los segundos del usuario.
static int segundos(){
int segundos;
Scanner seg = new Scanner(System.in);
//Utilizamos un try para comprobar que los datos sean enteros.
try {
System.out.print("Ingresa los segundo para comprobar: ");
segundos = seg.nextInt();
} catch (Exception e) {
//En caso que no sea entero volvemos a lanzar la función.
System.out.println("ERROR: Ingresar datos numéricos entero.");
segundos = segundos();
}
return segundos;
}
}

Java básico 049. Función, obtener el máximo de un “Array” utilizando recursividad.

Ejercicio: Desarrollar una función que calcule el valor máximo de una tabla (array) de forma recursiva.
Código Java
/**
*
* @author Ariel
*/

public class TablaMax {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Creamos un array con 10 elementos.
int t[] = new int[10];
//Cargamos el array con números generados de forma aleatoria.
for (int i = 0; i < t.length; i++) {
t[i] = (int) (Math.random() * 1000 + 1);
}
//Imprimimos los datos del array
System.out.println("Imprimiendo tabla.");
for (int i = 0; i < t.length; i++) {
int j = t[i];
System.out.print("[" + j + "]");
}
System.out.println("\nObteniendo el máximo.");
//Usamos la segunda función que retorna el valor del primero.
int maximo = maximo(t);
System.out.println("El máximo de la tabla es: " + "[" + maximo + "]");

}
static int maximo(int t[], int pos){
//A la función le pasamos 2 argumentos. El array y la posición inicial del índice.
int res;
//Si llegamos al final del array significa que el último es el máximo.
if(pos == t.length - 1){
res = t[pos];
}
else{
//Vamos iterando el array utilizando recursividad.
int k = maximo(t, pos + 1);
if (t[pos] > k){
res = t[pos];
}
else{
res = k;
}
}
return res;
}
//Sobrecargamos la primera función, a esta solo le pasamos un argumento,
//que es el array. La función retorna un entero que será el maximo llamando
//la primera función.
static int maximo(int t[]){
return maximo(t, 0);
}
}

Java básico 048. Función, factorial de “n” utilizando recursividad.

Ejercicio: Calcular el factorial de “n” recursivamente.
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FactorialRec {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
int n, factor;
Scanner num = new Scanner(System.in);
System.out.print("Ingresa un número para calcular el factorial: ");
n = num.nextInt();
factor = factorial(n);
System.out.println("El factorial de " + n + " es " + factor);
}
static int factorial(int n){
int factor;
if(n == 0){
factor = 1;
}
else{
factor = n * factorial(n - 1);
}
return factor;
}
}