Un método abstracto es un método que ha sido declarado pero que no ha sido implementado, en otras palabras el método no contiene código funcional. Una declaración de método abstracto no tiene las llaves de apertura y de cerradura { } en su lugar tiene un punto y comas ; en otras palabras no tiene un cuerpo, nosotros marcamos los métodos como abstractos para forzar a las subclases la implementación de dicho método. Por ejemplo si tenemos la siguiente clase abstracta:
public abstract class Vehiculo{
public abstract void frenar();
public abstract int kilometraje();
}
entonces las clases que extienden la clase anterior y que no sean abstractas deben dar una implementación a cada uno de los métodos abstractos:
public class Bicicleta extends Vehiculo{
public void frenar(){
-- Aqui la implementación del método frenar.
}
public int kilometraje(){
-- Aqui la implementación del método kilometraje.
}
}
Ojo, no podemos declarar un método abstracto en una clase que no es declarada tambien abstracta, por ejemplo lo siguiente es incorrecto:
-- Esta clase no es abstracta, es concreta.
public class Vehiculo{
-- La clase no es abstracta no tiene el modificador abstract
-- entonces un método abstracto es ilegal aquí.
public abstract void frenar();
}
Veamos otro ejemplo, si tenemos una clase abstracta como:
public abstract class Vehiculo{
public abstract void frenar(String tipoFreno, int tipoVehiculo);
}
y extendemos la clase de la siguiente manera:
public class Omnibus extends Vehiculo{
public void frenar(int tipoFreno, int tipoVehiculo){
-- Aqui la implementación del frenado.
}
}
Ahora, ¿la clase Omnibus extiende e implementa correctamente la clase abstracta Vehiculo?
No, claro que no, porque la clase Omnibus está sobrecargando(overloading) el método frenar no lo sobreescribe(overriding), por lo que la implementación en la subclase(Omnibus) es incorrecta, esto se puede ver porque el argumento en la clase Vehiculo es de tipo String y en la clase Omnibus de tipo int, para que el método abstracto pueda ser implementado correctamente en las subclases, estas deben de corresponder sus tipos de datos con los tipos de datos del método abstracto.
La siguiente clase implementa correctamente la clase abstracta, mira la diferencia con la anterior clase Omnibus:
public class Omnibus extends Vehiculo{
public void frenar(String tipoFreno, int tipoVehiculo){
-- Aqui la implementación del frenado.
}
}
Métodos sincronizados
La palabra clave synchronized indica que un método puede ser accedido solo por un hilo a la vez(saca tus libros de sistemas operativos para recordar que es un hilo), recuerda tambien que la palabra clave synchronized solo puede ser aplicada a métodos y solo a métodos no a variables, ni clases, una declaración típica de un método sincronizado es:
public synchronized long getSaldoDisponible(){
-- Implementación del método sincronizado
}
Métodos nativos
El modificador native indica que un método es implementado con código dependiente del sistema operativo, frecuentemente este código es 'C ' , la palabra clave native solo puede ser aplicado a métodos, no a variables o clases, y como los métodos abstractos no tiene un cuerpo por lo que finalizan con un punto y coma ;
Métodos con una lista de argumentos variable
Desde java5, nosotros podemos crear métodos que permiten tomar un número variable de argumentos, por ejemplo:
public class ClaseSimple{
public int sumar(int... operandos){
int suma = 0;
for(int operando:operandos)
suma = suma + operando;
return suma;
}
public void testSuma(){
-- Aqui podemos observar que la cantidad de
--argumentos para el método puede ser variable
int s0 = sumar();
int s1 = sumar(1,2,3);
int s2 = sumar(1,2,3,4,5);
int s3 = sumar(1,2);
int s4 = sumar(1,2,3,4,5,6,7,8,9);
}
}
Algunas declaraciones legales de métodos con cantidad de argumentos variable:
-- Espera primero un caracter, después cero o más caracteres
private void haceAlgo(char c, char... d){}
-- Espera primero un caracter, después cero o más enteros
private void haceAlgo(char c, int... d){}
-- Espera cero o más instancias de la clase ClaseX
private void haceAlgo(ClaseX... d){}
Algunas declaraciones ilegales de métodos con cantidad de argumentos variable:
-- Sintaxis incorrecta
private void haceAlgo(char d...){}
-- Solo podemos tener un argumento que sea variable
private void haceAlgo(char... d,char... d){}
-- El argumento variable debe de estar al final
private void haceAlgo(char... d,double x){}
