Directorio artículo
expresión 1 Lamda
JDK 1.8 desde el principio con el fin de simplificar el desarrollo de código de usuario, se proporciona un apoyo específicamente Lambda expresiones Con esta operación se puede realizar en forma de programación funcional. Para el lenguaje de programación funcional más conocida: Haskell, Scala, el uso de la programación funcional para evitar el engorroso proceso cabo para la edición en la programación orientada a objetos.
en el proceso de su desarrollo a largo plazo orientado a objetos ha sido parte de los oponentes, los oponentes argumentan que estos diseño orientado a objetos es demasiado complicado y demasiado complicado para programar un ejemplo sencillo.
Ejemplo: Observación de las cuestiones de desarrollo tradicionales
interface IMessage{
public abstract void fun();
}
public class JavaDemo{
public static void main(String[] args){
IMessage msg = new IMessage(){
public void fun(){
System.out.println("hhy");
}
};
msg.fun();
}
}
En un programa de este tipo que, de hecho, el diseño de la base de la función de la estructura sólo una instrucción de línea, pero todavía YAOAN dan un completo desarrollo orientado a objetos. Así que estos temas con el desarrollo de la tecnología, pero también cada vez más prominente.
Ejemplo: Uso Expresiones Lambda lograr exactamente la misma función que antes
interface IMessage{
public abstract void fun();
}
public class JavaDemo{
public static void main(String[] args){
IMessage msg = ()->{
System.out.println("hhy");
};
msg.fun();
}
}
Con esta forma evita los complejos requisitos de la estructura orientada a objetos.
Las expresiones lambda Si desea utilizar, se deben cumplir con un requisito importante: SAM (Método abstracta único), solo un método abstracto. Sólo un método de interfaz se llama una interfaz de función, la función de interfaz se puede utilizar solamente por las expresiones lambda. Con el fin de mostrar una interfaz de función de interfaz clara, utilice Anotación anotación (@FunctionalInterface).
Ejemplo: Utilización de interfaces de anotación funcional
@FunctionalInterface
interface IMessage{
public abstract void fun();
}
public class JavaDemo{
public static void main(String[] args){
IMessage msg = ()->{
System.out.println("hhy");
};
msg.fun();
}
}
A los efectos de las expresiones lambda, se proporciona los siguientes formatos:
(1) no hay parámetros: () -> {};
(2) :( parámetro que tiene parámetros, los parámetros) -> {};
(3) si la corriente :( comando retorna un único parámetro de la línea, el parámetro) -> declaración;
ejemplo: no hay manera de definir los parámetros.
@FunctionalInterface
interface IMessage{
public abstract void fun();
}
public class JavaDemo{
public static void main(String[] args){
IMessage msg = ()->{
System.out.println("hhy");
};
msg.fun();
}
}
Ejemplo: Definición de los parámetros de los métodos
@FunctionalInterface
interface IMath{
public abstract int add(int x, int y);
}
public class JavaDemo{
public static void main(String[] args){
IMath math = (x, y)->{
return x + y;
};
System.out.println(math.add(10, 3));
}
}
declaración única puede simplificarse aún
ejemplo: simplificar el código
@FunctionalInterface
interface IMath{
public abstract int add(int x, int y);
}
public class JavaDemo{
public static void main(String[] args){
IMath math = (x, y)-> x + y;
System.out.println(math.add(10, 3));
}
}
Uso expresión Lmbda de hecho puede deshacerse de las restricciones tradicionales orientados a objetos sobre la estructura, hace que el código sea más sencilla.
2 método de referencia
Referencia característica más grande es el tipo de memoria de datos puede apuntar a tratar, pero en el desarrollo tradicional, ha sido el uso de las operaciones de referencia de objetos, desde luego JDK 1.8, se proporciona también un método de referencia. , A saber: Diferentes métodos pueden ser descritas como el mismo nombre del método. Si desea proporcionar un método de referencia en Java que tiene cuatro formas:
(1) las referencias a un método estático: nombre de la clase :: nombre del método estático;
(2) una referencia a una instancia de método de un objeto: :: instancia de un métodos de objetos comunes;
(3 ) se refieren a un tipo específico de método: clase específica :: método convencional;
(4) de referencia constructor: nombre de clase :: nuevo.
Ejemplo: la referencia a un método estático
método static String: static public String valueOf (int i )
@FunctionalInterface
interface IFunction<T, U>{
public abstract T fun(U n);
}
public class JavaDemo{
public static void main(String[] args){
IFunction<String, Integer> f = String::valueOf;
System.out.println(String.valueOf(12));
System.out.println(f.fun(12));
}
}
El método de uso de una pluralidad de referencia se puede definir como un nombre de método, pero debe ser un requisitos de la interfaz de función.
Ejemplo: Ejemplo método de referencia objeto
@FunctionalInterface
interface IFunction<T>{
public abstract T fun();
}
public class JavaDemo{
public static void main(String[] args){
IFunction<String> f = "hhy"::toUpperCase;
System.out.println(f.fun());
}
}
Al llevar a cabo el método puede ser referenciado en algún método de referencia operaciones en una clase particular.
clase método de referencia especificado: Ejemplo
@FunctionalInterface
interface IFunction<T, U>{
public abstract T fun(U s1, U s2);
}
public class JavaDemo{
public static void main(String[] args){
IFunction<Integer, String> f = String::compareTo;
System.out.println(f.fun("A", "a"));
}
}
Ejemplo: constructor de referencia
@FunctionalInterface
interface IFunction<T>{
public abstract T fun(String s1, int s2);
}
class Person{
private String name;
private int age;
public Person(){}
public Person(String name, int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " " + age;
}
}
public class JavaDemo{
public static void main(String[] args){
IFunction<Person> f = Person::new;
System.out.println(f.fun("lks", 23));
}
}
Proporcionar un método de referencia en más circunstancias de concepto sólo compensar una referencia de apoyo.
3 incorporado en las interfaces de función
Siempre en el JDK 1.8 Las expresiones lambda también se proporciona un método referencias, pero se puede encontrar ahora si se define la función de interfaz por los propios desarrolladores, a menudo la necesidad de utilizar la anotación "@FunctionalInterface" declarar un montón, así que muchos de los casos si la orden función de referencia directa se puede proporcionar fácilmente en la interfaz del sistema.
Específicamente, se proporciona un paquete en el sistema de desarrollo java.util.function, que puede interactuar directamente la función, en este paquete son los siguientes unos pocos núcleo siguientes interfaces:
1, la función de interfaz funcional
definición de interfaz:
@FunctionalInterface
public interface Function<T,R>{
public R apply(T t);
}
Interfaz:
Cadena hay un método: startsWith public boolean (String str) ;
import java.util.function.*;
public class JavaDemo{
public static void main(String[] args){
Function<String, Boolean> fun = "**hello"::startsWith;
System.out.println(fun.apply("**"));
}
}
2, las funciones de consumo de interfaz: Tratamiento de datos únicas operaciones, sin ningún retorno.
Cuando la salida de datos se realiza utilizando el sistema: System.out ... println ();
definición de interfaz:
@FunctionalInterface
public interface Consumer<T>{
public void accept(T t);
}
interfaz:
import java.util.function.*;
public class JavaDemo{
public static void main(String[] args){
Consumer<String> con = System.out::println;
con.accept("hhy");
}
}
3, la oferta y la función de interfaz
provisto de una pequeña carta el método toLowerCase (), el valor de este método no es recibido en la clase String, pero tienen un valor de retorno
de definición de interfaz:
@FunctionalInterface
public interface Supplier<T>{
public T get();
}
interfaz:
import java.util.function.*;
public class JavaDemo{
public static void main(String[] args){
Supplier<String> sup = "HHY LOVE" :: toLowerCase;
System.out.println(sup.get());
}
}
4, la interfaz de función de tipo afirmación: el proceso de evaluación
tiene un método equalsIngoreCase () en la clase String.
definición de interfaz:
@FunctionalInterface
public interface Predicate<T>{
public boolean test(T t);
}
interfaz:
import java.util.function.*;
public class JavaDemo{
public static void main(String[] args){
Predicate<String> pre = "hhy" :: equalsIgnoreCase;
System.out.println(pre.test("HHY"));
}
}
Entre el desarrollo real del proyecto para el futuro, si el propio JDK proporciona la interfaz de la función puede ser utilizada por nosotros, entonces no hay necesidad de ser redefinido.
