【java】【函数式】java的函数式和非函数式的方式对照

lambda的表达式是从java1.8更新。函数其实是一种对于闭包。同时他也可以实现一种传递方法的作用。做到一种方法闭包。同时也可以做到多态。因为起方便传递一个方法。这里我们观看使用方式来探讨为什么函数式的设计思想。同时也结合golang来。大概是6个文章

package lambda;  
  
class ClownFish implements Fish {  
  
    @Override  
    public void swim() {  
        System.out.println("Clownfish swimming");  
    }  
}  
  
public class Aminals {  
  
    //静态内部类  
    static class SharkFish implements Fish {  
        @Override  
        public void swim() {  
            System.out.println("SharkFish swimming ");  
        }  
    }  
  
    public static void main(String[] args) {  
  
        //局部内部类  
        class Ray implements Fish {  
  
            @Override  
            public void swim() {  
                System.out.println("Ray swimming");  
            }  
        }  
  
        Fish  sharkFish = new SharkFish();  
        sharkFish.swim();  
        Fish clownFish = new ClownFish();  
        clownFish.swim();  
        Fish ray = new Ray();  
        ray.swim();  
        Fish aquarium =new Fish() {  
            @Override  
            public void swim() {  
                System.out.println("swimming");  
            }  
        };  
        aquarium.swim();  
  
        //lambda使用  
        Fish  fish = () -> {  
            System.out.println("fish swimming");  
        };  
        fish.swim();  
    }  
}  
  
@FunctionalInterface  
interface Fish{  
    public void swim();  

上面可以看到 其中lambda都极限省了 生成代码量。所以我这张就单纯通过作为一个匿名内部类的简化来进行使用

首先式有参数有返回值的使用

package lambda;  
  
  
  
public class Aminals {  
  
    public static void main(String[] args) {  
  
        Fish fish = ((name, value) -> {  
            System.out.println("吃了"+1+"条"+name);  
            return value-1;  
        });  
        System.out.println("还剩下"+fish.eat("虾米",10L));  
    }  
}  
  
  
interface Fish{  
  
    public Long eat(String name,Long value);  
  
}

然后也可以进行方法的引用 使用:: 静态方法

package lambda;  
  
  
  
public class Aminals {  
  
    public static void main(String[] args) {  
  
        Fish fish = SharkFish::eating;  
        System.out.println("还剩下"+fish.eat("大鱼",10L));  
    }  
}  
  
  
class SharkFish{  
    public static Long eating(String name,Long value){  
        System.out.println("吃了"+1+"条"+name);  
        return value-1;  
    }  
}  
  
interface Fish{  
  
    public Long eat(String name,Long value);  
  
}

非静态

package lambda;  
  
  
  
public class Aminals {  
  
    public static void main(String[] args) {  
  
        Fish fish =new SharkFish()::eating;  
        System.out.println("还剩下"+fish.eat("大鱼",10L));  
    }  
}  
  
  
class SharkFish{  
    public Long eating(String name,Long value){  
        System.out.println("吃了"+1+"条"+name);  
        return value-1;  
    }  
}  
  
interface Fish{  
  
    public Long eat(String name,Long value);  
  
}

然后构造方法

package lambda;  
  
  
  
public class Aminals {  
  
    public static void main(String[] args) {  
  
        GetFish getFish = Fish::new;  
        Fish fish = getFish.eat();  
        System.out.println(fish.name+fish.value);  
        GetFishWithInfo getFishWithInfo= Fish::new;  
        fish = getFishWithInfo.eat("大鱼",121L);  
        System.out.println(fish.name+fish.value);  
    }  
}  
  
  
  
  
class Fish{  
    String name;  
    Long value;  
  
    public Fish(){  
        System.out.println("看着来");  
    }  
    public Fish(String name,Long value){  
        this.name =  name;  
        this.value = value;  
        System.out.println("一餐吃"+value+"条"+name);  
    };  
  
}  
  
@FunctionalInterface  
interface GetFish{  
    Fish eat();  
}  
  
@FunctionalInterface  
interface GetFishWithInfo{  
    Fish eat(String name,Long value);  
}

从中我们看到,这个设计和面向对象相反。如果式以前的面向对象的有共同的行为。比如每个鱼类都有一个方法的对象。而lambda的函数式。是一种行为。每个对象都是有着共同行为的实体。是因为有这种行为。导致有这种实体。