Ejercicio. Lambdas

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

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

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

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

	}

}

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

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

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

}

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

Listo 😃

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

	}

}

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.

@FuntionalInterface
public interface ClickEvent{
	void click( String evento); 
}

public class Eventos{
	ClickEvent clickListener = (String evento) -> 		 
    System.out.println("Click en"+ evento);
	};
clickListener.click("evento");
}

public interface ClicleableComponent {

    void click(String message);
}

ClicleableComponent clicleableComponent = System.out::println;
clicleableComponent.click("Un mesaje");

<code>
@FunctionalInterface
public interface ExampleFunctionalInterfaces {
    public String clickeable(String param,String param2);
}
public class ButtomUI {
    public String message(){
        return "Usted ha dado clic en un ";
    }
}
public class LabelUI {
    public String message(){
        return "Usted ha dado clic en la ";
    }
}
public class Main {
    public static void main(String[] agrs){
        ButtomUI bu = new ButtomUI();
        LabelUI lu = new LabelUI();
        ImageUI iu = new ImageUI();
        
        ExampleFunctionalInterfaces efi = (param,param2) -> param+param2;
        
        System.out.println(efi.clickeable(bu.message(),"Buttom"));
        System.out.println(efi.clickeable(lu.message(),"Label"));
        System.out.println(efi.clickeable(iu.message(),"Image"));
    }
}

Otra opción de implementación. La única alteración se realizó en el método abstracto en la interfaz funcional, ahora solo recibe un parámetro.

<code>
public class Main {
    public static void main(String[] agrs){
        ButtomUI bu = new ButtomUI();
        LabelUI lu = new LabelUI();
        ImageUI iu = new ImageUI();
        
        ExampleFunctionalInterfaces efi = (param) ->{
            
            if(param.equals("Buttom")||param.equals("buttom")){
                System.out.println(bu.message()+param);
            }else if(param.equals("Label")||param.equals("label")){
                System.out.println(lu.message()+param);
            }else{
                System.out.println(iu.message()+param);
            }
        };
        efi.clickeable("image");
    }
}

Aplicando lambdas

@FunctionalInterface
public interface Click {

	void clickeable (Element element);
	
}```

public class Main {

public static void main(String[] args) {
	// TODO Auto-generated method stub
	

	Click click = new Click() {
		
		@Override
		public void clickeable(Element element) {
			// TODO Auto-generated method stub
		}
		
		Click cli = (Element element) -> {};
	};
}

}

}```

Defininiedo una clase de tipo interface funcional ‘IClickeable’ con su metodo onClick y luego desarrollando su comportamiento en cada instanciamiento de dicha fucionalidad

//Interface


Package com.administrador.interfase;}

@funtionalInterface
public interface setClickable(){
void setclickboton(String message);
}

public class EjemploLamda{
/*****************************************************************************************************/

//Clase Main

public static void main(String[] args){

	setClickable setclick = (String message)-> {
			
		 System.out.println("Este es un mensaje de lambda : " )
		
	}

  setclick. setclickboton("Para embeber codigo  de corto plazo.... :) ");

}

}

En una interfaz declaramos el método para clickear y lo implementamos mediante una lambda.

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

class Image implements Clickable {
	
	Clickable clickable = () -> {
		System.out.println("You've clicked me!");
	};
	
	void onClick() {
		clickable.click();
	}

}

Por alguna razón me dice que Image debe ser abstracta o implementar el método click cuando ya se está implementando en la Lambda. ¿?

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

import java.awt.Button;
public class UsaClickable{

public static void main(String[] args){

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

	Button button = new Button();
	Clickable clik = (button) -> {//Acciones}

}

}

@FunctionalInterface
public interface clickable {
void clickEvent(String message);
}

@FunctionalInterface
public interface Clickable{

	void clicked(String event);
	
}

public class Main{

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

		clicked.clicked("Evento");
		
	}

}

si utilizamos lambas no podemos solo podemos pasar un argumento en la función de la interfaz ya que no permite mas parámetros en lambas.

<code>
@FuntionalInterface
public interface ClickEvent{
	public void click( String evento); 
}

public class Eventos{
	public void eventClick(String evento ){
		ClickEvent click = mensaje -> 		 
    System.out.println("Click en"+ evento);
	}
}

Colocamos la clase Eventos en cada evento click como en Button , Text o Label

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

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

@functionalInterface
public interface onClickListtener()
{
	public void click(int buttonID);
}

main:

onClickListerner clicklistener = (2) -> {
 system.out.println("hola");
}

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

<code>
public class View {
	
	public static void main(String[] args){

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

		loginClickable .click(loginButton);
	}
}

(Elemento) -> {Funcionalidad Click};

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

@FunctionalInterface
public interface IOnClick {	
	void onClick(Elemento elemento);
}

public static void main(String[] args) {	
		IOnClick ionClick = new IOnClick() {			
			@Override
			public void onClick(Elemento elemento) {				
				// cuerpo
			}
		};

		ionClick.onclick(elemento);
<code>

@FunctionalInterface 
public Interface Clickenabled {
public void clickmoment(element button); 
}

Public class Main {
public static void main (Sring[] args);
Clickenabled clickenabled = (element button) -> {
	if (button.click == true){
		button.Setenabled == false;
	}
}
}
if (textbox1.value == null) {
	clickenabled.clickmoment(buttoncancel);
	}
}
<code>

Definiria los parametros necesarios para poder determinar en que momento un elemento pueda ser clickeable. Y justo cuando este cumpla con esos parametros se añade el comportamiento al dar le click.

HandleClickeable handleClickeable = (Object isTimeClick) ->{	
	if(isTimeClick){
		//Implementación de la acción del click
	}
}

Utilizando interfaces funcionales creaciòn el mètodo abstracto Clickeable, para poder utilizar el cualquier momento determinado.

<code>

@FucntionalInterface
public interface ClickAble{
void onClick(String message);
}

public static void main (String[] args) {
ClickAble click = (String message) -> {System.out.println(clickable.onClick(“FUNCIONA” + message));};
}

click.onClick(“Hola Mundo”);

@FunctionalInterface
public interface ClikListener {
	void onClick(String message);
}

	public static void main(String[] args) {
			ClikListener click = (message) -> {
				System.out.println("He hecho click y el message es "+ message);
			};
			click.onClick("Hize click ");
		}```

@FunctionalInterface
public interface OnClickListener {
void onClick(Element element);
}

public static void main(String[] args) {
OnClickListener clickListener = (Element element) ->{
System.out.println(" elemento: “+element);
}
clickListener.onClick(” se seleciono ");
}

package com.java.lambda.platzi;

@FunctionalInterface
public interface Click {

	void click(String element);
}

package com.java.lambda.platzi;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Click click = (String element) -> { System.out.println("Clickeaste "+element);};
		click.click("Image");
}

al objeto le cargo una una función sobreescrita proveniente de una interfaz SAM, clase anonima o una lamda. que se dispare ante el evento

package lamdas;

@FunctionalInterface
public interface Clickeable {
    void clicked(String message);
}

package lamdas;

public class Lamdas {

    public static void main(String[] args) {
        
        Clickeable clickeable = (String message) -> {
            System.out.println("click: " + message);  
        };
        
        clickeable.clicked("Doy click"); 
    }
    
}```

Bueno generalmente los botones, campos de texto y otros componentes ya tienen asociados interfaces que realizan comportamientos al momento de dar click, entonces lo que hay que hacer es llamar la interfaz que hace el comportamiento, ahora que estamos viendo la sintaxis de las lambas, funcionaria muy bien. Un ejemplo, puede ser:

pantalla.getBtnGuardar().addClickListener(event -> {
System.out.println("Este es un ejemplo ");
});

Para este caso en mi vista esta creado un boton, que tiene por nombre BtnGuardar, tiene sus respectivo Getter, el cual al momento de llamarlo en el controlador por medio de metodo anonimo, se puede invocar la interfaz de ClickListener, posteriormente colocamos la sintaxis de lambas vista en clase y ya solo es de colocarle el comportamiento que se quiere al momento que se de click sobre el boton.

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

`

package com.lambda.model;

@FunctionalInterface
public interface Clickeable {

	void setClickeable(String msg);
}

Run

package com.lambda.model;

public class Main {

	public static void main(String[] args) {
		
		Clickeable clic = (String msg) -> {
			System.out.println(msg);
		};
		
		clic.setClickeable("A clic");
		
	}

}

Genial, Lambdas es util para la reduccion de codigo y ayudarnos con la parte inmutabilidad. Lo que si no habia caido en cuenta es que ayuda con el encapsulamiento.

@FunctionalInterface
public interface Clickable {
void Click();
}

Clickable clickable = () -> {
System.out.println(“Practicando con Lambdas”);
};

clickable.Click();

Interface funcional

@FunctionalInterface
public interface Action {
	public void click(Slasher slasher);
}

public class MainClass {

	public static void main(String[] args) {
		
		ActionImpl action = (Slasher slasher) -> {};

	}
	
}

Yo lo resolvería creando una interfaz funcional llamada IClick con un metodo denominado void addEvent();

Y lo implementaría con una lambda así:

IClick onClick = () -> { System.out.println(“click”); };

onClick.addEvent();

Discusiones es con s. en el enunciado dice Discuciones.

Creé un código con un Lamda y Java Swing que ejemplifica cómo se haría esto en un caso real:

package com.anncode.lambdas;

import javax.swing.JButton;
import javax.swing.JFrame;

public class ClickableElementExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Clickable Element Example");

        JButton button = new JButton("Click Me");
        button.addActionListener(e -> {
            // Acción a realizar cuando se hace clic en el botón
            System.out.println("¡Has hecho clic en el botón!");
        });

        frame.getContentPane().add(button);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }
}

@FunctionalInterface
public interface Clickeable {
void Click(String element);

}

public class Main {

/**
 * @param args
 */
public static void main(String[] args) {

	Clickeable click = (String element) -> {
    System.out.println("Hi : " + element);

};
click.Click(“Dame un click 😄”);
}
}

/**
* paramns of class 
* clickeable
*/
public static class bodyclick{
  public void eventoclick(){
 System.out.println('hola mundo');
 }
}

@FunctionalInterface
public interface Clickable {
void Click();
}

Clickable clickable = () -> {
System.out.println(“Practicando con Lambdas”);
};

clickable.Click();

.Main

OnClickListener onClick = (boolean clicked)->{
			if (clicked == true) {
				System.out.println("Has presionado el boton Enter");	
			}
			
		};
	
		OnClickListener onClick2 = (boolean clicked)->{
			if (clicked == false) {
				System.out.println("No has presionado ningún botón");	
			}
			
		};
		
		onClick.onClick(true);
		onClick2.onClick(false);

.OnClickListener

package com.omarhdz.lambdas;

@FunctionalInterface
public interface OnClickListener {

		void onClick(boolean clicked );	
		
}