Los componentes Swing son similares a los componentes AWT, pero agregan nuevos métodos a cada componente y proporcionan componentes más avanzados.
Componentes básicos de Swing:
1. Botón (JBotón):
Los botones en Swing pueden mostrar imágenes, y el botón se puede configurar como el ícono predeterminado para una ventana, y se pueden asignar múltiples imágenes a un botón.
(1) Métodos de construcción de JButton comúnmente utilizados.
JButton(Texto de cadena): Caracteres que se muestran en el botón.
JButton(Icono de icono): muestra el icono en el botón.
JButton (texto de cadena, icono de icono): tanto los iconos como los caracteres se muestran en el botón.
(2). Métodos comúnmente utilizados:
b1.setEnabled(false); //Hacer que el botón no esté disponible actualmente
b1.setToolTipText("..."): //Establecer texto de sugerencia del botón
b1.setMnemonic(KeyEvent.VK_D); // Vincula b1 a la tecla alt+D
(3).Código de caso:
Copie el código de código de la siguiente manera:
la clase pública JButtonExample3 extiende JPanel implementa ActionListener {
JButton protegido b1, b2, b3;
público JButtonExample3() {
ImageIcon leftButtonIcon = createImageIcon("right.gif");
ImageIcon middleButtonIcon = createImageIcon("middle.gif");
ImageIcon rightButtonIcon = createImageIcon("left.gif");
b1 = new JButton("Botón central (D) no válido", leftButtonIcon);
b1.setVerticalTextPosition(AbstractButton.CENTER);//Alineación central horizontal
b1.setHorizontalTextPosition(AbstractButton.LEADING);//Equivalente a IZQUIERDA
b1.setMnemonic(KeyEvent.VK_D); // Vincula b1 a la tecla alt+D
b1.setActionCommand("deshabilitar");
b2 = new JButton("M botón central", middleButtonIcon);
b2.setVerticalTextPosition(AbstractButton.BOTTOM);
b2.setHorizontalTextPosition(AbstractButton.CENTER);
b2.setMnemonic(KeyEvent.VK_M); // Vincula b2 a la tecla alt+M
b3 = new JButton("E activa el botón central", rightButtonIcon);
b3.setMnemonic(KeyEvent.VK_E); // Vincula b3 a la tecla alt+E
b3.setActionCommand("habilitar");
b3.setEnabled(falso);
//Añadir detectores de eventos a 1 y 3
b1.addActionListener(esto);
b3.addActionListener(esto);
//Establecer el texto del mensaje del botón
b1.setToolTipText("¡Hacer clic en este botón invalidará el botón central!");
b2.setToolTipText("Haga clic en este botón, ¡no se producirá ningún evento!");
b3.setToolTipText("Al hacer clic en este botón, el botón central será efectivo");
//Añadir botón a JPanel
agregar(b1);
agregar(b2);
agregar(b3);
}
acción vacía pública realizada (ActionEvent e) {
if ("disable".equals(e.getActionCommand())) {
b2.setEnabled(falso);
b1.setEnabled(falso);
b3.setEnabled(verdadero);
} demás {
b2.setEnabled(verdadero);
b1.setEnabled(verdadero);
b3.setEnabled(falso);
}
}
ImageIcon estático protegido createImageIcon (ruta de cadena) {
java.net.URL imgURL = JButtonExample3.class.getResource(ruta);
si (imgURL! = nulo) {
devolver nuevo ImageIcon(imgURL);
} demás {
System.err.println("No se pudo encontrar el archivo: " + ruta);
devolver nulo;
}
}
público estático vacío principal (String [] argumentos) {
//Configurar para usar la nueva interfaz swing
//Proporciona una pista sobre si el JFrame recién creado debe tener las decoraciones de ventana proporcionadas por la apariencia actual (como bordes, widgets para cerrar la ventana, títulos, etc.).
JFrame.setDefaultLookAndFeelDecoated(verdadero);
//Crear un formulario
Marco JFrame = nuevo JFrame ("Botón del pequeño dragón");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Crear un panel
JButtonExample3 newContentPane = nuevo JButtonExample3();
newContentPane.setOpaque(verdadero);
frame.setContentPane(nuevoContentPane);
// mostrar formulario
marco.paquete();
marco.setLocation(300, 200);
frame.setVisible (verdadero);
}
}
Ejecutando captura de pantalla:
2. Cuadro combinado (JComboBox):
Explicación detallada de cómo utilizar el cuadro combinado (lista desplegable JComboBox) y ejemplos:
Método de construcción:
* JComboBox() crea un componente JComboBox.
* JComboBox (modelo ComboBoxModel) Crea un componente JComboBox basado en el modelo.
* JComboBox(Objext[] elementos) utiliza objetos de matriz para crear un componente JComboBox.
* JComboBox (elementos vectoriales) utiliza objetos vectoriales para crear un componente JComboBox.
Métodos comúnmente utilizados:
....
Ejemplo completo:
Copie el código de código de la siguiente manera:
import java.awt.* /* Contiene todas las clases para crear interfaces de usuario y dibujar imágenes gráficas. */
import javax.swing.* /* Proporciona un conjunto de componentes "ligeros" e intenta que estos componentes funcionen de la misma manera en todas las plataformas */
la clase pública JComboBoxDemo extiende JFrame {
JComboBoxDemo pública() {
/*
* Contenedor es la clase principal de todos los contenedores y una subclase de la clase de componente del lenguaje Java Componente. Un contenedor es un componente que tiene la función de acomodar otros componentes y contenedores.
* El elemento más básico de una interfaz gráfica de usuario de Java es un componente. Un componente es un objeto que se puede mostrar en la pantalla gráficamente e interactuar con el usuario, como un botón, un cuadro de texto, etc.
* En Java, los componentes generalmente se colocan en un contenedor determinado y el método this.getContentPane() se usa para devolver el objeto contentPane de este formulario.
*/
Panel de contenido del contenedor = this.getContentPane();
/* Cree un objeto de panel, especifique el administrador de diseño como GridLayout, 1 fila y 2 columnas. La administración de diseño predeterminada de Jpanel es FlowLayout */.
JPanel jPanel1 = nuevo JPanel(nuevo GridLayout(1, 2));
// Crea JComboBox usando una matriz de cadenas
Cadena[] fruta = { "manzana", "plátano", "naranja", "pera", "mango" };
JComboBox jComboBox1 = nuevo JComboBox(fruta);
jComboBox1.addItem("Otro"); //Agrega otra opción "Otro" al final de las opciones del cuadro de lista
//Establece el borde titulado del objeto jList1
jComboBox1.setBorder(BorderFactory.createTitledBorder("Tu fruta favorita:"));
//Añadir cuadro de lista jComboBox1 al panel
jPanel1.add(jComboBox1);
//Utiliza ComboBoxModel para crear JComboBox
ComboBoxModel miModelo = nuevo MiModelo();
JComboBox jComboBox2 = nuevo JComboBox(miModelo);
//Establece el borde titulado del objeto jList1
jComboBox2.setBorder(BorderFactory.createTitledBorder("Tu fruta favorita:"));
//Añadir cuadro de lista jComboBox2 al panel
jPanel1.add(jComboBox2);
//Agregar panel al contenedor principal
contentPane.add(jPanel1);
//Establece el título de este formulario
this.setTitle("JComboBoxDemo");
//Establece el tamaño inicial mostrado por este formulario
this.setSize(350, 90);
this.setLocation(300, 200);
//Configura este formulario para que sea inicialmente visible
this.setVisible(verdadero);
}
clase MyModel extiende DefaultComboBoxModel {
Cadena[] fruta = { "manzana", "plátano", "naranja", "pera", "mango" };
MiModelo() {
for (int i = 0; i < fruta.longitud; i++) {
/* El método addElement() se utiliza para agregar elementos de opción al cuadro de lista */
this.addElement(fruta[i]);
}
}
}
público estático vacío principal (String args []) {
Prueba JComboBoxDemo = nueva JComboBoxDemo();
}
}
captura de pantalla:
3. Cuadro de lista (JList):
La función del cuadro de lista es similar a la del cuadro de lista desplegable. También permite a los usuarios elegir entre varios elementos, pero existen algunas diferencias. Proporciona a los usuarios modos de selección más diversos, incluida la selección única y la selección continua. y selección múltiple, correspondiente a las 3 constantes en ListSelectionModel:
(1) static int SINGLE_SELECTION Solo se puede seleccionar uno.
(2) static int SINGLE_INTERVAL_SELECTION Mantenga presionada la tecla [Shift] para seleccionar el intervalo de contacto.
(3) static int MULTIPLE_INTERVAL_SELECTION Mantenga presionada la tecla [Ctrl] para seleccionar varios elementos.
El constructor es el siguiente:
(1) JList() crea un componente JList.
(2) JList (modelo ListModel) Cree un componente JList basado en el modelo.
(3) JList (elementos Objeto []) utiliza objetos de matriz para crear un componente JList.
(4) JList (elementos vectoriales) Utilice objetos vectoriales para crear un componente JList.
Agregar el cuadro de lista JList al JScrollPane puede lograr el desplazamiento del cuadro de lista.
El ejemplo 1 de uso del componente Lista (JList) es el siguiente:
Copie el código de código de la siguiente manera:
la clase pública JListDemo1 extiende JFrame{
Panel de contenido del contenedor;
JPanel jp;
JListjList1,jList2,jList3;
pública JListDemo1(){
panel de contenido = this.getContentPane();
jp = nuevo JPanel(nuevo GridLayout(1,3));
//Utiliza una matriz de cadenas para crear un objeto JList
String[] fruta={"manzana","plátano","naranja","pera","mango"};
jList1=nueva JList(fruta);
//Establece el borde titulado del objeto jList1
jList1.setBorder(BorderFactory.createTitledBorder("Tu fruta favorita: "));
//Establece el modo de selección del objeto jList1 en selección única
jList1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jp.add(jList1);
//Utiliza ListModel para crear un objeto JList para realizar la dinámica del contenido de la lista
ListModel myModel=new MyModel(); //Crea un objeto de modelo de lista
jList2=new JList(myModel); //Crea una lista basada en el objeto del modelo de lista
jList2.setBorder(BorderFactory.createTitledBorder("Tu fruta favorita: "));
//Establece el modo de selección del objeto jList2 para mantener presionado [Ctrl] para selecciones múltiples
jList2.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jp.add(jList2);
jList3=nueva JList(fruta);
jList3.setBorder(BorderFactory.createTitledBorder("Tu fruta favorita: "));
jList3.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jList3.setVisibleRowCount(3);
jList3.setFixedCellWidth(120);
jList3.setFixedCellHeight(30);
JScrollPane jScrollPane = nuevo JScrollPane(jList3);
jp.add(jScrollPane);
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(340,200);
//embalar();
this.setLocation(400, 300);
this.setVisible(verdadero);
}
//Al heredar la clase DefaultListModel, se puede lograr la selección de listas de contenido dinámico
clase MyModel extiende DefaultListModel{
String[] fruta={"manzana","plátano","naranja","pera","mango"};
MiModelo(){
for(int i=0;i<fruta.length;i++){
/* void addElement(Objeto obj)
* Agrega el componente especificado al final de dicha tabla. */
this.addElement(fruta[i]);
}
}
}
principal vacío estático público (String [] argumentos) {
Prueba JListDemo1=nueva JListDemo1();
}
}
Los resultados de la ejecución se muestran en la siguiente figura:
Código de ejemplo 2 del cuadro de lista:
Copie el código de código de la siguiente manera:
la clase pública JListDemo2 extiende JFrame {
Panel de contenido del contenedor;
JPanel jp;
JList jListFont, jListSize;
//Constructor
pública JListDemo2() {
panel de contenido = this.getContentPane();
jp = nuevo JPanel(nuevo GridLayout());
setJListFont();
setJListFontSize();
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(240, 200);
this.setLocation(400, 300);
this.setVisible(verdadero);
} // Fin de JListDemo2
conjunto vacío públicoJListFont() {
Entorno de gráficos ge = Entorno de gráficos
.getLocalGraphicsEnvironment();
final String fontName[] = ge.getAvailableFontFamilyNames() // Obtener la fuente local del sistema
jListFont = new JList(nombredefuente);
//Establece el borde titulado del objeto jList1
jListFont.setBorder(BorderFactory.createTitledBorder("Fuente del sistema: "));
//Establece el modo de selección del objeto jList1 en selección única
jListFont.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jListFont.setVisibleRowCount(3);
jListFont.setFixedCellWidth(120);
jListFont.setFixedCellHeight(20);
JScrollPane jScrollPane1 = nuevo JScrollPane(jListFont);
jp.add(jScrollPane1);
}
conjunto vacío públicoJListFontSize() {
final String fontSize[] = { "8", "9", "10", "12", "14", "15", "16",
"18", "20", "21", "22", "24", "26", "28", "30", "36", "48",
"54", "72", "89" };
//Crea un cuadro de lista de tamaños de fuente listSize
jListSize = nueva JList(fontSize);
jListSize.setBorder(BorderFactory.createTitledBorder("Tamaño de fuente: "));
//Establece el modo de selección del objeto jList2 para mantener presionado [Ctrl] para selecciones múltiples
jListSize
.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jListSize.setVisibleRowCount(3);
jListSize.setFixedCellWidth(120);
jListSize.setFixedCellHeight(20);
JScrollPane jScrollPane2 = nuevo JScrollPane(jListSize);
jp.add(jScrollPane2);
}
público estático vacío principal (String [] argumentos) {
Prueba JListDemo2 = nueva JListDemo2();
}
}
Diagrama esquemático del funcionamiento del programa:
4.javax.swing
Clase JColorChooser:
JColorChooser (cuadro de diálogo de selección de color) proporciona un panel de controlador que permite al usuario manipular y seleccionar colores.
Constructor JColorChooser:
JColorChooser (): crea un objeto JColorChooer, el color predeterminado es el blanco.
JColorChooser (Color inicialColor): crea un objeto JColorChooer y establece el color inicial.
JColorChooser (modal ColorSelectionModel): construye un objeto JColorChooser con ColorSelectionModel.
La forma más común de usar JColorChooser es usar el método estático showDialog () de JColorChooser. Es decir, en la mayoría de los casos, no crearemos un nuevo objeto JColorChooser, sino que usaremos directamente el método estático (showDialog ()) de JColorChooser. para generar el cuadro de diálogo de selección de color. Con este método, también podemos obtener el color seleccionado por el usuario. Si el usuario no elige, se devolverá un valor nulo.
Código de caso simple 1 para el diálogo de selección de color:
Copie el código de código de la siguiente manera:
clase pública JColorChooserDemo {
público estático vacío principal (String [] argumentos) {
Marco JFrame = nuevo JFrame("JColorChooserDemo");
Panel MiPanel = nuevo MiPanel();
frame.getContentPane().add(panel);
marco.paquete();
marco.setLocation(300, 200);
frame.setVisible (verdadero);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
clase MyPanel extiende JPanel implementa ActionListener {
serialVersionUID largo final estático privado = 1L;
botón JButton privado, rgb, rojo, verde, azul;
color privado color = nuevo color (255, 51, 150);
público MiPanel() {
botón = nuevo JButton("Obtener color");
rgb = nuevo JButton("RGB: ");
rojo = nuevo JButton("Rojo: ");
verde = nuevo JButton("Verde: ");
azul = nuevo JButton("Azul: ");
botón.addActionListener(esto);
setPreferredSize(nueva Dimensión(550, 250));
setLayout(nuevo FlowLayout(FlowLayout.CENTER, 5, 5));
establecerFondo(color);
agregar(botón);
agregar(rgb);
agregar (rojo);
agregar (verde);
agregar (azul);
}
acción vacía pública realizada (ActionEvent e) {
color = JColorChooser.showDialog(this, "Elegir color", color);
si (color! = nulo) {
establecerFondo(color);
button.setText("Obtener de nuevo");
rgb.setText("RGB: " + color.getRGB());
red.setText("Rojo: " + color.getRed());
green.setText("Verde: " + color.getGreen());
blue.setText("Azul: " + color.getBlue());
}
}
}
El diagrama de resultados de ejecución es el siguiente:
Otra forma común de usar JColorChooser es usar el método estático createDialog(). Después de usar este método estático, obtendrá un objeto JDialog. Sin embargo, podemos usar este objeto JDialog para realizar más configuraciones. Para utilizar este método, debe cooperar con el objeto JColorChooser, es decir, debe crear un nuevo objeto JColorChooser. El siguiente ejemplo presenta el JColorChooser más simple y práctico. Después de seleccionar el color, puede cambiar el color de fondo en JLabel.
Código de caso simple 2 para el diálogo de selección de color:
Copie el código de código de la siguiente manera:
importar java.awt.*;
importar java.awt.event.*;
importar javax.swing.*;
clase pública ColorChooserDemo1 extiende MouseAdapter {
JFrame f = nulo;
etiqueta JLabel = nulo;
JLabel etiqueta1 = nulo;
JLabel etiqueta2 = nulo;
Rectángulo rec1 = nulo;
Rectángulo rec2 = nulo;
público ColorChooserDemo1() {
f = new JFrame("Ejemplo de ColorChooser");
Panel de contenido del contenedor = f.getContentPane();
contentPane.addMouseListener(este);
etiqueta = nueva JLabel(" ", JLabel.CENTER);
label.setPreferredSize(nueva Dimensión(300, 20));
Panel JPanel = nuevo JPanel();
panel.setLayout(nuevo GridLayout(1, 2));
etiqueta1 = new JLabel("Etiqueta izquierda", JLabel.CENTER);
label1.setBackground(Color.rojo);
label1.setForeground(Color.negro);
label1.setOpaque(verdadero);
etiqueta1.setBounds(0, 0, 150, 150);
panel.add(etiqueta1);
etiqueta2 = new JLabel("Etiqueta derecha", JLabel.CENTER);
label2.setBackground(Color.verde);
label2.setForeground(Color.negro);
label2.setOpaque(verdadero);
label2.setBounds(150, 0, 150, 150);
panel.add(etiqueta2);
rec1 = etiqueta1.getBounds();
rec2 = etiqueta2.getBounds();
contentPane.add(panel, BorderLayout.CENTER);
contentPane.add(etiqueta, BorderLayout.SUR);
f.setSize(nueva Dimensión(300, 150));
f.setVisible (verdadero);
f.addWindowListener(nuevo WindowAdapter() {
ventana vacía públicaClosing(WindowEvent e) {
Sistema.salir(0);
}
});
}
// Implemente los métodos mousePressed() y mouseClicked() en MouseAdapter. Cuando se presiona el mouse, puede conocer la posición actual del cursor del mouse.
//Dos veces, si el cursor está en la etiqueta, aparecerá un cuadro de diálogo de selección de color y el usuario puede elegir cualquier color para cambiar el color de la etiqueta.
public void mousePressed(MouseEvent e) {
label.setText("Las coordenadas actuales del mouse (X,Y) son: (" + e.getX() + "," + e.getY() + ")");
}
mouseClicked vacío público (MouseEvent e) {
Punto punto = e.getPoint();
si (e.getClickCount() == 2) {
if (rec1.contiene(punto)) {
/*
* Utilice el método estático showDialog() de JColorChooser para generar el cuadro de diálogo de selección de color.
*, los tres parámetros en showDialog() son: componente principal del cuadro de diálogo, título del cuadro de diálogo de selección de color
*, con el color predeterminado del cuadro de diálogo Después de que el usuario seleccione el color, presione el botón "Aceptar" para regresar.
* Objeto de color, si se presiona el botón "Cancelar", se devuelve un valor nulo.
*/
Color color = JColorChooser.showDialog(f,
"Cambiar etiqueta1 Color", Color.blanco);
if (color! = null) // Si el valor es nulo, significa que el usuario presionó el botón Cancelar
etiqueta1.setBackground(color);
}
if (rec2.contiene(punto)) {
Color color = JColorChooser.showDialog(f,
"Cambiar color de etiqueta2", Color.amarillo);
if (color! = null) // Si el valor es nulo, significa que el usuario presionó el botón Cancelar
etiqueta2.setBackground(color);
}
}
}
público estático vacío principal (Cadena [] arg) {
nuevo ColorChooserDemo1();
}
}