Elementos clickeables en interfaz gráfica

Contenido del curso

Introducción al Curso

1
Java SE Avanzado: Programación Modular y Persistencia con JDBC
03:17 min

Clases avanzadas

JavaDocs

Clases Anidadas

Interfaces Avanzadas

Colecciones Avanzadas

21
Implementaciones y uso de Map en Java
01:42 min

Excepciones

JDBC

Lambdas

Fin del Curso

40
Programación Avanzada en Java: Clases e Interfaces
01:30 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

Estoy construyendo una interfaz gráfica que puede contener botones, etiquetas de texto, imágenes etc., cada elemento representa una clase.

¿Cómo resolvería que un elemento pueda ser clickeable en determinado momento?

Escribe tu respuesta en la sección de discuciones y comenta la respuesta de otro de tus compañeros.

Elementos clickeables en interfaz gráfica

Curso Avanzado de Java SE

Clase 36 de 40

Clase 36 / 40

Comentarios (69)69 comentarios

Carlos Uriel de Jesus Sánchez González

Hace 8 años

@FunctionalInterface
public interface Clickable{
    public void click(Element element);
}

public class MyView implements Clickable {
	
	public static void main(String[] args){
	
		@Override
		public void click(Element element){
			//Todo
		}

		Clickable cl = (Element element) -> {
			//Todo
}

	}
}

Daniel Alejandro Contreras Suárez

Hace 8 años

El override del método click tiene que ir afuera del método main, aunque de todas maneras no veo necesario implementar la interfaz en la clase.

GUIFOR PAUL PLAZA AGUIRRE

Hace 7 años

buen ejemplo.

Kevin Manuel Wong

Hace 6 años

Clase boton:

public class Boton {
	public void onClick(Listener listener) {
		listener.addOnClick();
	}
}

Interface funcional:

@FunctionalInterface
public interface Listener {
	void addOnClick();
}

Implementacion en el clase main:

Boton boton = new Boton();
		boton.onClick(()-> { System.out.println("click!");});

José Eduardo Guevara Soria

Hace 8 años

@FunctionalInterface
public Interface OnClickListener{
	public void click(Element element);
}

public class Main{
	public static void main(String[] args){
			OnClickListener onClickListener = (Element element) ->{
		}
	}
}

Marcos Emilio Velásquez Hidalgo

Hace 7 años

Es tan simple como crear una interfaz que maneje el evento "Click" llamada IClickable

@FunctionalInterface
public interface IClickable {
    public void OnClickListener();
}

Y luego darle el comportamiento deseado:

		IClickable clickable = () -> {
			System.out.println("El evento que le quiero dar");
		};

		clickable.OnClickListener();

Noe de Jesus Muñoz Martinez

Hace 8 años

@FunctionalInterface
public interface Clickeable {
	void click(Element element);
}

public class Main {
	public static void main(String[] args) {
		Clickeable clickeable = new Clickeable();

		@Override
		public void click(Element element) {
			// Todo el comportamiento
		}

		Clickeable clickeable2 = (Element element) -> {
			// Todo el comportamiento
		};

		clickeable.click(element);
		clickeable2.click(element)
	}
}

Laura Sofía Córdoba

Hace 7 años

Interface funcional

package com.lsc.lamba2;

@FunctionalInterface
public interface ClickElement {
	void oneClickElement(String message);

}

Método Main

package com.lsc.lamba2;

public class Main {

	public static void main(String[] args) {
		ClickElement clickElement = (String message) ->{
			System.out.println("click aqui " + message);
		};
		clickElement.oneClickElement("button"); 

	}

}

Paul Cortes

Hace 7 años

Excelente reto se aplica muy bien lo anterior que se acaba de explicar

@FunctionalInterface
public interface IClickeable {
	void OnClick();
}

Clase Label

public class Label  {
	public void onClick(OnOneListener oneListener, String message){
		oneListener.onOne(message);
	}
}

Desde Otra clase donde se invoque

Label label = new Label();
label.onClick((String message) -> {
	System.out.println("Recibido: "+ message);
}, "Prueba de mensaje");

Lázaro Bucio Marín

Hace 8 años

@FunctionalInterface
public Interface OnClickListener{
	publicvoidclick(Element element);
}

publicclassMain{
	publicstaticvoidmain(String[] args){
			OnClickListener onClickListener = (Element element) ->{
		}
	}
}```

Danner Adib Uribe

Hace 7 años

Este ejemplo lo que hace es llamar una interface, y luego de instanciarla le pasa el elemento para que lo imprima:

package com.pruebas;

@FunctionalInterface
public interface Clickable {

	void clicked(String event);
	
}

package com.pruebas;

public class Main {

	public static void main(String[] args) {
		
		Clickable clicked = (String element) -> { System.out.println("Clickeo " + element); };

		clicked.clicked("Evento");
		
	}

}

César Espitia

Hace 7 años

Acá dejo mi versión del ejercicio propuesto:

Interface Clickable

package com.erosennin.amazonviewer.challenges;

@FunctionalInterface
public interface Clickable {

    Object onClick(Object object);
}

Main

    public static void main(String[] args) {
        Clickable clickable = (name) -> {
                StringBuilder result = new StringBuilder();
                result.append("\nHola desde funcion Lambda ").append(name.toString());
                return result;
            };
        System.out.println(clickable.onClick("Cosme Fulanito"));
    }

Luis Cristóbal Oliden Albrecht

Hace 7 años

Usuario anónimo

User

Hace 6 años

Listo :)

Usuario anónimo

User

Hace 6 años

María Ximena Guamán Argudo

Hace 7 años

@FunctionalInterface

public Interface OnClickListener{
	public void click (Element element);
}

public class Main{
	public static void main (String[] args){
		OnClickListener onClickListener = (Element element) -> {
		}
	}
}

Oscar Escañuela Donoso

Hace 7 años

@FunctionalInterface
public interface Click{
	void clickeable(Element element);
}


public class Main {

	public static void main(String[] args) {
		
		click = (String element) -> {System.out.println("Clickeo: " + element);};
		click.clickeable("Objeto cliqueable");

	}

}

Jhon Alejandro Santamaria Vargas

Hace un mes

Para resolverlo, utilizaría herencia y polimorfismo, creando una clase o interfaz que defina el comportamiento de los elementos que pueden ser clickeables.

Por ejemplo, podría tener una interfaz Clickeable con un método hacerClick(). Luego, las clases que necesiten responder a un clic, como Boton, Imagen o incluso Etiqueta, implementarían esa interfaz. Así, cada elemento puede tener su propia acción cuando sea presionado.

Monica Cristina Montoya Gaviria

Hace 7 meses

public class Boton { public void onClick(Listener listener) { listener.addOnClick(); } }

}

Alejandro Soria

Hace 8 años

@FunctionalInterface
public interface EventoClick{

public void Click(Element elemento);

}

public class Main {

public static void main(String[] args) {

EventoClick ec = (Element element) --> {
.
.
.

};

Braian Peña

Hace 7 años

Muy útil para reducir cantidad de Código.

Vespaciano Forero Sanchez

Hace 8 años

Seria algo como esto:

@FunctionalInterface
public interface Click {
	void onClick(Class onClic);
}

public class Clickeable {
	public static void main(String[] args) {
		Click uno = (Class boton) -> {
			if(boton.onclick == true) {
				System.out.println("Bien");
			} else {
				System.out.println("Mal");
			}
		};
		
		uno.onClic(new Button);
	}
}

public class MyView implements Clickable {
	
	public static void main(String[] args){
	
		@Override
		public void click(Element element){
			//Todo
		}

		Clickable cl = (Element element) -> {
			//Todo
}

	}
}

@FunctionalInterface
public Interface OnClickListener{
	public void click(Element element);
}

public class Main{
	public static void main(String[] args){
			OnClickListener onClickListener = (Element element) ->{
		}
	}
}

public class Main {
	public static void main(String[] args) {
		Clickeable clickeable = new Clickeable();

		@Override
		public void click(Element element) {
			// Todo el comportamiento
		}

		Clickeable clickeable2 = (Element element) -> {
			// Todo el comportamiento
		};

		clickeable.click(element);
		clickeable2.click(element)
	}
}

package com.lsc.lamba2;

public class Main {

	public static void main(String[] args) {
		ClickElement clickElement = (String message) ->{
			System.out.println("click aqui " + message);
		};
		clickElement.oneClickElement("button"); 

	}

}

@FunctionalInterface
public Interface OnClickListener{
	publicvoidclick(Element element);
}

publicclassMain{
	publicstaticvoidmain(String[] args){
			OnClickListener onClickListener = (Element element) ->{
		}
	}
}```

package com.pruebas;

@FunctionalInterface
public interface Clickable {

	void clicked(String event);
	
}

package com.pruebas;

public class Main {

	public static void main(String[] args) {
		
		Clickable clicked = (String element) -> { System.out.println("Clickeo " + element); };

		clicked.clicked("Evento");
		
	}

}

    public static void main(String[] args) {
        Clickable clickable = (name) -> {
                StringBuilder result = new StringBuilder();
                result.append("\nHola desde funcion Lambda ").append(name.toString());
                return result;
            };
        System.out.println(clickable.onClick("Cosme Fulanito"));
    }

@FunctionalInterface

public Interface OnClickListener{
	public void click (Element element);
}

public class Main{
	public static void main (String[] args){
		OnClickListener onClickListener = (Element element) -> {
		}
	}
}

@FunctionalInterface
public interface Click{
	void clickeable(Element element);
}


public class Main {

	public static void main(String[] args) {
		
		click = (String element) -> {System.out.println("Clickeo: " + element);};
		click.clickeable("Objeto cliqueable");

	}

}

public class Clickeable {
	public static void main(String[] args) {
		Click uno = (Class boton) -> {
			if(boton.onclick == true) {
				System.out.println("Bien");
			} else {
				System.out.println("Mal");
			}
		};
		
		uno.onClic(new Button);
	}
}

Introducción al Curso

Java SE Avanzado: Programación Modular y Persistencia con JDBC

Clases avanzadas

Clases Abstractas y Polimorfismo en Java: Avances y Aplicaciones

Reducción de Código con Clases Abstractas en Java

Sobrescritura de métodos en clases derivadas en Java

Polimorfismo y Abstracción en Clases Java

JavaDocs

Generación de Documentación Java con Javadocs

Documentación en Java: Uso de Etiquetas y Comentarios HTML

Documentación de librería Report en Java SE

Documentación de Clases Heredadas en Java

Generación de Documentación JavaDoc en HTML

Clases Anidadas

Clases Anidadas en Java: Conceptos y Aplicaciones Prácticas

Clase Song como clase interna en Album en Java

Implementación de Clases Anidadas en Java: Ejemplo Práctico con Page y Book

Simulación de Lectura con Clases Anidadas en Java

Uso de Enumerations en Programación

Interfaces Avanzadas

Interfaces Avanzadas en Java: Métodos Default y Private

Creación de Interfaces DAO en Java para Gestión de Bases de Datos

Encapsulación y Abstracción en Diseño de APIs

Diferencias entre Clases Abstractas e Interfaces en Programación

Herencia y métodos en interfaces de Java 8 y 9

Colecciones Avanzadas

Implementaciones y uso de Map en Java

Excepciones

Manejo de Excepciones en Java: Errores Checked y Unchecked

Manejo de Excepciones en Java: Try-Catch y Try-With-Resources

JDBC

Conexión a Bases de Datos con JDBC en Java

Uso de PreparedStatement para consultas con filtros en JDBC

Configuración de phpMyAdmin y XAMPP para Bases de Datos

Conexión a MySQL usando Java JDBC: Configuración y Prácticas

Conexión y Lectura de Datos con JDBC en Java

Persistencia de Datos en Aplicaciones de Películas

Inserción y Visualización de Películas Vistas en Base de Datos SQL

Generación de Reportes Diarios con Fechas en Java

Lambdas

Modificación de tablas y manejo de fechas en MySQL

Interfaces Funcionales en Java: Conceptos y Ejemplos Prácticos

Programación Funcional: Paradigmas y Lambdas en Java

Lambdas en Java: Sintaxis y Aplicaciones Prácticas

Elementos clickeables en interfaz gráfica

Declaración de Lambdas y Recursividad en Java

Streams y Filters en Java para Optimizar Colecciones

Uso de Lambdas y Predicados en Streams Java

Fin del Curso

Programación Avanzada en Java: Clases e Interfaces

Elementos clickeables en interfaz gráfica