Introducción a CardLayout en Java
El siguiente artículo CardLayout en Java proporciona un resumen de los diferentes métodos de CardLayouts en Java. Como conocemos el concepto de Layout en Java y cómo los diferentes Layout Manager ayudan a administrar tantos componentes en un solo contenedor sin afectar el posicionamiento de cada uno. El diseño de la tarjeta es uno de ellos. A diferencia de otros diseños, que muestran los componentes de un contenedor de uno en uno, el Diseño de tarjeta, como su nombre lo indica, funciona como una baraja de cartas con una sola carta, es decir, la carta superior visible a la vez. Trata todos los componentes de un contenedor como una Tarjeta y el contenedor actúa como una Pila de cartas. El orden de las tarjetas en un contenedor se define internamente. Cuando el contenedor se muestra por primera vez, es el primer componente presente en el contenedor que está visible en ese momento.
Constructores de CardLayout en Java
CardLayout es una clase de Java y tiene algunos constructores. A continuación se presentan algunos de los constructores de CardLayout en Java:
CardLayout ()
Este constructor de la clase Java CardLayout se utiliza para crear un nuevo CardLayout con los espacios de tamaño cero (0) entre los diferentes componentes.
CardLayout (int hgap, int vgap)
Este constructor de Java se usa para crear un nuevo CardLayout con el espacio horizontal y vertical entre los componentes como se menciona en los argumentos. Hgap denota el espacio horizontal mientras que vgap representa el espacio vertical entre los componentes.
Métodos de la clase CardLayout en Java
A continuación se muestra la lista de los métodos de la clase CardLayout:
| Nombre del método | Descripción del método |
| público nulo primero (contenedor principal) | Método utilizado para voltear a la primera tarjeta del contenedor proporcionado |
| público vacío último (contenedor principal) | Método utilizado para voltear a la última tarjeta del contenedor proporcionado |
| público nulo siguiente (contenedor principal) | Método utilizado para pasar a la siguiente tarjeta del contenedor proporcionado |
| público nulo anterior (contenedor principal) | Método utilizado para voltear a la tarjeta anterior del contenedor proporcionado |
| show público vacío (contenedor principal, nombre de cadena) | Método utilizado para voltear al contenedor especificado con el nombre dado |
| getVgap () | Método utilizado para obtener el espacio vertical entre los componentes. |
| getHgap () | Método utilizado para obtener el espacio horizontal entre los componentes. |
| void addLayoutComponent (componente com, restricciones de objeto) | Método utilizado para agregar el componente especificado a la tabla interna de componentes de diseño de tarjeta |
| float getLayoutAlignmentX (contenedor principal) | El método devuelve la alineación a lo largo del eje x |
| float getLayoutAlignmentX (contenedor principal) | El método devuelve la alineación a lo largo del eje y |
| Dimensión maximumLayoutSize (destino del contenedor) | El método devuelve las dimensiones máximas para el diseño dado el componente en el contenedor de destino |
| Dimension mimimumLayoutSize (destino del contenedor) | El método devuelve las dimensiones mínimas para el diseño dado el componente en el contenedor de destino |
| Dimensión preferida Diseño de tamaño (Contenedor principal) | En este método, usando el diseño de la tarjeta, se determina el tamaño preferido del argumento contenedor |
| void removeLayoutComponent (Componente comp) | Este método elimina el componente especificado del diseño de la tarjeta |
| String toString () | Este método devuelve la representación de cadena del diseño de esta tarjeta |
| void invalidateLayout (destino del contenedor) | Este método invalida el contenedor que indica si, en caso de que el administrador de diseño haya almacenado en caché alguna información, debe descartarse |
Ejemplo para CardLayout en Java
// importing all the necessary packages
import java.awt.*;
import java.awt.event.*;
import javax.swing.JFrame;
import javax.swing.*;
// Class Cardlayout is extending the JFrame and implementing the interface of ActionListener
public class Cardlayout extends JFrame implements ActionListener (
// Declaring the objects of the above mentioned Cardlayout class.
CardLayout cd;
// Declaring the objects of JButton class which we want in our JFrame
JButton jb1, jb2, jb3;
// Declaring the object of the Container class with the name 'con'.
Container con;
// Using the constructor of the class CardLayout in order to initialise the above objects
Cardlayout()
(
// using the method in order to get the content
con = getContentPane();
// Initializing the object "cd” of CardLayout class with horizontal and vertical spaces as 70 and 50 respectively
cd = new CardLayout(70, 50);
// setting of the layout using the setLayout method
con.setLayout(cd);
// Initialising the object "jb1" of the above JButton class.
jb1 = new JButton("Hello");
// Initialising the object "jb2" of the above JButton class.
jb2 = new JButton("Hey");
// Initialising the object "jb3" of the above JButton class.
jb3 = new JButton("Hii");
// Using this Keyword in order to refers to the current object.
// Adding of Jbutton "jb1" on JFrame using the methods of ActionListener
jb1.addActionListener(this);
// Adding of Jbutton "jb2" on JFrame.
jb2.addActionListener(this);
// Adding of Jbutton "jb3" on JFrame.
jb3.addActionListener(this);
// Adding of the above buttons to the container one by one
// Adding the JButton "jb1" using add method
con.add("a", jb1);
// Adding the JButton "jb2" similar to the above
con.add("b", jb2);
// Adding the JButton "jb3" in the container
con.add("c", jb3);
)
public void actionPerformed(ActionEvent e)
(
// using next method to call the next card
cd.next(con);
)
// Main Method of Java class from where the execution starts
public static void main(String() args)
(
// Creating Object of CardLayout class.
Cardlayout cl1 = new Cardlayout();
// Setting the title of JFrame
cl1. setTitle("Checking how Card Layout works");
// Setting the size of JFrame.
cl1.setSize(800, 800);
// Setting the resizable value of JFrame.
cl1.setResizable(false);
// Setting the visibility of JFrame.
cl1.setVisible(true);
// Function to set default operation of JFrame.
cl1.setDefaultCloseOperation(EXIT_ON_CLOSE);
)
)
En el ejemplo anterior, Cardlayout es el nombre de la clase que hereda el JFrame e implementa la interfaz ActionListener. Estamos tratando de organizar los diversos componentes de JLabel en un JFrame. Estamos creando 3 jButtons con el nombre jb1, jb2, jb3 y los estamos agregando al JFrame. Los botones se agregan a jFrame utilizando el método add (). En la función principal, se utilizan varios métodos como setVisible () para establecer la visibilidad del marco, setResizable para establecer la capacidad de ajuste, setTitle y setSize para establecer el título y el tamaño del marco. Explicación
Salida:
Entonces, como se muestra a continuación, la salida sería un jFrame con el primer botón con el nombre "Hola" mostrado primero, haciendo clic en el segundo botón "Hey" se muestra y luego haciendo clic en el botón "Hii" se muestra al usuario.
Conclusión
Hay varios tipos de diseños en Java y cada diseño tiene su propia forma de organizar los componentes. Para trabajar de manera eficiente en aplicaciones GUI, la comprensión profunda y práctica de cada diseño es muy importante para un programador. La programación de gráficos también utiliza Layout Managers en su desarrollo, que es tendencia en la industria de TI.
Artículos recomendados
Esta es una guía de CardLayout en Java. Aquí discutimos la Introducción, Constructores y Métodos de Cardlayout en Java junto con algunos ejemplos. También puede consultar los siguientes artículos para obtener más información:
- Combinar Ordenar en Java
- Clasificación rápida en Java
- Mientras Loop en Java
- Patrones de estrellas en Java
- Diseño HTML