Tutorial donde mostramos paso a paso cómo desarrollar una aplicación Java usando el IDE NetBeans que, leyendo los nombres completos de dos personas (nombre, apellido primero y apellido segundo), devuelve el posible grado de parentesco (comparando los apellidos). Esta aplicación sirve como ejemplo para crear clases en Java con sus correspondientes métodos constructores y accesores (setters y getters). También sirve como ejemplo Java para referenciar e instanciar clases.
- Crear nueva aplicación o proyecto Java en el IDE NetBeans.
- Crear clase Persona en Java con NetBeans.
- Crear clase BuscarParentesco en Java con NetBeans.
- Instanciar y referenciar las clases y probar la aplicación Java para el cálculo de parentesco.
- Código fuente gratuito de aplicación de ejemplo AjpdSoft Buscar Parentesco en Java.
Crear nueva aplicación o proyecto Java en el IDE NetBeans
En primer lugar necesitaremos disponer del IDE de desarrollo NetBeans, a continuación mostramos un tutorial donde explicamos paso a paso cómo descargarlo e instalarlo:
Una vez instalado, para crear una nueva aplicación Java abriremos NetBeans y pulsaremos en el menú «Archivo» – «Proyecto Nuevo»:
Seleccionaremos en Categorías la categoría «Java» y en Proyectos el proyecto «Java Application»:
Introduciremos el nombre del proyecto (por ejemplo AjpdSoftBuscarParentesco) y la carpeta donde se guardará:
De esta forma NetBeans creará los ficheros iniciales necesarios para nuestro proyecto:
Crear clase Persona en Java con NetBeans
En primer lugar, tras crear el proyecto Java, crearemos una clase para gestionar las personas. Para ello, desde el IDE de NetBeans, sobre el paquete creado pulsaremos con el botón derecho y en el menú emergente seleccionaremos «Nuevo» – «Java Class»:
Especificaremos el nombre para la clase, por ejemplo «Persona» y pulsaremos «Terminar»:
Añadiremos el siguiente código Java para la clase Persona:
El código de la clase Persona.java:
|
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 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 |
/* * Persona */ package ajpdsoftbuscarparentesco; /** * * @author www.proyectoa.com */ public class Persona { private String nombre; private String apellido1; private String apellido2; private String nombreCompleto; // Constructor vacío public Persona() { } // Constructor, si se le pasa el nombre completo public Persona (String nombreCompleto) { this.nombreCompleto = nombreCompleto; } // Constructor si se pasa el nombre separado, solo setters public Persona(String nombre, String apellido1, String apellido2) { this.nombre = nombre; this.apellido1 = apellido1; this.apellido2 = apellido2; } // Setters public void setNombre(String nombre) { this.nombre = nombre; } public void setApellido1(String Apellido1) { this.apellido1 = Apellido1; } public void setApellido2(String Apellido2) { this.apellido2 = Apellido2; } public void setNombreCompleto(String nombreCompleto) { this.nombreCompleto = nombreCompleto; } //getters public String getNombre() { return nombre; } public String getApellido1() { return apellido1; } public String getApellido2() { return apellido2; } public String getNombreCompleto() { return nombreCompleto; } // Separar nombre y apellidos public void separarNombre () { int posPrimerEspacio; int postUltimoEspacio; //obtenemos el primer apellido (entre el primer y último espacio) posPrimerEspacio = nombreCompleto.indexOf(" "); postUltimoEspacio = nombreCompleto.lastIndexOf(" "); if (posPrimerEspacio > 0 & postUltimoEspacio > 0) { // Obtenemos el segundo apellido (entre el ultimo espacio // y el tamaño del nombre) this.apellido1 = nombreCompleto.substring(posPrimerEspacio, postUltimoEspacio).trim(); // Obtenemos el segundo apellido (entre el ultimo espacio //y el tamaño del nombre completo) this.apellido2 = nombreCompleto.substring(postUltimoEspacio, nombreCompleto.length()).trim(); // Obtenemos el nombre, entre el principio de la // cadena y el primer espacio this.nombre = nombreCompleto.substring(0, posPrimerEspacio).trim(); } else { this.nombre = ""; this.apellido1 = ""; this.apellido2 = ""; } } } |
En dicha clase definimos los atributos para una persona, que son:
- private String nombre;
- private String apellido1;
- private String apellido2;
- private String nombreCompleto;
Establecemos los métodos accesores setters y getters para establecer el nombre completo de la persona y devolver el nombre, apellido primero y apellido segundo.
En esta clase también definimos un método que nos permitirá separar de un nombre completo especificado el nombre, el apellido primero y el apellido segundo:
- public void separarNombre ()
Crear clase BuscarParentesco en Java con NetBeans
Tras crear la clase Persona, ahora crearemos la clase BuscarParentesto. En esta clase definiremos el método que calculará el posible parentesco de una Persona. Para ello, desde el IDE de NetBeans, sobre el paquete creado pulsaremos con el botón derecho y en el menú emergente seleccionaremos «Nuevo» – «Java Class»:
Especificaremos el nombre para la clase, por ejemplo BuscarParentesco y pulsaremos «Terminar»:
Añadiremos el siguiente código Java para la clase BuscarParentesco:
El código de la clase BuscarParentesco.java:
|
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 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
/* * BuscarParentesco */ package ajpdsoftbuscarparentesco; /** * * @author www.proyectoa.com */ public class BuscarParentesco { private String nombreCompleto1; private String nombreCompleto2; //Constructor vacío public BuscarParentesco () { } public BuscarParentesco (String nombre1, String nombre2) { this.nombreCompleto1 = nombre1; this.nombreCompleto2 = nombre2; } //Setters public void setNombreCompleto1 (String nombreCompleto) { this.nombreCompleto1 = nombreCompleto; } public void setNombreCompleto2 (String nombreCompleto) { this.nombreCompleto2 = nombreCompleto; } //Getters public String getNombreCompleto1() { return nombreCompleto1; } public String getNombreCompleto2() { return nombreCompleto2; } public String getGradoParentesco () { Persona persona1 = new Persona(nombreCompleto1); Persona persona2 = new Persona(nombreCompleto2); persona1.separarNombre(); persona2.separarNombre(); // Comprobamos grado de parentesco // Si los dos apellidos son iguales y el nombre es diferente podrían // ser hermanos o primos if (!persona1.getNombre().equalsIgnoreCase(persona2.getNombre()) & persona1.getApellido1().equalsIgnoreCase(persona2.getApellido1()) & persona1.getApellido2().equalsIgnoreCase(persona2.getApellido2())) { return "Hermanos o primos hermanos"; } else { //Si los nombres son iguales incluidos los apellidos podrían ser primos if (persona1.getNombre().equalsIgnoreCase(persona2.getNombre()) & persona1.getApellido1().equalsIgnoreCase(persona2.getApellido1()) & persona1.getApellido2().equalsIgnoreCase(persona2.getApellido2())) { return "Primos"; } else { //si el primer apellido es igual podrían ser primos hermanos if (persona1.getApellido1().equalsIgnoreCase(persona2.getApellido1())) { return "Primos hermanos"; } else { // Si el primer apellido es igual al segundo del otro // podrían ser primos segundos if (persona1.getApellido1().equalsIgnoreCase(persona2.getApellido2()) || persona1.getApellido2().equalsIgnoreCase(persona2.getApellido1()) || persona1.getApellido2().equalsIgnoreCase(persona2.getApellido2())) { return "Primos segundos"; } } } } return "Desconocidos"; } } |
En esta clase, en el método constructor pasamos como parámetro los valores de los atributos del nombre completo de dos personas:
- public BuscarParentesco (String nombre1, String nombre2)
Establecemos los métodos accesores (setters y getters) correspondientes para modificar o bien obtener el valor de los dos nombres completos.
Y por último definimos un método para buscar el parentesco de dos personas, donde referenciamos e instanciamos la clase Persona y la usamos para separar el nombre completo en nombre, apellido primero y apellido segundo:
- public String getGradoParentesco ()
Instanciar y referenciar las clases y probar la aplicación Java para el cálculo de parentesco
Para probar las clases persona y BuscarParentesco, desde la clase main principal de la aplicación, añadiremos el siguiente código al fichero AjpdSoftBuscarParentesco.java:
El código fuente completo del fichero AjpdSoftBuscarParentesco.java:
|
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 57 58 59 60 61 62 63 64 65 66 67 |
/* * AjpdSoftBuscarParentescoJava * Calcula el posible parentesco entre dos personas * Versión 1.0 * www.proyectoa.com */ package ajpdsoftbuscarparentesco; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * * @author www.proyectoa.com */ public class AjpdSoftBuscarParentesco { /** * @param args the command line arguments */ public static void main(String[] args) { String nombreCompleto1; String nombreCompleto2; try { BufferedReader entradaTeclado = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Nombre de la 1ª persona (nombre y apellidos): "); nombreCompleto1 = entradaTeclado.readLine(); System.out.print("Nombre de la 2ª persona (nombre y apellidos): "); nombreCompleto2 = entradaTeclado.readLine(); //comprobamos que se hayan introducido los dos nombres if (nombreCompleto1.trim().equalsIgnoreCase("") || nombreCompleto2.trim().equalsIgnoreCase("")) System.out.println("Falta algún nombre por introducir"); else { //comprobamos que haya al menos un espacio en el nombre if (nombreCompleto1.trim().indexOf(" ") <= 0 || nombreCompleto2.trim().indexOf(" ") <= 0) { System.out.println("No ha introducido el nombre completo"); } else { //instanciamos la clase para obtener el posible parestesco BuscarParentesco buscarParentesco = new BuscarParentesco(nombreCompleto1, nombreCompleto2); System.out.println("Posible parentesco: " + buscarParentesco.getGradoParentesco()); } } } catch (IOException e) { System.out.println("Error al introducir datos: " + e.getMessage()); } } } |
En el código anterior, básicamente, solicitamos al usuario la introducción de dos nombres completos, hacemos algunas comprobaciones (que lleven algún espacio y que tenga valor) y por último instanciamos la clase BuscarParentesco para usarla y mostrar el posible parentesco de dos personas según su nombre, apellido primero y apellido segundo.
Para probar la aplicación la compilaremos pulsando el el botón de «Ejecutar Project» o pulsando F6, la aplicación nos solicitará la introducción de dos nombres completos y devolverá su posible parentesco por pantalla:
Código fuente gratuito de aplicación de ejemplo AjpdSoft Buscar Parentesco en Java
A continuación indicamos la descarga gratuita del código fuente completo en Java de la aplicación AjpdSoft Buscar Parentesco con Java, aplicación de ejemplo de este tutorial:
