Curso Avanzado de Java SE

Curso Avanzado de Java SE

Anah铆 Salgado D铆az de la Vega

Anah铆 Salgado D铆az de la Vega

Ejercicio. Lambdas

36/40

Lectura

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

...

Reg铆strate o inicia sesi贸n para leer el resto del contenido.

Aportes 58

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥淐lick鈥 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) ->{
		}
	}
}```
@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");

	}

}

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 馃槂

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

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(鈥渃lick鈥); };

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

public class MainClass {

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

	}
	
}

Interface funcional

public interface ClicleableComponent {

    void click(String message);
}
ClicleableComponent clicleableComponent = System.out::println;
clicleableComponent.click("Un mesaje");

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.

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

Clickable clickable = () -> {
System.out.println(鈥淧racticando con Lambdas鈥);
};

clickable.Click();

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

main:

onClickListerner clicklistener = (2) -> {
 system.out.println("hola");
}
<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) ->{
}
}
}

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

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

}

}```

<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>

Aplicando lambdas

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

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

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

<code>

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

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

click.onClick(鈥淗ola Mundo鈥);

//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.... :) ");

}

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

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

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

Defininiedo una clase de tipo interface funcional 鈥業Clickeable鈥 con su metodo onClick y luego desarrollando su comportamiento en cada instanciamiento de dicha fucionalidad

Muy 煤til para reducir cantidad de C贸digo.
@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");
		
	}

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

}

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

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

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

Clickable clickable = () -> {
System.out.println(鈥淧racticando con Lambdas鈥);
};

clickable.Click();

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

@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(鈥淒ame un click 馃槃鈥);
}
}