Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Number() también sirve igual en este caso.
Aunque en otros casos más especiales, parseInt() y Number() tendrán comportamientos diferentes.

En este artículo (en inglés) lo explican muy bien, con ejemplos muy claros.
Guárdalo porque puede servirte para futuras referencias.

Sí.
Puedes parsear a entero para que el operador de suma trate los valores como números y no como cadenas String

alert(parseInt(num1) + parseInt(num2));

Coincido en la importancia de tener una formación reglada de cara al mercado laboral.

Pero también recomiendo no limitarse solo a eso. Esto de la programación es muy amplio, abarca muchos campos (lógica de la programación, desarrollo web, bases de datos, despliegue de aplicaciones, CRM's, redes,....)

Los planes de estudio de las formaciones regladas no abarcan todo (de hecho el TODO, es inabarcable porque está en continua expansión...) ni evolucionan igual de rápido que las herramientas de programación.

Por eso es recomendable intentar extraer conocimientos de TODAS partes: foros, cursos web, tutoriales Youtube,...
Incluso accediendo a distintos recursos que supuestamente están explicando LO MISMO, se puede aprender cosas diferentes, porque cada autor explica las cosas de una manera, y  puede exponer distintas soluciones a un mismo ejercicio.

Sobre este comentario:

Y viendo la web de ustedes entiendo que podría empezar por el curso : CURSO "FUNDAMENTOS DE PROGRAMACIÓN NIVEL I" con eso ver si realmente la programación es para mi y luego si es así, avanzar con más cursos.

Quisiera añadir, aunque no se si lo va a leer la persona que realizó la consulta, que ese curso, si bien es necesario, no lo consideraría determinante a la hora de decidir si la programación "es para él o no".

Me refiero que al tratarse de un curso principalmente teórico, donde no se pone en práctica lo que se explica de forma que se puedan visualizar resultados en un ordenador, a según que personas puede provocar tedio o dar la falsa sensación de que esto de la programación es demasiado abstracto y matemático..., y entonces dudar de si es asequible intelectualmente para dicha persona.

Pero esa sensación puede cambiar cuando se empieza a escribir los primeros programas, cuando se empiezan a ver que nuestras líneas de código dan resultados y podemos experimentar "a ver que pasa" si cambio esto o lo otro...

Por eso animo a no rendirse si ese primer curso se hace difícil. Incluso recomiendo que si uno de los temas del curso no se entiende, pues no quedarse ahí atascado. Se prosigue con el siguiente tema y ya está, no pasa nada, en el futuro puede revisitarse ese tema que no se entendió tantas veces como se necesite.
Incluso puede que cuando se empiece a experimentar con los primeros programas, al poner en práctica esos conceptos se entienda por fin la explicación teórica.

Yo creo que la programación es algo accesible para casi cualquiera. No hace falta ser ningún cerebrito.

Pero digo "casi cualquiera", porque sí he conocido a alguna persona que por mucho que lo ha intentado, apenas ha podido avanzar.
Y no porque fuera tonto, que no lo era, si no por carencias en digamos "pensamiento abstracto".
Por ejemplo, sabía y entendía lo que era un bucle, pero luego no discernía en que escenarios convenía usarlos para sacarles partido.
No conseguía "abstraerse" para comprender lo que pasaba en la "mente" de la máquina y al no ser capaz de "pensar" como ella, pues no conseguía desarrollar una lógica para escribir un programa.

Pero bueno, insisto en que prácticamente todo el mundo puede aprender a programar  (otra cosa es que pueda gustarte más o menos).
El inicio desde cero puede ser duro..., pero luego va siendo más asequible e incluso apasionante.

Un saludo.

Hola.

Todo depende un poco de cómo sea tu código.

Supongamos que has creado una clase (deberías) llamada Jugador, o Persona, o lo que sea...
Necesitas que esta clase sea capaz de calcular la edad del Jugador, según la fecha de nacimiento.

No se como estás recogiendo la fecha de nacimiento, puede ser un String, pero esto aumentará el código necesario para hacer el cálculo.

Si estás usando la clase LocalDate (deberías) entonces el cómputo es mucho más sencillo.
Expongo la clase que he escrito yo, al final hay dos métodos.
Uno para calcular la edad, que la retorna como valor int.

El otro es simplemente una sobreescritura del método toString(), para luego facilitar mostrar los datos en pantalla cuando haya que listar los jugadores:
import java.time.LocalDate;

public class Jugador {

private String nombre;
private String apellido;
private LocalDate fechaNac;
private String eps;
private String documento;

public Jugador(String nombre, String apellido, LocalDate fechaNac, String eps, String documento) {
this.nombre = nombre;
this.apellido = apellido;
this.fechaNac = fechaNac;
this.eps = eps;
this.documento = documento;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getApellido() {
return apellido;
}

public void setApellido(String apellido) {
this.apellido = apellido;
}

public LocalDate getFechaNac() {
return fechaNac;
}

public void setFechaNac(LocalDate fechaNac) {
this.fechaNac = fechaNac;
}

public String getEps() {
return eps;
}

public void setEps(String eps) {
this.eps = eps;
}

public String getDocumento() {
return documento;
}

public void setDocumento(String documento) {
this.documento = documento;
}

public int calculaEdad() {

LocalDate hoy = LocalDate.now();
//Calculamos años diferencia
int anios = hoy.getYear() - fechaNac.getYear();
//Afinamos cálculo segun dia del año
if (hoy.getDayOfYear() > fechaNac.getDayOfYear())
anios--; //Último año no está completo

return anios;
}

@Override
public String toString() {
return String.format("Nombre: %s %s\nFecha Nacimiento: %s\nEPS: %s\nDocumento: %s",
nombre, apellido, fechaNac.toString(), eps, documento);
}

}
Bien, vamos ahora a la clase principal.

Menú con tres opciones:
registrar jugador, listar categorías y terminar el programa

Usaremos un ArrayList para registrar a todos los jugadores que se introducen.
El proceso de registro lo haré mediante un método que pide los datos necesarios.

En el método para listar las categorías, lo que haré será crear 4 ArrayList, uno por cada categoría, y recorreré el ArrayList principal pidiendo a cada objeto Jugador que me de su edad.
Analizando la edad, introduciré a cada Jugador en el ArrayList correspondiente a su categoría.

Tras clasificar a todos los Jugadores, pues ahora muestro en pantalla el contenido de cada ArrayList de categorías.

Y listo, eso sería todo.
Básicamente es codificar un método capaz de calcular la edad, y en base a este dato, clasificar los jugadores en diferentes listados, según categoría.
Pregunta si algo no lo entiendes. Un saludo.

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Scanner;

public class GestionJugadores {

private static ArrayList<Jugador> jugadores = new ArrayList<Jugador>();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

char opcion = ' ';

do {
System.out.println("\n[1] -- Registrar Jugador");
System.out.println("[2] -- Listar por Categorías");
System.out.println("[0] -- FIN DE PROGRAMA");
System.out.print("Elija: ");
opcion = teclado.nextLine().charAt(0);

switch(opcion) {
case '0':
System.out.println("\n\t\tPROGRAMA TERMINADO");
break;
case '1':
registrarJugador();
break;
case '2':
listarCategorias();
break;
default:
System.out.println("Opción equivocada\n");
}

}while (opcion != '0');

}

private static void registrarJugador() {
System.out.println("\nNuevo Jugador...\n");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellido: ");
String apell = teclado.nextLine();
System.out.println("- Fecha Nacimiento -");
System.out.print("Dia: ");
int dia = Integer.parseInt(teclado.nextLine());
System.out.print("Mes: ");
int mes = Integer.parseInt(teclado.nextLine());
System.out.print("Año: ");
int anio = Integer.parseInt(teclado.nextLine());
System.out.print("EPS: ");
String eps = teclado.nextLine();
System.out.print("Documento: ");
String documento = teclado.nextLine();
//Datos capturados, registramos Jugador
jugadores.add(new Jugador(nombre, apell, LocalDate.of(anio, mes, dia), eps, documento));
}

private static void listarCategorias() {
System.out.println("\nListado por Categorías...\n");
if (jugadores.isEmpty())
System.out.println("No hay Jugadores registrados");
else {
//Creamos arrays para cada categoría
ArrayList<Jugador> infantil = new ArrayList<Jugador>();
ArrayList<Jugador> juvenil = new ArrayList<Jugador>();
ArrayList<Jugador> unica = new ArrayList<Jugador>();
ArrayList<Jugador> veteranos = new ArrayList<Jugador>();
//Recorremos Jugadores registrados y clasificamos según la edad
for (Jugador jugador: jugadores) {
int edad = jugador.calculaEdad();
System.out.println("\tEdad: " + edad);
if (edad >= 5 && edad <= 10)
infantil.add(jugador);
else if (edad >= 11 && edad <= 15)
juvenil.add(jugador);
else if (edad >= 16 && edad <= 34)
unica.add(jugador);
else if (edad >= 35)
veteranos.add(jugador);
}

//Listamos las categorías
System.out.println("\t- Infantil -\n");
if (infantil.isEmpty())
System.out.println("No hay Jugadores en esta Categoría");
else
for (Jugador infante: infantil)
System.out.println(infante + "\n");

System.out.println("\n\t- Juvenil -\n");
if (juvenil.isEmpty())
System.out.println("No hay Jugadores en esta Categoría");
else
for (Jugador joven: juvenil)
System.out.println(joven + "\n");

System.out.println("\n\t- Unica -\n");
if (unica.isEmpty())
System.out.println("No hay Jugadores en esta Categoría");
else
for (Jugador unico: unica)
System.out.println(unico + "\n");

System.out.println("\n\t- Veteranos -\n");
if (veteranos.isEmpty())
System.out.println("No hay Jugadores en esta Categoría");
else
for (Jugador veterano: veteranos)
System.out.println(veterano + "\n");
}
}

}

Veo varias inconsistencias.

Por ejemplo, dentro del ActionPerformed, encontramos estas líneas:

ClsFraccion resultado=new ClsFraccion();
Archivo file = new Archivo();
BtnGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent eventoAccion) {
GuardarArchivo(eventoAccion);
}
});
Sobre la segunda línea, marcada en negrita:

ClsFraccion resultado=new ClsFraccion();
      Archivo file = new Archivo();
      BtnGuardar.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent eventoAccion) {
            GuardarArchivo(eventoAccion);
         }
      });

Creas un nuevo objeto Archivo llamado file, pero luego parece que no haces nada con él.

Luego, la siguiente parte:

ClsFraccion resultado=new ClsFraccion();
      Archivo file = new Archivo();
      BtnGuardar.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent eventoAccion) {
            GuardarArchivo(eventoAccion);
         }
      });

Al botón guardar le agregas un ActionListener, pero esto es raro porque lo haces dentro del código del actionPerformed principal.
Es decir, cada vez que se clicka un botón, añades un ActionListener al botón guardar.
Estos ActionListener se van acumulando, ya que un botón, o cualquier otro objeto Swing, puede contener varios Listener. Así que si tras pulsar, no se... 8 botones y luego se pulsa el botón Guardar, se va a ejecutar 8 veces el mismo ActionListener, ya que están agregados a dicho botón.

Lo normal sería que le añadas el ActionListener, una sola vez, y esto se haga al iniciarse la aplicación.
Si lo que pretendes es que el botón Guardar no haga nada, hasta que previamente se hayan pulsado otros botones, esto lo puedes hacer con el método setEnabled() y pasarle true o false, según si quieres activar o desactivar el botón.

Y sobre ese ActionListener que le añades, consiste en el método llamado GuardarArchivo().

Que si observamos su código, atento a la línea en negrita:

private void GuardarArchivo(ActionEvent evt) {
      ClsFraccion c = new ClsFraccion();
      try {
            FileWriter fw = new FileWriter("Calculadora.txt");
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter pw = new PrintWriter(bw);
            
            pw.print(c.getResultado());
            pw.close();
            bw.close();
            
         }catch(java.io.IOException ioex) {
            JOptionPane.showMessageDialog(null, ioex.toString());
         }
      
      
      }

Lo primero que hace es crear un nuevo objeto ClsFraccion, el cuál al ser nuevo, su numerador y denominador es 0. No tiene ninguna relación con los cómputos que hayas hecho anteriormente. Probablemente por eso te guarda null en el txt.


Más cosas.
En el método main principal, estás creando dos Calculadoras:
public static void main(String[] args) {
new Calculadora();
Calculadora c = new Calculadora();

}Por lo tanto, se abren dos marcos JFrame al iniciar el programa.
No creo que sea eso lo que quieres, supongo que solo quieres una:
public static void main(String[] args) {
new Calculadora();

}
Y en el constructor de la Calculadora, sugiero que le añadas las dos líneas que marco en negrita:

      add(panel);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setSize(400, 400);
      setLocationRelativeTo(null);
      setVisible(true);

La primera hace que cuando cerremos el JFrame pulsando el aspa de cerrar ventana, entonces la aplicación debe terminar.
Si no lo indicamos, aunque el JFrame se cierre y ya no sea visible, en realidad el programa sigue funcionando... solo que sin un JFrame con el que poder interactuar.

La segunda línea hace que la ventana de aplicación aparezca en el centro de la pantalla, y no en una esquina.

Luego a parte, tienes un montón de imports y atributos (como un array de bytes) que no se están usando para nada y supongo que son restos de andar copiando código de otros ejemplos.


En fin, al no ser mi programa, y no tener muy claro cómo debe funcionar esto de las fracciones, no se bien como se debe arreglar para que quede correcto.

Si he podido pulirlo un poco y conseguir que ya no imprima null, aunque el resultado que se imprime no estoy seguro de si es correcto. Eso ya tendrás que revisarlo tú.

Bien, he eliminado varios import y atributos que no se usan. He dejado un par por si quizás son botones que luego quieras añadir más adelante a la interfaz, no lo se...
Por cierto, siempre recomendable (por no decir obligatorio) señalar como private los atributos de clase, a no ser que realmente necesitemos que sean public.
Marcar como private sirve, entre otras cosas, para detectar atributos que nos sobran, ya que entonces el compilador que estemos usando suele avisar de que hay atributos que no estamos dando uso.

El objeto ClsFracccion que llamas resultado, recomiendo declararlo como atributo de clase, y no como un objeto que se genera nuevo cada vez que se pulsa una acción.

Al botón Guardar, le vamos a escribir su propia clase ActionListener y se la añadiremos, una sola vez, en el constructor de la clase Calculadora.
Esta acción ejecutará el mismo código que escribiste tú en el método GuardarArchivo (ahora este método desaparece, porque se convierte directamente en un ActionListener), solo que esta vez tomará el getResultado(), del ClsFraccion llamado resultado que hemos declarado como atributo de clase.

La clase Archivo, no parece ser necesaria, al menos no tal y como está implementado el resto del código, yo ni siquiera la he añadido al proyecto que he creado.

Te dejo el código de Calculadora como lo tengo ahora, y marco en negrita los principales cambios.
Ahora ya imprime un resultado en el archivo de texto, pero no tengo claro si es un resultado correcto o no. A ver si a partir de aquí puedes seguir refinándolo.

Fíjate sobre todo que ahora el método GuardarArchivo(), se ha transformador en una clase ActionListener llamada AccionGuardar. Y que esta acción se la añadimos al botón guardar dentro del constructor de Calculadora

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.PrintWriter;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public final class Calculadora extends JFrame implements ActionListener {

   private JLabel eti1, guion1, guion2, ig, guion3, txtresn, txtresd;
   private JTextField txtvalores, txtnum1, txtden1, txtnum2, txtden2;
   private JButton BtnSuma, BtnResta, BtnMulti, BtnDiv, BtnIgual, BtnNumerador, BtnDenominador, BtnDEL, BtnDecimal,BtnGuardar,BtnAbrir;
   private JPanel panel;

   private ClsFraccion resultado;


   public Calculadora(){

      resultado = new ClsFraccion();

      eti1 = new JLabel("Calculadora de Fracciones");
      eti1.setBounds(128, 35, 200, 10);

      //txtvalores = new JTextField();
      //txtvalores.setBounds(58, 70, 280, 20);

      txtnum1 = new JTextField();
      txtnum1.setBounds(130, 60, 20, 20);

      guion1= new JLabel("_");
      guion1.setBounds(130, 70, 30, 20);

      txtden1= new JTextField();
      txtden1.setBounds(130, 90, 20, 20);

      txtnum2 = new JTextField();
      txtnum2.setBounds(160, 60, 20, 20);

      guion2= new JLabel("_");
      guion2.setBounds(160, 70, 30, 20);

      txtden2= new JTextField();
      txtden2.setBounds(160, 90, 20, 20);

      ig= new JLabel("=");
      ig.setBounds(190, 76, 20, 20);

      txtresn= new JLabel();
      txtresn.setBounds(210, 70, 20, 20);

      txtresd= new JLabel();
      txtresd.setBounds(210, 90, 20, 20);

      guion3= new JLabel("_");
      guion3.setBounds(210, 70, 30, 20);

      BtnNumerador = new JButton("Num");
      BtnNumerador.setBounds(60, 110, 90, 20);

      BtnDenominador = new JButton("Den");
      BtnDenominador.setBounds(230, 110, 90, 20);

      BtnSuma = new JButton("+");
      BtnSuma.setBounds(100, 150, 60, 20);
      BtnSuma.addActionListener(this);

      BtnResta = new JButton("-");
      BtnResta.setBounds(220, 150, 60, 20);
      BtnResta.addActionListener(this);

      BtnMulti = new JButton("x");
      BtnMulti.setBounds(100, 200, 60, 20);
      BtnMulti.addActionListener(this);

      BtnDiv = new JButton("/");
      BtnDiv.setBounds(220, 200, 60, 20);
      BtnDiv.addActionListener(this);

      BtnIgual = new JButton("=");
      BtnIgual.setBounds(100, 250, 60, 20);

      BtnDEL = new JButton("DEL");
      BtnDEL.setBounds(220, 250, 60, 20);

      BtnGuardar= new JButton("Guardar");
      BtnGuardar.addActionListener(new AccionGuardar());
      BtnGuardar.setBounds(140, 290, 100, 20);

      BtnAbrir= new JButton("Abrir");
      BtnAbrir.setBounds(180, 290, 100, 20);

      panel = new JPanel();
      panel.setLayout(null);

      panel.add(eti1);
      //panel.add(txtvalores);
      panel.add(txtnum1);
      panel.add(guion1);
      panel.add(txtden1);
      panel.add(txtnum2);
      panel.add(guion2);
      panel.add(txtden2);
      panel.add(txtresn);
      panel.add(txtresd);
      panel.add(guion3);
      panel.add(ig);
      //panel.add(BtnNumerador);
      //panel.add(BtnDenominador);
      panel.add(BtnSuma);
      panel.add(BtnResta);
      panel.add(BtnMulti);
      panel.add(BtnDiv);
      //panel.add(BtnIgual);
      //panel.add(BtnDEL);
      panel.add(BtnGuardar);

      add(panel);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setSize(400, 400);
      setLocationRelativeTo(null);
      setVisible(true);


   }//cerrar calculadora


   public static void main(String[] args) {
      new Calculadora();
   }

   public void actionPerformed(ActionEvent e) {
      //System.out.println("A");
      String sx1, sx2, sy1, sy2;
      int mcd, aux;
      sx1=txtnum1.getText();
      sx2=txtnum2.getText();
      sy1=txtden1.getText();
      sy2=txtden2.getText();


      ClsFraccion f1=new ClsFraccion(Integer.parseInt(sx1), Integer.parseInt(sy1));
      ClsFraccion f2=new ClsFraccion(Integer.parseInt(sx2), Integer.parseInt(sy2));

      if(e.getSource()==BtnSuma) {
         System.out.println("Suma");
         resultado=resultado.suma(f1, f2);
         mcd=resultado.mcdRecursivo(resultado.getNumerador(), resultado.getDenominador());
         txtresn.setText(String.valueOf(resultado.getNumerador()/mcd));
         txtresd.setText(String.valueOf(resultado.getDenominador()/mcd));
         resultado.Imprimir();
      }
      if(e.getSource()==BtnResta) {
         System.out.println("Resta");
         resultado=resultado.resta(f1, f2);
         mcd=resultado.mcdRecursivo(resultado.getNumerador(), resultado.getDenominador());

         txtresn.setText(String.valueOf(resultado.getNumerador()/mcd));
         txtresd.setText(String.valueOf(resultado.getDenominador()/mcd));

      }
      if(e.getSource()==BtnDiv) {
         System.out.println("Division");
         resultado=resultado.division(f1, f2);
         mcd=resultado.mcdRecursivo(resultado.getNumerador(), resultado.getDenominador());
         txtresn.setText(String.valueOf(resultado.getNumerador()/mcd));
         txtresd.setText(String.valueOf(resultado.getDenominador()/mcd));
         resultado.Imprimir();
      }
      if(e.getSource()==BtnMulti) {
         System.out.println("Multiplicacion");
         resultado=resultado.mul(f1, f2);
         mcd=resultado.mcdRecursivo(resultado.getNumerador(), resultado.getDenominador());
         txtresn.setText(String.valueOf(resultado.getNumerador()/mcd));
         txtresd.setText(String.valueOf(resultado.getDenominador()/mcd));
         resultado.Imprimir();

      }}


   private class AccionGuardar implements ActionListener {

      @Override
      public void actionPerformed(ActionEvent e) {
         try {
            FileWriter fw = new FileWriter("Calculadora.txt");
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter pw = new PrintWriter(bw);

            pw.print(resultado.getResultado());
            pw.close();
            bw.close();

         }catch(java.io.IOException ioex) {
            JOptionPane.showMessageDialog(null, ioex.toString());
         }

      }

   }
}

Para que un método recursivo funcione ha de recibir parámetros por argumentos, los cuáles se van modificando en cada llamada recursiva.

Así que si quieres seguir usando getResultado() tal cuál, quizás se pueda solucionar creando un segundo método de apoyo, que sería el recursivo.
Por cierto, al margen de esto, el String llamado equivalencia que tienes declarado como atributo de clase, debería reiniciarse a "cadena vacía" cada vez que llamas al método getResultado().
Si durante la ejecución del programa solo llamas una vez a ese método, no pasa nada.
Pero si se le llamase varias veces, cada vez que se le llama se concatenará la equivalencia computada anteriormente con la actual.

De hecho, no parece que sea necesario declarar ese String como atributo de clase, pero bueno, si lo quieres mantener así, y resolver el computo de manera recursiva, quizás funcione algo como lo que pondré a continuación.
No lo he probado..., en mi "compilador mental" diría que funciona je je...  , pero no es muy fiable así que si no funciona o da resultados raros, dímelo y ya haré pruebas más fiables.

Un saludo.

        public String getResultado()
        {
                equivalente = ""; //Reiniciamos a cadena vacía
                equivalente = computaEquivalencia(digitos.length-2); //Método recursivo
                return equivalente;
        }

        private String computaEquivalencia(int indice)
        {
                if (indice < 0)
                        return ""; //Fin de las llamadas recursivas
                else
                        return Character.toUpperCase(Character.forDigit(digitos[indice], 16)) + computaEquivalencia(--indice);
        }

Mira, te dejo mis clases para que veas cómo lo tengo yo hecho.
Pregunta si hay algo que no entiendas.

Esta es la clase Paciente
import java.util.Random;

public class Paciente {

private String rut;
private String nombre;
private int edad;
private char sexo;
private int[] pesoMensual;

public Paciente(String rut, String nombre, int edad, char sexo) {
this.rut = rut;
this.nombre = nombre;
this.edad = edad;
this.sexo = sexo;
pesoMensual = new int[12];

Random azar = new Random();
for (int i = 0; i < 12; i++)
pesoMensual[i] = azar.nextInt(251-70) + 70;
}

public String getRut() {
return rut;
}

public void setRut(String rut) {
this.rut = rut;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public int getEdad() {
return edad;
}

public void setEdad(int edad) {
this.edad = edad;
}

public char getSexo() {
return sexo;
}

public void setSexo(char sexo) {
this.sexo = sexo;
}

/**
* De los 12 pesos mensuales, retorna el menor.
* @return Mes con el menor peso.
*/
public String getMenorPesoMensual() {

//Para poder comparar, tomamos como referencia el primer mes
int menor = pesoMensual[0];
int mes = 0;
//Recorremos los otros 11 meses, a ver si alguno tiene un peso menor
for (int i = 1; i < 12; i++) {
if (pesoMensual[i] < menor) {
menor = pesoMensual[i];
mes = i;
}
}

switch(mes) {
case 0:
return "Enero -> Peso: " + menor;
case 1:
return "Febrero -> Peso: " + menor;
case 2:
return "Marzo -> Peso: " + menor;
case 3:
return "Abril -> Peso: " + menor;
case 4:
return "Mayo -> Peso: " + menor;
case 5:
return "Junio -> Peso: " + menor;
case 6:
return "Julio -> Peso: " + menor;
case 7:
return "Agosto -> Peso: " + menor;
case 8:
return "Septiembre -> Peso: " + menor;
case 9:
return "Octubre -> Peso: " + menor;
case 10:
return "Noviembre -> Peso: " + menor;
default:
return "Diciembre -> Peso: " + menor;
}
}


/**
* Calcula el IMC del paciente.
* @param estatura Estatura del paciente expresada en metros.
* @param mes Índice (entre 0 y 11) del array de pesos correspondiente
* al mes para el cuál se quiere calcular el IMC.
* @return Valor calculado del IMC.
*/
private float indiceMasaCorporal(float estatura, int mes) {
return pesoMensual[mes] / (estatura * estatura);
}

/**
* Devuelve un array con los pesos menores que el indicado
* como parámetro. Si no los hubiera, se retorna valor null.
* @param peso Pero de referencia del cuál buscar pesos menores.
* @return Array con los pesos menores, valor null si no los hay.
*/
public int[] menosDeXKilos(int peso) {

int[] pesosMenosDeX = null;

//Primero contamos cuántos pesos hay menores que el indicado
int contador = 0;
for (int i = 0; i < 12; i++) {
if (pesoMensual[i] < peso)
contador++;
}
//Ahora que los hemos contado, ya sabemos cuánto ha de medir el array
if (contador > 0) {
pesosMenosDeX = new int[contador];
int indiceArray = 0; //El array de pesos menores necesita su propio indice
for (int i = 0; i < 12; i++) {
if (pesoMensual[i] < peso) {
pesosMenosDeX[indiceArray] = pesoMensual[i];
indiceArray++;
}
}
}

return pesosMenosDeX;
}

/**
* Retorna una valoración según el IMC calculado para
* un determinado mes.
* @param estatura Estatura del paciente expresada en metros.
* @param mes Índice (entre 0 y 11) del array de pesos correspondiente
* al mes para el cuál se quiere calcular el IMC.
* @return Palabra String para valorar el IMC calculado.
*/
public String pesoMesX(float estatura, int mes) {
float imc = indiceMasaCorporal(estatura, mes);
if (imc < 15)
return "Inferior a Normal";
else if (imc >= 15 && imc < 20)
return "Normal";
else if (imc >= 20 && imc < 28)
return "SobrePeso";
else
return "Obeso";
}

@Override
public String toString() {
return String.format("RUT: %s\nNombre: %s\nEdad: %d\nSexo: %s\n", rut, nombre, edad, sexo);
}
}
Y una clase Menu con el método main()
import java.util.Scanner;

public class Menu {

private static Paciente paciente; //Paciente sobre el que se va a trabajar
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

String opcion = "";

while (!opcion.equals("6")) {
System.out.println("\n\t\tMenu Paciente");
System.out.println("\t\t---- --------\n");
System.out.println("[1] - Registrar Paciente.");
System.out.println("[2] - Mostrar datos del Paciente.");
System.out.println("[3] - Mostrar el mes con menor peso del Paciente.");
System.out.println("[4] - Listar pesos menores que un peso indicado.");
System.out.println("[5] - Ver condición del Paciente en mes de Noviembre");
System.out.println("[6] - SALIR");
System.out.print("Elija opción: ");
opcion = teclado.nextLine();

switch(opcion) {
case "1":
registrarPaciente();
break;

case "2":
System.out.println("\nDatos del Paciente.");
if (paciente != null)
System.out.println(paciente);
else
System.out.println("Aún no hay un Paciente registrado.");
break;

case "3":
System.out.println("\nMes con el menor peso:");
if (paciente != null)
System.out.println(paciente.getMenorPesoMensual());
else
System.out.println("Aún no hay un Paciente registrado.");
break;

case "4":
System.out.println("\nListar pesos menores que uno indicado.");
if (paciente != null) {
System.out.print("Indique peso: ");
int peso = Integer.parseInt(teclado.nextLine());
int[] menores = paciente.menosDeXKilos(peso);
if (menores == null)
System.out.println("No hay ningún peso mensual menor que el indicado");
else {
System.out.println("Pesos encontrados:");
for (int menor: menores)
System.out.println("-> " + menor);
}
}
else
System.out.println("Aún no hay un Paciente registrado.");
break;

case "5":
System.out.println("\nCondición del paciente en Noviembre");
if (paciente != null) {
System.out.println("Indique la altura (en metros): ");
float altura = Float.parseFloat(teclado.nextLine());
System.out.println("Condición: " + paciente.pesoMesX(altura, 10));//10 es Noviembre
}
else
System.out.println("Aún no hay un Paciente registrado.");
break;

case "6":
System.out.println("\n\t\tFIN DE PROGRAMA");
}
}
teclado.close();
}

private static void registrarPaciente() {
System.out.println("\nDatos nuevo Paciente.");
System.out.print("RUT: ");
String rut = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Edad: ");
int edad = Integer.parseInt(teclado.nextLine());
System.out.print("Sexo(M/F): ");
char sexo = teclado.nextLine().toUpperCase().charAt(0);
paciente = new Paciente(rut, nombre, edad, sexo);
System.out.println("\nNuevo Paciente Registrado...\n");
}

}

Otro comentario que me atrevo a añadir, es que por lo general no es necesario crear más de un Scanner para pedir diferentes datos, se puede hacer todo con uno solo.

De hecho en tu programa, a pesar de que declaras dos objetos Scanner (señalo en rojo), en realidad estás usando solo uno (señalo en verde)

Scanner valorScanner = new Scanner(System.in);
        texto1 = valorScanner.nextLine();
        System.out.println("Digite el segundo texto: ");
        Scanner valor2Scanner = new Scanner(System.in);
        texto2 = valorScanner.nextLine();

Así que la línea donde declaras el objeto valor2Scanner, la puedes borrar.

Un saludo. 

Me acabo de dar cuenta    de que no se necesitan dos funciones distintas.
Con una sola función es suficiente, si recibe un par trabajará con pares, y si recibe un impar lo hará con los mismos.... pues el proceso es el mismo.
Tanto a uno como otros, para pasar al siguiente de la lista, basta con restarle - 2

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

System.out.println("Suma de primeros pares.");
System.out.print("Indique tamaño serie: ");
int n = teclado.nextInt();

for (int i = 1; i <= n; i++) {
if ( i < n)
System.out.print((i * 2) + " + ");
else
System.out.println((i * 2) + " = " + sumaSerie(n*2));
}

System.out.println("Suma de primeros impares.");
System.out.print("Indique tamaño serie: ");
n = teclado.nextInt();

for (int i = 1; i <= n; i++) {
if ( i < n)
System.out.print((i * 2 - 1) + " + ");
else
System.out.println((i * 2 - 1) + " = " + sumaSerie((n*2) - 1));
}

teclado.close();

}


//Funcion recursiva
private static int sumaSerie(int n) {

if (n <= 0)
return 0;
else
return n + sumaSerie(n-2);
}

}

Pero no te están pidiendo ninguna serie Fibonacci, esta serie es un poco más compleja que una "simple" suma de pares/impares consecutivos.

Y bueno, he aquí otra cuestión:
 ¿Te están pidiendo que saques una serie de pares en pantalla?
¿O te están pidiendo que calcules la suma de esa serie de pares (sin tener que mostrar ninguna serie en pantalla)?

Si se trata de obtener la suma, que es lo que yo entiendo al leer esto:

La suma de los primeros n números pares.
Por ejemplo: si n=5 obtener 2+4+6+8+10
La suma de los primero n números impares.
Por ejemplo: si n=5 obtener 1+3+5+7+9

Puede hacerse con estos dos métodos recursivos que pongo en el código de abajo.

Lo que hacen es comenzar con el par (o impar) MAYOR de la serie.
En cada llamada recursiva, retorna ese par sumándole el siguiente par inferior.
Si nos piden la suma de los 5 primeros pares, comienza por 10 (2 * 5).
Y va sumando 10 + 8 + 6 + 4 + 2 + 0

public class ParesRecursivos {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

System.out.println("Suma de primeros pares.");
System.out.print("Indique tamaño serie: ");
int n = teclado.nextInt();

System.out.println("Suma = " + nPares(n * 2));

System.out.println("\n\nSuma de primeros impares.");
System.out.print("Indique tamaño serie: ");
n = teclado.nextInt();

System.out.println("Suma = " + nImpares((n * 2) - 1));

teclado.close();
}

private static int nPares(int n) {
if (n <= 0)
return 0;
else
return n + nPares(n - 2);
}

private static int nImpares(int n) {
if (n <= 0)
return 0;
else if (n == 1)
return 1;
else
return n + nImpares(n - 2);
}

}