Carlos Fernández García

Ejercicio 1

Desarrolla una aplicación que permita a los usuarios seleccionar una cantidad de productos utilizando un JSpinner. La aplicación debe mostrar un JSpinner que permita seleccionar un número entero que represente la cantidad de productos. Asegúrate de que el JSpinner sea fácil de entender y usar, y que la interfaz sea intuitiva para el usuario.

package jspinner;

import java.awt.BorderLayout;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;





public class Ejercicio1 {

	public static void main(String[] args) {
		MarcoProductos miMarco=new MarcoProductos();
		miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		miMarco.setVisible(true);

	}

}

class MarcoProductos extends JFrame{
	public MarcoProductos() {
		setBounds(0,0,300,100);
		setTitle("Prodcutos");
		setResizable(false);
		setLocationRelativeTo(null);
		
		LaminaProductos miLamina=new LaminaProductos();
		add(miLamina, BorderLayout.CENTER);
	}
}

class LaminaProductos extends JPanel{
	public LaminaProductos() {
		JPanel panelEncabezado = new JPanel();
		JLabel encabezado=new JLabel("PRODUCTOS");
		encabezado.setHorizontalAlignment(JLabel.CENTER);
		encabezado.setFont(new Font("Comic Sans",Font.BOLD,16));
		
		panelEncabezado.add(encabezado);
		
		
		JPanel panelSpinner=new JPanel();
		JLabel etiqueta=new JLabel("Cantidad");
		etiqueta.setHorizontalAlignment(JLabel.CENTER);
		etiqueta.setFont(new Font("Comic Sans",Font.BOLD,16));
		SpinnerNumberModel modeloSpinner = new SpinnerNumberModel(0, 0, 10, 1);
		JSpinner spinnerProductos=new JSpinner(modeloSpinner);
		
		
		JTextField campoNumero=new JTextField(5);
		campoNumero.setText("0");
		campoNumero.setHorizontalAlignment(JTextField.CENTER);;
		
		panelSpinner.add(etiqueta);
		panelSpinner.add(spinnerProductos);
		panelSpinner.add(campoNumero);
		
		
		setLayout(new BorderLayout());
		
		add(panelEncabezado,BorderLayout.NORTH);
		add(panelSpinner,BorderLayout.CENTER);
		
		spinnerProductos.addChangeListener(new ChangeListener() {

			@Override
			public void stateChanged(ChangeEvent e) {
				campoNumero.setText(""+spinnerProductos.getValue());
				
			}
			
		});
		
	}
}

Ejercicio 2

Desarrolla una aplicación que permita a los usuarios seleccionar una hora utilizando un JSpinner. La aplicación debe mostrar tres JSpinner, uno para las horas, otro para los minutos y otro para los segundos. Asegúrate de que los JSpinner sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario.

package jspinner;
 

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Font;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;





public class Ejercicio2 {

	public static void main(String[] args) {
		MarcoHora miMarco=new MarcoHora();
		miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		miMarco.setVisible(true);

	}

}

class MarcoHora extends JFrame{
	public MarcoHora() {
		setBounds(0,0,150,200);
		setTitle("Reloj");
		setResizable(false);
		setLocationRelativeTo(null);
		
		LaminaHora miLamina=new LaminaHora();
		add(miLamina, BorderLayout.CENTER);
	}
}

class LaminaHora extends JPanel{
	public LaminaHora() {
		JPanel panelEncabezado = new JPanel();
		JLabel encabezado=new JLabel("HORARIO");
		encabezado.setHorizontalAlignment(JLabel.CENTER);
		encabezado.setFont(new Font("Comic Sans",Font.BOLD,16));
		
		panelEncabezado.add(encabezado);
		
		
		JPanel panelSpinner=new JPanel();
		JLabel etiquetaHoras=new JLabel("Horas");
		etiquetaHoras.setHorizontalAlignment(JLabel.LEFT);
		etiquetaHoras.setFont(new Font("Comic Sans",Font.BOLD,16));
		SpinnerNumberModel modeloHoras = new SpinnerNumberModel(0, 0, 23, 1);
		JSpinner spinnerHoras=new JSpinner(modeloHoras);
		spinnerHoras.setAlignmentX(Component.LEFT_ALIGNMENT);

		
		JLabel etiquetaMinutos=new JLabel("Minutos");
		etiquetaMinutos.setHorizontalAlignment(JLabel.LEFT);
		etiquetaMinutos.setFont(new Font("Comic Sans",Font.BOLD,16));
		SpinnerNumberModel modeloMinutos = new SpinnerNumberModel(0, 0, 59, 1);
		JSpinner spinnerMinutos=new JSpinner(modeloMinutos);
		spinnerMinutos.setAlignmentX(Component.LEFT_ALIGNMENT);
		
		JLabel etiquetaSegundos=new JLabel("Segundos");
		etiquetaSegundos.setHorizontalAlignment(JLabel.LEFT);
		etiquetaSegundos.setFont(new Font("Comic Sans",Font.BOLD,16));
		SpinnerNumberModel modeloSegundos = new SpinnerNumberModel(0, 0, 24, 1);
		JSpinner spinnerSegundos=new JSpinner(modeloSegundos);
		spinnerSegundos.setAlignmentX(Component.LEFT_ALIGNMENT);
		
		
		
		
		panelSpinner.add(spinnerHoras);
		panelSpinner.add(etiquetaHoras);
		
		panelSpinner.add(spinnerMinutos);
		panelSpinner.add(etiquetaMinutos);
		
		panelSpinner.add(spinnerSegundos);
		panelSpinner.add(etiquetaSegundos);
		
		
		JPanel panelReloj=new JPanel();
		JTextField campoReloj=new JTextField(5);
		campoReloj.setHorizontalAlignment(JTextField.CENTER);
		campoReloj.setFont(new Font("Comic Sans",Font.BOLD,16));
		campoReloj.setText("0:0:0");
		
		panelReloj.add(campoReloj);
		
		setLayout(new BorderLayout());
		
		add(panelEncabezado,BorderLayout.NORTH);
		add(panelSpinner,BorderLayout.CENTER);
		add(panelReloj,BorderLayout.SOUTH);
		
		ArrayList<JSpinner> listaJspinner=new ArrayList<JSpinner>(Arrays.asList(spinnerHoras,spinnerMinutos,spinnerSegundos));
		
		for (JSpinner jSpinner : listaJspinner) {
			jSpinner.addChangeListener(new ChangeListener() {

				@Override
				public void stateChanged(ChangeEvent e) {
					campoReloj.setText(spinnerHoras.getValue()+":"+spinnerMinutos.getValue()+":"+spinnerSegundos.getValue());
					
				}
				
			});
		}
	}
}

Ejercicio 3

Desarrolla una aplicación que permita a los usuarios seleccionar una fecha utilizando tres JSpinner, uno para el día, otro para el mes y otro para el año. La aplicación debe asegurarse de que la fecha seleccionada sea válida y debe mostrar un mensaje de error si se selecciona una fecha inválida. Asegúrate de que los JSpinner sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario.


package jspinner;

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.time.LocalDate;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;

public class Ejercicio3 {

    public static void main(String[] args) {
        // Crea una instancia de MarcoFecha y configura la operación de cierre y visibilidad
        MarcoFecha miMarco = new MarcoFecha();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoFecha extends JFrame {
    public MarcoFecha() {
        // Configura las propiedades de la ventana principal
        setBounds(0, 0, 120, 220);
        setTitle("CALENDARIO");
        setResizable(false);
        setLocationRelativeTo(null);
        
        // Añade la lamina principal al marco
        LaminaFecha miLamina = new LaminaFecha();
        add(miLamina, BorderLayout.CENTER);
    }
}

class LaminaFecha extends JPanel {
    public LaminaFecha() {
        // Panel del encabezado con el título del calendario
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("CALENDARIO");
        encabezado.setHorizontalAlignment(JLabel.CENTER);
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16));
        panelEncabezado.add(encabezado);
        
        // Panel de etiquetas para los spinners (día, mes, año)
        JPanel panelEtiquetas = new JPanel();
        panelEtiquetas.setLayout(new BoxLayout(panelEtiquetas, BoxLayout.Y_AXIS));
        
        JLabel etiquetaDia = new JLabel("DIAS");
        etiquetaDia.setHorizontalAlignment(JLabel.LEFT);
        etiquetaDia.setFont(new Font("Comic Sans", Font.BOLD, 16));
        
        JLabel etiquetaMes = new JLabel("MES");
        etiquetaMes.setHorizontalAlignment(JLabel.LEFT);
        etiquetaMes.setFont(new Font("Comic Sans", Font.BOLD, 16));
        
        JLabel etiquetaAnio = new JLabel("AÑO");
        etiquetaAnio.setHorizontalAlignment(JLabel.LEFT);
        etiquetaAnio.setFont(new Font("Comic Sans", Font.BOLD, 16));
        
        // Añade las etiquetas al panel
        panelEtiquetas.add(Box.createRigidArea(new Dimension(0, 4)));
        panelEtiquetas.add(Box.createRigidArea(new Dimension(25, 0)));
        panelEtiquetas.add(etiquetaDia);
        panelEtiquetas.add(Box.createRigidArea(new Dimension(0, 11)));
        panelEtiquetas.add(etiquetaMes);
        panelEtiquetas.add(Box.createRigidArea(new Dimension(0, 10)));
        panelEtiquetas.add(etiquetaAnio);
        
        // Año actual para el spinner del año
        int anioActual = LocalDate.now().getYear();
        
        // Panel para los spinners
        JPanel panelSpinner = new JPanel();
        panelSpinner.setLayout(new BoxLayout(panelSpinner, BoxLayout.Y_AXIS));
        
        // Modelos de los spinners con rangos válidos
        SpinnerNumberModel modeloDia = new SpinnerNumberModel(1, 1, 31, 1);
        SpinnerNumberModel modeloMes = new SpinnerNumberModel(1, 1, 12, 1);
        SpinnerNumberModel modeloAnio = new SpinnerNumberModel(anioActual, 0, anioActual, 1);
        
        // Spinners para seleccionar día, mes y año
        JSpinner spinnerDia = new JSpinner(modeloDia);
        JSpinner spinnerMes = new JSpinner(modeloMes);
        JSpinner spinnerAnio = new JSpinner(modeloAnio);
        
        // Ajusta el tamaño de los spinners
        spinnerDia.setPreferredSize(new Dimension(60, 25));
        spinnerMes.setPreferredSize(new Dimension(60, 25));
        spinnerAnio.setPreferredSize(new Dimension(60, 25));
        
        // Añade los spinners al panel
        panelSpinner.add(spinnerDia);
        panelSpinner.add(spinnerMes);
        panelSpinner.add(spinnerAnio);
        
        // Panel para mostrar la fecha seleccionada y el botón de validación
        JPanel panelFecha = new JPanel();
        panelFecha.setLayout(new BoxLayout(panelFecha, BoxLayout.Y_AXIS));
        
        // Campo de texto para mostrar la fecha seleccionada
        JTextField campoFecha = new JTextField(8);
        campoFecha.setHorizontalAlignment(JTextField.CENTER);
        campoFecha.setFont(new Font("Comic Sans", Font.BOLD, 16));
        campoFecha.setText("../../....");
        panelFecha.add(campoFecha);
        
        // Botón para validar la fecha seleccionada
        JButton validar = new JButton("Validar");
        panelFecha.add(validar);
        
        // Establece el diseño del panel principal y añade los subpaneles
        setLayout(new BorderLayout());
        add(panelEncabezado, BorderLayout.NORTH);
        add(panelEtiquetas, BorderLayout.CENTER);
        add(panelSpinner, BorderLayout.EAST);
        add(panelFecha, BorderLayout.SOUTH);
        
        // Acción del botón de validación
        validar.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Obtiene los valores seleccionados
                int dia = (int) spinnerDia.getValue();
                int mes = (int) spinnerMes.getValue();
                int anio = (int) spinnerAnio.getValue();
                boolean valido = false;
                
                // Verifica la validez de la fecha
                if (mes == 2) { // Febrero
                    if ((anio % 4 == 0) && ((anio % 100 != 0) || (anio % 400 == 0))) {
                        // Año bisiesto
                        if (dia <= 29) {
                            valido = true;
                        }
                    } else {
                        // Año no bisiesto
                        if (dia <= 28) {
                            valido = true;
                        }
                    }
                } else if (mes == 4 || mes == 6 || mes == 9 || mes == 11) {
                    // Meses con 30 días
                    if (dia <= 30) {
                        valido = true;
                    }
                } else {
                    // Meses con 31 días
                    valido = true;
                }
                
                // Muestra el mensaje correspondiente y actualiza el campo de texto
                JOptionPane panel = new JOptionPane();
                if (valido) {
                    panel.showMessageDialog(null, "Fecha válida", "Validación de fecha", JOptionPane.INFORMATION_MESSAGE);
                    String campoDia = (dia < 10) ? "0" + dia : "" + dia;
                    String campoMes = (mes < 10) ? "0" + mes : "" + mes;
                    campoFecha.setText(campoDia + "/" + campoMes + "/" + anio);
                    campoFecha.setForeground(Color.black);
                } else {
                    panel.showMessageDialog(null, "Fecha no válida", "Validación de fecha", JOptionPane.ERROR_MESSAGE);
                    campoFecha.setText("ERROR");
                    campoFecha.setForeground(Color.red);
                }
            }
        });
    }
}

Ejercicio 4

Desarrolla una aplicación que permita a los usuarios planificar un viaje utilizando JSpinner. La aplicación debe incluir tres JSpinner: uno para seleccionar el número de días del viaje, otro para seleccionar el número de personas y otro para seleccionar el presupuesto diario por persona. La aplicación debe calcular y mostrar el costo total del viaje en un JLabel cuando el usuario presione un botón de "Calcular". Asegúrate de que los JSpinner sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario. Requisitos: JSpinner para Días del Viaje: Valores de 1 a 30. JSpinner para Número de Personas: Valores de 1 a 10. JSpinner para Presupuesto Diario por Persona: Valores de 50 a 1000 (en la moneda que prefieras). Botón "Calcular": Al presionar este botón, se debe calcular el costo total del viaje y mostrarlo en un JLabel. Etiqueta para el Costo Total: Muestra el resultado del cálculo: Costo Total = Número de Días * Número de Personas * Presupuesto Diario por Persona. Interfaz Intuitiva: Asegúrate de que la disposición de los componentes sea clara y fácil de usar.


package jspinner;

import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.NumberFormat;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Crea y configura la ventana principal de la aplicación
        MarcoViajes miMarco = new MarcoViajes();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoViajes extends JFrame {
    public MarcoViajes() {
        // Configura las propiedades de la ventana principal
        setBounds(0, 0, 200, 200);
        setTitle("Agencia de viajes");
        setResizable(false);
        setLocationRelativeTo(null);
        
        // Añade la lamina principal al marco
        LaminaViajes miLamina = new LaminaViajes();
        add(miLamina, BorderLayout.CENTER);
    }
}

class LaminaViajes extends JPanel {
    public LaminaViajes() {
        // Panel del encabezado con el título de configuración del viaje
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("CONFIGURAR VIAJE");
        encabezado.setHorizontalAlignment(JLabel.CENTER);
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16));
        panelEncabezado.add(encabezado);
        
        // Panel para seleccionar los valores del viaje
        JPanel panelSeleccion = new JPanel();
        
        // Etiqueta y spinner para el número de días
        JLabel etiquetaDias = new JLabel("Nº dias");
        etiquetaDias.setHorizontalAlignment(JLabel.CENTER);
        etiquetaDias.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloDias = new SpinnerNumberModel(1, 1, 30, 1);
        JSpinner spinnerDias = new JSpinner(modeloDias);
        
        // Etiqueta y spinner para el número de personas
        JLabel etiquetaPersonas = new JLabel("Nº personas");
        etiquetaPersonas.setHorizontalAlignment(JLabel.CENTER);
        etiquetaPersonas.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloPersonas = new SpinnerNumberModel(1, 1, 10, 1);
        JSpinner spinnerPersonas = new JSpinner(modeloPersonas);
        
        // Etiqueta y spinner para el gasto diario por persona
        JLabel etiquetaGasto = new JLabel("Gasto Diario");
        etiquetaGasto.setHorizontalAlignment(JLabel.CENTER);
        etiquetaGasto.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloGasto = new SpinnerNumberModel(50, 50, 1000, 50);
        JSpinner spinnerGasto = new JSpinner(modeloGasto);
        
        // Añade las etiquetas y spinners al panel de selección
        panelSeleccion.add(etiquetaDias);
        panelSeleccion.add(spinnerDias);
        panelSeleccion.add(etiquetaPersonas);
        panelSeleccion.add(spinnerPersonas);
        panelSeleccion.add(etiquetaGasto);
        panelSeleccion.add(spinnerGasto);
        
        // Panel para mostrar el costo total y el botón de cálculo
        JPanel panelTotal = new JPanel();
        
        // Botón para calcular el costo total
        JButton botonCalcular = new JButton("Calcular");
        
        // Campo de texto para mostrar el costo total
        JTextField campoTotal = new JTextField(5);
        campoTotal.setText("0€");
        campoTotal.setHorizontalAlignment(JTextField.CENTER);
        campoTotal.setFont(new Font("Comic Sans", Font.BOLD, 16));
        campoTotal.setEditable(false);
        
        // Añade el botón y el campo de texto al panel total
        panelTotal.add(botonCalcular);
        panelTotal.add(campoTotal);
        panelTotal.setLayout(getLayout());
        
        // Establece el diseño del panel principal y añade los subpaneles
        setLayout(new BorderLayout());
        add(panelEncabezado, BorderLayout.NORTH);
        add(panelSeleccion, BorderLayout.CENTER);
        add(panelTotal, BorderLayout.SOUTH);
        
        // Acción del botón de cálculo
        botonCalcular.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Calcula el costo total del viaje
                int total = (int) spinnerDias.getValue() * (int) spinnerPersonas.getValue() * (int) spinnerGasto.getValue();

                // Formatea el total como moneda
                NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
                campoTotal.setText(currencyFormat.format(total));
                
                
            }
        });
    }
}

Ejercicio 5

Desarrolla una aplicación que permita a los usuarios configurar las especificaciones de un ordenador utilizando JSpinner. La aplicación debe incluir varios JSpinner para seleccionar la cantidad de RAM, el tamaño del disco duro, la velocidad del procesador y la cantidad de núcleos del procesador. La aplicación debe mostrar un resumen de la configuración seleccionada en un JLabel cuando el usuario presione un botón de "Mostrar Resumen". Asegúrate de que los JSpinner sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario. Requisitos: JSpinner para Cantidad de RAM: Valores de 2 a 64 en incrementos de 2 GB. JSpinner para Tamaño del Disco Duro: Valores de 128 a 4096 en incrementos de 128 GB. JSpinner para Velocidad del Procesador: Valores de 1.0 a 5.0 en incrementos de 0.1 GHz. JSpinner para Cantidad de Núcleos del Procesador: Valores de 1 a 16. Botón "Mostrar Resumen": Al presionar este botón, se debe mostrar un resumen de la configuración seleccionada en un JLabel. Etiqueta para el Resumen de Configuración: Muestra el resumen de la configuración seleccionada por el usuario. Interfaz Intuitiva: Asegúrate de que la disposición de los componentes sea clara y fácil de usar.

package jspinner;

import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerNumberModel;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crea y configura la ventana principal de la aplicación
    	MarcoPc miMarco = new MarcoPc();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoPc extends JFrame {
    public MarcoPc() {
        // Configura las propiedades de la ventana principal
        setBounds(0, 0, 800, 150); // Establece el tamaño de la ventana
        setTitle("Configurador de Pc"); // Establece el título de la ventana
        setResizable(false); // No permite redimensionar la ventana
        setLocationRelativeTo(null); // Centra la ventana en la pantalla
        
        // Añade la lamina principal al marco
        LaminaPc miLamina = new LaminaPc();
        add(miLamina, BorderLayout.CENTER); // Añade la lamina en el centro de la ventana
    }
}

class LaminaPc extends JPanel {
    public LaminaPc() {
        
        // Panel para el encabezado
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("CONFIGURA TU PC"); // Crea una etiqueta para el encabezado
        encabezado.setHorizontalAlignment(JLabel.CENTER); // Centra el texto de la etiqueta
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16)); // Establece la fuente y el tamaño de la letra
        panelEncabezado.add(encabezado); // Añade la etiqueta al panel
        
        // Panel para las opciones de configuración
        JPanel panelOpciones = new JPanel();
        
        // Etiquetas y JSpinners para cada opción de configuración
        JLabel etiquetaRam = new JLabel("GB RAM");
        etiquetaRam.setHorizontalAlignment(JLabel.CENTER);
        etiquetaRam.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloRam = new SpinnerNumberModel(2, 2, 64, 2); // Valores de 2 a 64 en incrementos de 2
        JSpinner spinnerRam = new JSpinner(modeloRam);
        
        JLabel etiquetaHdd = new JLabel("GB HDD");
        etiquetaHdd.setHorizontalAlignment(JLabel.CENTER);
        etiquetaHdd.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloHdd = new SpinnerNumberModel(128, 128, 4096, 128); // Valores de 128 a 4096 en incrementos de 128
        JSpinner spinnerHdd = new JSpinner(modeloHdd);
        
        JLabel etiquetaMhz = new JLabel("Velocidad procesador (GHz)");
        etiquetaMhz.setHorizontalAlignment(JLabel.CENTER);
        etiquetaMhz.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloMhz = new SpinnerNumberModel(1.0, 1.0, 5.0, 0.1); // Valores de 1.0 a 5.0 en incrementos de 0.1
        JSpinner spinnerMhz = new JSpinner(modeloMhz);
        
        JLabel etiquetaNucleos = new JLabel("Núcleos procesador");
        etiquetaNucleos.setHorizontalAlignment(JLabel.CENTER);
        etiquetaNucleos.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloNucleos = new SpinnerNumberModel(1, 1, 16, 1); // Valores de 1 a 16
        JSpinner spinnerNucleos = new JSpinner(modeloNucleos);
        
        // Añade las etiquetas y JSpinners al panel de opciones
        panelOpciones.add(etiquetaRam);
        panelOpciones.add(spinnerRam);
        panelOpciones.add(etiquetaHdd);
        panelOpciones.add(spinnerHdd);
        panelOpciones.add(etiquetaMhz);
        panelOpciones.add(spinnerMhz);
        panelOpciones.add(etiquetaNucleos);
        panelOpciones.add(spinnerNucleos);
        
        // Panel para mostrar el resumen de configuración
        JPanel panelResumen = new JPanel();
        panelResumen.setLayout(new BoxLayout(panelResumen, BoxLayout.Y_AXIS));
        JButton botonConfigurar = new JButton("Mostrar Resumen"); // Botón para mostrar el resumen
        JLabel resumen = new JLabel(); // Etiqueta para mostrar el resumen
        resumen.setFont(new Font("Comic sans", Font.ITALIC, 18));
        resumen.setHorizontalAlignment(JLabel.LEFT);
        
        // Añade el botón y la etiqueta al panel de resumen
        panelResumen.add(botonConfigurar);
        panelResumen.add(resumen);

        // Configuración del diseño de la lamina principal
        setLayout(new BorderLayout());
        
        // Añade los paneles al contenedor principal
        add(panelEncabezado, BorderLayout.NORTH); // Añade el panel del encabezado en la parte superior
        add(panelOpciones, BorderLayout.CENTER); // Añade el panel de opciones en el centro
        add(panelResumen, BorderLayout.SOUTH); // Añade el panel del resumen en la parte inferior
        
        // Acción del botón Configurar
        botonConfigurar.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Obtiene los valores seleccionados en los JSpinners y los muestra en la etiqueta de resumen
                resumen.setText("Memoria RAM: " + spinnerRam.getValue() + "GB | " +
                                "Disco Duro: " + spinnerHdd.getValue() + "GB | " +
                                "Velocidad Procesador: " + spinnerMhz.getValue() + "GHz | " +
                                "Núcleos Procesador: " + spinnerNucleos.getValue());
            }
        });
    }
}

Ejercicio 6

Desarrolla una aplicación que permita a los usuarios calcular el costo de un viaje en automóvil utilizando JSpinner. La aplicación debe incluir JSpinners para seleccionar la distancia del viaje en kilómetros, el rendimiento del vehículo en kilómetros por litro y el precio del combustible por litro. Cuando el usuario presione un botón de 'Calcular Costo', la aplicación debe mostrar el costo total del viaje en un JLabel. Asegúrate de que los JSpinners sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario.

package jspinner;
import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerNumberModel;

public class Ejercicio6 {

    public static void main(String[] args) {
        // Crea y configura la ventana principal de la aplicación
        MarcoConsumo miMarco = new MarcoConsumo();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

// Clase para la ventana principal
class MarcoConsumo extends JFrame {
    public MarcoConsumo() {
        // Configura las propiedades de la ventana principal
        setBounds(0, 0, 200, 200); // Establece el tamaño de la ventana
        setTitle("CONSUMO VEHICULO"); // Establece el título de la ventana
        setResizable(false); // No permite redimensionar la ventana
        setLocationRelativeTo(null); // Centra la ventana en la pantalla
        
        // Añade la lamina principal al marco
        LaminaConsumo miLamina = new LaminaConsumo();
        add(miLamina, BorderLayout.CENTER); // Añade la lamina en el centro de la ventana
    }
}

// Clase para la lamina principal
class LaminaConsumo extends JPanel {
    public LaminaConsumo() {
        // Panel para el encabezado
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("CALCULO GASTO"); // Etiqueta para el encabezado
        encabezado.setHorizontalAlignment(JLabel.CENTER); // Centra el texto de la etiqueta
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16)); // Establece la fuente y el tamaño de la letra
        panelEncabezado.add(encabezado); // Añade la etiqueta al panel
        
        JPanel panelAuto = new JPanel();
        
        // Etiquetas y JSpinners para cada opción de configuración
        JLabel etiquetaDistancia = new JLabel("Km recorridos");
        etiquetaDistancia.setHorizontalAlignment(JLabel.CENTER);
        etiquetaDistancia.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerDistancia = new JSpinner();
        
        JLabel etiquetaConsumo = new JLabel("Gasto a los 100");
        etiquetaConsumo.setHorizontalAlignment(JLabel.CENTER);
        etiquetaConsumo.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloConsumo = new SpinnerNumberModel(3.3, 3.3, 30, 0.1);
        JSpinner spinnerConsumo = new JSpinner(modeloConsumo);
        
        JLabel etiquetaPrecio = new JLabel("€/Litro");
        etiquetaPrecio.setHorizontalAlignment(JLabel.CENTER);
        etiquetaPrecio.setFont(new Font("Comic Sans", Font.BOLD, 16));
        SpinnerNumberModel modeloPrecio = new SpinnerNumberModel(1.10, 1.10, 1.90, 0.01);
        JSpinner spinnerPrecio = new JSpinner(modeloPrecio);
        
        panelAuto.add(etiquetaDistancia);
        panelAuto.add(spinnerDistancia);
        panelAuto.add(etiquetaConsumo);
        panelAuto.add(spinnerConsumo);
        panelAuto.add(etiquetaPrecio);
        panelAuto.add(spinnerPrecio);
        
        // Panel para mostrar el resumen de configuración
        JPanel panelCalculo = new JPanel();
        panelCalculo.setLayout(new BoxLayout(panelCalculo, BoxLayout.Y_AXIS));
        JButton botonCalculo = new JButton("Calcular costo");
        JLabel total = new JLabel(); // Etiqueta para mostrar el resumen
        total.setFont(new Font("Comic sans", Font.BOLD, 13));
        total.setHorizontalAlignment(JLabel.LEFT);
        total.setText("0€");
        // Añade el botón y la etiqueta al panel de resumen
        panelCalculo.add(botonCalculo);
        panelCalculo.add(total);

        // Configuración del diseño de la lamina principal
        setLayout(new BorderLayout());
        
        // Añade los paneles al contenedor principal
        add(panelEncabezado, BorderLayout.NORTH); // Añade el panel del encabezado en la parte superior
        add(panelAuto, BorderLayout.CENTER); // Añade el panel de opciones en el centro
        add(panelCalculo, BorderLayout.SOUTH); // Añade el panel del resumen en la parte inferior
        
        // Acción del botón Calcular costo
        botonCalculo.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Obtener los valores de los JSpinner
                int distancia = (int) spinnerDistancia.getValue();
                double consumo = (double) spinnerConsumo.getValue();
                double precio = (double) spinnerPrecio.getValue();

                // Calcular el costo total del viaje
                double costoTotal = (distancia / 100.0) * consumo * precio;

                // Mostrar el resultado en la etiqueta de resumen
                total.setText("El costo del viaje es: " + String.format("%.2f", costoTotal) + "€");
            }
        });
    }
}

Ejercicio 7

Desarrolla una aplicación que permita a los usuarios personalizar la apariencia de un texto utilizando JSpinner. La aplicación debe incluir JSpinners para seleccionar el tamaño de la fuente, el color del texto (usando valores RGB), y el ángulo de rotación del texto. Cuando el usuario presione un botón de 'Aplicar Estilo', la aplicación debe mostrar el texto con el estilo seleccionado en un JLabel. Asegúrate de que los JSpinners sean fáciles de entender y usar, y que la interfaz sea intuitiva para el usuario. Requisitos: JSpinner para Tamaño de la Fuente: Valores de 10 a 50 en incrementos de 1. JSpinner para Color del Texto (RGB): Tres JSpinners para seleccionar los valores de rojo, verde y azul. Valores de 0 a 255 en incrementos de 1 para cada color. JSpinner para Ángulo de Rotación del Texto: Valores de 0 a 360 en incrementos de 1. Botón 'Aplicar Estilo': Al presionar este botón, se debe aplicar el estilo seleccionado al texto mostrado en un JLabel. Etiqueta para el Texto Personalizado: Muestra el texto con el estilo seleccionado por el usuario. Interfaz Intuitiva: Asegúrate de que la disposición de los componentes sea clara y fácil de usar


package jspinner;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerNumberModel;

public class Ejercicio7 {

    public static void main(String[] args) {
        // Crea y configura la ventana principal de la aplicación
        MarcoEstilo miMarco = new MarcoEstilo();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoEstilo extends JFrame {
    public MarcoEstilo() {
        // Configura las propiedades de la ventana principal
        setBounds(0, 0, 600, 400);
        setTitle("CONFIGURACION ESTILO");
        setResizable(false);
        setLocationRelativeTo(null);

        // Añade la lamina principal al marco
        LaminaEstilo miLamina = new LaminaEstilo();
        add(miLamina, BorderLayout.CENTER);
    }
}

// Clase personalizada para mostrar el texto rotado
class RotatedLabel extends JLabel {
    private double angle;

    public RotatedLabel(String text) {
        super(text);
        this.angle = 0;
        setHorizontalAlignment(JLabel.CENTER);
        setVerticalAlignment(JLabel.CENTER);
    }

    public void setAngle(double angle) {
        this.angle = angle;
        repaint();
    }

    @Override
    public Dimension getPreferredSize() {
        // Calcula el tamaño del componente después de la rotación
        Dimension originalSize = super.getPreferredSize();
        double radians = Math.toRadians(angle);
        double sin = Math.abs(Math.sin(radians));
        double cos = Math.abs(Math.cos(radians));
        int w = (int) Math.floor(originalSize.width * cos + originalSize.height * sin);
        int h = (int) Math.floor(originalSize.height * cos + originalSize.width * sin);
        return new Dimension(w, h);
    }

    @Override
    protected void paintComponent(Graphics g) {
        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        int x = getWidth() / 2;
        int y = getHeight() / 2;
        g2d.rotate(Math.toRadians(angle), x, y);
        super.paintComponent(g2d);
        g2d.dispose();
    }
}

class LaminaEstilo extends JPanel {
    public LaminaEstilo() {

        // Panel del encabezado
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("ESTILO LABEL"); // Etiqueta para el encabezado
        encabezado.setHorizontalAlignment(JLabel.CENTER); // Centra el texto de la etiqueta
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16)); // Establece la fuente y el tamaño de la letra
        panelEncabezado.add(encabezado); // Añade la etiqueta al panel
        
        // Panel para los spinners
        JPanel panelSpinner = new JPanel();
        
        // Modelos para los spinners de colores RGB
        SpinnerNumberModel modeloRojo = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloVerde = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloAzul = new SpinnerNumberModel(0, 0, 255, 1);
        
        // Etiquetas y spinners para los colores RGB
        JLabel etiquetaRojo = new JLabel("R");
        etiquetaRojo.setHorizontalAlignment(JLabel.CENTER);
        etiquetaRojo.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerRojo = new JSpinner(modeloRojo);
        
        JLabel etiquetaVerde = new JLabel("G");
        etiquetaVerde.setHorizontalAlignment(JLabel.CENTER);
        etiquetaVerde.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerVerde = new JSpinner(modeloVerde);
        
        JLabel etiquetaAzul = new JLabel("B");
        etiquetaAzul.setHorizontalAlignment(JLabel.CENTER);
        etiquetaAzul.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerAzul = new JSpinner(modeloAzul);
        
        // Modelo y spinner para el ángulo de rotación
        SpinnerNumberModel modeloAngulo = new SpinnerNumberModel(0, 0, 360, 1);
        JLabel etiquetaAngulo = new JLabel("º");
        etiquetaAngulo.setHorizontalAlignment(JLabel.CENTER);
        etiquetaAngulo.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerAngulo = new JSpinner(modeloAngulo);
        
        // Configura el panel de spinners
        panelSpinner.setLayout(new BoxLayout(panelSpinner, BoxLayout.Y_AXIS));
        panelSpinner.add(etiquetaRojo);
        panelSpinner.add(spinnerRojo);
        panelSpinner.add(etiquetaVerde);
        panelSpinner.add(spinnerVerde);
        panelSpinner.add(etiquetaAzul);
        panelSpinner.add(spinnerAzul);
        panelSpinner.add(etiquetaAngulo);
        panelSpinner.add(spinnerAngulo);
        
        // Panel para la etiqueta central
        JPanel panelEtiqueta = new JPanel();
        RotatedLabel etiquetaCentro = new RotatedLabel("HOLA MUNDO");
        etiquetaCentro.setAlignmentY(JLabel.BOTTOM_ALIGNMENT);
        etiquetaCentro.setFont(new Font("Comic Sans", Font.BOLD, 38));
        etiquetaCentro.setForeground(new Color(0, 0, 0));
        panelEtiqueta.add(Box.createRigidArea(new Dimension(0, 200)));
        panelEtiqueta.add(etiquetaCentro);
        
        // Panel para el botón de aplicar
        JPanel panelBoton = new JPanel();
        JButton botonAplicar = new JButton("Aplicar");
        botonAplicar.setHorizontalAlignment(JLabel.CENTER);
        botonAplicar.setFont(new Font("Comic Sans", Font.BOLD, 38));
        panelBoton.add(botonAplicar);
        
        // Configura el diseño de la lámina principal
        setLayout(new BorderLayout());
        
        add(panelEncabezado, BorderLayout.NORTH);
        add(panelSpinner, BorderLayout.WEST);
        add(panelEtiqueta, BorderLayout.CENTER);
        add(panelBoton, BorderLayout.SOUTH);
        
        // Acción para el botón aplicar
        botonAplicar.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int rojo = (int) spinnerRojo.getValue();
                int verde = (int) spinnerVerde.getValue();
                int azul = (int) spinnerAzul.getValue();
                int angulo = (int) spinnerAngulo.getValue();

                // Aplica el color seleccionado al texto
                etiquetaCentro.setForeground(new Color(rojo, verde, azul));
                // Aplica el ángulo de rotación al texto
                etiquetaCentro.setAngle(angulo);

                // Actualiza el tamaño preferido del panelEtiqueta
                panelEtiqueta.setPreferredSize(etiquetaCentro.getPreferredSize());
                panelEtiqueta.revalidate();
            }
        });
    }
}

Ejercicio 8

Desarrolla una aplicación que permita a los usuarios personalizar la apariencia de un componente JSpinner. La aplicación debe incluir opciones para cambiar el color de fondo, el color del texto, el tamaño de la fuente y el tipo de borde del JSpinner. Requisitos: JSpinner para Color de Fondo: Tres JSpinner para seleccionar los valores de rojo, verde y azul. Valores de 0 a 255 en incrementos de 1 para cada color. JSpinner para Color del Texto: Tres JSpinner para seleccionar los valores de rojo, verde y azul. Valores de 0 a 255 en incrementos de 1 para cada color. JSpinner para Tamaño de la Fuente: Valores de 10 a 30 en incrementos de 1. Selector de Tipo de Borde: Un JSpinner con opciones para seleccionar el tipo de borde del JSpinner. Opciones disponibles: "Sin Borde", "Línea Sencilla", "Línea Doble". Botón 'Aplicar Estilo': Al presionar este botón, se debe aplicar el estilo seleccionado al JSpinner principal. Interfaz Intuitiva: La disposición de los componentes debe ser clara y fácil de usar. El JSpinner principal debe estar centrado en la ventana de la aplicación para facilitar su visualización. La aplicación debe reflejar en tiempo real los cambios de apariencia del JSpinner cada vez que se presione el botón "Aplicar Estilo". Asegúrate de que los usuarios puedan experimentar con diferentes combinaciones de estilos de manera intuitiva

package jspinner;

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.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerListModel;
import javax.swing.SpinnerNumberModel;
import javax.swing.border.Border;

public class Ejercicio8 {

    public static void main(String[] args) {
        
    	MarcoEstiloSpinner miMarco = new MarcoEstiloSpinner();
        miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        miMarco.setVisible(true);
    }
}

class MarcoEstiloSpinner extends JFrame {
    public MarcoEstiloSpinner() {
        
        setBounds(0, 0, 600, 600);
        setTitle("CONFIGURACION ESTILO");
        setResizable(false);
        setLocationRelativeTo(null);

        
        LaminaEstiloSpinner miLamina = new LaminaEstiloSpinner();
        add(miLamina, BorderLayout.CENTER);
    }
}

class LaminaEstiloSpinner extends JPanel {
    public LaminaEstiloSpinner() {

        // Panel del encabezado
        JPanel panelEncabezado = new JPanel();
        JLabel encabezado = new JLabel("ESTILO LABEL"); // Etiqueta para el encabezado
        encabezado.setHorizontalAlignment(JLabel.CENTER); // Centra el texto de la etiqueta
        encabezado.setFont(new Font("Comic Sans", Font.BOLD, 16)); // Establece la fuente y el tamaño de la letra
        panelEncabezado.add(encabezado); // Añade la etiqueta al panel
        
        // Panel para los spinners
        JPanel panelSpinner = new JPanel();
        panelSpinner.setPreferredSize(new Dimension(90,10));
        
        SpinnerNumberModel modeloFondoRojo = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloFondoVerde = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloFondoAzul = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloRojo = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloVerde = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloAzul = new SpinnerNumberModel(0, 0, 255, 1);
        SpinnerNumberModel modeloTamanio = new SpinnerNumberModel(10, 10, 30, 1);
        
        ArrayList<String> listaBordes = new ArrayList<String>(Arrays.asList("Sin borde","Linea Sencilla","Linea Doble")); 
        SpinnerListModel modeloBorde = new SpinnerListModel(listaBordes);
        
        JLabel etiquetaFondoRojo = new JLabel("F.ROJO");
        etiquetaFondoRojo.setHorizontalAlignment(JLabel.LEFT);
        etiquetaFondoRojo.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerFondoRojo = new JSpinner(modeloFondoRojo);
        
        JLabel etiquetaFondoVerde = new JLabel("F.VERDE");
        etiquetaFondoVerde.setHorizontalAlignment(JLabel.LEFT);
        etiquetaFondoVerde.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerFondoVerde = new JSpinner(modeloFondoVerde);
        
        JLabel etiquetaFondoAzul = new JLabel("F.Azul");
        etiquetaFondoAzul.setHorizontalAlignment(JLabel.LEFT);
        etiquetaFondoAzul.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerFondoAzul = new JSpinner(modeloFondoAzul);
        
        
        JLabel etiquetaRojo = new JLabel("ROJO");
        etiquetaRojo.setHorizontalAlignment(JLabel.LEFT);
        etiquetaRojo.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerRojo = new JSpinner(modeloRojo);
        
        JLabel etiquetaVerde = new JLabel("VERDE");
        etiquetaVerde.setHorizontalAlignment(JLabel.LEFT);
        etiquetaVerde.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerVerde = new JSpinner(modeloVerde);
        
        JLabel etiquetaAzul = new JLabel("AZUL");
        etiquetaAzul.setHorizontalAlignment(JLabel.LEFT);
        etiquetaAzul.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerAzul = new JSpinner(modeloAzul);
        
        JLabel etiquetaTamanio = new JLabel("TAMAÑO");
        etiquetaTamanio.setHorizontalAlignment(JLabel.LEFT);
        etiquetaTamanio.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerTamanio = new JSpinner(modeloTamanio);
        
        JLabel etiquetaBorde = new JLabel("Borde");
        etiquetaBorde.setHorizontalAlignment(JLabel.LEFT);
        etiquetaBorde.setFont(new Font("Comic Sans", Font.BOLD, 16));
        JSpinner spinnerBorde = new JSpinner(modeloBorde);
        spinnerBorde.setFont(new Font("Comic Sans",Font.BOLD,11));
        spinnerBorde.setPreferredSize(new Dimension(50,50));
        
        // Configura el panel de spinners
        panelSpinner.setLayout(new BoxLayout(panelSpinner, BoxLayout.Y_AXIS));
        panelSpinner.add(etiquetaFondoRojo);
        panelSpinner.add(spinnerFondoRojo);
        panelSpinner.add(etiquetaFondoVerde);
        panelSpinner.add(spinnerFondoVerde);
        panelSpinner.add(etiquetaFondoAzul);
        panelSpinner.add(spinnerFondoAzul);
        panelSpinner.add(etiquetaRojo);
        panelSpinner.add(spinnerRojo);
        panelSpinner.add(etiquetaVerde);
        panelSpinner.add(spinnerVerde);
        panelSpinner.add(etiquetaAzul);
        panelSpinner.add(spinnerAzul);
        panelSpinner.add(etiquetaTamanio);
        panelSpinner.add(spinnerTamanio);
        panelSpinner.add(etiquetaBorde);
        panelSpinner.add(spinnerBorde);
        
        
        
        ArrayList<String> prueba=new ArrayList<String>();
        prueba.add("Hola Mundo!!!!");
        SpinnerListModel modeloPrueba=new SpinnerListModel(prueba);
        JPanel panelModeloPrueba = new JPanel();
        JSpinner spinnerPrueba=new JSpinner(modeloPrueba);
        spinnerPrueba.setPreferredSize(new Dimension(300,100));
        spinnerPrueba.setForeground(new Color(0,0,0));
        spinnerPrueba.setFont(new Font(Font.SANS_SERIF,Font.PLAIN,10));
        JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) spinnerPrueba.getEditor();
        JFormattedTextField textField = editor.getTextField();
        textField.setHorizontalAlignment(textField.CENTER);
        
        
        panelModeloPrueba.add(Box.createRigidArea(new Dimension(0, 400)));
        panelModeloPrueba.add(spinnerPrueba);
        
        // Panel para el botón de aplicar
        JPanel panelBoton = new JPanel();
        JButton botonAplicar = new JButton("Aplicar");
        botonAplicar.setHorizontalAlignment(JLabel.CENTER);
        botonAplicar.setFont(new Font("Comic Sans", Font.BOLD, 38));
        panelBoton.add(botonAplicar);
        
        // Configura el diseño de la lámina principal
        setLayout(new BorderLayout());
        
        add(panelEncabezado, BorderLayout.NORTH);
        add(panelSpinner, BorderLayout.WEST);
        add(panelModeloPrueba, BorderLayout.CENTER);
        add(panelBoton, BorderLayout.SOUTH);
        
        
        botonAplicar.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				int fondoRojo=(int)spinnerFondoRojo.getValue();
				int fondoVerde=(int)spinnerFondoVerde.getValue();
				int fondoAzul=(int)spinnerFondoAzul.getValue();
				int rojo=(int)spinnerRojo.getValue();
				int verde=(int)spinnerVerde.getValue();
				int azul=(int)spinnerAzul.getValue();
				int tamanio=(int)spinnerTamanio.getValue();
				String borde=(String) spinnerBorde.getValue();
				
				spinnerPrueba.setOpaque(true);
				textField.setBackground(new Color(fondoRojo, fondoVerde, fondoAzul));
				textField.setForeground(new Color(rojo,verde,azul));
				spinnerPrueba.setFont(new Font(Font.SANS_SERIF,Font.PLAIN,tamanio));
				Border bordes=null;
				switch (borde){
					case "Sin borde":
						bordes = BorderFactory.createMatteBorder(0, 0, 0, 0, Color.BLUE);
						break;
					case "Linea Sencilla":
						bordes = BorderFactory.createMatteBorder(1, 1, 1, 1, Color.BLUE);
						break;
					case "Linea Doble":
						bordes = BorderFactory.createMatteBorder(2, 2, 2, 2, Color.BLUE);
						break;
						
				}
				
				spinnerPrueba.setBorder(bordes);
			}
        	
        });
    }
}