PDF de programación - Java Clases Abstractas

CLASES ABSTRACTAS

En el mundo real estamos rodeados de conceptos, algunos de estos los podemos
asociar con objetos tangibles como una silla o un ratón, y objetos intangibles como una
empresa o una profesión, pero hay muchos otros conceptos que referencian a objetos
abstractos y que solo nos sirven como eso, como concepto, no especifican ningun objeto en
particular, sino al contrario agrupan a muchos objetos que comparter ciertas caracteristicas y
comportamientos, como por ejemplo el concepto "animal", si tratamos de graficarlo,
dibujamos un gato, un perro, pero no podemos dibujar un animal como tal, ya que este es
solo un concepto abstracto, que agrupa a un conjunto de objetos que estan dentro de esa
clasificación. La forma de representar ese objeto abstracto en la POO es a través de las
clases abstractas.

Una clase abstracta es una clase que solo se utiliza para generar clases hijas, por lo

que no puede instanciar objetos. En este tipo de clases tiene las siguientes caracteristicas:

Comienzan con la palabra reservada abstract
Se pueden implementar atributos de la misma forma que una clase normal
Se pueden implementar métodos (normales y/o abstractos)
No se puede instanciar
No se define un constructor (por lo mismo del punto anterior)

Los métodos abstactos son aquellos que solo se declaran, y no se define el cuerpo de
estos, delegando esa tarea a las clases hijas. Estos al igual que las clases abstactas se
reconocen por la palabla reservada abstract.

Si una clase tiene al menos un método abstracto debe ser declarada como abtracta,

ya que no provee la implementación para este.

Ejemplo:

El departamento de remunaraciones desea implementar una aplicación para calcular
el sualdo de los empleados, clasificandose estos en 2 tipos: a Honorarios, y con Contrato,
ambos comparten los mismos datos base, pero se diferencian en el calculo del sueldo.

Por las características del problema planteado, se puede declarar una clase, que
reuna las características comunes de los empleados (clase Empleado), pero debido a que el
método de calculo de sueldo es diferente para los distintos tipos de empleado, este debe ser
abstracto para que cada clase hija lo implemente de acuerdo a sus necesidades, por lo tanto
la clase también debe ser declarada como abstracta.

-
-
-
-
-
Declaración de la clase abstacta:

public abstract class Empleado {
    private String nombre;
    private int sueldoBase;

// Clase Abstacta

    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public int getSueldoBase() {
        return sueldoBase;
    }
    public void setSueldoBase(int sueldo) {
        this.sueldoBase = sueldo;
    }    
    public abstract int calcSueldo();   // Método abstracto    
}

Declaración de las clases hijas (Honorarios y Contrato):

public class Contrato extends Empleado{
    
    public Contrato(){}

    @Override
    public int calcSueldo() {
        int sb, desc, afp, salud, liquido;
        
        sb = this.getSueldoBase();
        afp = (int)(sb * 0.13);     // 13% prevision (AFP)
        salud = (int)(sb * 0.07);   // 7% Salud (Fonasa)
        desc = afp + salud;
        liquido = sb ­ desc;
        return liquido;        
    }    
}

public class Honorario extends Empleado{
    
    public Honorario(){}

    @Override
    public int calcSueldo() {
        int sb, desc, liquido;
        sb = this.getSueldoBase();
        desc = (int)(sb * 0.1);     // Descuenta 10% provisional
        liquido = sb ­ desc;
        return liquido;
    }
     
}

Ejemplo de implementación del main():

public class EjemAbstracta {
    public static void main(String[] args) {
        int aPagar;
        
        Honorario emp_1 = new Honorario();
        Contrato emp_2 = new Contrato();
        
        emp_1.setSueldoBase(120000);
        aPagar = emp_1.calcSueldo();
        System.out.println("Empleado a Honorarios: "+aPagar);
        
        emp_2.setSueldoBase(120000);
        aPagar = emp_2.calcSueldo();
        System.out.println("Empleado con Contrato: "+aPagar);        
    }
}

Si bien ambos trabajadores tiene el mismo sueldo base, por la naturaleza del

empleado, obtienen un sueldo liquido distinto.

INTERFACES

Se puede decir que una interfaz, al igual que una clase o una clase abstracta, define
un tipo de dato, con la diferencia que en la interefaz no se pueden declarar variables de
instancia o de clase (atributos), ni tampoco se pueden implementar métodos. Las interfaces
tiene las siguientes caracteristicas:

– Permite declarar métodos (ojo, solo declararlos)
– Permite declarar constantes (static final)
– Permiten heredar (extends) de otras interfaces
– Una clase puede implementar varias interfaces

Cuando una clase implementa cierta interfaz, debe proporcionar el código para cada
uno de los métodos declarados en la interfaz, lo cual garantiza que la clase tendrá
determinados métodos, con los cuales las demás clases podrán interactuar, independiente
de como se implementen, ya que tendrán los mismos parámetros de entrada y la misma
salida.

Las interfaces son útiles cuando objetos de distintas clases, para ciertas situaciones,
operan de la mima forma. Por ejemplo ditintos aparatos electrónicos, si bien realizan ditintas
tareas, comparten la acción de encerderse y apagarse. Hay que tener en cuenta que se está
hablando de clases que no comparten la misma clase padre, por lo que no podriamos
heredar estos comportamiento comunes, como por ejemplo un tostador eléctrico (clase
Electrodomesticos) es encendible, al igual que un automovil (de la clase Vehiculo).

Ejemplo:

Se creará la interfaz "Encedible", que luego será implementada por 2 clases
totalmente ditintas, pero que comparten las acciones de "encender" y "apagar", además se
declaran 2 constantes para indicar el estado de "Encendido" o "Apagado":

public interface Encendible {
    // Constantes
    public static final char ENCENDIDO = 1;
    public static final char APAGADO = 0;

    // Metodos
    public String Encender();
    public void Apagar();
}

Ahora se implementa la interfaz en la clase "Linterna"

public class Linterna implements Encendible {
    private int pilas;
    private int estado;

    public Ampolleta(int numero) {
        this.pilas = numero;
        this.estado = APAGADO;
    }
    
    @Override
    public String Encender() {        
        this.estado = ENCENDIDO;
        return("Se hizo la luz!!!");
    }

// Constante de la interfaz

// Constante de la interfaz

    @Override
    public void Apagar() {        
        this.estado = APAGADO;
    }

// Constante de la interfaz        

    // Implementación de los demás metodos de la clase
}

public class Tostador implements Encendible {
    private int pilas;
    private int estado;

    public Tostador() {
        this.estado = APAGADO;
    }
    
    @Override
    public String Encender() {        
        this.estado = ENCENDIDO;
        return("Al rico pan tostado!!!");
    }

// Constante de la interfaz

// Constante de la interfaz

    @Override
    public void Apagar() {        
        this.estado = APAGADO;
    }

// Constante de la interfaz        

    // Implementación de los demás metodos de la clase
}

(nota: es un tostador eléctrico)

Implementación de la clase persona, la cual utilizara las interfaces de los objetos de

ambas clases para interactuar con ellos:

public class Persona{
    public Persona() {}
    
    public void EncenderAparato(Endendible e){
        System.out.print(e.Encender())
    }
}

// Metodo de la interfaz

Implementación del metodo main(), donde interactua el objeto de la clase "Persona"

con los objetos de las clases "Linterna" y "Tostador", a través de su interfaz en común:

public class EjemploInterface {
    public static void main(String[] args) {
        Linterna linterna1 = new Linterna(4);
        Tostador tostador1 = new Tostador();
        Persona juanPerez = new Persona();

        // Se ha costado la luz y Juan Perez procede a encender la linterna

  juanPerez.EncenderAparato(linterna1);

        // Juan Perez procede a prepararse desayuno con unas tostadas
        juanPerez.EncenderAparato(tostador1);
    }
}

TIPO DE DATOS ENUMERADOS

Los tipos enumerados sirven para restringir el contenido de una variable a una serie
de valores predefinidos. Esto suele ayudar a reducir los errores en nuestro código. Estos
valores predefinidos son el equivalente a las contantes, solo que agrupadas bajo un
concepto en común, evitando así, tener que definir muchas constantes por separado.

En Java, los tipos enumerados se pueden definir fuera o dentro de una clase, pero no
dentro de un método. Otra ventaja que traen los tipos enum de Java, es que al ser una
“especie de clase” podemos añadirles métodos, variables de instancia, constructores, etc…
lo que los hace muy potentes. Al igual que una clase normal, no se puede invocar el
contructor directamente, sino que a través de la creación de la instancia. Tambien se puede
utilizar la sobrecarga de contructores.

A continuación les dejo un pequeño ejemplo que ilustra todos estos conceptos.

package ejemploenum;

public class EjemploEnum {
    // Tipo enumerado simple
    enum dias{lunes, martes, miercoles, jueves, viernes, sabado, domingo}
    
    // Tipo enumerado complejo
    enum meses{
        enero(31), febrero(28),marzo(31),abril(30),mayo(31),junio(30),
        julio(31),agosto(31),septiembre(30),octubre(31),noviembre(30),
        diciembre(31);
        
        private int d;
        
        meses (int d){
            this.d = d;
        }
        
        public int diasxmes(){
            return this.d;
        }