Longevidad


Miquel, un amigo nuestro que tiene una empresa de manufacturación de productos , se ha enterado de que hemos hecho un programa de cálculo de edades para bebés, y ahora nos propone lo siguiente:

Él necesita sacar un listado de los años , meses y días que lleva en activo cada trabajador de su empresa , de cara a pasar los datos a Hacienda .

Para hacerlo , hemos tenido que preguntarle qué diseño quería para tener una idea de los datos que deberemos tratar y nos ha dicho que quiere un formato como el siguiente :

Longevidad de los Trabajadores .

Nombre Sección Fecha Alta Vida laboral
Pedro Administrador 14/ 04 /1982 22 años 6 meses y 20 días
Anna Contable 30/ 06 /1998 6 años 4 meses y 4 días
Miguel Ángel Director 25/10/ 2002 2 años 0 meses y 9 días

CUENTA ! El ejemplo expuesto supone que estamos a 3 de Noviembre de 2004 .

Por tanto , habrá que realizar un programa que nos permita introducir los datos necesarios para poder realizar los cálculos pertinentes para visualizar la tabla anterior . Si los datos están mal introducidos, el programa deberá avisar .


NOTAS

Nota: Un año es bisiesto si es múltiplo de 4 . El múltiplos de 100 no lo son , excepto aquellos que lo son de 400 .



  1.  
  2.  
  3.    import cs1.Keyboard;
  4.    import java.util.Date;
  5.    import java.text.DateFormat;
  6.    import java.text.SimpleDateFormat;
  7.  
  8.    public class practica7
  9.    {
  10.       public static void main (String[] args)
  11.       {
  12.       //Variables
  13.          String fecha_alt, fecha_alt2, fecha_alt3, nom, nom2, nom3, seccio, seccio2, seccio3, fechasistema, sel, sel2, fechaintroducida = "0";
  14.          int anys, mesos, dies = 0, any_act, mes_act, dia_act, any_int = 0, mes_int = 0, dia_int = 0, numDies = 0, anys2, mesos2, dies2 = 0, any_int2 = 0, mes_int2 = 0, dia_int2 = 0, numDies2 = 0, anys3, mesos3, dies3 = 0, any_int3 = 0, mes_int3 = 0, dia_int3 = 0, numDies3 = 0, numDiesA = 0, longfecha, longfecha2, longfecha3;
  15.          char b1, b2, b1b, b2b, b1c, b2c;
  16.          boolean errors = false, errors2 = false, errors3 = false, errors4 = false;
  17.          
  18.       //Introducció de dades
  19.          System.out.println( "Escoge la opcion adecuada: " );
  20.          System.out.println( " 1 - Fecha del sistema" );
  21.          System.out.println( " 2 - Introduce la fecha final" );
  22.          sel2 = Keyboard.readString();
  23.          if (sel2.equals("2")){
  24.             System.out.println( "Introduce la fecha final" );
  25.             fechaintroducida = Keyboard.readString();
  26.          }
  27.          System.out.println( "Introduce tu nombre: " );
  28.          nom = Keyboard.readString();
  29.          System.out.println( "Introduce tu seccion: " );
  30.          seccio = Keyboard.readString();
  31.          System.out.println( "Introduce la fecha de alta con este formato (dd/mm/aaaa): " );
  32.          fecha_alt = Keyboard.readString();
  33.          System.out.println( "Introduce el segundo nombre: " );
  34.          nom2 = Keyboard.readString();
  35.          System.out.println( "Introduce su seccin; " );
  36.          seccio2 = Keyboard.readString();
  37.          System.out.println( "Introduce la fecha de alta con este formato (dd/mm/aaaa): " );
  38.          fecha_alt2 = Keyboard.readString();
  39.          System.out.println( "Introduce su nombre: " );
  40.          nom3 = Keyboard.readString();
  41.          System.out.println( "Introduce su seccion " );
  42.          seccio3 = Keyboard.readString();
  43.          System.out.println( "Introduce la fecha de alta con este formato (dd/mm/aaaa): " );
  44.          fecha_alt3 = Keyboard.readString();
  45.          System.out.println( "Escoge la opcion mas adecuada: ");
  46.          System.out.println( " 1 - Contar a partir del dia siguiente" );
  47.          System.out.println( " 2 - Contar con el dia de hoy inclusive" );
  48.          sel = Keyboard.readString();
  49.          
  50.          if (!sel2.equals("1") && !sel2.equals("2")){
  51.             System.out.println( "Has de seleccionar una de las dos opciones" );
  52.          }
  53.          else {
  54.            
  55.             if (!sel.equals("1") && !sel.equals("2")){
  56.                System.out.println( "Has de seleccionar una de las dos opciones" );
  57.             }
  58.            
  59.             else {
  60.              
  61.                //Convertir a cadena la fecha del sistema
  62.                Date fechasis = new Date();
  63.                SimpleDateFormat format1 = new SimpleDateFormat("dd/MM/yyyy");
  64.                fechasistema = format1.format(fechasis);
  65.                
  66.                if (sel2.equals("2")){
  67.                   fechasistema = fechaintroducida;
  68.                }
  69.                try {
  70.                 // Convertir a integer la fecha actual
  71.                   dia_act = Integer.valueOf(fechasistema.substring(0,2)).intValue();
  72.                   mes_act = Integer.valueOf(fechasistema.substring(3,5)).intValue();
  73.                   any_act = Integer.valueOf(fechasistema.substring(6)).intValue();
  74.                
  75.                //Determinar la longitud d la fecha
  76.                   longfecha = fecha_alt.length();
  77.                   longfecha2 = fecha_alt2.length();
  78.                   longfecha3 = fecha_alt3.length();
  79.                  
  80.                
  81.                //Decidint si la fecha té el format correcte
  82.                   if (longfecha != 10) {
  83.                      System.out.println( "La longitud de la fecha no es correcta" );
  84.                   }
  85.                   else {
  86.                      //Definimos el formato de la fecha de alta
  87.                      b1 = fecha_alt.charAt(2);
  88.                      b2 = fecha_alt.charAt(5);
  89.                      if ((b1 != '/') || (b2 != '/')){
  90.                         System.out.println( "La fecha no tiene un formato dd/mm/aaaa" );
  91.                      }
  92.                      else {
  93.                         if (longfecha2 != 10){
  94.                            System.out.println( "La longitud de la fecha 2 no es correcta" );
  95.                         }
  96.                         else {
  97.                            b1b = fecha_alt2.charAt(2);
  98.                            b2b = fecha_alt2.charAt(5);
  99.                            if ((b1b != '/') || (b2b != '/')){
  100.                               System.out.println( "La fecha 2 no tiene un formato dd/mm/aaaa" );
  101.                            }
  102.                            else {
  103.                               if (longfecha3 != 10){
  104.                                  System.out.println( "La longitud de la fecha 3 no es correcta" );
  105.                               }
  106.                               else {
  107.                                  b1c = fecha_alt3.charAt(2);
  108.                                  b2c = fecha_alt3.charAt(5);
  109.                                  if ((b1c != '/') || (b2c != '/')){
  110.                                     System.out.println( "La fecha 3 no tiene un formato dd/mm/aaaa" );
  111.                                  }
  112.                                  else {
  113.                                    
  114.                                     try {
  115.                                        // Convertir a integer los datos introducidos
  116.                                        dia_int = Integer.valueOf(fecha_alt.substring(0,2)).intValue();
  117.                                        mes_int = Integer.valueOf(fecha_alt.substring(3,5)).intValue();
  118.                                        any_int = Integer.valueOf(fecha_alt.substring(6)).intValue();
  119.                                        
  120.                                        dia_int2 = Integer.valueOf(fecha_alt2.substring(0,2)).intValue();
  121.                                        mes_int2 = Integer.valueOf(fecha_alt2.substring(3,5)).intValue();
  122.                                        any_int2 = Integer.valueOf(fecha_alt2.substring(6)).intValue();
  123.                                        
  124.                                        dia_int3 = Integer.valueOf(fecha_alt3.substring(0,2)).intValue();
  125.                                        mes_int3 = Integer.valueOf(fecha_alt3.substring(3,5)).intValue();
  126.                                        any_int3 = Integer.valueOf(fecha_alt3.substring(6)).intValue();
  127.                                          
  128.                                        if (any_act < 0) {
  129.                                           System.out.println( "el año final no puede ser negativo" );
  130.                                        }
  131.                                        else{
  132.                                           if (any_int < 0){
  133.                                              System.out.println( "el año no puede ser negativo" );
  134.                                           }
  135.                                           else {
  136.                                              if (any_int2 < 0){
  137.                                                 System.out.println( "el año 2 no puede ser negativo" );
  138.                                              }
  139.                                              else {
  140.                                                 if (any_int3 < 0){
  141.                                                    System.out.println( "el año 3 no puede ser negativo" );
  142.                                                 }
  143.                                                 else {                  
  144.                                                    if ((dia_int > dia_act) && (mes_int >= mes_act) && (any_int >=any_act) || ((dia_int <= dia_act) && (mes_int > mes_act) && (any_int >= any_act) || (any_int > any_act))){
  145.                                                       System.out.println( "La fecha introducida pertenece al futuro" );
  146.                                                    }
  147.                                                    else {
  148.                                                       if ((dia_int2 > dia_act) && (mes_int2 >= mes_act) &&(any_int2 >= any_act) || ((dia_int2 <= dia_act) && (mes_int2 > mes_act) && (any_int2 >= any_act) || (any_int2 >any_act))){
  149.                                                          System.out.println( "La fecha 2 introducida pertenece al futuro" );
  150.                                                       }
  151.                                                       else {
  152.                                                          if ((dia_int3 > dia_act) && (mes_int3 >= mes_act) &&(any_int3 >= any_act) || ((dia_int3 <= dia_act) && (mes_int3 > mes_act) && (any_int3 >= any_act) || (any_int3 >any_act))){
  153.                                                             System.out.println( "La fecha 3 introducida pertenece al futuro" );
  154.                                                          }                                             
  155.                                                          else {  
  156.                                                             //Calculo de los años de traspaso
  157.                                                             if ( ((any_int % 4 == 0) && !(any_int % 100 == 0)) ||(any_int % 400 == 0) )
  158.                                                                numDies = 29;
  159.                                                             else
  160.                                                                numDies = 28;
  161.                                                            
  162.                                                             if ( ((any_int2 % 4 == 0) && !(any_int2 % 100 == 0))|| (any_int2 % 400 == 0) )
  163.                                                                numDies2 = 29;
  164.                                                             else
  165.                                                                numDies2 = 28;
  166.                                                            
  167.                                                             if ( ((any_int3 % 4 == 0) && !(any_int3 % 100 == 0))|| (any_int3 % 400 == 0) )
  168.                                                                numDies3 = 29;
  169.                                                             else
  170.                                                                numDies3 = 28;
  171.                                                          
  172.                                                             if (sel2.equals("2")){
  173.                                                                if ( ((any_act % 4 == 0) && !(any_act % 100 == 0))|| (any_act % 400 == 0) )
  174.                                                                   numDiesA = 29;
  175.                                                                else
  176.                                                                   numDiesA = 28;
  177.                                                             }
  178.                                                            
  179.                                                             //Definimos las condiciones
  180.                                                             switch (mes_int) {
  181.                                                                case 1:
  182.                                                                   case 3:
  183.                                                                   case 5:
  184.                                                                   case 7:
  185.                                                                   case 8:
  186.                                                                   case 10:
  187.                                                                   case 12:
  188.                                                                   if (dia_int > 31 || dia_int < 1) {
  189.                                                                      System.out.println( "El dia introducido no es valido" );
  190.                                                                      errors = true;
  191.                                                                   }
  192.                                                                  
  193.                                                                   break;
  194.                                                                case 2:
  195.                                                                   if (dia_int > numDies || dia_int < 1) {
  196.                                                                      System.out.println( "El dia introducido no es valido" );
  197.                                                                      errors = true;
  198.                                                                   }
  199.                                                                   break;
  200.                                                                
  201.                                                                case 4:
  202.                                                                   case 6:
  203.                                                                   case 9:
  204.                                                                   case 11:
  205.                                                                   if (dia_int > 30 || dia_int < 1) {
  206.                                                                      System.out.println( "El dia introducido no es valido" );
  207.                                                                      errors = true;
  208.                                                                   }
  209.                                                                   break;
  210.                                                                
  211.                                                                
  212.                                                                default:
  213.                                                                   System.out.println( "El mes introducido es incorrecto" );
  214.                                                                   errors = true;
  215.                                                                   break;               
  216.                                                             }
  217.                                                            
  218.                                                             switch (mes_int2) {
  219.                                                                
  220.                                                                case 1:
  221.                                                                   case 3:
  222.                                                                   case 5:
  223.                                                                   case 7:
  224.                                                                   case 8:
  225.                                                                   case 10:
  226.                                                                   case 12:
  227.                                                                   if (dia_int2 > 31 || dia_int2 < 1) {
  228.                                                                      System.out.println( "El segundo dia introducido no es valido" );
  229.                                                                      errors2 = true;
  230.                                                                   }
  231.                                                                  
  232.                                                                   break;
  233.                                                                case 2:
  234.                                                                   if (dia_int2 > numDies2 || dia_int2 < 1) {
  235.                                                                      System.out.println( "El segundo dia introducido no es valido" );
  236.                                                                      errors2 = true;
  237.                                                                   }
  238.                                                                   break;
  239.                                                                case 4:
  240.                                                                   case 6:
  241.                                                                   case 9:
  242.                                                                   case 11:
  243.                                                                   if (dia_int2 > 30 || dia_int2 < 1) {
  244.                                                                      System.out.println( "El segundo dia introducido no es valido" );
  245.                                                                      errors2 = true;
  246.                                                                   }
  247.                                                                   break;
  248.                                                                default:
  249.                                                                   System.out.println( "El segundo mes introducido es incorrecto" );
  250.                                                                   errors2 = true;
  251.                                                                   break;               
  252.                                                             }
  253.                                                             switch (mes_int3) {
  254.                                                                case 1:
  255.                                                                   case 3:
  256.                                                                   case 5:
  257.                                                                   case 7:
  258.                                                                   case 8:
  259.                                                                   case 10:
  260.                                                                   case 12:
  261.                                                                   if (dia_int3 > 31 || dia_int3 < 1) {
  262.                                                                      System.out.println( "El tercer dia introducido no es valido" );
  263.                                                                      errors3 = true;
  264.                                                                   }
  265.                                                                  
  266.                                                                   break;
  267.                                                                case 2:
  268.                                                                   if (dia_int3 > numDies3 || dia_int3 < 1) {
  269.                                                                      System.out.println( "El tercer dia introducido no es valido" );
  270.                                                                      errors3 = true;
  271.                                                                   }
  272.                                                                   break;
  273.                                                                case 4:
  274.                                                                   case 6:
  275.                                                                   case 9:
  276.                                                                   case 11:
  277.                                                                   if (dia_int3 > 30 || dia_int3 < 1) {
  278.                                                                      System.out.println( "El tercer dia introducido no es valido" );
  279.                                                                      errors3 = true;
  280.                                                                   }
  281.                                                                   break;
  282.                                                                default:
  283.                                                                   System.out.println( "El tercer mes introducido es incorrecto" );
  284.                                                                   errors3 = true;
  285.                                                                   break;               
  286.                                                             }
  287.                                                             if (sel2.equals("2")){
  288.                                                            
  289.                                                             //Definimos las condiciones
  290.                                                                switch (mes_act) {
  291.                                                                   case 1:
  292.                                                                   case 3:
  293.                                                                   case 5:
  294.                                                                   case 7:
  295.                                                                   case 8:
  296.                                                                   case 10:
  297.                                                                   case 12:
  298.                                                                      if (dia_act > 31 || dia_act < 1) {
  299.                                                                         System.out.println( "El dia final introducido no es valido" );
  300.                                                                         errors4 = true;
  301.                                                                      }
  302.                                                                  
  303.                                                                      break;
  304.                                                                   case 2:
  305.                                                                      if (dia_act > numDiesA || dia_act < 1) {
  306.                                                                         System.out.println( "El dia final introducido no es valido" );
  307.                                                                         errors4 = true;
  308.                                                                      }
  309.                                                                      break;
  310.                                                                
  311.                                                                   case 4:
  312.                                                                   case 6:
  313.                                                                   case 9:
  314.                                                                   case 11:
  315.                                                                      if (dia_act > 30 || dia_act < 1) {
  316.                                                                         System.out.println( "El dia final introducido no es valido" );
  317.                                                                         errors4 = true;
  318.                                                                      }
  319.                                                                      break;
  320.                                                                
  321.                                                                
  322.                                                                   default:
  323.                                                                      System.out.println( "El mes final introducido es incorrecto" );
  324.                                                                      errors4 = true;
  325.                                                                      break;            
  326.                                                                }
  327.                                                             }
  328.                                                            
  329.                                                             //Condiciones de errores
  330.                                                             if (errors == false && errors2 == false && errors3 ==false && errors4 == false) {  
  331.                                                                
  332.                                                                 //Operaciones de la primera fecha
  333.                                                                anys = any_act - any_int;
  334.                                                                mesos = mes_act - mes_int;
  335.                                                                if ( (dia_act - dia_int) < 0 ) {
  336.                                                                   switch (mes_int) {
  337.                                                                      case 1:
  338.                                                                      case 3:
  339.                                                                      case 5:
  340.                                                                      case 7:
  341.                                                                      case 8:
  342.                                                                      case 10:
  343.                                                                      case 12:
  344.                                                                         dies =  (dia_act + 31) - dia_int;
  345.                                                                         mesos = mesos - 1;
  346.                                                                         break;
  347.                                                                  
  348.                                                                      case 2:
  349.                                                                         dies =  (dia_act + numDies) - dia_int;
  350.                                                                         mesos = mesos - 1;
  351.                                                                         break;
  352.                                                                  
  353.                                                                      case 4:
  354.                                                                      case 6:
  355.                                                                      case 9:
  356.                                                                      case 11:
  357.                                                                         dies = (dia_act + 30) - dia_int;
  358.                                                                         mesos = mesos - 1 ;
  359.                                                                         break;
  360.                                                                   }
  361.                                                                
  362.                                                                }
  363.                                                                else {
  364.                                                                   dies = dia_act - dia_int;
  365.                                                                }
  366.                                                            
  367.                                                                if ((mes_act - mes_int) < 0){
  368.                                                                   mesos = (mes_act + 12) - mes_int;
  369.                                                                   if ( (dia_act - dia_int) < 0 ) {
  370.                                                                      switch (mes_int) {
  371.                                                                         case 1:
  372.                                                                         case 3:
  373.                                                                         case 5:
  374.                                                                         case 7:
  375.                                                                         case 8:
  376.                                                                         case 10:
  377.                                                                         case 12:
  378.                                                                            dies =  (dia_act + 31) - dia_int;
  379.                                                                            mesos = mesos - 1;
  380.                                                                            break;
  381.                                                                      
  382.                                                                         case 2:
  383.                                                                            dies =  (dia_act + numDies) - dia_int;
  384.                                                                            mesos = mesos - 1;
  385.                                                                            break;
  386.                                                                      
  387.                                                                         case 4:
  388.                                                                         case 6:
  389.                                                                         case 9:
  390.                                                                         case 11:
  391.                                                                            dies = (dia_act + 30) - dia_int;
  392.                                                                            mesos = mesos - 1 ;
  393.                                                                            break;
  394.                                                                      }
  395.                                                                  
  396.                                                                   }
  397.                                                                   else {
  398.                                                                      dies = dia_act - dia_int;
  399.                                                                   }
  400.                                                                   anys = anys - 1;
  401.                                                                }
  402.                                                            
  403.                                                             //Operacions de la segunda fecha
  404.                                                                anys2 = any_act - any_int2;
  405.                                                                mesos2 = mes_act - mes_int2;
  406.                                                                if ( (dia_act - dia_int2) < 0 ) {
  407.                                                                   switch (mes_int2) {
  408.                                                                      case 1:
  409.                                                                      case 3:
  410.                                                                      case 5:
  411.                                                                      case 7:
  412.                                                                      case 8:
  413.                                                                      case 10:
  414.                                                                      case 12:
  415.                                                                         dies2 =  (dia_act + 31) - dia_int2;
  416.                                                                         mesos2 = mesos2 - 1;
  417.                                                                         break;
  418.                                                                  
  419.                                                                      case 2:
  420.                                                                         dies2 =  (dia_act + numDies2) - dia_int2;
  421.                                                                         mesos2 = mesos2 - 1;
  422.                                                                         break;
  423.                                                                  
  424.                                                                      case 4:
  425.                                                                      case 6:
  426.                                                                      case 9:
  427.                                                                      case 11:
  428.                                                                         dies2 = (dia_act + 30) - dia_int2;
  429.                                                                         mesos2 = mesos2 - 1 ;
  430.                                                                         break;
  431.                                                                  
  432.                                                                   }
  433.                                                                
  434.                                                                }
  435.                                                                else {
  436.                                                                   dies2 = dia_act - dia_int2;
  437.                                                                }
  438.                                                            
  439.                                                                if ((mes_act - mes_int2) < 0){
  440.                                                                   mesos2 = (mes_act + 12) - mes_int2;
  441.                                                                   if ( (dia_act - dia_int2) < 0 ) {
  442.                                                                      switch (mes_int2) {
  443.                                                                         case 1:
  444.                                                                         case 3:
  445.                                                                         case 5:
  446.                                                                         case 7:
  447.                                                                         case 8:
  448.                                                                         case 10:
  449.                                                                         case 12:
  450.                                                                            dies2 =  (dia_act + 31) - dia_int2;
  451.                                                                            mesos2 = mesos2 - 1;
  452.                                                                            break;
  453.                                                                      
  454.                                                                         case 2:
  455.                                                                            dies2 =  (dia_act + numDies2) -dia_int2;
  456.                                                                            mesos2 = mesos2 - 1;
  457.                                                                            break;
  458.                                                                      
  459.                                                                         case 4:
  460.                                                                         case 6:
  461.                                                                         case 9:
  462.                                                                         case 11:
  463.                                                                            dies2 = (dia_act + 30) - dia_int2;
  464.                                                                            mesos2 = mesos2 - 1 ;
  465.                                                                            break;
  466.                                                                      
  467.                                                                      }
  468.                                                                  
  469.                                                                   }
  470.                                                                   else {
  471.                                                                      dies2 = dia_act - dia_int2;
  472.                                                                   }
  473.                                                                
  474.                                                                   anys2 = anys2 - 1;
  475.                                                                }
  476.                                                                                                                    
  477.                                                                //Operacions de la tercera fecha
  478.                                                                anys3 = any_act - any_int3;
  479.                                                                mesos3 = mes_act - mes_int3;
  480.                                                                if ( (dia_act - dia_int3) < 0 ) {
  481.                                                                   switch (mes_int3) {
  482.                                                                      case 1:
  483.                                                                         case 3:
  484.                                                                         case 5:
  485.                                                                         case 7:
  486.                                                                         case 8:
  487.                                                                         case 10:
  488.                                                                         case 12:
  489.                                                                         dies3 =  (dia_act + 31) - dia_int3;
  490.                                                                         mesos3 = mesos3 - 1;
  491.                                                                         break;
  492.                                                                      
  493.                                                                      case 2:
  494.                                                                         dies3 =  (dia_act + numDies3) - dia_int3;
  495.                                                                         mesos3 = mesos3 - 1;
  496.                                                                         break;
  497.                                                                      
  498.                                                                      case 4:
  499.                                                                         case 6:
  500.                                                                         case 9:
  501.                                                                         case 11:
  502.                                                                         dies3 = (dia_act + 30) - dia_int3;
  503.                                                                         mesos3 = mesos3 - 1 ;
  504.                                                                         break;
  505.                                                                   }
  506.                                                                  
  507.                                                                }
  508.                                                                else {
  509.                                                                   dies3 = dia_act - dia_int3;
  510.                                                                }
  511.                                                                
  512.                                                                if ((mes_act - mes_int3) < 0){
  513.                                                                   mesos3 = (mes_act + 12) - mes_int3;
  514.                                                                   if ( (dia_act - dia_int3) < 0 ) {
  515.                                                                      switch (mes_int3) {
  516.                                                                         case 1:
  517.                                                                         case 3:
  518.                                                                         case 5:
  519.                                                                         case 7:
  520.                                                                         case 8:
  521.                                                                         case 10:
  522.                                                                         case 12:
  523.                                                                            dies3 =  (dia_act + 31) - dia_int3;
  524.                                                                            mesos3 = mesos3 - 1;
  525.                                                                            break;
  526.                                                                      
  527.                                                                         case 2:
  528.                                                                            dies3 =  (dia_act + numDies3) -dia_int3;
  529.                                                                            mesos3 = mesos3 - 1;
  530.                                                                            break;
  531.                                                                      
  532.                                                                         case 4:
  533.                                                                         case 6:
  534.                                                                         case 9:
  535.                                                                         case 11:
  536.                                                                            dies3 = (dia_act + 30) - dia_int3;
  537.                                                                            mesos3 = mesos3 - 1 ;
  538.                                                                            break;
  539.                                                                      }
  540.                                                                  
  541.                                                                   }
  542.                                                                   else {
  543.                                                                      dies3 = dia_act - dia_int3;
  544.                                                                   }
  545.                                                                
  546.                                                                   anys3 = anys3 - 1;
  547.                                                                }
  548.                                                                if (sel.equals("2")){
  549.                                                                   dies = dies + 1;
  550.                                                                   dies2 = dies2 + 1;
  551.                                                                   dies3 = dies3 + 1;
  552.                                                                }
  553.                                                                
  554.                                                                System.out.println( "Nombre" + "          " +"Seccion" + "          " + " Fecha de alta" + "          " + "Vida laboral" );
  555.                                                                System.out.println( nom + "        " + seccio + "         " + fecha_alt + "           " + dies + " dia/es" + " " + mesos + " mes/es y " + anys + " año/s" );
  556.                                                                System.out.println( nom2 + "        " + seccio2 + "         " + fecha_alt2 + "           " + dies2 + " dia/es" + " " + mesos2 + " mes/os i " + anys2 + " any/s" );
  557.                                                                System.out.println( nom3 + "        " + seccio3 + "         " + fecha_alt3 + "           " + dies3 + " dia/es" + " " + mesos3 + " mes/os i " + anys3 + " any/s" );
  558.                                                                
  559.                                                             }
  560.                                                             else {
  561.                                                                System.out.println( "Alguna cosa falla" );
  562.                                                             }
  563.                                                          }
  564.                                                       }
  565.                                                    }
  566.                                                 }
  567.                                              }
  568.                                           }
  569.                                        }
  570.                                     }
  571.                                        catch (NumberFormatException ex) {
  572.                                           System.out.println( "Los datos no pueden contener letres" );
  573.                                        }                  
  574.                                  }
  575.                               }
  576.                            }
  577.                         }        
  578.                      }
  579.                   }
  580.                }
  581.                   catch (NumberFormatException ex) {
  582.                      System.out.println( "La fecha final introducida no tiene un format dd/mm/aaaa vàlid" );
  583.                   }
  584.             }
  585.          }
  586.       }
  587.    }

No hay comentarios:

Publicar un comentario