Suplemento Nº 7 de New 2 Java (Ene-2002)
Lenguaje Java Básico
Usar las Palabras Claves this y super
Los constructores son métodos especiales usados para crear e inicializar ejemplares de clases. Podemos proporcionar uno o más constructores, dependiendo de cúantas formas diferentes queremos que sopore la inicialización de una clase. Cuando definimos un constructor para una clase, el nombre del constructor debe ser el mismo que el nombre de la clase. Aquí la clase Person tiene un constructor que acepta un argumento String:
class Person {
String name;
Person(String name) {
this.name = name;
}
}
Para crear un ejemplar de la clase Person, llamamos al constructor con la palabra clave new:
Person p = new Person("Ophelia Jones");
Esto crea un nuevo ejemplar Person, y este ejemplar tiene su name inicializado la valor de "Ophelia Jones".
Las clases no están limitadas a un sólo constructor. Mientras que su lista de argumentos sea diferente, podemos usar varios constructores en una clase. Por ejemplo, si queremos crear un objeto Person y no conocemos su nombre, podemos proporcionar un segundo constructor que no acepte argumentos y proporcione un valor por defecto para el nombre:
class Person {
String name;
Person() {
this.name = "Jane Doe";
}
Person(String name) {
this.name = name;
}
}
Usamos this para acceder a la variable de ejemplar. Normalmente, no necesitamos usar this. Sin embargo, cuando una variable de ejemplar y una variable local comparten el mismo nombre, debemos diferenciar entre las dos poniéndole un prefijo al acceso a la variable de ejemplar con el uso de this.
Hay un fallo para este método de proporcionar múltiples constructores: todos el código inicial está duplicado en cada constructor, sólo proporcionando un nombre específico en el primero. En su lugar, una forma más eficiente es hacer que el primer constructor llame al segundo. Para llamar a un constructor desde otro constructor, la primer línea no comentada del constructor debe ser el método this, pasandole los parámetros apropiados, normalmente rellenando estos valores con las selecciones por defecto. Aquí, el constructor sin argumentos, llama al otro constructor pasándole el nombre por defecto a través de la llamada this. Ahora, todo el código de inicialización está centralizado en el segundo constructor. En otras palabras para las clases en que sea necesario, sólo necesitamos actualizar un constructor, no los dos:
class Person {
String name;
Person() {
this("Jane Doe");
}
Person(String name) {
this.name = name;
}
}
Cuando creamos una subclase, su constructor llama automáticamente a la versión sin argumentos de la clase padre, a menos que le digamos lo contrario. Por ejemplo, la siguiente clase define un Soldier con las propiedades name, rank, y serialNumber (el name viene de Person):
class Soldier extends Person {
String rank;
String serialNumber;
Soldier(String name, String rank,
String serialNumber) {
this.rank = rank;
this.serialNumber = serialNumber;
}
}
Como el constructor de Soldier no dice lo contrario, se llama al versión del argumento del constructor de la clase padre para inicializar el estado de Person. Esto significa que todos los soldados tendrán un nombre de "Jane Doe" según está escrita la clase actualmente. Para corregir este comportamiento, llamamos explícitamente al constructor de la superclase que acepta un parámetro name. Esto se hace añadiendo una llamada a super() en la primera línea del constructor.
class Soldier extends Person {
String rank;
String serialNumber;
Soldier(String name, String rank,
String serialNumber) {
super(name);
this.rank = rank;
this.serialNumber = serialNumber;
}
}
Cualquier cosa que pasemos a la llamada al constructor de Soldier será pasada al constructor de Person.
El uso de las llamadas a this y super está reservado sólo para la primera línea de un constructor. No podemos tener los dos en una llamada a un constructor. Si ninguna está presente. se asume una llamada vacía a super.
Entender la Librería de Clases Java
La Clase JFrame
Un JFrame es una clase predefinida del paquete javax.swing y es una versión extendida de java.awt.Frame. Usamos un JFrame para construir una ventana de alto nivel con un borde, unos botones de maximizar y minimizar y un botón de cierre. Además un JFrame es un contenedor Swing que contiene otros contenedores y componentes como paneles y menús a través de asociación conuno de sus sub-paneles.
La clase JFrame tiene cuatro constructores en Java 1.3 para construir un objeto JFrame:
- JFrame()
Este es el constructor por defecto, que crea un JFrame invisible y que no tiene ninguna otra característica.
- JFrame(GraphicsConfiguration gc)
Este segundo constructor crea un JFrame en el GraphicsConfiguration especificado de un dispositivo de pantalla con un título en blanco.
- JFrame(String title)
El tercer constrcutor acepta un String como argumento y crea un JFrame con un título específico.
- JFrame(String title, GraphicsConfiguration gc)
Este último constructor crea un JFrame con el título especificado y el GraphicsConfiguration especificado en un dispositivo de pantalla.
Inicializamos un objeto JFrame, usando el tercer constructor de esta forma:
JFrame f = new JFrame("A Frame Example");
Incluso más común es usar la palabra clave extends con una clase hijo de JFrame para obtener los beneficios de la herencia, y luego llamar al constructor de la clase padre JFrame con:
super("A Frame Example");
- getContentPane
- getGlassPane
- getJMenuBar
- getLayeredPane
- getRootPane
El frame no es visible hasta que nosotros hagamos que lo sea. Hacemos una marco visible, llamando al el método show y seleccionadolo a true. Esto nos asegura que el marco aparecerá:
setVisible(true);
También podemos seleccionar el tamaño de nuestro marco llamando a setSize e incluyendo la anhura y la altura:
setSize(350, 200);
Para especificar lo que sucede cuando el usuario cierra ese marco, llamamos al método setDefaultCloseOperation y especificamos una de las siguientes opciones:
- DO_NOTHING_ON_CLOSE
Requiere que el programa maneje la operación en el método windowClosing de un objeto WindowListener registrado.
- HIDE_ON_CLOSE
Este comportamiento por defecto oculta automáticametne el marco después de llamar a un objeto WindowListener registrado.
- DISPOSE_ON_CLOSE
Oculta automáticametne y desactiva el marco después de llamar a un objeto WindowListener registrado.
- EXIT_ON_CLOSE
Sale de la aplicación usando el método exit de System. Sólo debemos usar esto en aplicaciones.
El siguiente ejemplo demuestra los conceptos cubiertos hasta ahora:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
// FrameExample inherits from JFrame
// through use of the extends keyword.
public class FrameExample extends JFrame
{
// Variables for objects
JButton button;
JPanel buttonPanel;
public FrameExample()
{
// Initialize the button and panel.
button = new JButton("A Button Framed");
buttonPanel = new JPanel();
// Add the button to the panel
buttonPanel.add(button);
// Add the panel to the content pane
// of the JFrame in the North region of
// the default layout, in this case
// BorderLayout.
getContentPane().add(buttonPanel,
BorderLayout.NORTH);
// To close the window
setDefaultCloseOperation(EXIT_ON_CLOSE);
// Sets the width and height of the frame.
setSize(350, 200);
setVisible(true);
}
public static void main(String args[])
{
FrameExample fe = new FrameExample();
}
}
Programa Ejercicio
Cuando se trabaja con componentes JFrame, el comportamiento por defecto cuando se intenta cerrar el marco es ocultarse a sí mismo, pero no se apaga completamente. Frecuentemente querremos que la aplicación se apague cuando se cierre.
Crea una clase padre que apague la aplicación cuando se cierre.
- Crea una subclase que tenga el comportamiento de salir de la aplicación. Evitando llamar a System.exit tu mismo.
- Usa el método setDefaultCloseOperation de JFrame para configurar el comportamiento.
- Proporciona un constructor de reemplazao para los cuatro constructores de JFrame.
Un poco de Java
Herencia de Clases
¿Por qué escribir código desde el inicio cuando existe un objeto similar? No deberías. En su lugar puedes uesar la palabra clave extends para heredar las características de una clase ya existente.
Cuando desarrollamos una clase que desciende de otra clase, la clase que estámos escribiendo es el hijo o subclase -- la clase superior es la clase padre. Usando extends, nuestras clases heredan los campos y los métodos de la clase padre. Además podemos ocultar campos o sobreescribir métodos de la clase padre para cubrir mejor las necesidades de nuestra subclase.
Por ejemplo, lee la clase padre y sus hijos de abajo:
// Parent class that represents a basic
// vehicle feature and function.
class Vehicle
{
int wheels = 4;
public void engineStart()
{
System.out.println("Engine started. . .");
}
public void drive()
{
System.out.println("Driving on the pavement
on " + wheels + " wheels.");
}
}
// Subclass that uses the parent class' features
// and adds a method unique to this kind of vehicle.
class Car extends Vehicle
{
public Car()
{
System.out.println("I'm a car:");
}
public void doorLock()
{
System.out.println("Locking all doors.");
}
}
// Subclass that hides the field of the parent
// class with its own more appropriate data, and
// adds a method unique to this vehicle.
class Motorcycle extends Vehicle
{
// Hides the data of the parent class.
int wheels = 2;
public Motorcycle()
{
System.out.println("I'm a motorcycle:");
}
public void riding()
{
System.out.println("Riding on " + wheels +
" wheels.");
}
public void doingaWheelie()
{
System.out.println("Riding only on one wheel!");
}
}
// Subclass with additional data, a method
// that overrides the parent drive method,
// then later calls the parent's drive method
// within a method for this subclass.
class Truck extends Vehicle
{
String storageBed1 = "long bed";
String storageBed2 = "short bed";
public Truck()
{
System.out.println("I'm a truck.");
}
// This method overrides the parent class
// drive method, printing different text.
public void drive()
{
System.out.println("Use either 4-wheel
or 2-wheel drive.");
}
public void showFeatures()
{
// Use of the super keyword here calls the
// drive method of the parent class. If you
// omit super, then drive() from this
// subclass is called.
super.drive();
System.out.println("I have a "
+ storageBed1 + " for storage.");
}
}
// Class to instantiate the object listed above and
// call the parent classes as well as the subclass
// methods.
public class VehicleTest
{
public static void main(String[] args)
{
Car aCar = new Car();
aCar.engineStart();
aCar.drive();
aCar.doorLock();
Motorcycle aMotorcycle = new Motorcycle();
aMotorcycle.engineStart();
aMotorcycle.riding();
aMotorcycle.doingaWheelie();
Truck aTruck = new Truck();
aTruck.engineStart();
aTruck.drive();
aTruck.showFeatures();
}
}
Ejecutar VehicleTest dará el siguiente resultado:
I'm a car:
Engine started. . .
Driving on the pavement on 4 wheels.
Locking all doors.
I'm a motorcycle:
Engine started. . .
Riding on 2 wheels.
Riding only on one wheel!
I'm a truck.
Engine started. . .
Use either 4-wheel or 2-wheel drive.
Driving on the pavement on 4 wheels.
I have a long bed for storage.
Como ilustramos arriba, una subclase hereda campos y métodos de su clase padre, pero algunas veces necesitamos ocultar los datos del padre o sobreescribir métodos del padre para refinar la subclase. Ocultar los datos se hace simplemente usando el mismo nombre y tipo de variable. Sobreescribir los métodos del padre se hace usando el mismo nombre y la misma firma de método. Si hemos sobreescrito un método del padre, y luego encontramos que necesitamos llamar a la versión del padre de este método, usamos la palabra clave super y el operador punto.
Solución al Programa de Ejercicio
Hay muchas forma diferentes de implementar este ejercicio. Aquí tenemos una forma que se aprovecha del método de inicialización frameInit. También podemos inicializar la selección en los cuatro constructores.
import javax.swing.*;
public class ExitableJFrame extends JFrame {
public ExitableJFrame() {
}
public ExitableJFrame(String title) {
super(title);
}
public ExitableJFrame(GraphicsConfiguration gc) {
super(gc);
}
public ExitableJFrame(String title, GraphicsConfiguration gc) {
super(title, gc);
}
protected void frameInit() {
super.frameInit();
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Descargar la Plataforma Java 2
Para la mayoría del desarrollo Java, necesitas las librerías de clases Java, el compilador, las herramientas, y el entorno de ejecución proporcionado por el kit de desarrollo de Java 2, Standard Edition.
Tutoriales
