A ver si puedo ayudarte mañana, pero es que son las 2:45 de la mañana aquí en España y tengo sueño... demasiado sueño...
Sin embargo, te dejo un ejemplo que venían en mis apuntes de clase:
Cita: 1er Ejemplo: Crear un programa gráfico en java que muestre una ventana cuyo diseño se muestra. Realizar el programa haciendo uso de herencia con la clase Ventana.
Nombre: ____________________
Apellidos: _________________
Insertar
Ventana {hereda de JFrame}
+ Ventana(titulo:String)
+ crearComponentesVentana():Container {abstracto}
//Ventana.java
import javax.swing.JFrame;
import java.awt.Container;
import javax.swing.JPanel;
public abstract class Ventana extends JFrame {
public Ventana(String titulo){
super(titulo);
setTitle(titulo);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) ;
setContentPane(crearComponentesVentana());
pack() ;
}
public abstract Container crearComponentesVentana();
}//end_class
//MiVentana.java
import java.awt.*;
import javax.swing.*;
public class MiVentana extends Ventana {
public MiVentana(String titulo){
super(titulo);
}
public Container crearComponentesVentana(){
JPanel panel1=new JPanel();
panel1.setLayout(new GridLayout(3,1));
JPanel panel2=new JPanel();
panel2.setLayout(new FlowLayout(FlowLayout.LEFT));
panel2.add(new JLabel("Nombre:"));
panel2.add(new JTextField(30));
JPanel panel3=new JPanel();
panel3.setLayout(new FlowLayout(FlowLayout.LEFT));
panel3.add(new JLabel("Apellidos:"));
panel3.add(new JTextField(50));
JPanel panel4=new JPanel();
panel4.add(new JButton("Insertar"));
panel1.add(panel2);
panel1.add(panel3);
panel1.add(panel4);
return(panel1);
}
}
//EjemploVentana.java
public class EjemploVentana {
public static void main(String[] args) {
MiVentana ventana=new MiVentana("Ejemplo Ventana");
ventana.setVisible(true);
}
}//end_class
Y una pequeña ayuda, también de esos apuntes que te decía:
Cita: 8.- EJEMPLOS DE UTILIZACIÓN DE LA HERENCIA, CLASES ABSTRACTAS Y POLIMORFISMO EN JAVA.
Para hacer los ejemplos utilizaremos las librerías de clases gráficas de Java (awt y swing). A continuación se dan unas nociones básicas de estas librerías.
Existen unas clases llamadas contenedores superiores que implementan ventanas normales, ventanas de diálogo y applets. Estas clases son: Jframe, Jdialog y Japplet.
Las clases que representan contenedores superiores disponen de un panel de contenidos en el que se pueden incluir componentes. Los métodos Container getContenPane() y void setContentPane(Container) permiten acceder y modificar, respectivamente, dicho panel de contenidos.
JFrame
+ setVisible(visible:boolean) //muestra u oculta la ventana
Los contenedores intermedios son los encargados de almacenar los componentes visuales de la aplicación. Ademas, estos pueden incluir otros contenedores, lo que proporciona un modelo muy flexible para realizar aplicaciones con una interfaz compleja. De entre todos los contenedores intermedios, el más utilizado es JPanel, que proporciona una funcionalidad básica para colocar componentes.
Jpanel {descendiente de Container}
+ setLayout(mgr:LayoutManager) //set the layout manager para este contenedor.
+ add(arg0:Component)
Los gestores de esquema (LayoutManager) son los encargados de “colocar” los diversos componentes de un contenedor intermedio en un lugar u otro dentro de su area de visualización. Los gestores de esquemas más habituales son los siguientes:
El gestor de esquemas FlowLayout es el gestor de esquemas más simple. Distribuye los componentes en filas de izquierda a derecha y de arriba a abajo seg ún se van introduciendo en el contenedor.
El gestor de esquemas BorderLayout permite que el contenedor tenga como máximo cinco componentes, que serán colocados al norte, sur, este, oeste y centro del contenedor intermedio. Para introducir estos componentes se usa una versión sobrecargada del método void add(Container, int), donde el entero puede ser una de las constantes NORTH, SOUTH,EAST, WEST y CENTER definidas en la clase BorderLayout.
Por último, el gestor de esquemas GridLayout dispone de un constructor en el que se indica el número de filas y columnas en las que va a quedar dividido el contenedor intermedio. Cuando se utiliza este gestor, los componentes se van incluyendo ocupando filas de arriba a abajo, y cada fila de izquierda a derecha; además, todas las componentes introducidas ocuparán el mismo espacio dentro del contenedor intermedio.
FlowLayout //implementa interface LayoutManager
- CENTER: int {estatico} //alineacion centrada
- LEFT: int {estatico} //alineacion izquierda
- RIGHT: int {estatico} //alineacion derecha
+ FlowLayout() //construye un FlowLayout con alineación centrada y 5 unidades verticales y horizontales de //separación con los bordes
+ FlowLayout(int alineacion) //construye un FlowLayout con la alineación indicada y 5 unidades verticales y horizontales de
Un componente es un objeto gráfico que puede ser mostrado en la pantalla y con el que el usuario puede interactuar. Examplos de componentes son: botones, cajas de chequeo, barras de desplazamiento, cajas de texto, etc.
JButton {descendiente de Component}
+ JButton(arg0:String) //se le pasa el texto del botón
JLabel {descendiente de Component}
+ JLabel(arg0:String) //se le pasa el texto a mostrar
JTextField {descendiente de Component}
+ JTextField(arg0: int) //se le pasa el tamaño de la caja de texto
Si tienes dudas, o quieres que te lo explique personalmente, dímelo y mañana te escribo aquí El Mini Quijote... xD (tampoco sé mucho de Java, pero lo poquito que sé creo que te puede valer...)
También tienes un manual aquí:
http://www.cica.es/formacion/JavaTut/Cap4/awt.html
Un saludo! ;)