CLASES ABSTRACTAS
* Este post informativo les dejo aqui teoria al que le pueda servir, se trata de teoremas de lcases de usos sobre la programación, es una base para aprender a programar en java, masadelante les voi pasando ams información y tutoriales, es la carrera que estoy siguiendo en analista de sistemas y las fuentes son 100 % confiables provistas por nuestra propia web xmlstudio.com.ar
Clases Abstractas
La idea de las clases abstractas es tener una clase genérica con atributos y métodos que serán compartidos por todas las subclases que hereden de esta clase genérica.
Para definir una clase como abstracta se debe utilizar el calificador de clase “abstract”. Lo que se debe tener en cuenta para este tipo de clase es que si se pueden generar variables de estas clases pero “no se pueden generar objetos, es decir, no pueden ser instancias”. Las instancias se realizan con las subclases siempre que estas no sean también abstractas, y al igual que en la herencia común se pueden declara directamente y crear objetos con las subclases.
Cuerpo de la clase:
abstract class <nomb_clase> {
/**************************
Desarrollo de la clase
**************************/
}
Ej.:
import java.lang.*;
abstract class Cuadrupedos{
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
abstract void quienSoy();
}
class Perro extends Cuadrupedos{
String raza;
public Perro (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un perro: " + raza);
}
}
public class EjMetodoAbstracta{
public static void main (String args[]){
Perro b= new Perro ("Bruno", "Perro", "Dogo";
b.quienSoy();
Cuadrupedos a= new Perro ("Catalina", "Perro", "Batata"; //Polimorfismo
a.quienSoy();
}
}
Mostrara por pantalla
Soy un perro: Dogo
Soy un perro: Batata
Si en el programa principal se hubiera intentado crear un objeto de la clase cuadrúpedo se hubiera producido un error de compilación por ser abstracta. No se pueden crear objetos de clases abstractas
Ej.:
public class EjAbstracta{
public static void main (String args[]){
Cuadrupedos a= new Cuadrupedos (“Catalina”, “Perro”); //error de compilación
}
}
Métodos abstractos
La idea de los métodos abstractos es tener métodos que sean comunes a las subclases que se hereden de la clase abstracta, con la finalidad que en la subclase se obligue a desarrollar los métodos abstractos heredados para cada subclase en particular.
Se debe tener en cuenta las siguientes condiciones:
- Cuando una clase contiene un método abstracto dicha clase se considera abstracta por lo tanto debe calificarse como tal, sino se produce un error de compilación.
- En caso de que una clase herede de una clase abstracta y no implemente los métodos abstractos dicha clase también será abstracta.
- En caso de declara una variable de una clase abstracta y asignarle un objeto de una subclase (concreta, no abstracta) y la subclase posea métodos no heredados sino declarados dentro de ella, es decir que no están en la clase abstracta sino en la subclase, y se desea activar estos métodos que no se encuentran en la clase abstracta se producirá un error de compilación.
- No es obligatorio que los métodos de la clase abstracta sean abstractos, es decir puede existir clases abstractas sin métodos abstractos, por lo tanto las clases que hereden de ella serán concretas a menos que se las califique como abstracta.
Cuerpo del método.
abstract <valor_devuelto> <nomb_metodo> ( );
Ej.:
import java.lang.*;
abstract class Cuadrupedos{
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
abstract void quienSoy();
}
class Perro extends Cuadrupedos{
String raza;
public Perro (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un perro: " + raza);
}
}
class Gato extends Cuadrupedos{
String raza;
public Gato (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un gato: " + raza);
}
}
public class EjMetodoAbstracta{
public static void main (String args[]){
Cuadrupedos a= new Perro ("Catalina", "Perro", "Batata";
a.quienSoy(); // error de compilación
Cuadrupedos b= new Gato ("Marcelo", "Gato", "Siames";
b.quienSoy(); // error de compilación
}
}
Mostrara por pantalla
Soy un perro: Batata
Soy un gato: Siames
Si la clase Cuadrúpedo no hubiera sido declarada como abstracta se hubiera producido un error de compilación, por que dicha clase posee un método abstracto y por ende se considera abstracta la clase.
Ej.:
class Cuadrupedos{ // Error de compilation
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
abstract void quienSoy();
}
A continuación se da un ejemplo de una subclase que hereda de una clase abstracta y no implementa los métodos abstractos, por lo tanto sigue siendo abstracta.
Ej.:
La subclase sigue siendo abstracta por que no se implemento el método abstracto heredado.
abstract class Animales {
abstract void tipoAnimal ();
}
abstract class Cuadrupedos extends Animales{
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
}
La subclase sigue siendo abstracta por que no se implemento el método abstracto heredado. Por lo tanto da un error de compilación sino se coloca la palabra abstrac en la subclase.
abstract class Animales {
abstract void tipoAnimal ();
}
class Cuadrupedos extends Animales{ // Error de compilación
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
}
A continuación se da un ejemplo de una clase abstracta que no posee métodos abstractos.
Ej.:
import java.lang.*;
abstract class Cuadrupedos{
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
void quienSoy(){
System.out.println("Soy lo que soy, y que!!";
}
}
class Perro extends Cuadrupedos{
String raza;
public Perro (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un perro: " + raza);
}
}
class Gato extends Cuadrupedos{
String raza;
public Gato (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un gato: " + raza);
}
}
public class EjMetodoAbstracta{
public static void main (String args[]){
Cuadrupedos a= new Perro ("Catalina", "Perro", "Batata";
a.quienSoy();
Cuadrupedos b= new Gato ("Marcelo", "Gato", "Siames";
b.quienSoy();
}
}
Muestra por pantalla
Soy un perro: Batata
Soy un gato: Siames
A continuación se da un ejemplo de querer activar un método que no se encuentra en la clase abstracta y por lo tanto se produce un error de compilación, debido a que el tipo de variable declarada es de la clase abstracta pero el objeto de instanciado es de la subclase.
Ej.:
import java.lang.*;
abstract class Cuadrupedos{
String nombre;
String distincion;
public Cuadrupedos (String pnombre, String pdistincion){
nombre = pnombre;
distincion= pdistincion;
}
}
class Perro extends Cuadrupedos{
String raza;
public Perro (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un perro: " + raza);
}
}
class Gato extends Cuadrupedos{
String raza;
public Gato (String pnombre, String pdistincion, String praza){
super (pnombre, pdistincion);
raza=praza;
}
public void quienSoy (){
System.out.println ("Soy un gato: " + raza);
}
}
public class EjMetodoAbstracta{
public static void main (String args[]){
Cuadrupedos a= new Perro ("Catalina", "Perro", "Batata";
a.quienSoy(); // error de compilación
Cuadrupedos b= new Gato ("Marcelo", "Gato", "Siames";
b.quienSoy(); // error de compilación
}
}
Clases Final
Atributo final:
Un atributo final no pueda modificar su valor. Entonces no se trata de una variable, sino de una constante. El valor de un atributo final debe ser asignado en la declaración del mismo. Cualquier intento de modificar su valor generará el consiguiente error por parte del compilador.
Formato:
<modificador_acceso> final <tipo_dato> <nomb_atributo>= <valor_asignar>;
Ej.:
import java.lang.*;
class Circulo {
final double pi=3.14;
int radio;
Circulo(int pradio) {
radio=pradio;
}
public double area() {
return pi*radio*radio;
}
}
class EjAtributoFinal {
public static void main(String argumentos[]) {
Circulo c = new Circulo(15);
System.out.println(c.area());
}
}
Muestra por pantalla:
706.85
Supongamos que queremos modificar el valor de un atributo tipo final luego de la inicialización se producirá un error de compilación, por que una vez inicializado el atributo este no puede ser modificado.
Ej.:
import java.lang.*;
class Circulo {
final double PI=3.14159265;
int radio;
Circulo(int pradio) {
radio=pradio;
}
public double area() {
return PI*radio*radio;
}
}
class EjAtributoFinal {
public static void main(String argumentos[]) {
Circulo c = new Circulo(15);
System.out.println(c.area());
c.PI = 15.47; // Error de compilación trato de modificar el valor de un atributo tipo final.
System.out.println(c.area());
}
}
Método final:
Un Método final no puede ser redefinido por ningún descendiente de la clase. A diferencia del modificador abstract, pueden existir en la clase métodos final sin que la clase que los contiene sea final (sólo se protegen algunos métodos de la clase que no pueden ser redefinidos).
Declarar un método final supone que la clase se ejecute con mayor eficiencia porque el compilador puede colocar el código en bytes del método directamente en el lugar del programa donde se invoque a dicho método, ya que se garantiza que el método no va a cambiar.
final <tipovalor_deregreso> <nomb_metodo> ( <lista_ parámetros>{
/******************************
Desarrollo del método
******************************/
}
Ej.1:
import java.lang.*;
class Circulo {
final double PI=3.14159265;
int radio;
Circulo(int pradio) {
radio=pradio;
}
public final double area() {
return PI*radio*radio;
}
}
class EjMetodoFinal {
public static void main(String argumentos[]) {
Circulo c = new Circulo(15);
System.out.println(c.area());
}
}
Muestra por pantalla:
706.85
En el siguiente programa se producirá un error de compilación debido a que se redefine el método área el cual al ser calificado como final no puede cambiar en aquellas clases que lo hereden.
Ej.2:
import java.lang.*;
class Circulo {
final double PI=3.14159265;
int radio = 15;
public final double area() {
return PI*radio*radio;
}
}
class Circulo2 extends Circulo{
public final double area() { // error de compilación se modifica un método final de la superclase
return radio*radio;
}
}
public class EjMetodoFinal {
public static void main(String argumentos[]) {
Circulo2 c = new Circulo2();
System.out.println(c.area());
}
}
Clases Final:
Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por lo tanto una clase no puede ser final y abstracta a la vez, ya que abstracta requiere descendiente como se explico antes. Si puede ser public abstract o public final. Además se debe tener en cuenta que una clase final hace que sus métodos se conviertan automáticamente a final.
Formato:
final class <nomb_clase> {
/*************************
Desarrollo de la clase
*************************/
}
Ej1.:
import java.lang.*;
class Padre {
String variablePadre;
void metodo() {
variablePadre = "Padre";
System.out.println(variablePadre);
}
}
final class Hija extends Padre {
String variableHija;
void metodo() {
variableHija = "Hija";
super.metodo();
System.out.println(variableHija);
}
}
public class Principal{
public static void main(String argumentos[]) {
Hija var = new Hija ();
var. metodo ();
}
}
Muestra por pantalla:
Padre
Hija
Ej2.:
El siguiente programa produce un error de compilación por que se trata de heredar de una clase final.
import java.lang.*;
class Padre {
String variablePadre;
void metodo() {
variablePadre = "Padre";
System.out.println(variablePadre);
}
}
final class Hija extends Padre {
String variableHija;
void metodo() {
variableHija = "Hija";
super.metodo();
System.out.println(variableHija);
}
}
class Hermano extends Hija { // error de compilación se hereda de una clase final
String variableHermano;
void metodoHermano() {
variableHermano = "Hermano";
System.out.println("Soy el: " + variableHermano);
}
}
public class Principal{
public static void main(String argumentos[]) {
Hija var = new Hija ();
var. metodo ();
}
}