FlowLayout (diseño de flujo): Es la disposición por defecto al crear un marco siempre que no le indiquemos lo contrario al crear un marco.
o
Constructores:
FlowLayout()
FlowLayout(int alineación)
FlowLayout (int alineación, int separación entre botones, int separación_vertical al borde)
Ejemplo:
import
java.awt.FlowLayout;
import javax.swing.*;
public class
otroEjemplodelayout {
public static void main (String[] asgs) {
(new
Marco123456789()).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
(new Marco123456789()).setVisible(true);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica");
setBounds(600,350,600,300);
Panel
LAmina = new
Panel();
LAmina.setLayout(new FlowLayout(FlowLayout.RIGHT,50,100));
add(LAmina);
}
class Panel extends JPanel{
public Panel() {
add(new JButton ("Uno"));
add(new JButton ("Dos"));
add(new JButton ("Tres"));
}
}
Otra forma
de hacerlo sería la siguiente. Pondremos el constructor del Layout en el
constructor de la Lámina(JPanel). Es más limpia y fácil.
import java.awt.FlowLayout;
import javax.swing.*;
public class
otroEjemplodelayout {
public static void main (String[] asgs) {
(new Marco123456789()).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
(new Marco123456789()).setVisible(true);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica");
setBounds(600,350,600,300);
add(new Panel());
}
}
class Panel extends JPanel{
public Panel() {
setLayout(new FlowLayout(FlowLayout.RIGHT,50,100));
add(new JButton ("Uno"));
add(new JButton ("Dos"));
add(new JButton ("Tres"));
}
}
BorderLayout (diseño
de borde): Dispondremos los objetos
utilizando los puntos cardinales como referencia. Los componentes que
introduzcamos en cada una de las zonas se harán lo suficiente mente grandes
como para llenar la zona a la que pertenecen.
BorderLayout
tiene una característica peculiar y es que los componentes que introduzcamos en
cada una de las zonas se harán lo suficiente mente grandes como para llenar la
cuadricula en la que se encuentra.
Ejemplo con el constructor por
defecto BorderLayout():
class Panel extends JPanel{
public Panel() {
setLayout(new BorderLayout());
add(new JButton ("NORTE"),BorderLayout.NORTH);
add(new JButton ("CENTRO"),BorderLayout.CENTER);
add(new JButton ("OUESTE"),BorderLayout.EAST);
add(new JButton("SUR"),BorderLayout.SOUTH);
add(new JButton("ESTE"),BorderLayout.WEST);
}
}
Existe un segundo constructor que nos permite dar espacio entre los
componentes
BorderLayout(espacio
horizontal entre componentes, espacio vertical entre componentes )
class Panel extends JPanel{
public Panel() {
setLayout(new BorderLayout(10,20));
add(new JButton ("NORTE"),BorderLayout.NORTH);
add(new JButton ("CENTRO"),BorderLayout.CENTER);
add(new JButton ("OUESTE"),BorderLayout.EAST);
add(new JButton("SUR"),BorderLayout.SOUTH);
add(new JButton("ESTE"),BorderLayout.WEST);
}
}
En el siguiente
ejercicio vamos a ver como unir
dos Layout en un mismo marco. Utilizaremos un único marco como
contenedor y dos láminas. En la primera lámina crearemos varios objetos
dispuesto con diseño BorderLayout que
utilizaremos para el cuerpo del Frame y una segunda lámina con diseño
FlowLayout para poner un menú al marco. Al final uniremos las dos layout en un
solo marco con diseño BorderLayout para orientarlas en
el espacio.
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import javax.swing.*;
public class
otroEjemplodelayout {
public static void main (String[] asgs) {
(new
Marco123456789()).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
(new Marco123456789()).setVisible(true);
}
}
class Panel extends JPanel{
public Panel()
{
setLayout(new BorderLayout(10,10));
add(new JButton ("BOTON 1"),BorderLayout.NORTH);
add(new JButton ("BOTON 2"),BorderLayout.CENTER);
add(new JButton ("BOTON 3"),BorderLayout.EAST);
add(new JButton("BOTON 4"),BorderLayout.SOUTH);
add(new JButton("BOTON 5"),BorderLayout.WEST);
}
}
class Panel2 extends JPanel{
public Panel2() {
setLayout(new FlowLayout(FlowLayout.CENTER));
add(new JButton ("1"));
add(etiqueta = new JLabel
("Etiqueta"));
add(Caja_voz = new
JCheckBox ("ChexkBox"));
add(Check_redondo = new
JRadioButton ("check
redondo"));
Combo=new JComboBox();
Combo.addItem("");
Combo.addItem("uno");
Combo.addItem("dos");
Combo.addItem("tres");
add(Combo);
add(Texto=new
JTextField("texto"));
}
JLabel etiqueta;
JCheckBox Caja_voz;
JRadioButton Check_redondo;
JComboBox
Combo;
JTextField Texto;
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica");
setBounds(700,250,500,300);
//creamos objetos con
las laminas
Panel Panel_de_cuerpo =new
Panel();
Panel2 Panel_menu =new
Panel2();
//Las unimos al
marco y disponemos en el espacio con
BorderLayout
add(Panel_de_cuerpo,BorderLayout.CENTER);
add(Panel_menu,BorderLayout.NORTH);
}
}
GridLayout (diseño
cuadricula): distribuirá nuestro marco formando una cuadricula como la de una
hoja de Excel.
o
Constructor:
GridLayout () constructor por defecto
crea una columna por cada componente que tenga en una sola fila
GridLayout (int
rows, int cols) crea las filas y
columnas que le indiquemos nosotros (rows = filas, cols = columnas).
GridLayout (int
rows, int cols, int hgap, int vgap) crea las filas y columnas que le indiquemos y
da separación entre los objetos ( hgap
= separcion horizontal, vgap = separación vertical).
o
Métodos:
§
setHgap(int separacion)
§
setVgap(int separacion)
En el siguiente ejemplo vamos a
crear dos láminas una en la que incluiremos los números y otra en la que
ponderemos un cuadro de texto.
import java.awt.*;
import javax.swing.*;
public class
otroEjemplodelayout {
public static void main (String[] asgs) {
(new
Marco123456789()).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
(new Marco123456789()).setVisible(true);
}
}
class Panel extends JPanel{
public Panel() {
setLayout(new GridLayout(5,3));//rows (filas), cols(columnas)
add(new JButton("1"));
add(new JButton("2"));
add(new JButton("3"));
add(new JButton("4"));
add(new JButton("5"));
add(new JButton("6"));
add(new JButton("7"));
add(new JButton("8"));
add(new JButton("9"));
add(new JButton("0"));
add(new JButton("+"));
add(new JButton("-"));
add(new JButton("/"));
add(new JButton("*"));
}
}
class Consola extends JPanel{
public Consola(){
JTextField cuadro_texto =new
JTextField ("0",15);
cuadro_texto.setBackground(Color.magenta);
cuadro_texto.setFont(new Font("Arial Black",Font.BOLD,25));
add(cuadro_texto);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica");
setBounds(300,100,500,500);
Panel Panel_de_cuerpo =new
Panel();
Consola zona_calculo = new
Consola();
//combinamos las dos
laminas en un frame
add(zona_calculo, BorderLayout.NORTH);
add(Panel_de_cuerpo, BorderLayout.CENTER);
}
}
También podemos cargar los datos
en la lámina utilizando un array. Y en Lugar del setBounds para dar tamaño al
cuadro utilizar pack(), que le dará tamaño de forma automática.
package poo;
import java.awt.*;
import javax.swing.*;
public class otroEjemplodelayout
{
public static void main (String[] asgs) {
(new
Marco123456789()).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
(new Marco123456789()).setVisible(true);
}
}
class Panel extends JPanel{
public Panel() {
setLayout(new GridLayout(9,4));//rows (filas), cols(columnas)
//creamos un array con
los botones
JButton Botones_Calculo[] = {
new JButton("0"),new
JButton("1"),new
JButton("2"),new
JButton("3"),
new JButton("4"),new
JButton("5"),new
JButton("6"),new
JButton("7"),
new JButton("8"),new
JButton("9"),new
JButton("+"),new
JButton("-"),
new JButton("/"),new
JButton("*"),new
JButton("=")
};
//utilizamos un for
each para cargar los botones en la lamina
int n=0;
for (JButton i:Botones_Calculo) {
add(Botones_Calculo[n]);
n++;
}
}
}
class Consola extends JPanel{
public Consola(){
JTextField cuadro_texto =new
JTextField ("0",15);
cuadro_texto.setBackground(Color.magenta);
cuadro_texto.setFont(new Font("Arial Black",Font.BOLD,25));
add(cuadro_texto);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica");
Panel Panel_de_cuerpo =new
Panel();
Consola zona_calculo = new
Consola();
//combinamos las dos
laminas en un frame
add(zona_calculo, BorderLayout.NORTH);
add(Panel_de_cuerpo, BorderLayout.CENTER);
/*el metodo pack() da
tamaño de forma automática a nuestro cuadro
* con el taño del conjunto
de los objetos que lo componen
*/
pack();
}
}
Ahora vamos a poner a la escucha, cuando los presionemos imprimirá
en consola el número que refleja nuestro botón.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class otroEjemplodelayout {
public static void main (String[] asgs) {
Marco123456789
Calculator = new
Marco123456789();
Calculator.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Calculator.setVisible(true);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica de
Calculadora");
setBounds(300,100,350,400);
Consola Calculadora = new
Consola();
add(Calculadora);
}
}
class Consola extends JPanel implements ActionListener{
public Consola(){
setLayout(new BorderLayout());
cuadro_texto =new JTextField ("0",10);
cuadro_texto.setBackground(Color.magenta);
cuadro_texto.setFont(new Font("Arial Black",Font.BOLD,35));
//cuadro_texto.setLayout(new
BorderLayout());
add(cuadro_texto,BorderLayout.NORTH);
Panel =new JPanel();
Panel.setLayout(new GridLayout(5,4));
//creamos un array con los botones
JButton Botones_Calculo[] = {
new JButton("0"),new
JButton("1"),new
JButton("2"),new
JButton("3"),
new JButton("4"),new
JButton("5"),new
JButton("6"),new
JButton("7"),
new JButton("8"),new
JButton("9"),new
JButton("+"),new
JButton("-"),
new JButton("/"),new
JButton("*"),new
JButton("=")
};
//utilizamos un for each para cargar
los botones en la lamina y poner a la escucha
los botones
int n=0;
for (JButton i:Botones_Calculo) {
Panel.add(Botones_Calculo[n]); Botones_Calculo[n].addActionListener(this);
n++;
}
add(Panel,BorderLayout.CENTER);
}
//declaramos las variables fuera de
la case para utilizarlas en ActionListener
JPanel Panel;
JTextField cuadro_texto;
public void actionPerformed(ActionEvent e) {
//obtenemos el texto del botón getActionCommand()
String entrada = e.getActionCommand();
//discriminamos los botones + - / …
if (entrada !="+" && entrada !="-" && entrada !="/" && entrada !="*" && entrada !="=")
cuadro_texto.setText(entrada);
}
}
Ahora organizaremos los botones
mejor daremos un tamaño mayor a los números y funcionalidad para que pueda
realizar cálculos:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class otroEjemplodelayout {
public static void main (String[] asgs) {
Marco123456789
Calculator = new
Marco123456789();
Calculator.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Calculator.setVisible(true);
}
}
class Marco123456789 extends JFrame{
public Marco123456789() {
setTitle("Practica de
Calculadora");
setBounds(300,100,350,400);
Consola
Calculadora = new
Consola();
add(Calculadora);
}
}
class Consola extends JPanel implements ActionListener{
public Consola(){
setLayout(new BorderLayout());
resetea=true;
cuadro_texto =new
JTextField ("0",10);
cuadro_texto.setBackground(Color.WHITE);
cuadro_texto.setFont(new Font("Arial Black",Font.BOLD,35));
//cuadro_texto.setLayout(new
BorderLayout());
add(cuadro_texto,BorderLayout.NORTH);
Panel =new JPanel();
Panel.setLayout(new GridLayout(4,4,3,3));
//creamos un array con
los botones
JButton
Botones_Calculo[] = {
new JButton("7"),new
JButton("8"),new
JButton("9"),new
JButton("*"),
new JButton("4"),new
JButton("5"),new
JButton("6"),new
JButton("-"),
new JButton("1"),new
JButton("2"),new
JButton("3"),new
JButton("+"),
new JButton("."),new
JButton("0"),new
JButton("/"),new
JButton("=")
}
//utilizamos un for
each para cargar los botones en la lamina
int n=0;
for (JButton i:Botones_Calculo) {
Botones_Calculo[n].setFont(new Font("Arial Black",Font.BOLD,30));
Botones_Calculo[15].setBackground(Color.CYAN);
Panel.add(Botones_Calculo[n]);
Botones_Calculo[n].addActionListener(this);
n++;
}
add(Panel,BorderLayout.CENTER);
}
//declaramos las variables fuera de la
case para utilizarlas en ActionListener
private JPanel Panel;
private
JTextField cuadro_texto;
private boolean resetea;
private double num1,num2,resultado;
String operador;
public void actionPerformed(ActionEvent e) {
String
entrada = e.getActionCommand();
if(resetea) {
//si resetea ==true limpia
pantalla
cuadro_texto.setText("");
resetea=false;
}
if(entrada !="+" && entrada !="-"
&& entrada !="/"
&& entrada !="*" &&
entrada !="="){
cuadro_texto.setText(cuadro_texto.getText()+entrada);
}
if (entrada =="+" || entrada =="-" || entrada =="/" || entrada =="*" ) {
num1= Double.parseDouble(cuadro_texto.getText());
cuadro_texto.setText("0");
operador= entrada;
System.out.println(num1+ "
"+ operador);
resetea=true;
}
if(entrada=="=") {
num2= Double.parseDouble(cuadro_texto.getText());
resetea=true;
switch (operador) {
case
"-":
resultado= num1 - num2;
//String.VAlueOf combierte un
numero en String
cuadro_texto.setText( String.valueOf(resultado));
break;
case "/" :
resultado= num1 / num2;
cuadro_texto.setText( String.valueOf(resultado));
break;
case "+" :
resultado= num1 + num2;
cuadro_texto.setText( String.valueOf(resultado));
break;
case "*" :
resultado= num1 * num2;
cuadro_texto.setText( String.valueOf(resultado));
break;
}
}
}
}
BoxLayout(diseño de caja): Dispone todos los objetos en cajas que podemos organizar de
diferentes formas utilizando sus métodos. Pude venirnos muy bien para
formularios. para mensajes de alerta, cajas de password…
No tenemos que
crear láminas y luego unirlas al marco, creamos las cajas (Box) y las unimos al
marco.
Sintaxis general:
JPanel LaminaRadioButton = new
JPanel();
LaminaRadioButton.setLayout(new BoxLayout(LaminaRadioButton, BoxLayout.PAGE_AXIS));
Azul= new
JRadioButton("Azul");
Rojo= new
JRadioButton("Rojo");
Verde= new
JRadioButton("Verde");
LaminaRadioButton.add(Rojo);
LaminaRadioButton.add(Verde);
LaminaRadioButton.add(Azul);
Métodos de BoxLayout:
§
createHorizontalBox() dispone las cajas una al lado de otra a lo
largo de la lámina. Si excedemos el tamaño de la lámina los elementos que
queden fuera no los veríamos. Para poder verlos tendríamos que ampliar la caja.
§
createVerticalBox() dispone las cajas una encima de otra a lo largo
de nuestra lámina. Si excedemos el tamaño de la lámina los elementos que queden
fuera no los veríamos Para poder verlos tendríamos que ampliar la caja.
§
createVerticarStrut(int height) determina
la distancia Vertical entre cajas utilizando un intger que le pasamos por
parámetros.
§
createHorizontalStrut(int Width) determina
la distancia horizontal entre cajas utilizando un intger que le pasamos
§ createGlue() adapta la distancia que existe entre dos componentes
cuando se redimiensiona el marco, por lo que la distancia se ampliara
proporcionalmente cuando ampliemos
EJERCICIO:
public class ejemoloBoxLayout {
public static void main(String[] args) {
MarcoBox x = new MarcoBox();
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
x.setVisible(true);
}
}
class MarcoBox extends JFrame{
public MarcoBox() {
setBounds(700,100,300,200);
texto1 = new JLabel("USUSRIO");
texto2 = new JLabel("contraseña");
cajatexto1 = new JTextField(10);
cajatexto2 = new JTextField(10);
Boton1 = new JButton("ACCEDER");
Boton2 = new JButton("NO ACCEDER");
cajatexto1.setMaximumSize(cajatexto1.getPreferredSize());
cajatexto2.setMaximumSize(cajatexto2.getPreferredSize());
Box principal = Box.createVerticalBox();
Box caja1 = Box.createHorizontalBox();
caja1.add(texto1);
caja1.add(Box.createHorizontalStrut(15));//espacio entre cajas
caja1.add(cajatexto1);
Box caja2 = Box.createHorizontalBox();
caja2.add(texto2);
caja2.add(Box.createHorizontalStrut(15));//espacio entre cajas
caja2.add(cajatexto2);
Box caja3 = Box.createHorizontalBox();
caja3.add(Boton1);
caja3.add(Box.createGlue());//espacio entre cajas
dinamico
caja3.add(Boton2);
principal.add (caja1);
principal.add (caja2);
principal.add (caja3);
add(principal,BorderLayout.CENTER);
}
private JLabel texto1,texto2;
private JTextField cajatexto1,cajatexto2;
private JButton Boton1,Boton2;
}
CardLayout (diseño
carta): Dispone un cuadro combinado en la parte superior centrado y
dependiendo del que seleccionemos aparecerán diferentes controles en la parte
inferior.
GropuLayout(diseño de grupo): El diseño se define para cada
dimensión de forma independiente. En consecuencia, sin embargo, cada
componente debe definirse dos veces en el diseño. Se utiliza para los
constructores GUI.
SpringLayout (diseño
primavera o muelle): Nos permite especificar relaciones entre los
componentes bajo nuestro
control.
Creamos una especie de puelles entre los objetos y
cuando se redimensiona adquieren la separación dependiendo de los parámetros
que le pasemos. A mayor tensión más le
costará estirar entre botones, contra menor sea la tensión más se separaran.
1.
Crearemos un SpringLayout en nuestra lámina para disponerla con este
diseño predeterminado de java.
SpringLayout LY_Spring
= new SpringLayout();
2.
Mas adelante crearemos una instancia a la clase Spring.
Spring separador
= Spring.constant(0, 10, 100);
3.
Ahora Utilizaremos el método PutContraint(inicio muelle,ElementoUnion,Objeto
Spring creado,proximoObjeto)
LY_Spring.putConstraint(SpringLayout.WEST, BOTON1, separador, SpringLayout.WEST, this);
LY_Spring.putConstraint(SpringLayout.WEST, BOTON2, separador, SpringLayout.EAST, BOTON1);
LY_Spring.putConstraint(SpringLayout.WEST, BOTON3, separador, SpringLayout.EAST, BOTON2);
LY_Spring.putConstraint(SpringLayout.EAST, this, separador, SpringLayout.EAST, BOTON3);
Por lo que el cídigo completo sería el siguiente:
import javax.swing.*;
public class
PracticaSrpingLayout {
public static void main (String[] args) {
MarcoPracticaSrpingLayout
xyy = new MarcoPracticaSrpingLayout();
xyy.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
xyy.setVisible(true);
xyy.add(xyy);
}
}
class MarcoPracticaSrpingLayout extends JFrame{
public MarcoPracticaSrpingLayout() {
setBounds(700,200,500,350);
LaminaMuelle
lam = new LaminaMuelle();
lam.setVisible(true);
add(lam);
}
class LaminaMuelle extends JPanel{
public LaminaMuelle(){
BOTON1= new JButton
("muelle 1");
BOTON2= new JButton
("muelle 2");
BOTON3= new JButton
("muelle 3");
//******* carga del
layout **********
SpringLayout
LY_Spring = new
SpringLayout();
setLayout(LY_Spring);
add(BOTON1);
add(BOTON2);
add(BOTON3);
Spring separador = Spring.constant(10, 30,
200);
LY_Spring.putConstraint(SpringLayout.WEST, BOTON1, separador, SpringLayout.WEST, this);
LY_Spring.putConstraint(SpringLayout.WEST, BOTON2, separador, SpringLayout.EAST, BOTON1);
LY_Spring.putConstraint(SpringLayout.WEST, BOTON3, separador, SpringLayout.EAST, BOTON2);
LY_Spring.putConstraint(SpringLayout.EAST, this, separador, SpringLayout.EAST, BOTON3);
}
JButton BOTON1,BOTON2,BOTON3;
}
}
No hay comentarios:
Publicar un comentario