java8新特性之函数式接口、lambda表达式、接口的默认方法、方法和构造函数的引用

最新推荐文章于 2024-04-25 21:32:44 发布
最新推荐文章于 2024-04-25 21:32:44 发布
阅读量1.2w 收藏 20
点赞数 8
分类专栏： java 文章标签： java 函数式 新特性 jdk8 lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zymx14/article/details/70175746
版权
函数式接口
     当接口里只有一个抽象方法的时候，就是函数式接口，可以使用注解(@FunctionalInterface)强制限定接口是函数式接口，即只能有一个抽象方法。

例如： 
public interface Integerface1 {
     void test();
}
上面的接口只有一个抽象方法，则默认是函数式接口。

interface Integerface3 {
     void test();
     void test2();
}
该接口有两个抽象方法，不是函数式接口 

@FunctionalInterface
interface Integerface2 {
    
}
上面这样写编译会报错，因为@FunctionalInterface注解声明了该接口是函数式接口，必须且只能有一个抽象方法。
如： 
@FunctionalInterface
interface Integerface2 {
     void test();
}
Lambda表达式只能针对函数式接口使用。

接口里的静态方法
     从java8开始接口里可以有静态方式，用static修饰，但是接口里的静态方法的修饰符只能是public，且默认是public。 
interface TestStaticMethod {
     static void test1() {
           System.out.println("接口里的静态方法！");
     }
}
用接口类名调用静态方法： 
public class Test {
     public static void main(String[] args) {
           TestStaticMethod.test1();
     }
}



//函数式接口
@FunctionalInterface
interface TestStaticMethod {
     //这是一个抽象方法
     void test();
     //静态方法，不是抽象方法
     static void test1() {
           System.out.println("接口里的静态方法！");
     }
}
上面的代码编译器并不会报错，可以看到该接口仍然是函数式接口。
接口的默认方法
 java8里，除了可以在接口里写静态方法，还可以写非静态方法，但是必须用default修饰，且只能是public，默认也是public。 
//非静态default方法
interface TestDefaultMethod{
     default void test() {
           System.out.println("这个是接口里的default方法test");
     }
     public default void test1() {
           System.out.println("这个是接口里的default方法test1");
     }
     //编译报错
//   private default void test2() {
//         System.out.println("这个是接口里的default方法");
//   }
}
由于不是静态方法，所以必须实例化才可以调用。 
public class Test {
     public static void main(String[] args) {

           //使用匿名内部类初始化实例
           TestDefaultMethod tx = new TestDefaultMethod() {
           };
           tx.test();
           tx.test1();
     }
}


默认方法可以被继承。但是要注意，如果继承了两个接口里面的默认方法一样的话，那么必须重写。
如： 
interface A {
     default void test() {
           System.out.println("接口A的默认方法");
     }
}
interface B {
     default void test() {
           System.out.println("接口B的默认方法");
     }
}
interface C extends A,B {

}
这里接口c处会报错，因为编译器并不知道你到底继承的是A的默认方法还说B的默认方法。可以修改如下进行重写，用super明确调用哪个接口的方法： 
interface C extends A,B {

     @Override
     default void test() {
           A.super.test();
     }

}
测试：
public class Test {
     public static void main(String[] args) {
           C c = new C() {
           };
           c.test();
     }
}


类继承两个有同样默认方法的接口也是一样，必须重写。
下面的代码编译会报错 
class D implements A,B {
     void test() {

     }
}
因为A或B的test方法是默认方法，修饰符为public，重写该方法修饰符必须等于或者大于它，而public已经是最大的访问修饰符，所以这里修饰符必须是public 
class D implements A,B {
     @Override
     public void test() {
           A.super.test();
     }
}

     public static void main(String[] args) {

           D d = new D();
           d.test();
     }


注意：默认方法并不是抽象方法，所以下面这个接口仍然是函数式接口。 
@FunctionalInterface
interface A {
     default void test() {
           System.out.println("接口A的默认方法");
     }
     void test1();
}

在接口里可以使用默认方法来实现父接口的抽象方法。如： 
interface C extends A,B {

     @Override
     default void test() {
           A.super.test();
     }
     default void test1() {
           System.out.println("在子接口实现父接口的抽象方法");
     }

}

C c = new C() {
 };
c.test1();


在实际使用匿名函数调用时可以重写： 
           C c = new C() {
                @Override
                public void test1() {
                     System.out.println("调用时重写");
                }
           };
           c.test1();



可以在子接口里重写父接口的默认方法，使其成为抽象方法。
例如： 
interface E {
     default void test() {
           System.out.println("接口E的默认方法");
     }
}
interface F extends E {
    void test();
}
下面main方法里这样写不会报错 
           E e = new E(){

           };
           e.test();
但如果是这样： 
           F f = new F(){

           };
           f.test();
则编译报错，要求你必须实现test()方法：

可以改为： 
     public static void main(String[] args) {
 
           F f = new F(){
                @Override
                public void test() {
                     System.out.println("F接口实现");
                }
           };
           f.test();
     }


Lanbda表达式
可以认为是一种特殊的匿名内部类
lambda只能用于函数式接口。
lambda语法：
     （[形参列表，不带数据类型]）-> {
     //执行语句
     [return..;]
}
注意：
1、如果形参列表是空的，只需要保留（）即可
2、如果没有返回值。只需要在{}写执行语句即可
3、如果接口的抽象方法只有一个形参，（）可以省略，只需要参数的名称即可
4、如果执行语句只有一行，可以省略{}，但是如果有返回值时，情况特殊。
5、如果函数式接口的方法有返回值，必须给定返回值，如果执行语句只有一句，还可以简写，即省去大括号和return以及最后的；号。
6、形参列表的数据类型会自动推断，只需要参数名称。 
package com.Howard.test12;

public class TestLambda {
     public static void main(String[] args) {
           TestLanmdaInterface1 t1 = new TestLanmdaInterface1() {
                @Override
                public void test() {
                     System.out.println("使用匿名内部类");

                }
           };
           //与上面的匿名内部类执行效果一样
           //右边的类型会自动根据左边的类型进行判断
           TestLanmdaInterface1 t2 = () -> {
                System.out.println("使用lanbda");
           };
           t1.test();
           t2.test();

           //如果执行语句只有一行，可以省略大括号
           TestLanmdaInterface1 t3 = () -> System.out.println("省略执行语句大括号，使用lanbda");
           t3.test();

           TestLanmdaInterface2 t4 = (s) -> System.out.println("使用lanbda表达式，带1个参数，参数为："+s);
           t4.test("字符串参数1");

           TestLanmdaInterface2 t5 = s -> System.out.println("使用lanbda表达式，只带1个参数，可省略参数的圆括号，参数为："+s);
           t5.test("字符串参数2");

           TestLanmdaInterface3 t6 = (s,i) -> System.out.println("使用lanbda表达式，带两个参数，不可以省略圆括号，参数为："+s+"  "+ i);
           t6.test("字符串参数3",50);
     }
}

@FunctionalInterface
interface TestLanmdaInterface1 {
     //不带参数的抽象方法
     void test();
}
@FunctionalInterface
interface TestLanmdaInterface2 {
     //带参数的抽象方法
     void test(String str);
}
@FunctionalInterface
interface TestLanmdaInterface3 {
     //带多个参数的抽象方法
     void test(String str,int num);
}



package com.Howard.test12;

public class CloseDoor {
     public void doClose(Closeable c) {
           System.out.println(c);
           c.close();
     }

     public static void main(String[] args) {
           CloseDoor cd = new CloseDoor();
           cd.doClose(new Closeable() {
                @Override
                public void close() {
                     System.out.println("使用匿名内部类实现");

                }
           });

           cd.doClose( () -> System.out.println("使用lambda表达式实现"));
     }
}
@FunctionalInterface
interface Closeable {
     void close();
}

可以看出，lambda表达式和匿名内部类并不完全相同

观察生成的class文件可以看出，lambda表达式并不会生成额外的.class文件，而匿名内部类会生成CloseDoor$1.class

和匿名内部类一样，如果访问局部变量，要求局部变量必须是final，如果没有加final，会自动加上。
例如： 
public class TestLambdaReturn {
     void re(LambdaReturn lr) {
           int i = lr.test();
           System.out.println("lambda表达式返回值是："+i);
     }

     public static void main(String[] args) {
           int i = 1000;
           tlr.re( () -> i);
           
     }
}
interface LambdaReturn {
     int test();
}
          
如果只是上面那样写，编译不会报错，但是如果改为：
     public static void main(String[] args) {
           int i = 1000;
           tlr.re( () -> i); //报错
           i = 10;
     }
把i当作非final变量用，则lambda表达式那行会报错。

方法的引用
     引用实例方法：自动把调用方法的时候的参数，全部传给引用的方法
                              <函数式接口> <变量名> = <实例> :: <实例方法名>
                              //自动把实参传递给引用的实例方法
                              <变量名>.<接口方法>（[实参]）
     引用类方法：自动把调用方法的时候的参数，全部传给引用的方法
     引用类的实例方法：定义、调用接口方法的时候需要多一个参数，并且参数的类型必须和引用实例方法的类型必须一致，
                                   把第一个参数作为引用的实例，后面的每个参数全部传递给引用的方法。
                              interface <函数式接口> {
                                   <返回值> <方法名>(<类名><名称> [,其它参数...])    
                              }
                              <变量名>.<方法名>（<类名的实例>[,其它参数]）
     具体例子参考下面代码
构造器的引用
      把方法的所有参数传递给引用的构造器，根据参数的类型来推断调用的构造器。
     参考下面代码 
package com.Howard.test12;

import java.io.PrintStream;
import java.util.Arrays;

/**
 * 测试方法的引用
 * @author Howard
 * 2017年4月14日
 */
public class TestMethodRef {
     public static void main(String[] args) {
           MethodRef r1 = (s) -> System.out.println(s);
           r1.test("普通方式");

           //使用方法的引用：实例方法的引用
           //System.out是一个实例  out是PrintStream 类型，有println方法
           MethodRef r2 = System.out::println;
           r2.test("方法引用");

           //MethodRef1 r3 =(a)-> Arrays.sort(a);
           //引用类方法
           MethodRef1 r3 = Arrays::sort;
           int[] a = new int[]{4,12,23,1,3};
           r3.test(a);
           //将排序后的数组输出
           r1.test(Arrays.toString(a));

           //引用类的实例方法
           MethodRef2 r4 = PrintStream::println;
           //第二个之后的参数作为引用方法的参数
           r4.test(System.out, "第二个参数");

           //引用构造器
           MethodRef3 r5 = String::new;
           String test = r5.test(new char[]{'测','试','构','造','器','引','用'});
           System.out.println(test);
           //普通情况
           MethodRef3 r6 = (c) -> {
                return new String(c);
           };
           String test2 = r6.test(new char[]{'测','试','构','造','器','引','用'});
           System.out.println(test2);
     }
}

interface MethodRef {
     void test(String s);
}

interface MethodRef1 {
     void test(int[] arr);
}

interface MethodRef2 {
     void test(PrintStream out,String str);
}
//测试构造器引用
interface MethodRef3 {
     String test(char[] chars);
}


Howard_14
关注
  • 8
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java8新特性之Lambda、函数式接口、方法引用
热爱生活の李
04-03 364
Lambda表达式就是函数式思想 一、Lambda 1.体验Lambda表达式 public class Lambda { public static void main(String[] args) { //实现类的方式实现需求 MyRunnable my = new MyRunnable(); Thread t = new Thread(my); t.start(); //匿名内部类 new Thre
Java8 新特性（Lambda、函数式接口、方法引用、Optional）
Dang.L 的博客
03-23 1359
一. 函数式接口 函数式接口是实现 Lambda 表达式的前提 只包含一个抽象方法的接口 可通过 Lambda 表达式创建接口对象 在接口上使用 @FunctionInterface 注解，可以检查该接口是否是函数式接口 Java 常用四个函数式接口 函数式接口 参数类型 返回值 抽象方法 方法说明 Consumer T void void accept(T t) 接收一个 T 类型的参数，对其进行操作 Supplier 无 T T get() 返回 T 类型的对
Java技术分享：Lambda表达式之接口实例化
xiaoxijinger的博客
06-11 610
今天小千给大家分享的技术是：Lambda表达式之接口实例化。 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及java.util.stream 包。 流(stream)就如同迭代器(
java8新特性十大特性详解
weixin_44694660的博客
06-30 1695
越来越多的项目已经使用 Java 8 了，毫无疑问，Java 8 是Java自Java 5（发布于2004年）之后的最重要的版本。这个版本包含语言、编译器、库、工具和 JVM 等方面的十多个新特性。在本文中我们将学习这些新特性，并用实际的例子说明在什么场景下适合 适合有用过 lambda 表达式的同学，想彻底了解清楚 了解 java8 的函数式接口和 Lambda 表达式 方法引用的使用 接口的静态方法和默认方法 Date/Time Api 的使用 Stream API 的使用 Java 语言的新特性 J
Lambda表达式与函数式接口
最新发布
pythontxt的博客
04-25 725
Lambda表达式
Java8中的新特性
比起日出，我更喜欢日落。我的意思是比起遇见你，我更喜欢与你终老
03-21 109
流式API（Stream API）是一种对集合进行操作的新方式，它可以实现对集合中的元素进行过滤、映射、排序、分组等操作。Lambda表达式是一种简洁的函数式编程方式，它可以替代传统的匿名内部类。函数式接口是一个只包含一个抽象方法的接口，它可以被Lambda表达式所使用。Java8中的新特性主要包括Lambda表达式、函数式接口、流式API、默认方法、接口的静态方法、Optional类、DateTime API等。默认方法可以在不破坏现有实现的情况下，向接口中添加新的方法。
Java8 Lambda表达式用法
qq_45054124的博客
09-18 912
Lambda表达式
函数式接口，方法和构造函数引用
happyJared
07-29 264
函数式接口 如何让现有的函数更友好地支持 Lambda，最好的方法是：增加函数式接口。所谓 “函数式接口”，是指仅仅只包含一个抽象方法，但是可以有多个非抽象方法(也就是之前提到的默认方法)的接口。 像这样的接口，可以被隐式转换为 lambda 表达式。 java.lang.Runnable 与 java.util.concurrent.Callable 是...
Java 8 新特性终极版指南详解
09-02
2.3 默认方法与接口的扩展默认方法是Java 8引入的一个关键特性，它允许在接口中定义带有实现的方法，这使得接口可以在不破坏现有实现的情况下添加新功能。例如，`java.util.Collection`接口新增了一个`default void ...
Java8 Lamda方法引用和构造引用原理
08-19
主要介绍了Java8 Lamda方法引用和构造引用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
尚硅谷Java视频Java8新特性视频教程
02-17
尚硅谷_Java8新特性_四大内置核心函数式接口 ·06. 尚硅谷_Java8新特性_方法引用与构造器引用 ·07. 尚硅谷_Java8新特性_创建 Stream ·08. 尚硅谷_Java8新特性_Stream_筛选与切片 ·09. 尚硅谷_Java8新特性_Stream...
Java 8 中的 10 个特性总结及详解
09-01
9. **方法引用和构造器引用**：与Lambda表达式紧密相关，方法引用和构造器引用允许直接引用已有方法或构造器，进一步减少了代码的冗余。 10. **日期与时间API的改进**：Java 8引入了`java.time`包，提供了更强大、...
Java 8新特性：Lambda表达式, Stream API, Optional类，函数式接口
KIMTOU的博客
10-23 544
文章目录接口默认方法函数式接口实战运用方法引用Lambda表达式实战运用Stream API什么是StreamStream聚合操作流的创建collect收集filter过滤map映射distinct去重limitskip分页操作countsorted排序Optional类源码分析of与ofNullable测试其他实用方法map与flatMap小试身手 在 Java 8 中，增加了Lambda表达式、函数式接口、接口的默认方法和静态方法等语言新特性；在类库方面又新增了Stream API、Optional
【Java新特性学习 二】JDK8: 语言新特性之Lambda表达式、函数式接口、接口的默认方法和静态方法
MaoLin Tian's Blog
12-24 695
总而言之，通过写这篇博客刷新了一些关于函数式编程模式的一些认知，最深刻的感受就是我们可能太OOP了，有时候感觉没有对象就什么也干不成了，做一些逻辑实现时总要定义一些冗余的类，接口，其实有些时候只需要关注最核心的实现可以减少大量的代码编写，忘记实例创建、忘记方法声明、忘记new吧，只关注核心实现！当然这也不是说别OOP了，其实无论是命令式编程还是函数式编程都有其具体的应用场景，Java这样的OOP语言也不会把函数式编程模式完全隔绝出去，这才引入了Lambda。所以一切不以应用场景为前提的优劣比较都是耍流氓
Q22：Java接口解析
白菜小皮艇的博客
10-21 178
接口是可以多继承的 接口不能被实例化 格式是：【访问权限】 interface 接口名 { 公开静态常量列表； （public static final）int a =10; 公共抽象方法列表； （public abstract）void t1（）; （JDK1.8后有默认方法） default void t4（）{ 方法体 } } public class TestBird { public static void main(String[] args) { // TODO Auto-gene.
Java8新特性-接口实现默认方法
有见寒舍
02-09 1575
【代码】Java8新特性-接口实现默认方法。
Java8 Lambda表达式用法详解
怪咖@的博客
05-17 2938
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。
函数式接口和lambda表达式
09-05
总的来说，函数式接口和Lambda表达式是Java 8中引入的功能，它们可以使代码更简洁、更灵活，并提供了更好的方法来处理事件和迭代列表。<span class="em">1</span><span class="em">2</span><span class="em">3 #### ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值