Después  de algún tiempo regreso para compartirles algo que he aprendido. Durante los últimos dos años he estado trabajando en el lenguaje de programación JAVA. Ya compartiré algunas cosas que he aprendido al respecto.

Por ahora les comento que recientemente obtuve la certificación Java OCJP (Oracle Certification Java Professional JAVA SE 6 Programmer), aquí les voy a comentar qué deben hacer para aplicar.

Como requisito previo que necesitan para aplicar es tener una Tarjeta de Crédito Internacional para poder comprar la certificación, ya que se compra por Internet.

Los pasos que deben seguir son los siguientes:

  • Van a donde dice Sign in para que crean una nueva cuenta.
Certificación Java: Crear cuenta en PearsonVue

Certificación Java

  • En la siguiente pantalla deben escoger las opciones: en Narrow by Category seleccionan Information Technology TI. y en Select your testing program escogen Oracle.
Escoger Information Technology y Oracle.

Escoger Information Technology y Oracle.

  • En la siguiente ventana damos clic en Schedule a Test
Damos clic en Schedule a Test

Damos clic en Schedule a Test

  • Bajamos un poco y damos clic en el enlace que dice Proctored
Clic en Proctored

Clic en Proctored

  • En la siguiente pantalla damos clic al enlace Create a Web Account
Creamos una cuenta en PearsonVue

Creamos una cuenta en PearsonVue

  • En la siguiente página llenamos los datos personales y donde dice: Previous Testing History escogemos No. Aquí algo importante es que cuando nos pida la dirección pongamos lo más explícita que podamos, es decir, calle principal, número, calle secundaria, nombre del edificio y alguna referencia, ya que a esa dirección nos enviarán la certificación.
Certificacion Java

Escogemos que no tenemos un ID de Oracle Testing

Como yo ya tengo una cuenta voy a iniciar sesión. Después que creen su cuenta para iniciar sesión deben seguir los pasos previos e ingresan su usuario y contraseña temporal que les será enviado por correo electrónico.

El usuario y contraseña enviados al correo

El usuario y contraseña enviados al correo

  • Después de iniciar sesión en la siguiente pantalla deben elegir el examen que van a dar para obtener la certificación que en nuestro caso es el 1Z0-851 Java Standard Edition 6 Programmer Certified Professional Exam.
    Escogemos examen 1Z0-851

    Escogemos examen 1Z0-851

     

  • Luego escogemos el idioma en que queremos dar el examen y nos aparece el precio, en esta caso cuesta 150 dólares.
Escogemos el idioma en que daremos el examen

Escogemos el idioma en que daremos el examen

  • Damos clic en Next y en la siguiente pantalla indicamos nuestra ubicación geográfica y seleccionamos el centro donde daremos el examen de certificación:
Escogemos el centro donde daremos el examen

Escogemos el centro donde daremos el examen

  • Damos clic en Next y escogemos la fecha y hora en la que daremos el examen:
Escogemos fecha y hora para el examen

Escogemos fecha y hora para el examen

  • Luego damos clic en Next y se nos muestra toda la información sobre el examen como fecha, hora y el centro donde se dará, verificamos la información y damos clic en Next:
Verificamos la información

Verificamos la información

  • En la siguiente pantalla ingresamos la forma de pago, es decir los datos de la tarjeta de crédito:
Ingresamos datos de la tarjeta de crédito

Ingresamos datos de la tarjeta de crédito

  • Todavía no se ha procesado la forma de pago y aún no hemos hecho el pago de 150 dólares. Damos clic en Next y en la siguiente pantalla se muestra la confirmación del pago. Una vez que demos clic en Next en la siguiente pantalla se habrá efectuado el cargo a la tarjeta de crédito. De ahí solo queda esperar la confirmación que nos llegará al mail con la factura y la información del examen.

Y eso es todo para aplicar a una certificación Java.

Los duendes de las estadísticas de WordPress.com prepararon un informe sobre el año 2012 de este blog.

Aquí hay un extracto:

Unos 55,000 turistas visitan a Liechtenstein cada año. Este blog ha sido visto cerca de 290.000 veces en 2012. Si fuera Liechtenstein, se necesitarían alrededor de 5 años para que todos lo vean. Tu blog tuvo más visitas que un pequeño país en Europa!

Haz click para ver el reporte completo.

Vamos a ver un ejemplo de polimorfismo en Java con el uso de interfaces. En la definición de Polimorfismo tenemos:

El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos simplifica la programación.

No nos vamos a enfocar mucho en la teoría sino en la parte práctica. Vamos a usar una interfaz para aplicar el concepto de polimorfismo.

Primero creamos un proyecto Java en Eclipse. y vamos a crear en el src el package llamado com.practica.polimorfismo.

Ahora vamos a crear la clase Figura.java que contendrá el siguiente código:

publicclass Figura  {

private String nombre;

private String color;

public Figura(String nombre) {

super();

this.nombre = nombre;

}

public Figura(String nombre, String color) {

super();

this.nombre = nombre;

this.color = color;

}

public String getNombre() {

return nombre;

}

publicvoid setNombre(String nombre) {

this.nombre = nombre;

}

public String getColor() {

return color;

}

publicvoid setColor(String color) {

this.color = color;

}

}

Esta va a ser nuestra super clase de la cual heredarán otro tipo de figuras. Esta clase es simplemente un POJO que tiene el nombre y el colo de la figura y sus getters y setters y dos constructores, aunque solo usaremos uno.

Ahora vamos a crear una interfaz. En Eclipse nos vamos a File -> New -> Other -> Interface. La interfaz se llamara OperacionesFigura.java Esta interfaz contendrá el siguiente código:

package com.practica.polimorfismo;

publicinterface OperacionesFigura {

      double calcularArea();

Figura figura();

}

Básicamente la interfaz tendrá dos métodos. Uno es el método calcularArea() que devolverá un double con el valor del área de la figura, y otro método que nos devolverá todo el objeto Figura. Como sabemos cada figura tiene diferente forma de calcular el área, pero todas tienen esta característica por eso las figuras que implementen esta interfaz deberán implementar estos dos métodos.

Ahora vamos a crear la clase Triángulo.java. Esta clase va a extender o heredar de Figura y a implementar la interfaz OperacionesFigura.

package com.practica.polimorfismo;

publicclass Triangulo extends Figura implements OperacionesFigura {

privatedouble base;

private Double altura;

public Triangulo(String nombre, String color, double base, Double altura) {

super(nombre, color);

this.base = base;

this.altura = altura;

}

@Override

publicdouble calcularArea() {

return (base * altura) / 2;

}

publicdouble getBase() {

return base;

}

publicvoid setBase(double base) {

this.base = base;

}

public Double getAltura() {

return altura;

}

publicvoid setAltura(Double altura) {

this.altura = altura;

}

@Override

public Figura figura() {

return new Figura(getNombre(), getColor());

}

}

Triangulo.java tendrá los atributos propios de un triángulo que son base y altura y además los atributos de la super clase Figura, es decir el nombre y el color. Aquí al implementar la interfaz tenemos el método calcularArea() que es base * altura dividido para 2, en el método figura retornamos una nueva Figura obteniendo el nombre y el color de la super clase. Además tenemos un constructor con todos los atributos de Triangulo y de la super clase Figura.

Ahora aplicamos lo mismo a otra figura. Creamos la clase Circulo.java:

package com.practica.polimorfismo;

importstatic java.lang.Math.*;

publicclass Circulo extends Figura implements OperacionesFigura {

privatedouble radio;

public Circulo(String nombre, String color, double radio) {

super(nombre, color);

this.radio = radio;

}

/*

* (non-Javadoc)

*

* @see com.practica.polimorfismo.OperacionesFigura#calcularArea()

*/

@Override

publicdouble calcularArea() {

returnPI * pow(radio, 2);

}

publicdouble getRadio() {

return radio;

}

publicvoid setRadio(double radio) {

this.radio = radio;

}

@Override

public Figura figura() {

returnnew Figura(getNombre(), getColor());

}

}

Tiene la misma estructura que Triangulo. En este caso tiene como atributo el radio del círculo y en calcularArea() aplicamos la fórmula del área del círculo.

Una vez realizado esto vamos a ver cómo ejecutar estos procedimientos. Para ello creamos la clase CalcularOperacionesFigura.java que contendrá el siguiente código:

package com.practica.polimorfismo;

import java.util.ArrayList;
import java.util.List;

public class CalcularOperacionesFigura {

/**
* @param args
*/

public static void main(String[] args) {
OperacionesFigura of = new Triangulo(“Triangulo”, “Azul”, 15.0, 3.0);
OperacionesFigura of2 = new Circulo(“Circulo”, “Verde”, 12.3);
List<OperacionesFigura> lista = new ArrayList<OperacionesFigura>();
lista.add(of);
lista.add(of2);

calcularArea(lista);
}

public static void calcularArea(List<OperacionesFigura> listaOperacionesFiguras) {
for (OperacionesFigura of : listaOperacionesFiguras) {
System.out.println(“Area es:  ” + of.calcularArea());
System.out.println(“Nombre es: ” + of.figura().getNombre());
System.out.println(“Color es: ” + of.figura().getColor());
}
}

}

Analicemos un poco el código.

En el método main creamos una instancia de la interfaz OperacionesFigura y le decimos que es igual a new Triángulo y llenamos los valores del constructor: nombre, color, base, altura. Podemos hacer esto porque Triángulo implementa OperacionesFigura. Luego hacemos lo propio para Circulo.java  y le instanciamos desde la interfaz.

Hecho esto creamos una lista genérica de la interfaz List<OperacionesFigura> lista, como es genérica solo se puede agregar a la lista objetos de tipo OperacionesFigura. Hecho eso agregamos a la lista las dos interfaces que instanciamos anteriormente

Ahora creamos un método que se llama calcularArea que recibe como parámetro una lista de interfaz de tipo OperacionesFigura. Luego con un foreach recorremos nuestra lista y accedemos a los métodos de la interfaz que son calcularArea() y figura() y de esa manera podemos obtener el área de la Figura que creamos en la instancia. Nótese que se accede a los métodos de la interfaz y no de Triangulo o Circulo. De esta manera la interfaz sabrá qué calculo debe hacer para obtener el área gracias a la implementación de la interfaz.

Este es un ejemplo sencillo de polimorfismo.

Para descargar el código fuente se puede ir a: http://mygnet.net/codigos/java/varios/ejemplo_de_polimorfismo_en_java.3541

El concierto de Ricardo Arjona con su Tour 2012 Metamorfosis está confirmado tanto en Quito como en Guayaquil, el artista Guatemalteco Ricardo Arjona  regresa a Ecuador luego de un par de años de no visitarnos .

QUITO 22 DE JUNIO 2012 – Estadio Olímpico Atahualpa

COSTO DE ENTRADAS Y LOCALIDADES

BLACKBOX: 170$
GOLDEN: 130$
VIP: 90$
PALCO: 65$
TRIBUNA: 50$
CANCHA: 30$
GENERAL: 27.5$
MENOR VALOR 25$

Mapa del concierto en Quito

Puntos de Venta Ecutickets:

CCI, El Recreo, EL Bosque

Llama gratis al: 1800 328 842 (Entradas a la venta a partir del lunes 14 de mayo)

GUAYAQUIL 20 DE JUNIO 2012  – Feria de Durán 

COSTO DE ENTRADAS Y LOCALIDADES

ARJONABOX (numerado): 210$
GOLDEN BOX (numerado): 170$
VIP: 120$
TRIBUNA: 65$
GENERAL: 35$

Puntos de Venta TicketShow:

Musicalísimo del Policento, Mall del Sol y Village Plaza

Amigos les cuento que el Tour de Ricardo Arjona Metamorfosis World Tour 2012 pronto hará su parada en Ecuador. Llegará nuevamente de la mano de Team Producciones, si bien la fecha aún no está confirmada, se cree que visitará el país en junio o julio de 2012. Así que estén pendientes.

La fecha tentativa en Quito es el 21 de junio. Está por confirmarse.

Los duendes de las estadísticas de WordPress.com prepararon un reporte para el año 2011 de este blog.

Aqui es un extracto

El Museo del Louvre tiene 8.5 millones de visitantes por año. Este blog fue visto cerca de 180.000 veces en 2011. Si fuese una exposición en el Museo del Louvre, se precisarían alrededor de 8 días para que toda esa gente la visitase.

Haz click para ver el reporte completo.

Voy a subir mis publicaciones a un Blog dentro de un dominio propio, y ahí seguiré poniendo nuevos artículos.

Se aceptan sugerencias del nombre del dominio.

En la primera parte les mostré cómo validar el RUC de una persona natural.  En la segunda parte les mostré cómo validar el RUC para persona jurídica o extranjera.  Ahora les mostraré cómo validar el RUC para empresas públicas.

RUC para empresas públicas

La estructura de este tipo de RUC se muestra en la siguiente figura:

RUC empresa públicaLa validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

  • Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
  • Se suma ese resultado.
  • Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
  • Se resta el módulo (en este caso 11) de el residuo de la división anterior.
  • El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 9 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente:     3     2     7    6    5    4   3   2

RUC:                   1     7     6    0   0   0    1    5     5   0   0   0   1

Producto:         3   14   42   0   0   0   3   10   14

Sumatoria:        72

Residuo:             72 dividido para 11 da como respuesta 6, y como residuo 6.

Resta:                 11 – 6 = 5.

5 Es el dígito verificador.

El código es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class ValidaRucEP {
 
	public static final int NUM_PROVINCIAS = 24;
 
	public static Boolean validaRucEP(String ruc) {
		final int prov = Integer.parseInt(ruc.substring(0, 2));
		boolean resp = false;
 
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			resp = false;
		}
 
		// boolean val = false;
		Integer v1, v2, v3, v4, v5, v6, v7, v8, v9;
		Integer sumatoria;
		Integer modulo;
		Integer digito;
		int[] d = new int[ruc.length()];
 
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(ruc.charAt(i) + "");
		}
 
		v1 = d[0] * 3;
		v2 = d[1] * 2;
		v3 = d[2] * 7;
		v4 = d[3] * 6;
		v5 = d[4] * 5;
		v6 = d[5] * 4;
		v7 = d[6] * 3;
		v8 = d[7] * 2;
		v9 = d[8];
 
		sumatoria = v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
		modulo = sumatoria % 11;
		if (modulo == 0) {
			return true;
		}
		digito = 11 - modulo;
 
		if (digito.equals(v9)) {
			resp = true;
		} else {
			resp = false;
		}
		return resp;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1760001550001";
		if (validaRucEP(ruc_dato)) {
			System.out.println("El RUC es correcto");
		} else
			System.out.println("El RUC es incorrecto");
	}
}

Espero que les sirva.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace:

Valida RUC Empresas Públicas del Ecuador
Valida RUC Empresas Públicas del Ecuador
ValidaRucEP.java
Version: 1.0
1.2 KiB
631 Downloads
Details

En la primera parte les mostré cómo validar el RUC de una persona natural. Ahora les mostraré cómo validar el RUC de una persona jurídica o extranjera.

RUC de persona jurídica o extranjera

La estructura de este tipo de RUC se muestra en la siguiente figura:

Estructura del RUC de persona jurídicaLa validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 4, 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

  • Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
  • Se suma ese resultado.
  • Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
  • Se resta el módulo (en este caso 11) de el residuo de la división anterior.
  • El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 10 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente:     4     3     2    7   6   5   4   3   2

RUC:                   1     7     9    0   0   1    1    6     7   4   0   0   1

Producto:         4   21   18   0   0   5   4   18   14

Sumatoria:        84

Residuo:             84 dividido para 11 da como respuesta 7, y como residuo 7.

Resta:                 11 – 7 = 4.

4 Es el dígito verificador.

El código es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class ValidaRucSociedades {
 
	/**
	 * @param args
	 */
	private static final int NUM_PROVINCIAS = 24;
	// public static String rucPrueba = “1790011674001″;
	private static int[] coeficientes = { 4, 3, 2, 7, 6, 5, 4, 3, 2 };
	private static int constante = 11;
 
	public static Boolean validacionRUC(String ruc) {
		boolean resp_dato = false;
		final int prov = Integer.parseInt(ruc.substring(0, 2));
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			resp_dato = false;
		}
 
		int[] d = new int[10];
		int suma = 0;
 
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(ruc.charAt(i) + "");
		}
 
		for (int i = 0; i &lt; d.length - 1; i++) {
			d[i] = d[i] * coeficientes[i];
			suma += d[i];
		}
 
		int aux, resp;
 
		aux = suma % constante;
		resp = constante - aux;
 
		resp = (aux == 0) ? 0 : resp;
 
		if (resp == d[9]) {
			resp_dato = true;
		} else {
			resp_dato = false;
		}
		return resp_dato;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1790011674001";
		if (validacionRUC(ruc_dato))
			System.out.println("El RUC es correcto");
		else
			System.out.println("El RUC es incorrecto");
	}
}

En la tercera parte les enseñaré a validar el RUC para empresas públicas.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace:

Valida RUC Sociedades Ecuador
Valida RUC Sociedades Ecuador
ValidaRucSociedades.java
Version: 1.0
1.2 KiB
637 Downloads
Details

En este nuevo tutorial les voy a enseñar a validar el RUC ecuatoriano. La validación de la cédula del Ecuador lo pueden encontrar en el siguiente enlace: http://www.coplec.org/?q=2008/07/01/validador-de-c%C3%A9dula-ecuatoriana

Les puse ese enlace porque usaremos ese código para validar uno de los tres tipos de RUC que existen en el Ecuador.

Los tres tipos de RUC son:

  1. RUC de persona jurídica o extranjera.- Es del tipo 1790011674001
  2. RUC de persona pública (entidades estatales).- Es del tipo 1760001550001
  3. RUC de persona natura.- Es del tipo 1701300103001

Se mostrará la validación por partes según cada tipo de RUC.

RUC de personas naturales

La estructura de este tipo de RUC se muestra en la siguiente figura:

Estructura del RUC de persona naturalSu validación se explica a continuación:

  • El RUC de una persona natural será 13 dígitos, sin letras, sin caracteres especiales , únicamente números, de los cuales los 10 primeros será la cédula de identidad.
  • Las 2 primeras posiciones corresponden a la provincia donde fue expedida, por lo cual los dos primeros números no será mayor a 24 ni menor a 1.
  • El tercer dígito es menor a 6 ( 0,1,2,3,4,5 ).
  • Del cuarto al noveno dígito es un número consecutivo de 6 dígitos.
  • El décimo dígito es el dígito verificador.
  • Del décimo primer dígito al décimo tercer dígito, identifican en forma consecutiva el número de establecimientos. Empieza siempre con el 0001.

El número de RUC es: 1710034065001 independientemente del número de establecimientos que tenga el contribuyente, no existe un número de RUC tal como 1710034065002.

La validación de la cédula de Identidad pasa un algoritmo “Módulo 10″. Al número se lo divide en 13 partes, las 9 primeras son el número mismo, la 10 es el dígito autoverificador, y las 3 restantes indican si es principal o establecimiento adicional. Los coeficientes usados para verificar el décimo dígito de la cédula, mediante el algoritmo “Módulo 10″ son: 2.1.2.1.2.1.2.1.2

Como se ve en la imagen se usan los 9 primeros dígitos del RUC. Los números de las posiciones impares e multiplican por 2, y los números de las posiciones pares se multiplican por 1. Si el resultado de multiplicar por 2 es mayor a 9, se resta 9. Como en la figura, 12 – 9 = 3.

Luego se suman todos los valores del producto. En este caso la respuesta es 25.

Luego se resta este número de su decena superior. La decena superior a 25 es 30. Por lo tanto queda: 30 – 25 = 5.

Y 5 es el dígito verificador, si este número coincide con el décimo dígito del RUC la cédula es correcta.

Excepción: Si el resultado de la resta es 10, el dígito verificador será 0.

Usando el código de la página que les puse arriba y haciéndole una pequeña modificación, el resultado queda:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class ValidaCedula {
	private static final int NUM_PROVINCIAS = 24;
 
	public static Boolean validacionCedula(String cedula) {
		boolean isValid = false;
		if (cedula == null || cedula.length() != 10) {
			isValid = false;
		}
		final int prov = Integer.parseInt(cedula.substring(0, 2));
 
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			isValid = false;
		}
 
		int[] d = new int[10];
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(cedula.charAt(i) + "");
		}
 
		int imp = 0;
		int par = 0;
 
		for (int i = 0; i &lt; d.length; i += 2) { 			d[i] = ((d[i] * 2) &gt; 9) ? ((d[i] * 2) - 9) : (d[i] * 2);
			imp += d[i];
		}
 
		for (int i = 1; i &lt; (d.length - 1); i += 2) {
			par += d[i];
		}
 
		final int suma = imp + par;
 
		int d10 = Integer.parseInt(String.valueOf(suma + 10).substring(0, 1)
				+ "0")
				- suma;
 
		d10 = (d10 == 10) ? 0 : d10;
 
		if (d10 == d[9]) {
			isValid = true;
		} else {
			isValid = false;
		}
 
		return isValid;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1710034065001";
		if (validacionCedula(ruc_dato.substring(0, 10)))
			System.out.println("El RUC es correcto");
		else
			System.out.println("El RUC es incorrecto");
	}
}

Una explicación del código. Hay una parte donde dice:

d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);

El uso del símbolo de pregunta ? es un equivalente al uso del if. Todo lo que está entre el ? y los dos puntos será lo que suceda en caso de ser verdadero, y lo que está después de los dos puntos sucederá en caso de ser falso.

Validar el ingreso del RUC de Ecuador en Java – Segunda parte

Validar el ingreso del RUC de Ecuador en Java – Tercera parte

Para conocer un poco más sobre la estructura del RUC pueden visitar el siguiente sitio: http://www.campvs.org/legislacion/index.php?option=com_content&task=view&id=18&Itemid=69

Si desean pueden descargarse el archivo en el siguiente enlace:

Valida Cedula del Ecuador
Valida Cedula del Ecuador
ValidaCedula.java
Version: 1.0
1.3 KiB
881 Downloads
Details
Polls

¿Qué lenguaje de programación utilizas más?

View Results

Loading ... Loading ...
Síguenos en Twitter
Cyberexplorador en Twitter
Comparte este blog
Bookmark and Share
Publicidad
Follow

Get every new post on this blog delivered to your Inbox.

Join other followers: