3.1 Definición: clase base, clase derivada. LA HERENCIA es una propiedad esencial de la Programación Orientada a Obje tos que consiste en la creación de nuevas clases a partir de otras ya existentes. Este término térm ino ha sido prestado de la Biología donde afirmamos que un niño tiene la cara de su padre, que ha heredado ciertas facetas físicas o del comportamiento de sus progenitores. La herencia es la c aracterística fundamental que distingue un lenguaje orientado a objetos, como el C++ o Java, de otro convencional como C, BASIC, etc. Java permite heredar a las clases características y conductas de una o varias clases denominadas base. Las clases que heredan de clases base se denominan derivadas, estas a su vez pueden ser clases bases para otras otr as clases derivadas. Se establece así una clasificación jerárquica, similar a la existente en Biología con los animales y las plantas. La herencia ofrece una ventaja importante, permite la reutilización del código. Una vez que una clase ha sido depurada y probada, el código fuente de dicha clase no necesita modificarse. Su funcionalidad se puede cambiar derivando una nueva clase que herede la funcionalidad de la clase base y le añada otros comportamientos. Reutilizando el código existente, el programador ahorra tiempo y dinero, ya que solamente tiene que ve rificar la nueva conducta que proporciona la clase derivada. Los programadores crean clases base: 1.
Cuando se dan cuenta que diversos tipos tienen algo en común, por ejemplo en el juego del ajedrez
peones, alfiles, rey, reina, caballos y torr es, son piezas del juego. Creamos, por tanto, una clase base y derivamos cada pieza individual a partir de dicha clase base. 2.
Cuando se precisa ampliar la funcionalidad de un programa sin tener que modificar el código existente.
Clase Base Vamos a poner un ejemplo del segundo tipo, que simule la utilización de librerías de clases para crear un interfaz gráfico de usuario
Supongamos que tenemos una clase que describe la conducta de una ventana muy simple, aquella que no dispone de título en la parte superior, por tanto no puede desplazarse, pero si cambiar de tamaño actuando con el ratón en los bordes derecho e inferior. La clase Ventana tendrá los siguientes miembros dato: la posición x e y de la ventana, de su esquina superior izquierda y las dimensiones de la ventana: ancho y alto. public class Ventana { protected int x; protected int y; protected int ancho; protected int alto; public Ventana(int x, int y, int ancho, int alto) { this.x=x; this.y=y; this.ancho=ancho;
this.alto=alto; }
Las funciones miembros, además del constructor serán las siguientes: la función mostrar que simula una ventana en un entorno gráfico, aquí solamente nos muestra la posición y las dimensiones de la ventana. public void mostrar(){ System.out.println("posici ón : x="+x+", y="+y); System.out.println("dimensiones : w="+ancho+", h="+alto); }
La función cambiarDimensiones que simula el cambio en la anchura y altura de la ventana. public void cambiarDimensiones(int dw, int dh){ ancho+=dw; alto+=dh; }
El código completo de la clase base Ventana, es el siguiente package ventana; public class Ventana { protected int x; protected int y; protected int ancho; protected int alto; public Ventana(int x, int y, int ancho, int alto) { this.x=x; this.y=y; this.ancho=ancho; this.alto=alto; } public void mostrar(){ System.out.println("posici ón : x="+x+", y="+y); System.out.println("dimensiones : w="+ancho+", h="+alto); } public void cambiarDimensiones(int dw, int dh){ ancho+=dw; alto+=dh; } }
La clase derivada Incrementamos la funcionalidad de la clase Ventana definiendo una clase derivada denominada VentanaTitulo. Los objetos de dicha clase tendrán todas las características de los objetos de la clase base, pero además tendrán un t ítulo, y se podrán desplazar (se simula el desplazamiento de una ventana con el ratón).
La clase derivada heredará los miembros dato de la clase base y las funciones miembro, y t endrá un miembro dato más, el título de la ventana. public class VentanaTitulo extends Ventana{ protected String titulo; public VentanaTitulo(int x, int y, int w, int h, String nombre) { super(x, y, w, h); titulo=nombre; } extends es la palabra reservada que indica que la clase VentanaTitulo deriva, o es una subclase, de la clase Ventana. La primera sentencia del constructor de la clase derivada es una llamada al constructor de la clase base mediante la palabra reservada super . La llamada super(x, y, w, h); inicializa los cuatro miembros dato de la clase base Ventana: x, y, ancho, alto. A continuación, se inicializa los miembros dato de la clase derivada, y se realizan las tareas de inicialización que sean necesarias. Si no se llama explícitamente al constructor de la clase base Java lo realiza por nosotros, llamando al constructor por defecto si existe. La función miembro denominada desplazar cambia la posición de la ventana, añadiéndoles el desplazamiento. public void desplazar(int dx, int dy){ x+=dx; y+=dy; }
Redefine la función miembro mostrar para mostrar una ventana con un título. public void mostrar(){ super.mostrar(); System.out.println("titulo
: "+titulo);
} En la clase derivada se define una función que t iene el mismo nombre y los mismos parámetros que la de la clase base. Se dice que redefinimos la función mostrar en la clase derivada. La función miembro mostrar de la clase derivada VentanaTitulo hace una llamada a la función mostrar de la clase base Ventana, mediante super.mostrar(); De este modo aprovechamos el código ya escrito, y le añadimos el código que describe la nueva funcionalidad de la ventana por ejemplo, que muestre el título. Si nos olvidamos de poner la palabra reservada super llamando a la función mostrar, tendríamos una función recursiva. La función mostrar llamaría a mostrar indefinidamente. public void mostrar(){ //¡ojo!, función recursiva System.out.println("titulo
: "+titulo);
mostrar(); }
La definición de la clase derivada VentanaTitulo, será la siguiente. package ventana; public class VentanaTitulo extends Ventana{ protected String titulo; public VentanaTitulo(int x, int y, int w, int h, String nombre) { super(x, y, w, h); titulo=nombre; } public void mostrar(){ super.mostrar(); System.out.println("titu lo : "+titulo); } public void desplazar(int dx, int dy){ x+=dx; y+=dy; } }
package ventana; public class VentanaApp { public static void main(String[] args) { VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal"); ventana.mostrar(); ventana.cambiarDimensiones(10, -5); ventana.desplazar(4, 3); System.out.println("************************"); ventana.mostrar();
try { //espera la pulsación de una tecla y luego RETORNO System.in.read(); }catch (Exception e) { } } }
Objetos de la clase derivada Creamos un objeto ventana de la clase derivada VentanaTitulo VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");
Mostramos la ventana con su título, llamando a la función mostrar , redefinida en la clase derivada ventana.mostrar();
Desde el objeto ventana de la clase derivada llamamos a las funciones miembro definidas en dicha clase ventana.desplazar(4, 3);
Desde el objeto ventana de la clase derivada podemos llamar a las funciones miembro definidas en la clase base. ventana.cambiarDimensiones(10, -5);
Para mostrar la nueva ventana desplazada y cambiada de tamaño escribimos ventana.mostrar();
Parte2 Problema 1:
Ahora plantearemos el primer problema utilizando herencia. Supongamos que necesitamos implementar dos clases que llamaremos Suma y Resta. Cada clase tiene como atributo valor1, valor2 y resultado. Los métodos a definir son cargar1 (que inicializa el atributo valor1), carga2 (que inicializa el atributo valor2), operar (que en el caso de la clase "Suma" suma los dos atributos y en el caso de la clase "Resta" hace la diferencia entre valor1 y valor2, y otro método mostrarResultado. Si analizamos ambas clases encontramos que muchos atributos y métodos son idénticos. En estos casos es bueno definir una clase padre que agrupe dichos atributos y responsabilidades comunes. La relación de herencia que podemos disponer para este problema es: Operacion Suma
Resta
Solamente el método operar es distinto para las clases Suma y Resta (esto hace que no lo podamos disponer en la clase Operacion), luego los métodos cargar1, cargar2 y mostrarResultado son idénticos a las dos clases, esto hace que podamos disponerlos en la clase Operacion. Lo mismo los atributos valor1, valor2 y resultado se definirán en la clase padre Operacion.
Crear un proyecto y luego crear cuatro clases llamadas: Operacion, Suma, Resta y Prueba Programa:
import java.util.Scanner; public class Operacion { protected Scanner teclado; protected int valor1; protected int valor2; protected int resultado; public Operacion() { teclado=new Scanner(System.in); } public void cargar1() { System.out.print("Ingrese el primer valor:"); valor1=teclado.nextInt(); } public void cargar2() { System.out.print("Ingrese el segundo valor:"); valor2=teclado.nextInt(); } public void mostrarResultado() { System.out.println(resultado); } }
public class Suma extends Operacion{ void operar() { resultado=valor1+valor2; }
}
public class Resta extends Operacion { public void operar(){ resultado=valor1-valor2; } }
public class Prueba { public static void main(String[] ar) { Suma suma1=new Suma(); suma1.cargar1(); suma1.cargar2(); suma1.operar(); System.out.print("El resultado de la suma es:"); suma1.mostrarResultado(); Resta resta1=new Resta(); resta1.cargar1(); resta1.cargar2(); resta1.operar(); System.out.print("El resultado de la resta es:"); resta1.mostrarResultado(); } } La clase Operación define los cuatro atributos: import java.util.Scanner; public class Operacion { protected Scanner teclado; protected int valor1; protected int valor2; protected int resultado;
Ya veremos que definimos los atributos con este nuevo modificador de acceso (protected) para que la subclase tenga acceso a dichos atributos. Si los definimos private las subclases no pueden acceder a dichos atributos.
Los métodos de la clase Operacion son: public Operacion() { teclado=new Scanner(System.in); } public void cargar1() { System.out.print("Ingrese el primer valor:"); valor1=teclado.nextInt(); } public void cargar2() { System.out.print("Ingrese el segundo valor:"); valor2=teclado.nextInt(); } public void mostrarResultado() { System.out.println(resultado); }
Ahora veamos como es la sintaxis para indicar que una clase hereda de otra: public class Suma extends Operacion{
Utilizamos la palabra clave extends y seguidamente el nombre de la clase padre (con esto estamos indicando que todos los métodos y atributos de la clase Operación son también métodos de la clase Suma. Luego la característica que añade la clase Suma es el siguiente método: void operar() { resultado=valor1+valor2; }
El método operar puede acceder a los atributos heredados (siempre y cuando los mismos se declaren protected, en caso que sean private si bien lo hereda de la clase padre solo los pueden modificar métodos de dicha clase padre. Ahora podemos decir que la clase Suma tiene cinco métodos (cuatro heredados y uno propio) y 3 atributos (todos heredados) Luego en otra clase creamos un objeto de la clase Suma: public class Prueba { public static void main(String[] ar) { Suma suma1=new Suma(); suma1.cargar1(); suma1.cargar2(); suma1.operar(); System.out.print("El resultado de la suma es:"); suma1.mostrarResultado(); Resta resta1=new Resta(); resta1.cargar1(); resta1.cargar2(); resta1.operar(); System.out.print("El resultado de la resta es:"); resta1.mostrarResultado(); } }
Podemos llamar tanto al método propio de la clase Suma "operar()" como a los métodos heredados. Quien utilice la clase Suma solo debe conocer que métodos públicos tiene (independientemente que pertenezcan a la clase Suma o a una clase superior) La lógica es similar para declarar la clase Resta.
La clase Operación agrupa en este caso un conjunto de atributos y métodos comunes a un conjunto de subclases (Suma, Resta). No tiene sentido definir objetos de la clase Operacion. El planteo de jerarquías de clases es una tarea compleja que requiere un perfecto entendimiento de todas las clases que intervienen en un problema, cuales son sus atributos y responsabilidades.
Problemas propuestos 1. Confeccionar una clase Persona que tenga como atributos el nombre y la edad. Definir como responsabilidades un método que cargue los datos personales y otro que los imprima. Plantear una segunda clase Empleado que herede de la clase Persona. Añadir un atributo sueldo y los métodos de cargar el sueldo e imprimir su sueldo. Definir un objeto de la clase Persona y llamar a sus métodos. También crear un objeto de la clase Empleado y llamar a sus métodos.
3.2 Clasificación. Herencia simple, herencia múltiple.
Herencia
La herencia es un mecanismo que permite la definición de una clase a partir de la definición de otra ya existente. La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos. La herencia está fuertemente ligada a la reutilización del código en la OOP. Esto es, el código de cualquiera de las clases puede ser utilizado sin más que crear una clase derivada de ella, o bien una subclase . Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple . La primera indica que se pueden definir nuevas clases solamente a partir de una clase inicial mientras que la segunda indica que se pueden definir nuevas clases a partir de dos o más clases iniciales. Java sólo permite herencia simple.
¿Existe la herencia múltiple en Java? ¿Por qué? Objetivo: fortalecer los conceptos de clases, métodos, propiedades o atributos, herencia, constructores y acerca de los métodos Get y Set. Todo est o con ayuda del programa realizado en la guía anterior con nuestro “Silabario para programadores”. El trabaj o estructurado de la semana pasada ahora lo traslademos a una aplicación, siempre en el ambiente consola, en la cual definamos con un alto grado de encapsulamiento, las clases que harán posible la realización de la aplicación y llevarán definida todo el funcionamiento, o lo que es mismo, la capa de negocios del programa. El ejemplo es sencillo. El Silabario lo que realiza es una serie de operaciones básicas que resuelven 4 tipos de problemas distintos: El factorial de número, la tabla de multiplicar de un número, la clasificación de la edad del usuario y la elección de la estación del año favorita del usuario. El silabario además, tiene la característica que el programador escogerá la sentencia o instrucción básica que brinde la solución más sencilla y óptima para cada uno de los p roblemas.
Para efectos de esta práctica, y porque creo que es la mejor manera de poder apreciar las clases y objetos de este ejercicio, definiremos cada clase como una clase “Operación”, que e s la que facilitará y tendrá las herr amientas necesarias para efectuar la resolución de cada uno de los problemas. Un objeto operación necesita de propiedades o atributos. Una operación necesita de operadores, uno, dos ó más. Es por eso que definiremos dos atributos para realizar dichas operaciones. Con dos bastarán para este ejercicio. Los métodos de esta clase son muy variados. Cada una de las operaciones realizará uno diferente, por lo tanto no cabe dentro de la percepción de un obje to “Operación” básico, la definición de cada uno de los m étodos. Los métodos que sí se necesitarían son los populares métodos GET y SET, que nos sirven para leer y cambiar los valores de una propiedad específica. Como hemos definido propiedades, éstas necesitan de sus getters y setters. La clase de una Operación Básica para el silabario quedará así: public class operacionBase { protected int operador; public operacionBase(){ this.operador=0; } public void setOperador(int o){ this.operador=o; } public int getOperador(){ return this.operador; } } Declaramos la propiedad con visibilidad protected por motivos de seguridad, para que solamente los miembros de esa clase y los que heredan de ella, es decir las subclases, puedan accesar a estos atributos. Como hemos definido ya una clase base, ahora podremos definir el resto de clases que podrán heredar de la clase base. Cabe destacar que no siempre se podrá hacer una clase base y con respecto a esta empezar a heredarles a otras. Esto depende de la naturaleza de cada aplicación, y de la manera de cómo el programador diseñe su capa de negocios. Para realizar la clase que nos devuelva el factorial de un número, el programador puede escoger la instrucción While. Por lo tanto el programador debe desarrollar el método que reciba como parámetro el número del que se desee el factorial y que devuelva el resultado esperado. Heredando de la clase base, tenemos ya garantizados los atributos y métodos propios de la misma, por lo tanto, la clase para realizar el factorial del número podría quedar así: public class operacionFactorial extends operacionBase{ public operacionFactorial(){ super(); } public int devolverFactorial(){ int factorial=1; int cont=1; while (cont <= this.operador) { factorial *= cont; cont++; } return factorial; } } El diagrama UML nos ayudará a comprender mejor la herencia y estructura de estas clases:
Como puede observar el programador, se utiliza la propiedad “operador” cuya definición pertenece a la clase base. Sin embargo, como la clase “operacionFactorial” hereda todos los atributos y métodos de la clase básica, podemos hacer un llamado a dicha propiedad con la ayuda de la sentencia “this”.
3.3 Reutilización de miembros heredados.
La reutilización de código se refiere al comportamiento y a las técnicas que garantizan que una parte o la totalidad de un programa informático existente se pueda emplear en la construcción de otro programa. De esta forma se aprovecha el trabajo anterior, se economiza tiempo, y se reduce la redundancia. La manera más fácil de reutilizar código es copiarlo total o parcialmente desde el programa antiguo al programa en desarrollo. Pero es trabajoso mantener múltiples copias del mismo código, por lo que en general se elimina la redundancia dejando el código reusable en un único lugar, y llamándolo desde los diferentes programas. Este proceso se conoce como abstracción. La abstracción puede verse claramente en las bibliotecas de software, en las que se agrupan varias operaciones comunes a cierto dominio para facilitar el desarrollo de programas nuevos. Hay bibliotecas para convertir información entre diferentes formatos conocidos, acceder a dispositivos de almacenamiento externos, proporcionar una interfaz con otros programas, manipular información de manera conocida (como números, fechas, o cadenas de texto). Para que el código existente se pueda reutilizar, debe definir alguna forma de comunicación o interfaz. Esto se puede dar por llamadas a una subrutina, a un objeto, o a una clase.
Como se ha comentado anteriormente la clase descendiente puede añadir sus propios atributos y métodos pero también puede sustituir u ocultar los heredados. En concreto: 1. Se puede declarar un nuevo atributo con el mismo identificador que uno heredado, quedando este atributo oculto . Esta técnica no es recomendable. 2. Se puede declarar un nuevo método de instancia con la misma cabecera que el de la clase ascendiente, lo que supone su sobreescritura . Por lo tanto, la sobreescritura o redefinición consiste en
que métodos adicionales declarados en la clase descendiente con el mismo nombre, tipo de dato devuelto y número y tipo de parámetros sustituyen a los heredados. 3. Se puede declarar un nuevo método de clase con la misma cabecera que el de la clase ascendiente, lo que hace que éste quede oculto . Por lo tanto, los métodos de clase o estáticos (declarados como static) no pueden ser redefinidos. 4. Un método declarado con el modificador final tampoco puede ser redefinido por una clase derivada. 5. Se puede declarar un constructor de la subclase que llame al de la superclase de forma implícita o de mediante la palabra reservada super. 6. En general puede accederse a los métodos de la clase ascendiente que han sido redefinidos empleando la palabra reservada super delante del identificador del método. Este mecanismo sólo permite acceder al metodo perteneciente a la clase en el nivel inmediatamente superior de la jerarquía de clases. Practicas: Construyamos la clase Taxista.java con el siguiente código: public class Taxista extends Persona { private int nLicencia; public void setNLicencia(int num) { nLicencia = num; } public int getLicencia() { return nLicencia; } } Y construyamos ArranqueTaxista.java: public class ArranqueTaxista { public static void main (String arg[]){ Taxista tax1 = new Taxista(); tax1.setNombre("Luis"); tax1.setEdad(50); System.out.println( tax1.getNombre()); System.out.println(tax1.getEdad()); } } Ahora intentemos usar el constructor que existía en la clase Persona que recibia el n ombre de la persona y vamos a usarlo para la clase Taxista. Para ello construyamos la clase ArranqueTaxista2.java:
public class ArranqueTaxista2 { public static void main (String arg[]){ Taxista tax1 = new Taxista("Jose"); tax1.setEdad(50); System.out.println( tax1.getNombre()); System.out.println(tax1.getEdad()); System.out.println(tax1.getNLicencia()); } } Se genera un error de compilación, debido a que los constructores no se heredan, sino que hay que definir nuestros propios constructores. Agreguemos en la clase Taxista los siguientes constructores: public Taxista(int licencia) { super(); nLicencia = licencia; } public Taxista(String nombre,int licencia) { super(nombre); nLicencia = licencia; } Ahora si podremos compilar y ejecutar la clase ArranqueTaxista2. La llamada al método super indica que estamos llamando a un constructor de la clase base (pensemos que un Taxista antes que Taxista es Persona y por tanto tiene sentido llamar al constructor de Persona antes que al de Taxista). Además gracias al número de parámetros de la llamada a super podemos especificar cuál de los constructores de la clase base queremos llamar. En java se pueden emplear dos palabras clave: this y super . Como vimos en la introducción a la programación orientada a objetos, this hace alusión a todo el objeto y super hace alusión a la parte heredada, por ello empleamos super para referenciar al constructor de la clase base.
Practicas: Ahora vamos a agregar la función getNom bre dentro de la clase Taxista, es decir, tenemos la misma función en Persona y en Taxista: public String getNombre() { return "Soy un taxista y me llamo: " + super.getNombre(); } Compilamos Taxista y ejecutamos ArranqueTaxista2. Veremos que el mensaje que aparece en pantalla demuestra que la función getNombre llamada es la de del tipo real del objeto construido, en este caso la de la clase derivada que es Taxista. Tambien apreciamos que para acceder al atributo nombre es necesario acceder al método getNombre de la clase base (y por ello emplear super). En java los atributos y métodos de la clase base pueden cambiar su modificador de visibilidad dentro de la clase derivada, la siguiente tabla recoge dichos cambios: Modificadores en la clase base public private protected paquete En la clase derivada se transforman en public inaccesible protected paquete Inaccesible significa que, a pesar de haber sido heredado, no hay permisos en la clase derivada para poder acceder a dicho elemento inaccesible, pero aún así, se pueden llamar a métodos de la clase base que si pueden acceder y modificar al elemento. Recordemos que protected significa que es private, pero que al heredar no se hace inaccesible, es decir que desde la clase derivada se puede acceder.
3.4 Referencia al objeto de la clase base
La jerarquía de clases que describen las figuras planas figura : Figura.java, FiguraApp.java Consideremos las figuras planas cerradas como el rectángulo, y el círculo. Tales figuras comparten características comunes como es la posición de la figura, de su centro, y el área de la figura, aunque el procedimiento para calcular dicha área sea completamente distinto. Podemos por tanto, diseñar una jerarquía de clases, tal que la clase base denominada Figura, tenga las características comunes y cada clase derivada las específicas. La relación jerárquica se muestra en la figura
La clase Figura es la que contiene las características comunes a dichas figuras concretas por tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase abstracta, declarando la función miembro area abstract . Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases. En el juego del ajedrez podemos definir una clase base denominada Pieza, con las características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular. Así pues, la clase Pieza será una clase abstracta con una función abstract denominada mover , y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.
La clase Figura
La definición de la clase abstracta Figura, contiene la posición x e y de la figura particular, de su centro, y la función area, que se va a definir en las clases derivadas para calcular el área de cada figura en particular. public abstract class Figura { protected int x; protected int y; public Figura(int x, int y) { this.x=x; this.y=y; } public abstract double area(); }
La clase Rectangulo
Las clases derivadas heredan los miembros dato x e y de la clase base, y definen la función area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una fórmula distinta para calcular su área. Por ejemplo, la clase derivada Rectangulo, tiene como datos, aparte de su posición (x, y) en el plano, sus dimensiones, es decir, su anchura ancho y altura alto.
class Rectangulo extends Figura{ protected double ancho, alto; public Rectangulo(int x, int y, double ancho, double alto){ super(x,y); this.ancho=ancho; this.alto=alto; } public double area(){ return ancho*alto; } }
La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base, para ello se emplea la palabra reservada super. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros dato ancho y alto. En la definición de la función area, se calcula el área del rectángulo como producto de la anchura por la altura, y se devuelve el resultado
La clase Circulo
class Circulo extends Figura{ protected double radio; public Circulo(int x, int y, double radio){ super(x,y); this.radio=radio; } public double area(){ return Math.PI*radio*radio; } }
Como vemos, la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabara reservada super. Posteriormente, se inicializa el miembro dato radio, de la clase derivada Circulo. 2 En la definición de la función area, se calcula el área del círculo mediante la conocida fórmula r , o bien *r*r. La constante Math.PI es una aproximación decimal del número irracional .
Uso de la jerarquía de clases Creamos un objeto c de la clase Circulo situado en el punto (0, 0) y de 5.5 unidades de radio. Calculamos y mostramos el valor de su área. Circulo c=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+c.area());
Creamos un objeto r de la clase Rectangulo situado en el punto (0, 0) y de dimensiones 5.5 de anchura y 2 unidades de largo. Calculamos y mostramos el valor de su área. Rectangulo r=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo "+r.area());
Veamos ahora, una forma alternativa, guardamos el valor devuelto por new al crear objetos de las clases derivadas en una variable f del tipo Figura (clase base). Figura f=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+f.area()); f=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo "+f.area());
