Si bien en el Programando en Java anterior dije que iba a enseñar polimorfismo, lo pensé mejor y creo que no es hora de aprender un tema tan complicado desde el inicio, por lo tanto voy a enseñar lo básico de herencia, terminar de dar vectores y mejorar un poco el entendimiento de cómo se deben hacer los métodos dentro de las clases.
Si bien este último tema es algo que ya queda como obvio, la idea es mejorar y repasar; además daré algunas referencias para hacer algunas cosas automáticas para que se escriba el código solo.
Comenzamos:
La herencia de clases es un procedimiento en el cual se tiene una clase y se le suman todos los métodos y atributos (algunos) a la clase que hereda.
O sea, se le dice a la clase hija que hereda de la clase padre, esto hace que a clase hija pueda acceder y usar como propio todos los elementos descritos en la clase padre como si fueran propios.
Respecto de los atributos, la visibilidad de los mismos dependerá de si la clase hija los pueda usar o no, o sea, hay tres clases básicas de visibilidades: public, private y protected.
La visibilidad public genera que todo aquello que escriba en la clase pueda ser visto fuera de esta y usado como tal. Generalmente por una cuestión metodológica en Java los atributos pueden ser privados y protegidos, pero no públicos. Esto se debe a una cuestión de seguridad dentro del programa .
En otros lenguajes, como por ejemplo Python, no tienen estas clases de visibilidades, haciendo mas sencilla la realización de un programa y que para cuestiones de seguridad hace comprobaciones tras comprobaciones.
Un ejemplo donde nos salimos de lo ortodoxo para demostrar como es que funciona la visibilidad pública es el siguiente:
<?
/**
*
* @author Lelale
*/
public class Clase_Prueba_Visibilidad { // Fíjense que las dos variables son públicas y que no hago ningún método para que capture algún dato o lo devuelva.
public String algo;
public String otro_algo;
}
>
<?
/**
*
* @author Lelale
*/
public class elMain {
public static void main(String[] args) {
Clase_Prueba_Visibilidad cl = new Clase_Prueba_Visibilidad();
cl.algo = "Hola mundo"; // Como verán, puedo asignar un valor sin llamar a algún método, lo que hago es accesar a la variable directamente por que es pública.
cl.otro_algo = "Chau mundo";
System.out.println(cl.algo); // Y devuelvo el valor de dicha variable tal como fue asignada.
System.out.println(cl.otro_algo);
}
>
En el caso de private, eso que ven en el ejemplo no podrían poder hacerlo, si escriben la variable les daría error por que no se puede accesar de afuera.
En el caso de herencia, si una variable o método está descrito como protected, desde afuera tampoco podrá accesarse, pero la diferencia con private es que si una clase hija hereda de una clase padre un atributo o método puesto en protected, ésta podrá accederla como si fuera suya. Es como si la clase hija suma todo lo que pueda de la clase padre.
En el siguiente ejemplo veremos cómo una clase hereda de la otra.
Para ese ejemplo utilizaré con algunos cambios que verán, la clase Persona de Programando en Java 3.
<?
*
* @author Lelale
*/
public class Persona {
protected String nombre; // Noten la diferencia: Les puse protected a todas las variables.
protected String apellido;
protected String direccion;
protected long id; //Esta es un atributo de prueba para que vean como se pueden ver algunas cosas.
public void setNombre(String elNombre){
nombre = elNombre;
}
public void setApellido(String elApellido){
apellido = elApellido;
}
public void setDireccion(String laDireccion){
direccion = laDireccion;
}
public String getNombre(){
return nombre;
}
public String getApellido(){
return apellido;
}
public String getDireccion(){
return direccion;
}
}
>
<?
/**
*
* @author Lelale
*/
public class Trabajador extends Persona{
private String legajo;
private String departamento;
private String cargo;
private int num_interno;
//Aclaración previa: this.cualquier_cosa el "this" significa que se refiere a la clase actual, o sea, si es this solo es que estás usando todo lo que contiene la clase.
//Si es this. algo, estás accesando a algo que está en la misma clase. No es la misma varialbe this.nombre a nombre a secas.
//Si se fijan bien, no les hará error de sintaxis o atributo repetido por que al poner this delante no lo están declarando, sino que están poniéndo una referencia a cual de las cosas se quieren fijar.
public void setId(long id){
this.id = id; //Acá se ve cómo pueden ver la variable id que no fue declarada en Trabajador, pero que se puede usar acá gracias a que la declaré en la clase padre que es Persona.
}
public void setCargo(String cargo) {
this.cargo = cargo;
}
public void setDepartamento(String departamento) {
this.departamento = departamento;
}
public void setLegajo(String legajo) {
this.legajo = legajo;
}
public void setNum_interno(int num_interno) {
this.num_interno = num_interno;
}
public String getCargo() {
return cargo;
}
public String getDepartamento() {
return departamento;
}
public String getLegajo() {
return legajo;
}
public int getNum_interno() {
return num_interno;
}
}
>
En síntesis, si yo hago una instancia de la clase Trabajador (Trabajador trab = new Trabajador()
ocupo todos los atributos de la clase Persona y todos sus métodos, además de los atributos y métodos propios de la clase trabajador.
Terminado este tema, pasaré a lo que faltó de dar en vectores: Matrices.
Una matriz es como una tabla de excel, o sea, tengo columnas y filas. Pero en síntesis es un conjunto de vectores puestos uno sobre otro como si lo estuviera dibujando en una hoja de cálculo.
Para saber como está funcionando, imagínense un tablero del juego batalla naval, cuando quiero tirar un tiro a un casillero específico digo la latitud y longitud del tablero, o sea, canto el número de columna y la letra de las filas.
"A5" "Agua", "B6" "Bomba".
La matriz funciona igual y permite hacer más versátil muchas cosas (incluso se pueden hacer matrices de objetos).
<?
/**
*
* @author Lelale
*/
public class elMain {
public static void main(String[] args) {
int[][] matriz = new int[2][3]; //Como verán esta es una matriz de dos dimenciones, donde las columnas serán de 2 espacios y las filas de 3. En total habrá un espacio de 6 celdas.
matriz[0][0] = 1;
matriz[1][0] = 2;
matriz[0][1] = 3;
matriz[1][1] = 4;
matriz[0][2] = 5;
matriz[1][2] = 6;
}
}
>
<?
/**
*
* @author Lelale
*/
public class elMain {
public static void main(String[] args) {
int[][][] matriz = new int[2][3][5]; //Si bien esta es una forma que no creo que usen en su vida, la matriz puede ser hecha de multiples dimenciones, en este caso es un... "cubo" medio rectangular, donde tenemos columnas de 2, tres filas y 5 espacios en el eje z.
matriz[0][0][0] = 1;
matriz[1][0][0] = 2;
matriz[0][1][4] = 3;
matriz[1][1][3] = 4;
matriz[0][2][2] = 5;
matriz[1][2][1] = 6; //A medida que vamos agregando dimensiones, la capacidad de guardar lugares es mayor, pero la dificultad de manejarlos también crece.
}
}
>
Por último vamos a dar algo que es para que mejores un poco en la velocidad al momento de crear métodos para capturar datos y devolverlos.
Una vez que crearon la clase sin nada crean los atributos como se muestran en el ejemplo:
<?
/**
*
* @author Lelale
*/
public class Trabajador extends Persona{
private String legajo;
private String departamento;
private String cargo;
private int num_interno;
}
>
Ponen el cursor al final de todo y marcan con el clik derecho en la pantalla donde se escribe el código; en NetBeans aparece una pequeña opción donde tienen que marcar "Insert Code..." y luego marcar en el menú que les aparece Setter... luego una ventana se les abrirá y podrán marcar las variables que quieran que les capture algún dato.
Luego hacen lo mismo y en vez de poner Setter (si les aparece, no aparece cuando todas las variables tienen algún método setXxx()) ponen Getter. Marcan todas las variables que quieran para devolver datos y básicamente tienen toda una clase armada lista para ser usada.
En el caso de Eclipse, para lograr lo mismo tienen que marcar con click derecho el lugar donde van a comenzar a escribir el código para capturar y devolver datos y luego tienen que marcar en las opciones descendentes Source/Generate Getters and Setters . Ésto les abrirá una ventana donde podrán insertar cuales son los atributos que quieran generar para que se capturen datos de entrada y de salida.
En síntesis tiene que quedar en los dos IDEs así:
<?
/**
*
* @author Lelale
*/
public class Trabajador extends Persona{
private String legajo;
private String departamento;
private String cargo;
private int num_interno;
public void setCargo(String cargo) {
this.cargo = cargo;
}
public void setDepartamento(String departamento) {
this.departamento = departamento;
}
public void setLegajo(String legajo) {
this.legajo = legajo;
}
public void setNum_interno(int num_interno) {
this.num_interno = num_interno;
}
public String getCargo() {
return cargo;
}
public String getDepartamento() {
return departamento;
}
public String getLegajo() {
return legajo;
}
public int getNum_interno() {
return num_interno;
}
}
>
En el siguiente programando en Java vamos ahí si a ver algunas cosas más de herencia, polimorfismo, y si hay tiempo, constructores.