Herencia

APARTADOS

Herencia
Control de acceso

Herencia

La herencia permite la creación de nuevas clases definidas en términos de clases ya existentes. Si disponemos de la clase cPunto, se podrá definir la clase cCírculo en base a la clase cPunto.

La palabra reservada "extends" se usa para definir una subclase (especialización). Se dice que la subclase hereda o deriva de la superclase sobre la cual se ha definido.

La subclase heredará propiedades y métodos de la superclase.

En Java una clase solamente podrá tener una superclase (por tanto no admite herencia múltiple)

A continuación se va a ver un ejemplo muy sencillo de herencia:

//*************************************cEmpleado.java*******************************************

//NOTA IMPORTANTE: Para resumir el código no se ha incluido el bloque de código de las clases "cPersona" y "cEntrada"

//Decripción: Implementación de la clase cEmpleado, la cual realiza una herencia de la clase cPersona
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com
import java.io.*; //Para poder recuperar datos de la "entrada" estándar habrá que importar el paquete "io"

//AQUÍ VENDRÍA EL CÓDIGO DE cPersona Y cEntrada

/La sintaxis para declarar una subclase sería la siguiente:
//class subClase extends superClase { .... }

class cEmpleado extends cPersona
{
 

private double saldo;

public cEmpleado(double saldo)
{
   

//MUY IMPORTANTE-> ASÍ SE LLAMARÁ AL CONSTRUCTOR DE LA SUPERCLASE:
super();

//LA LLAMADA AL CONSTRUCTOR DE LA SUPERCLASE TENDRÁ QUE SER LA PRIMERA
//LÍNEA DE CÓDIGO DEL CONSTRUCTOR PUES SINO DARÍA EL
//SIGUIENTE ERROR: "call to super must be first statement in constructor"

this.saldo = saldo;
 

}

//En Java no se pueden definir parámetros con valores por defecto, es decir, la sentencia "public cEmpleado(double saldo=0)" es incorrecta.

// Para poder realizar un comportamiento similar, habrá que definir el constructor con dos versiones: versión en la que se ha pasado el parámetro y //versión en la que se no ha enviado ningún parámetro.
public cEmpleado()
{
   

super();

this.saldo = 0;
 

}

public double getSaldo(){return saldo;}
public void setSaldo (double saldo)
{
    this.saldo = saldo;
  }
public void visualiza()
{
   
//Se llama primero al visualiza de la superclase
super.visualiza();
System.out.println("Saldo: " + saldo);
  }
public static void main(String args[])
{
   

cEmpleado empleado1;
String apellidosLocal;
String nombreLocal;
int edadLocal;
long dniLocal;
double saldo;

//Para capturar datos de la entrada estándar
cEntrada entrada = new cEntrada();

System.out.println("************************************");
System.out.println("Introduzca los siguientes datos");

System.out.print("Nombre: ");
nombreLocal = entrada.leeCadena();

System.out.print("Apellidos: ");
apellidosLocal = entrada.leeCadena();

//leeCadena devuelve únicamente cadenas => habrá que modificar el tipo de dato
System.out.print("Edad: ");
edadLocal = Integer.parseInt(entrada.leeCadena());

System.out.print("DNI: ");
dniLocal = Long.parseLong(entrada.leeCadena());

System.out.print("Saldo empleado: ");
saldo = Double.parseDouble(entrada.leeCadena());

//Se instancia la clase(se crea el objeto). Por tanto se llamará al constructor
empleado1 = new cEmpleado(saldo);

//Sentencias para probar el objeto creado
empleado1.setApellidos(apellidosLocal);
empleado1.setNombre(nombreLocal);
empleado1.setEdad(edadLocal);
empleado1.setDNI(dniLocal);
empleado1.visualiza();
  }  
}    

EJERCICIO: Definir la clase cPunto. Ésta contendrá como mínimo las propiedades necesarias para almancenar las coordenas sobre las cuales está situado (en 2 dimensiones). Posteriormente implementar la clase cCirculo en base a la clase cPunto. La clase cCírculo contendrá el radio del mismo. y métodos para el cálculo de la superficie y la longitud. NOTA: Definir la constante PI.

EJERCICIO: Realizar un programa que implemente el siguiente diagrama:

Fórmula: atracción partículas:

(G*p1.masa* p2.masa )/ (( d i s t a n c i a (p1, p2 ))^2 );

Siendo p1 y p2 las dos partículas y G = 6.67e-11

Control de acceso

Los métodos y las propiedades de una clase pueden ser definidos como public, protected, private o friendly. La sintaxis sería la siguiente:

[control_acceso] cabecera_suprograma. Ejemplo: public void accesoPublico()

El siguiente ejemplo refleja que mientras no se produzca herencia no afectan, en absoluto, los modificadores de control de acceso:

//Descripción: Pruebas de control de acceso.
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com
//Cuando se ejecute este programa no aparecerá ningún tipo de error

class cControlAcceso
{
  private int propiedadPrivate;
public int propiedadPublic;
protected int propiedadProtected;
//Recordad que si no se indica ningún especificador de acceso tomará
//por defecto "friendly"
int propiedadFriendly;

public cControlAcceso()
{
    propiedadPrivate = 0;
propiedadPublic = 1;
propiedadProtected = 2;
propiedadFriendly = 3;
  }

public void setPropiedadPrivate(int valor)
{
    propiedadPrivate=valor;
  }

public static void main(String args[])
{
    cControlAcceso control = new cControlAcceso();

control.setPropiedadPrivate(3);
control.propiedadPublic = 6;
control.propiedadProtected = 7;
control.propiedadFriendly = 8;
System.out.println("Propiedad privada: " + control.propiedadPrivate );
System.out.println("Propiedad publica: " + control.propiedadPublic );
System.out.println("Propiedad protegida: " + control.propiedadProtected );
System.out.println("Propiedad friendly: " + control.propiedadFriendly );
  }  
}    

En el siguiente ejemplo sí se aplica el mecanismo de herencia. Se ilustra el comportamiento del control de acceso "private" y la aplicación por defecto "friendly":

/Descripción: Segunda prueba de control de acceso.
//verificar el acceso
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com
//Cuando se ejecute este programa no aparecerá ningún tipo de error

class cControlAcceso
{
  private int propiedadPrivate;
public int propiedadPublic;
protected int propiedadProtected;
int propiedadFriendly;

public cControlAcceso()
{
    propiedadPrivate = 0;
propiedadPublic = 1;
propiedadProtected = 2;
propiedadFriendly = 3;
  }

public int getPropiedadPublic()
{
    return(propiedadPublic);
  }
private int getPropiedadPrivate()
{
    return(propiedadPrivate);
  }
protected int getPropiedadProtected()
{
    return(propiedadProtected);
  }
//método "friendly"
int getPropiedadFriendly()
{
    return(propiedadFriendly);
  }

}

class cControlAcceso2 extends cControlAcceso
{
  public static void main(String args[])
{
    cControlAcceso2 control = new cControlAcceso2();

//Si estuviese la siguiente sentencia:
// control.propiedadPrivate = 3;
//produciría el siguiente error:
// propiedadPrivate has private access in cControlAcceso

//Si estuviese la siguiente sentencia:
// System.out.println("Propiedad privada:" + control.getPropiedadPrivate());
//produciría el siguiente error:
//cannot find symbol symbol : method getPropiedadPrivate()

System.out.println("Propiedad publica:" + control.getPropiedadPublic());
System.out.println("Propiedad protegida:" + control.getPropiedadProtected());
System.out.println("Propiedad friendly:" + control.getPropiedadFriendly());
  }  
}    

El siguiente ejemplo refleja la aplicación del control de acceso "protected":

//Descripción: Tercera prueba de control de acceso.
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com

class cControlAcceso
{

  protected int propiedadProtected;
public cControlAcceso()
{
    propiedadProtected=1;
  }  

}

class cControlAcceso2 extends cControlAcceso
{
  public int devPropiedadProtected()
{
    return(propiedadProtected);
  }  

}

class cControlAcceso3 extends cControlAcceso2
{
  public static void main(String args[])
{
    cControlAcceso3 control = new cControlAcceso3();
System.out.println("Propiedad protegida: " + control.propiedadProtected);
  }  

}

//Resultado de ejecución:
//Propiedad protegida: 1

Volver al sumario