(anterior) En esta sección puedes descargar ejemplos de Herencia (Programación Orientada a Objetos), la cual es una forma de reutilización de software en la que nuevas clases se desarrollan rápida y fácilmente al absorber las características de las clases existentes y agregar nuevas características que sean apropiadas. También se muestran ejemplos introductorios sobre superclases y subclases, el modificador de acceso protected, las superclases directas e indirectas, el uso de constructores en superclases y subclases, y la ingeniería de software con herencia. Veámos entonces los típicos ejemplos de aprendizaje para la Herencia:

Jerarquía de herencia de tres niveles

Este ejemplo posee 4 clases. La primera es la clase Punto3:

// La declaración de la clase Punto representa un par de coordenadas x-y.

public class Punto3 {
   private int x;  // parte x de un par de coordenadas
   private int y;  // parte y de un par de coordenadas

   // constructor sin argumentos
   public Punto3()
   {
       // la llamada implícita al constructor de Object ocurre aquí
   } 

   // constructor
   public Punto3( int valorX, int valorY )
   {
      // la llamada implícita al constructor de Object ocurre aquí
      x = valorX;  // no hay necesidad de validación
      y = valorY;  // no hay necesidad de validación
   } 

   // establecer x en el par de coordenadas
   public void establecerX( int valorX )
   {
      x = valorX;  // no hay necesidad de validación
   } 

   // devolver x del par de coordenadas
   public int obtenerX()
   {
      return x;
   } 

   // establecer y en el par de coordenadas
   public void establecerY( int valorY )
   {
      y = valorY;  // no hay necesidad de validación
   } 

   // devolver y del par de coordenadas
   public int obtenerY()
   {
      return y;
   } 

   // devolver la representación String del objeto Punto3
   public String toString()
   {
      return "[" + obtenerX() + ", " + obtenerY() + "]";
   } 

} // fin de la clase Punto3

La segunda es la clase Circulo4:

// La clase Circulo4 hereda de Punto3 y accede a las variables x e y
// de Punto 3 mediante los métodos public de Punto3.

public class Circulo4 extends Punto3 {

   private double radio;  // El radio de Circulo4

   // constructor sin argumentos
   public Circulo4()
   {
      // La llamada implícita al constructor de Punto3 ocurre aquí
   } 

   // constructor
   public Circulo4( int valorX, int valorY, double valorRadio )
   {
      super( valorX, valorY );  // llamar explícitamente al constructor de Punto3
      establecerRadio( valorRadio );
   } 

   // establecer el radio
   public void establecerRadio( double valorRadio )
   {
      radio = ( valorRadio < 0.0 ? 0.0 : valorRadio );
   } 

   // devolver el radio
   public double obtenerRadio()
   {
      return radio;
   } 

   // calcular y devolver el diámetro
   public double obtenerDiametro()
   {
      return 2 * obtenerRadio();
   } 

   // calcular y devolver la circunferencia
   public double obtenerCircunferencia()
   {
      return Math.PI * obtenerDiametro();
   } 

   // calcular y devolver el área
   public double obtenerArea()
   {
      return Math.PI * obtenerRadio() * obtenerRadio();
   } 

   // devolver la representación String del objeto Circulo4
   public String toString()
   {
      return "Centro = " + super.toString() + "; Radio = " + obtenerRadio();
   } 

} // fin de la clase Circulo4

Y la cuarta es la clase PruebaCilindro que contiene el método main:

// Prueba de la clase Cilindro.
import java.text.DecimalFormat;
import javax.swing.JOptionPane;

public class PruebaCilindro {

   public static void main( String[] args )
   {
       // crear el objeto Cilindro
       Cilindro cilindro = new Cilindro( 12, 23, 2.5, 5.7 );

       // obtener las coordenadas x-y, radio y altura iniciales del Cilindro
       String salida = "La coordenada X es " + cilindro.obtenerX() +
          "\nLa coordenada Y es " + cilindro.obtenerY() + "\nEl radio es " +
          cilindro.obtenerRadio() + "\nLa altura es " + cilindro.obtenerAltura();

       cilindro.establecerX( 35 );          // establecer la nueva coordenada x
       cilindro.establecerY( 20 );          // establecer la nueva coordenada y
       cilindro.establecerRadio( 4.25 );   // establecer el nuevo radio
       cilindro.establecerAltura( 10.75 );  // establecer la nueva altura

       // obtener la representación String del nuevo valor de cilindro
       salida +=
          "\n\nLa nueva ubicación, radio y altura del cilindro son\n" +
          cilindro.toString();

       // dar formato a los valores de punto flotante con 2 dígitos de precisión
       DecimalFormat dosDigitos = new DecimalFormat( "0.00" );

       // obtener el diámetro del Cilindro
       salida += "\n\nEl diámetro es " +
          dosDigitos.format( cilindro.obtenerDiametro() );

       // obtener la circunferencia del Cilindro
       salida += "\nLa circunferencia es " +
          dosDigitos.format( cilindro.obtenerCircunferencia() );

       // obtener el área del Cilindro
       salida += "\nEl área es " + dosDigitos.format( cilindro.obtenerArea() );

       // obtener el volumen del Cilindro
       salida += "\nEl volumen es " + dosDigitos.format( cilindro.obtenerVolumen() );

       JOptionPane.showMessageDialog( null, salida ); // mostrar resultados

       System.exit( 0 );

    } // fin de main

} // fin de la clase PruebaCilindro

Descargar código fuente

Constructores y finalizadores en las subclases

Este ejemplo posee 3 clases. La primera es la clase Punto:

// La declaración de la clase Punto representa un par de coordenadas x-y.

public class Punto {
    private int x;  // parte x del par de coordenadas
    private int y;  // parte y del par de coordenadas

    // constructor sin argumentos
    public Punto()
    {
       // la llamada implícita al constructor de Object ocurre aquí
       System.out.println( "Constructor sin argumentos de Punto: " + this );
    } 

    // constructor
    public Punto( int valorX, int valorY )
    {
       // la llamada implícita al constructor de Object ocurre aquí
       x = valorX;  // no hay necesidad de validación
       y = valorY;  // no hay necesidad de validación

       System.out.println( "Constructor de Punto: " + this );
    } 

    // finalizador
    protected void finalize()
    {
       System.out.println( "Finalizador de Punto: " + this );
    } 

    // establecer x en el par de coordenadas
    public void establecerX( int valorX )
    {
       x = valorX;  // no hay necesidad de validación
    } 

    // devolver x del par de coordenadas
    public int obtenerX()
    {
       return x;
    } 

    // establecer y en el par de coordenadas
    public void establecerY( int valorY )
    {
       y = valorY;  // no hay necesidad de validación
    } 

    // devolver y del par de coordenadas
    public int obtenerY()
    {
       return y;
    } 

    // devolver la representación String del objeto Punto
    public String toString()
    {
       return "[" + obtenerX() + ", " + obtenerY() + "]";
    } 

} // fin de la clase Punto

La segunda es la clase Circulo:

// Declaración de la clase Circulo.

public class Circulo extends Punto {

   private double radio;  // el radio del Circulo

   // constructor sin argumentos
   public Circulo()
    {
       // la llamada implícita al constructor de Punto ocurre aquí
       System.out.println( "Constructor sin argumentos de Circulo: " + this );
    } 

    // constructor
    public Circulo( int valorX, int valorY, double valorRadio )
    {
       super( valorX, valorY );  // llamar al constructor de Punto
       establecerRadio( valorRadio );

       System.out.println( "Constructor de Circulo: " + this );
    } 

    // finalizador
    protected void finalize()
    {
       System.out.println( "Finalizador de Circulo: " + this );

       super.finalize();  // llamar al método finalize de la superclase
    }

    // establecer el radio
    public void establecerRadio( double valorRadio )
    {
       radio = ( valorRadio < 0.0 ? 0.0 : valorRadio );
    } 

    // devolver el radio
    public double obtenerRadio()
    {
       return radio;
    } 

    // calcular y devolver el diámetro
    public double obtenerDiametro()
    {
       return 2 * obtenerRadio();
    } 

    // calcular y devolver la circunferencia
    public double obtenerCircunferencia()
    {
       return Math.PI * obtenerDiametro();
    } 

    // calcular y devolver el área
    public double obtenerArea()
    {
       return Math.PI * obtenerRadio() * obtenerRadio();
    } 

    // devolver la representación String del objeto Circulo
    public String toString()
    {
       return "Centro = " + super.toString() + "; Radio = " + obtenerRadio();
    } 

} // fin de la clase Circulo

Y la tercera es la clase PruebaConstructorFinalizador que contiene el método main:

// Muestra el orden en que se hacen las llamadas a los constructores
// y finalizadores de la superclase y la subclase.

public class PruebaConstructorFinalizador {

   public static void main( String args[] )
   {
      Punto punto;
       Circulo circulo1, circulo2;

       punto = new Punto( 11, 22 );

       System.out.println();
       circulo1 = new Circulo( 72, 29, 4.5 );

       System.out.println();
       circulo2 = new Circulo( 5, 7, 10.67 );

       punto = null;    // se marca para la recolección de basura
       circulo1 = null;  // se marca para la recolección de basura
       circulo2 = null;  // se marca para la recolección de basura

       System.out.println();

       System.gc();  // llamar al recolector de basura

    } // fin de main

} // fin de la clase PruebaConstructorFinalizador

Descargar código fuente