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.
- Descarga el Paquete de Software J2SE 1.4.
- A�ade a tu Bookmark las Especificaciones del API