Elementos clickeables en interfaz gráfica

Clase 36 de 40 • Curso Avanzado de Java SE

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.

Carlos Uriel de Jesus Sánchez González

student•

@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

student•

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

student•

buen ejemplo.

Kevin Manuel Wong

student•

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

student•

@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

student•

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

student•

@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

student•

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

student•

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

student•

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

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

Danner Adib Uribe

student•

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

student•

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

student•

Usuario anónimo

user•

Listo :)

Usuario anónimo

user•

María Ximena Guamán Argudo

student•

@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

student•

@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");

	}

}

Alejandro Soria

student•

@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

student•

Muy útil para reducir cantidad de Código.

Vespaciano Forero Sanchez

student•

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);
	}
}

Luis Carlos

student•

Atendiendo al tema en cuestión, primeramente estableciendo que parámetro recibiré, asumo que sera el evento, entonces este seria el parámetro, el cuerpo podría ser la acción o acciones que va a realizar el botón.

Rodolfo Sáenz

student•

@FunctionalInterface
public interface Clickable {
    public void click(Button button);
}

public class MyView {
	
	public static void main(String[] args){

		Button loginButton = new Button();
		Button registerButton = new Button();

		Clickable loginClickable = loginButton -> { 
			System.out.println("Click login");
		}

		Clickable registerClickable = registerButton -> { 
			System.out.println("Click register");
		}

		loginClickable .click(loginButton);
		registerClickable .click(registerButton);
	}
}

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);
	}
}

public class MyView {
	
	public static void main(String[] args){

		Button loginButton = new Button();
		Button registerButton = new Button();

		Clickable loginClickable = loginButton -> { 
			System.out.println("Click login");
		}

		Clickable registerClickable = registerButton -> { 
			System.out.println("Click register");
		}

		loginClickable .click(loginButton);
		registerClickable .click(registerButton);
	}
}

Elementos clickeables en interfaz gráfica

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