Saltar al contenido

CIF. Calcular el CIF en java.

El CIF, es el Código de Identificación Fiscal para empresas. Este código, se constituye de nueve caracteres. Además, el CIF, puede estar constituido de dos formas diferentes.

  • Por un lado, puede estar constituido por una letra alfabética más 8 dígitos numéricos. Por ejemplo el siguiente: B39353610.
  • Sin embargo, también podemos encontrarnos CIF con una letra alfabética, 7 dígitos y otra letra alfabética. Por ejemplo P3935361J

Asimismo, cuando hablamos del código CIF, podemos dividir sus nueve caracteres de la siguiente manera.

División del CIF de una empresa.

  • En primer lugar, la primera letra, corresponde al tipo de sociedad a la que corresponde la empresa.
  • Seguidamente, se introducen los 8 dígitos divididos de la siguiente forma.
    • Los dos primeros dígitos corresponden a la provincia donde está registrada la empresa.
    • Los cinco siguientes dígitos constituye un número correlativo de inscripción en el registro provincial.
    • Por último, el último dígito es un código de control que puede ser un número o una letra.

¿Cuándo el dígito control, es un número o un letra?

Para aclarar este aspecto, diremos que el digito o caracter control de un CIF:

  • Será una letra, si el CIF comienza por «P», «Q», «R», «S» o «W».
  • También, si los dos dígitos iniciales indican son dos ceros.

¿Cómo se calcula el dígito control de un CIF?

Antes de crear un programa en java para calcular el dígito control de un CIF, veamos como se calcula. Para ello tomaremos hacemos un ejemplo con el siguiente código de identificación fiscal. A58818501.

  • En primer lugar, eliminaremos tanto la letra (A) como el último dígito (el uno final). Por lo tanto la cadena nos queda de la siguiente forma: «5881850«.
  • A continuación, sumaremos los números que ocupan las posiciones pares, es decir, el 8, el 1, y el 5. Esto da un resultado de 14. Diremos que la suma de las posiciones pares es igual a 14.
  • En tercer lugar, multiplicaremos por dos los números que ocupen las posiciones impares. En este caso quedaría de la siguiente manera:
    • 5 x 2 = 10.
    • 8 x 2 = 16.
    • 8 x 2 = 16.
    • 0 x 2 = 0.
  • Al multiplicar los tres primeros dígitos que ocupan una posición impar, nos da como resultado un número de dos cifras. Así que sumamos esas cifras.
    • El 10 quedaría: 1 + 0 = 1.
    • En cuanto al 16 tendríamos lo siguiente: 1 + 6 = 7.
    • Vamos con el último 16 que tenemos: 1 + 6 = 7.
    • Por último, el cero queda como cero. 0 = 0;
  • Sumamos el resultado: 1 + 7 + 7 + 0 = 15. Ahora diremos que la suma de los número de las posiciones impares es igual a 15.
  • Sumamos el valor total de la suma de los números de las posiciones impares y los pares. Lo llamaremos Suma final.
    • Resultado de la suma final = 14 + 15 = 29.
  • En este penúltimo paso, cogeremos la cifra de las unidades del resultado final de la suma. Por consiguiente, utilizaremos el 9.
  • Por último al numero 10, le restaremos el número 9. Entonces, quedaría de la siguiente forma: 10 – 9 = 1. Este uno, es el dígito control del CIF, es decir, el último dígito de Código de Identificación Fiscal.

Para finalizar, como en este caso, el CIF, comienza por una A, el digito control, es el uno que nos ha salido en el último paso. Sin embargo, si al extraer la unidades de la suma total, el número hubiese sido un cero, sería ese cero el digito control del CIF.

Por otra parte si el CIF con el que estamos haciendo el ejemplo, hubiese comenzado por «P», «Q», «R», «S» o «W», el digito control, hubiese sido un caracter de tipo alfabético. Los caracteres alfabéticos en este caso, serían los siguientes. J = 0, A = 1, B = 2, C= 3, D = 4, E = 5, F = 6, G = 7, H = 8, I = 9.

Programa para verificar el digito control de un CIF.

Ahora ha llegado el momento de aprender a crear un programa para validar si un CIF es correcto o no. Para ello, lo primero que haremos, será crear una clase llamada Cif.

package CalculoCIF;
/**
 * Clase que utilizamos para validar el CIF de una empresa.
 * @author Fran
 * @version 1.0, 29/11/2020
 */
public class Cif {


}

Dentro de esta clase, vamos a incluir los siguientes atributos.

Atributos de la clase Cif.

    private final String letrasCif; // Caracteres validos pra el CIF.
    private String cadenaCif; // Contiene toda la cadena del CIF.
    private String letraCif; // Almacena la letra del CIF.
    //El siguiente atributo (ultimoDigitoCIF) es opcional:
    private String ultimoDigitoCif; // Contiene el último dígito del CIF.
    // Contiene los dígitos para calcular el dígito control.
    private String calculoDigitoControl;
    private int sumaPares; // Suma de números de las posiciones pares.
    private int sumaImpares; // Suma de números de las posiciones impares.
    private int sumaTotal; // Guarda la suma total de pares e impares.
    private int unidades; // Almacena el dígito de las uds. de la suma total.
    private int resultadoResta; // Guarda el resultado de restar las uds. a 10.
    /* Guarda los caracteres control por lo que puede comenzar un CIF.*/
    private final char[] letraControl;
    /*En caso de que el CIF, comience por una letra el caracter control
    será una letra almacenada en este atributo.*/
    private final String primerCaracterLetra;
    private String caracterControl; // Guarda un caracter control tipo letra
    private String digitoControl; // Guarda un digito control de tipo numérico.
    private String cifValido; // Almacena un CIF cuyo dígito control es válido.

A continuación, crearemos un método constructor que recibirá lo que el usuario introduce por teclado.

Crear un método Constructor.

    /**
     * Crea un objeto de tipo Cif
     * @param cif: cadena de 9 caracteres introducida por el usuario.
     */
    public Cif(String cif){
        // Iniciamos las cadenas necesarias.
        this.letrasCif = "ABCDEFGHJKLMNPQRSUVW";
        this.letraControl = new char[]
        {'J','A','B','C','D','E','F','G','H','I'};
        this.primerCaracterLetra="NPQRSW";
        
        /* Si la cadena introducida por el usuario, contiene una letra
        de la lista de caracteres letrasCIF...*/
        if(letrasCif.indexOf(cif.charAt(0)) != -1){
            this.cadenaCif=cif; // asignamos la cadena al atributo cadenaCIF
            
            // Extraemos la letra del CIF a un atributo llamado letraCif
            this.letraCif = cif.substring(0, 1);
            
            /* Extraemos 7 siguientes caracteres a un atributo llamado
            calculoDigitoControl*/
            this.calculoDigitoControl = cadenaCif.substring(1, cif.length()-1);
            
            // Extraemos el último dígito del CIF (opcional)
            this.ultimoDigitoCif= cadenaCif.substring(cadenaCif.length()-1);
        }
    }

Por último, debemos crear los métodos getter y setter necesarios para que poder utilizar los atributos de la clase.

Métodos getter y setter de la clase Cif.

En este caso, no utilizaremos ningún método set, ya que no vamos a establecer ningún valor. Es más, el valor que vamos a utilizar, será el que le pasamos al constructor al principio del programa.

    /**
     * Devuelve la cadena de caracteres introducida por el usuario.
     * @return Devuelve el CIF en formato texto con la letra en mayúscula.
     */
    public String getCadenaCif(){
        return this.cadenaCif.toUpperCase();
    }
    
    /**
     * Devuelve la letra del cif introducido por teclado.
     * @return Devuelve la letra del CIF convertida en mayúsculas
     */
    public String getLetraCif(){
        return this.letraCif.toUpperCase();
    }
    
    /**
     * Devuelve el número sobre el que se va a calcular el dígito control
     * @return Devuelve el un número de 7 cifras en formato texto.
     */
    public String getCalculoDigitoControl(){
        return this.calculoDigitoControl;
    }
    
    /**
     * Devuelve el último dígito del CIF introducido por teclado. (Opcional) 
     * @return Devuelve el último digito en formato Texto.
     */
    public String getUltimoDigitoCif(){
        return this.ultimoDigitoCif;
    }
    
    /**
     * Suma los números de las posiciones pares del número de 7 dígitos.
     * @return Devuelve el resultado en formato de número entero.
     */
    public int getSumaPares(){
        // Creamos un bucle para recorrer las posiciones pares.
        for(int pos =1;pos< this.getCalculoDigitoControl().length();pos+=2){
            /* A la variable sumaPares le sumamos lo que tenga la variable
            en ese momento, más el número convertido en dato numérico*/
            this.sumaPares = this.sumaPares + Integer.parseInt(
                    this.calculoDigitoControl.substring(pos, pos + 1));
        }
        return sumaPares;
    }
    
    /**
     * Multiplica por dos los números de las posiciones impares
     * y devuelve la suma, si el resultado es de dos cifras, suma ambas cifras.
     * @return Devuelve el resultado de la suma en formato número entero.
     */
    public int getSumaImpares(){
        Integer longitudCifraImpar;
        for(int pos =0;pos<this.getCalculoDigitoControl().length();pos+=2){
            /* A la variable sumaImpares le sumamos lo que tenga la variable
            en ese momento, más el número convertido en dato numérico
            multiplicado por dos*/
            longitudCifraImpar = 2*Integer.parseInt(
                    this.calculoDigitoControl.substring(pos, pos + 1));
            
            /* Si al multiplicar por dos un numero de unaposicion impar
            el restultado tiene una longitud de más de 1 cifra..*/
            if(longitudCifraImpar.toString().length()>1){
                /*Sumamos las dos cifras*/
                longitudCifraImpar = Integer.parseInt
        (longitudCifraImpar.toString().substring(0, 1)) + Integer.parseInt(
                                longitudCifraImpar.toString().substring(1, 2));
            }
            // Sino, sumamos el resultado a la suma impar
            this.sumaImpares=this.sumaImpares+longitudCifraImpar; 
        }
        return sumaImpares;
    }
    
   /**
    * Obtiene el dígito control valido para el CIF que el usuario introduce
    * por teclado.
    * @return Devuelve un valor de tipo entero con el dígito control siempre
    * que el valor de las unidades sea mayor que cero.
    */
    public int getObtenerDigitoControl(){
        // Sumamos el resultado de los pares y los impares        
        this.sumaTotal= this.getSumaPares()+this.getSumaImpares();
        
        // Nos quedamos con las unidades de dicha suma
        this.unidades = this.sumaTotal % 10;
        
        // Si el valor de las unidades es 0
        if(this.unidades > 0){
            // Restamos de 10 las unidades obtenidas.
            this.resultadoResta = 10 - this.unidades;
        }
        else{ // En caso contrario
            this.resultadoResta=0;
        }
        
        // Devolvemos el resultado.
        return this.resultadoResta;
    }
    
    /**
     * Comprueba si el CIF introducido por el usuario es correcto.
     * @return Devuelve verdaddero el si CIF introducido es correcto.
     */
    public boolean getEstablecerDigitoControl(){
        
        // Guardamos el dígito control en una variable tipo texto.
        this.digitoControl = String.valueOf(this.getObtenerDigitoControl());
        
        /*Si los dos primeros dígitos de la cadena que se utiliza para calcular
        el digito control son dos ceros o bien, si la letra del CIF
        esta contenida en la cadena primerCaracterLetra, el dígito control
        del CIF será una letra*/
        if(this.getCalculoDigitoControl().substring(1, 2).equals("00") || 
                primerCaracterLetra.indexOf(
                        this.getLetraCif().charAt(0)) != -1){
            
            // Almacenamos un caracter de control tipo letra
            this.caracterControl = Character.toString(
                    this.letraControl[this.resultadoResta]);
            
            // Armamos el CIF con la letra.
            this.cifValido = this.getLetraCif() + 
                    this.getCalculoDigitoControl() + this.caracterControl;   
        
        }
        else{ // En caso de no comenzar por una letra, almacenamos un número.
            
            // Almacenamos un caracter control de tipo numérico
            this.cifValido = this.getLetraCif() + 
                    this.getCalculoDigitoControl() + this.digitoControl;
        }
        
        // Si el CIF válido coincide con la cadena introducida por el usuario
        // el método equals de la clase String, devuelve verdadero.
        // Por lo tanto podemos crear el return de la siguiente forma:
        return this.getCadenaCif().equals(this.cifValido);
    }

Para finalizar el programa, utilizaremos, esta clase desde el método main que se encuentra en una clase llamada Principal.

Construcción del método main.

package Calcularcif;
import java.util.*;
/**
 * @version 1.0, 29/11/2020.
 * @author Fran
 */
public class CalcularCif {
    
    // Objeto de tipo lectura.
    private static Scanner lectura = new Scanner (System.in);
    
    // Almacena la cadena introducida por el usuario
    private static String cadenaCIF ="";
    
    // Almacena un objeto de tipo CIF.
    private static Cif nuevoCif;
    
    public static void main(String[] args) {
        
        // Pedimos el CIF por teclado
        do {            
            System.out.println("Introduce los nueve ´caracteres del CIF:");
            cadenaCIF=lectura.nextLine();
            // Pasamos la cadena a mayúsculas
            cadenaCIF = cadenaCIF.toUpperCase();
        } while (cadenaCIF.isEmpty() || cadenaCIF.length()!=9);
        
        // Creamos un nuevo objeto CIF
        nuevoCif = new Cif(cadenaCIF);
        
        // Comprobamos que el CIF sea correcto.
        if(nuevoCif.getEstablecerDigitoControl()){
            System.out.println("El CIF es correcto");
        }
        else{
            System.out.println("El CIF NO es incorrecto");
        } 
    }
}

DESCARGAR PROYECTO