Carlos Fernández García

Ejercicio 1

Desarrolla una aplicación de interfaz gráfica en Java que permita a los usuarios alternar entre dos estados (activo e inactivo) utilizando un JToggleButton. La aplicación debe incluir lo siguiente: JToggleButton para Alternar Estados: Un JToggleButton etiquetado como "Activar" cuando está en estado inactivo y "Desactivar" cuando está en estado activo. Cambio de Estado en la Interfaz: Al activar el botón, el fondo de la interfaz debe cambiar a verde y el texto del botón a "Desactivar". Al desactivar el botón, el fondo de la interfaz debe cambiar a rojo y el texto del botón a "Activar". Diseño de la Interfaz: Un panel central que muestra el JToggleButton. Aplicar Cambios en Tiempo Real: Los cambios en el estado del botón deben aplicarse inmediatamente al seleccionar o deseleccionar el JToggleButton.

package jtogglebutton;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JToggleButton;

public class Ejercicio1 {

    public static void main(String[] args) {
        // Crear instancia del marco y configurar la operación de cierre
        MarcoPrueba miMarco = new MarcoPrueba();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoPrueba extends JFrame {
    public MarcoPrueba() {
        // Configurar las propiedades del marco
        setBounds(0, 0, 200, 200); // Establecer tamaño y posición
        setTitle("Prueba JToggleButton"); // Establecer título
        setResizable(false); // Evitar redimensionamiento
        setLocationRelativeTo(null); // Centrar en la pantalla

        // Crear instancia del panel y añadirla al marco
        LaminaPrueba miLamina = new LaminaPrueba();
        add(miLamina);
    }
}

class LaminaPrueba extends JPanel {
    public LaminaPrueba() {
        setLayout(new BorderLayout()); // Establecer el layout

        // Crear panel de pruebas y establecer su color de fondo
        JPanel panelPruebas = new JPanel();
        panelPruebas.setBackground(Color.red);

        // Crear panel para el botón
        JPanel panelBoton = new JPanel();
        // Crear el botón de alternar (JToggleButton)
        JToggleButton botonActivar = new JToggleButton("Activar");
        panelBoton.add(botonActivar);

        // Añadir los paneles al panel principal
        add(panelPruebas, BorderLayout.CENTER); // Añadir al centro
        add(panelBoton, BorderLayout.SOUTH); // Añadir al sur

        // Añadir un listener al botón para manejar los eventos de clic
        botonActivar.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Alternar el estado del botón y el color del panel
                if (botonActivar.getText().equals("Activar")) {
                    botonActivar.setText("Desactivar");
                    panelPruebas.setBackground(Color.green);
                } else {
                    botonActivar.setText("Activar");
                    panelPruebas.setBackground(Color.red);
                }
            }
        });
    }
}

Ejercicio 2

Desarrolla una aplicación que simule un sistema de encendido y apagado de luces en una casa utilizando JToggleButton. La interfaz debe incluir los siguientes elementos: Tres botones de alternancia (JToggleButton) que representen las luces de la Sala, la Cocina y el Dormitorio. Cada botón debe mostrar el estado de la luz: "Encendida" o "Apagada". Un área de visualización que muestre el estado actual de todas las luces. Esta área debe actualizarse en tiempo real cada vez que se presione un botón de alternancia. Un botón "Encender Todo" que encienda todas las luces cuando se presione. Un botón "Apagar Todo" que apague todas las luces cuando se presione. Un contador que muestre la cantidad de luces encendidas en cada momento. Requisitos: Al presionar cada JToggleButton, debe cambiar el estado de la luz correspondiente (de "Encendida" a "Apagada" y viceversa) y actualizar el área de visualización. Los botones "Encender Todo" y "Apagar Todo" deben afectar el estado de todas las luces de manera inmediata. El contador debe actualizarse automáticamente cada vez que cambie el estado de alguna luz. La interfaz debe ser clara y fácil de usar, con cada botón y área de visualización claramente etiquetados.

package jtogglebutton;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToggleButton;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Crear instancia del marco y configurar la operación de cierre
        MarcoLuces miMarco = new MarcoLuces();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true); // Hacer el marco visible
    }
}

class MarcoLuces extends JFrame {
    public MarcoLuces() {
        // Configurar las propiedades del marco
        setBounds(0, 0, 400, 200); // Establecer tamaño y posición
        setTitle("Luces"); // Establecer título
        setResizable(false); // Evitar redimensionamiento
        setLocationRelativeTo(null); // Centrar en la pantalla

        // Crear instancia del panel y añadirla al marco
        LaminaLuces miLamina = new LaminaLuces();
        add(miLamina);
    }
}

class LaminaLuces extends JPanel {
    public LaminaLuces() {
        setLayout(new BorderLayout()); // Establecer el layout

        // Panel para los botones de luces
        JPanel panelBotonesLuces = new JPanel();
        JToggleButton botonSala = new JToggleButton("Sala");
        JToggleButton botonCocina = new JToggleButton("Cocina");
        JToggleButton botonDormitorio = new JToggleButton("Dormitorio");
        panelBotonesLuces.add(botonSala);
        panelBotonesLuces.add(botonCocina);
        panelBotonesLuces.add(botonDormitorio);
        
        // Lista de botones
        ArrayList<JToggleButton> listaBotones = new ArrayList<>(Arrays.asList(botonSala, botonCocina, botonDormitorio));

        // Panel para representar las luces
        JPanel panelLuces = new JPanel();
        JPanel luzSala = new JPanel();
        JPanel luzCocina = new JPanel();
        JPanel luzDormitorio = new JPanel();
        
        // Lista de paneles que representan el estado de las luces
        ArrayList<JPanel> listaPaneles = new ArrayList<>(Arrays.asList(luzSala, luzCocina, luzDormitorio));
        for (JPanel panel : listaPaneles) {
            panel.setBackground(Color.black); // Inicialmente apagadas
            panel.setPreferredSize(new Dimension(75, 75)); // Tamaño de cada panel
            panelLuces.add(panel);
        }
        
        // Panel para los botones de encendido y apagado
        JPanel panelInterruptores = new JPanel();
        JButton botonApagar = new JButton("Apagar");
        JButton botonEncender = new JButton("Encender");
        
        panelInterruptores.add(botonApagar);
        panelInterruptores.add(botonEncender);
        
        // Panel para el contador de luces encendidas
        JPanel panelContador = new JPanel();
        panelContador.setLayout(new BoxLayout(panelContador, BoxLayout.Y_AXIS));
        JLabel etiquetaLuces = new JLabel("Luces Encendidas");
        JTextField contadorTexto = new JTextField(2);
        contadorTexto.setText("0");
        contadorTexto.setHorizontalAlignment(JTextField.CENTER);
        contadorTexto.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 20));
        
        panelContador.add(etiquetaLuces);
        panelContador.add(contadorTexto);
        
        // Añadir paneles al layout principal
        add(panelBotonesLuces, BorderLayout.NORTH);
        add(panelLuces, BorderLayout.CENTER);
        add(panelInterruptores, BorderLayout.SOUTH);
        add(panelContador, BorderLayout.EAST);
        
        // Añadir ActionListener a cada botón de luz
        for (JToggleButton botonLuz : listaBotones) {
            botonLuz.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (botonLuz.getText().equals("Sala")) {
                        encender(botonLuz, luzSala, "Sala", contadorTexto);
                    } else if (botonLuz.getText().equals("Cocina")) {
                        encender(botonLuz, luzCocina, "Cocina", contadorTexto);
                    } else {
                        encender(botonLuz, luzDormitorio, "Dormitorio", contadorTexto);
                    }
                }
            });
        }
        
        // Añadir ActionListener al botón de apagar todas las luces
        botonApagar.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                operarTodos(false, listaBotones, listaPaneles, contadorTexto);
            }
        });
        
        // Añadir ActionListener al botón de encender todas las luces
        botonEncender.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                operarTodos(true, listaBotones, listaPaneles, contadorTexto);
            }
        });
    }

    // Método para encender o apagar todas las luces
    private void operarTodos(boolean estado, ArrayList<JToggleButton> listaBotones, ArrayList<JPanel> listaPaneles, JTextField contadorTexto) {
        for (JToggleButton botonLuz : listaBotones) {
            botonLuz.setSelected(estado);
        }
        for (JPanel panel : listaPaneles) {
            if (estado) {
                panel.setBackground(Color.yellow);
                contadorTexto.setText("3"); // Todas las luces encendidas
            } else {
                panel.setBackground(Color.black);
                contadorTexto.setText("0"); // Todas las luces apagadas
            }
        }
    }

    // Método para encender o apagar una luz individual
    private void encender(JToggleButton boton, JPanel panel, String habitacion, JTextField contadorTexto) {
        int contador = Integer.parseInt(contadorTexto.getText());
        if (boton.isSelected()) {
            panel.setBackground(Color.yellow);
            contador++;
        } else {
            panel.setBackground(Color.black);
            contador--;
        }
        contadorTexto.setText(String.valueOf(contador)); // Actualizar contador de luces encendidas
    }
}

Ejercicio 3

Desarrolla una aplicación que simule un sistema de selección de modo único utilizando JToggleButton. La interfaz debe incluir los siguientes elementos: Cinco botones de alternancia (JToggleButton) que representen diferentes modos: Modo A, Modo B, Modo C, Modo D y Modo E. Solo un botón puede estar presionado a la vez. Cuando un botón se presiona, los demás deben desactivarse automáticamente. Un área de visualización que muestre el modo actual seleccionado. Esta área debe actualizarse en tiempo real cada vez que se presione un botón de alternancia. Requisitos: Al presionar un JToggleButton, debe cambiar el estado de ese botón a "presionado" y desactivar los otros botones (cambiando su estado a "no presionado"). El área de visualización debe mostrar claramente cuál es el modo actual seleccionado. La interfaz debe ser clara y fácil de usar, con cada botón y área de visualización claramente etiquetados.

package jtogglebutton;

import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JToggleButton;

public class Ejercicio3 {

    public static void main(String[] args) {
        // Crear instancia del marco y configurar la operación de cierre
        MarcoModo miMarco = new MarcoModo();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoModo extends JFrame {
    public MarcoModo() {
        // Configurar las propiedades del marco
        setBounds(0, 0, 500, 200); // Establecer tamaño y posición
        setTitle("Modo Alterno"); // Establecer título
        setResizable(false); // Evitar redimensionamiento
        setLocationRelativeTo(null); // Centrar en la pantalla

        // Crear instancia del panel y añadirla al marco
        LaminaModo miLamina = new LaminaModo();
        add(miLamina);
    }
}

class LaminaModo extends JPanel {
    public LaminaModo() {
        setLayout(new BorderLayout()); // Establecer el layout

        // Crear panel para los botones de modo
        JPanel panelModos = new JPanel();

        // Crear botones de modo
        JToggleButton botonModoA = new JToggleButton("Modo A");
        JToggleButton botonModoB = new JToggleButton("Modo B");
        JToggleButton botonModoC = new JToggleButton("Modo C");
        JToggleButton botonModoD = new JToggleButton("Modo D");
        JToggleButton botonModoE = new JToggleButton("Modo E");

        // Añadir los botones a la lista
        ArrayList<JToggleButton> listaModos = new ArrayList<>(Arrays.asList(botonModoA, botonModoB, botonModoC, botonModoD, botonModoE));

        // Añadir los botones al panel de modos
        for (JToggleButton botonModo : listaModos) {
            panelModos.add(botonModo);
        }

        // Crear panel para la información del modo seleccionado
        JPanel panelInformacion = new JPanel();
        JLabel labelInformacion = new JLabel("");
        labelInformacion.setHorizontalAlignment(JLabel.CENTER);
        labelInformacion.setFont(new Font(Font.SERIF, Font.BOLD, 20));
        panelInformacion.add(labelInformacion);

        // Añadir los paneles al panel principal
        add(panelModos, BorderLayout.CENTER); // Añadir al centro
        add(panelInformacion, BorderLayout.SOUTH); // Añadir al sur

        // Configurar los listeners para los botones de modo
        for (JToggleButton botonModo : listaModos) {
            botonModo.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // Actualizar el estado del botón presionado y la etiqueta de información
                    if (botonModo.isSelected()) {
                        labelInformacion.setText(botonModo.getText() + " activado");
                    } else {
                        labelInformacion.setText(botonModo.getText() + " desactivado");
                    }

                    // Desactivar los otros botones
                    for (JToggleButton desactivo : listaModos) {
                        if (!desactivo.equals(botonModo)) {
                            desactivo.setSelected(false);
                        }
                    }
                }
            });
        }
    }
}

Ejercicio 4

Desarrolla una aplicación de votación simple utilizando JToggleButton y ButtonGroup. La interfaz debe incluir los siguientes elementos: Cinco botones de alternancia (JToggleButton) que representen diferentes candidatos en una votación: Candidato A Candidato B Candidato C Candidato D Candidato E Un ButtonGroup para asegurar que solo uno de los candidatos puede estar seleccionado a la vez. Un botón "Votar" que registre el voto para el candidato seleccionado. Un área de visualización que muestre el candidato actualmente seleccionado. Esta área debe actualizarse en tiempo real cada vez que se seleccione un botón de alternancia. Un área de visualización adicional que muestre los resultados acumulados de la votación cada vez que se presione el botón "Votar". Los resultados deben mostrar la cantidad de votos obtenidos por cada candidato. Requisitos: Al presionar un JToggleButton, debe cambiar el estado de ese botón a "presionado" y desactivar los otros botones (cambiando su estado a "no presionado"). El botón "Votar" debe registrar el voto solo para el candidato seleccionado y actualizar los resultados de la votación. El área de visualización debe mostrar claramente cuál es el candidato actualmente seleccionado. La interfaz debe ser clara y fácil de usar, con cada botón y área de visualización claramente etiquetados. Debe haber validación para asegurar que no se puede registrar un voto si no hay un candidato seleccionado.

package jtogglebutton;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToggleButton;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Crear instancia del marco y configurar la operación de cierre
        MarcoVotacion miMarco = new MarcoVotacion();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoVotacion extends JFrame {
    public MarcoVotacion() {
        // Configurar las propiedades del marco
        setBounds(0, 0, 200, 300); // Establecer tamaño y posición
        setTitle("Modo Alterno"); // Establecer título
        setResizable(false); // Evitar redimensionamiento
        setLocationRelativeTo(null); // Centrar en la pantalla

        // Crear instancia del panel y añadirla al marco
        LaminaVotacion miLamina = new LaminaVotacion();
        add(miLamina);
    }
}

class LaminaVotacion extends JPanel {
    public LaminaVotacion() {
        setLayout(new BorderLayout()); // Establecer el layout

        // Crear panel para los candidatos y configurar su layout
        JPanel panelCandidatos = new JPanel();
        panelCandidatos.setLayout(new BoxLayout(panelCandidatos, BoxLayout.Y_AXIS));
        
        // Crear un ButtonGroup para asegurar que solo uno de los candidatos puede estar seleccionado a la vez
        ButtonGroup grupoCandidatos = new ButtonGroup();
        
        // Crear botones de alternancia para los candidatos
        JToggleButton botonCandidatoA = new JToggleButton("Candidato A");
        JToggleButton botonCandidatoB = new JToggleButton("Candidato B");
        JToggleButton botonCandidatoC = new JToggleButton("Candidato C");
        JToggleButton botonCandidatoD = new JToggleButton("Candidato D");
        JToggleButton botonCandidatoE = new JToggleButton("Candidato E");

        // Añadir los botones a la lista
        ArrayList<JToggleButton> listaCandidatos = new ArrayList<>(Arrays.asList(botonCandidatoA, botonCandidatoB, botonCandidatoC, botonCandidatoD, botonCandidatoE));

        // Añadir los botones al ButtonGroup y al panel de candidatos
        for (JToggleButton candidato : listaCandidatos) {
            grupoCandidatos.add(candidato);
            panelCandidatos.add(Box.createRigidArea(new Dimension(0, 20))); // Añadir espacio entre los botones
            panelCandidatos.add(candidato);
        }

        // Crear panel para la información del modo seleccionado
        JPanel panelInformacion = new JPanel();
        JLabel labelInformacion = new JLabel("............................");
        labelInformacion.setHorizontalAlignment(JLabel.CENTER);
        labelInformacion.setFont(new Font(Font.SERIF, Font.BOLD, 14));
        panelInformacion.add(labelInformacion);
        
        // Crear panel para los resultados de la votación y configurar su layout
        JPanel panelResultados = new JPanel();
        panelResultados.setLayout(new BoxLayout(panelResultados, BoxLayout.Y_AXIS));
        
        // Crear etiquetas y campos de texto para los votos de cada candidato
        JLabel etiquetaCandidatoA = new JLabel("A");
        JLabel etiquetaCandidatoB = new JLabel("B");
        JLabel etiquetaCandidatoC = new JLabel("C");
        JLabel etiquetaCandidatoD = new JLabel("D");
        JLabel etiquetaCandidatoE = new JLabel("E");
        
        JLabel[] listaEtiquetas = {etiquetaCandidatoA, etiquetaCandidatoB, etiquetaCandidatoC, etiquetaCandidatoD, etiquetaCandidatoE};
        
        JTextField votoCandidatoA = new JTextField(3);
        JTextField votoCandidatoB = new JTextField(3);
        JTextField votoCandidatoC = new JTextField(3);
        JTextField votoCandidatoD = new JTextField(3);
        JTextField votoCandidatoE = new JTextField(3);
        
        JTextField[] listaVotos = {votoCandidatoA, votoCandidatoB, votoCandidatoC, votoCandidatoD, votoCandidatoE};
        
        // Añadir las etiquetas y los campos de texto al panel de resultados
        for (int i = 0; i < listaVotos.length; i++) {
            panelResultados.add(listaEtiquetas[i]);
            panelResultados.add(listaVotos[i]);
            listaEtiquetas[i].setHorizontalAlignment(JLabel.CENTER);
            listaEtiquetas[i].setFont(new Font(Font.SERIF, Font.BOLD, 12));
            listaVotos[i].setHorizontalAlignment(JTextField.CENTER);
            listaVotos[i].setFont(new Font(Font.SERIF, Font.BOLD, 18));
            listaVotos[i].setText("0"); // Inicializar los campos de texto con "0"
        }
        
        // Añadir los paneles al panel principal
        add(panelCandidatos, BorderLayout.CENTER); // Añadir al centro
        add(panelInformacion, BorderLayout.SOUTH); // Añadir al sur
        add(panelResultados, BorderLayout.EAST); // Añadir al este

        // Configurar los listeners para los botones de modo
        for (JToggleButton candidato : listaCandidatos) {
            candidato.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // Actualizar el estado del botón presionado y la etiqueta de información
                    if (candidato.isSelected()) {
                        labelInformacion.setText("Voto registado al " + candidato.getText());
                    }
                    // Actualizar el conteo de votos para el candidato seleccionado
                    switch (candidato.getText()) {
                        case "Candidato A":
                            listaVotos[0].setText(String.valueOf(Integer.parseInt(listaVotos[0].getText()) + 1));
                            break;
                        case "Candidato B":
                            listaVotos[1].setText(String.valueOf(Integer.parseInt(listaVotos[1].getText()) + 1));
                            break;
                        case "Candidato C":
                            listaVotos[2].setText(String.valueOf(Integer.parseInt(listaVotos[2].getText()) + 1));
                            break;
                        case "Candidato D":
                            listaVotos[3].setText(String.valueOf(Integer.parseInt(listaVotos[3].getText()) + 1));
                            break;
                        case "Candidato E":
                            listaVotos[4].setText(String.valueOf(Integer.parseInt(listaVotos[4].getText()) + 1));
                            break;
                    }
                }
            });
        }
    }
}

Ejercicio 5

Desarrolla una aplicación de encuesta de satisfacción utilizando JToggleButton y ButtonGroup. La interfaz debe incluir los siguientes elementos: Cinco botones de alternancia (JToggleButton) que representen diferentes niveles de satisfacción en una encuesta: - Muy insatisfecho - Insatisfecho - Neutral - Satisfecho - Muy satisfecho Un ButtonGroup para asegurar que solo uno de los niveles de satisfacción puede estar seleccionado a la vez. Un botón "Enviar" que registre la respuesta seleccionada. Un área de visualización que muestre el nivel de satisfacción actualmente seleccionado. Esta área debe actualizarse en tiempo real cada vez que se seleccione un botón de alternancia. Un área de visualización adicional que muestre las estadísticas acumuladas de las respuestas cada vez que se presione el botón "Enviar". Las estadísticas deben mostrar el número total de respuestas para cada nivel de satisfacción. Requisitos: - Al presionar un JToggleButton, debe cambiar el estado de ese botón a "presionado" y desactivar los otros botones (cambiando su estado a "no presionado"). - El botón "Enviar" debe registrar la respuesta solo para el nivel de satisfacción seleccionado y actualizar las estadísticas de la encuesta. - El área de visualización debe mostrar claramente cuál es el nivel de satisfacción actualmente seleccionado. - La interfaz debe ser clara y fácil de usar, con cada botón y área de visualización claramente etiquetados. - Debe haber validación para asegurar que no se puede registrar una respuesta si no hay un nivel de satisfacción seleccionado.


package jtogglebutton;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JToggleButton;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crear instancia del marco y configurar la operación de cierre
    	MarcoSatisfacion miMarco = new MarcoSatisfacion();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoSatisfacion extends JFrame {
    public MarcoSatisfacion() {
        // Configurar las propiedades del marco
        setBounds(0, 0, 600, 200); // Establecer tamaño y posición
        setTitle("Grado de satisfacion"); // Establecer título
        setResizable(false); // Evitar redimensionamiento
        setLocationRelativeTo(null); // Centrar en la pantalla

        // Crear instancia del panel y añadirla al marco
        LaminaSatisfacion miLamina = new LaminaSatisfacion();
        add(miLamina);
    }
}

class LaminaSatisfacion extends JPanel {
    public LaminaSatisfacion() {
        setLayout(new BorderLayout()); // Establecer el layout

        // Crear panel de botones de satisfacción
        JPanel panelBotones = new JPanel();
       
        ButtonGroup grupoBotones= new ButtonGroup();
        // Crear botones de satisfacción
        JToggleButton botonSatisfacion1 = new JToggleButton("Muy insatisfecho");
        JToggleButton botonSatisfacion2 = new JToggleButton("Insatisfecho");
        JToggleButton botonSatisfacion3 = new JToggleButton("Neutral");
        JToggleButton botonSatisfacion4 = new JToggleButton("Satisfecho");
        JToggleButton botonSatisfacion5 = new JToggleButton("Muy satisfecho");
        
        // Agregar los botones al grupo y al panel
        ArrayList<JToggleButton> listaBotones = new ArrayList<JToggleButton>(Arrays.asList(botonSatisfacion1,botonSatisfacion2,botonSatisfacion3,botonSatisfacion4,botonSatisfacion5));
        panelBotones.add(Box.createRigidArea(new Dimension(0,50))); // Espacio en blanco
        for (JToggleButton botonSatisfacion : listaBotones) {
			grupoBotones.add(botonSatisfacion);
			panelBotones.add(botonSatisfacion);
		}

        // Panel para mostrar la selección actual
        JPanel panelInfo = new JPanel();
        JLabel labelInfo = new JLabel("...................");
        labelInfo.setHorizontalAlignment(JLabel.CENTER);
        labelInfo.setFont(new Font(Font.SERIF,Font.BOLD,22));
        panelInfo.add(labelInfo);
        
        // Panel para el botón "Enviar"
        JPanel panelBoton = new JPanel();
        panelBoton.setLayout(new BoxLayout(panelBoton, BoxLayout.Y_AXIS));
        JButton botonEnviar = new JButton("Enviar");
        botonEnviar.setFont(new Font(Font.SERIF,Font.BOLD,16));
        panelBoton.add(Box.createRigidArea(new Dimension(120,0))); // Espacio en blanco
        panelBoton.add(botonEnviar);
        panelBoton.add(Box.createRigidArea(new Dimension(0,20))); // Espacio en blanco

        // Añadir los paneles al panel principal
        add(panelBotones, BorderLayout.NORTH);
        add(panelInfo, BorderLayout.CENTER);
        add(panelBoton, BorderLayout.SOUTH); 
        
        // Acción al presionar el botón "Enviar"
        botonEnviar.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// Obtener la selección actual
				for (JToggleButton botonSatisfacion : listaBotones) {
					if(botonSatisfacion.isSelected()) {
		        		labelInfo.setText("Mi grado de satisfacion es " + botonSatisfacion.getText());
		        	}
				}
			}
        });
        
        // Acción al seleccionar un botón de satisfacción
        for (JToggleButton botonSatisfacion : listaBotones) {
			botonSatisfacion.addActionListener(new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
					labelInfo.setText("..................."); // Restablecer el texto de información
				}
			});
		}	
    }
}