java--基础--25--函数式接口

已于 2023-10-09 16:54:24 修改
阅读量615 收藏 2
点赞数
分类专栏： java基础 文章标签： java 开发语言 mysql
于 2023-05-25 12:12:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhou920786312/article/details/130864541
版权

java–基础–25–函数式接口

代码
https://gitee.com/DanShenGuiZu/learnDemo/tree/mysql_mybaties_DB/jdk8-learn

1、函数式接口定义

  1. 有且仅有一个抽象方法的接口

2、@FunctionalInterface

  1. 放在接口定义的上方，表示该接口是函数式接口
  2. 接口有且仅有一个抽象方法
  3. 定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。

2.1、常用的函数式接口

  1. Supplier接口
  2. Consumer接口
  3. Predicate接口
  4. Function接口

2.2、案例

2.2.1、函数式接口作为方法的参数

在这里插入图片描述

public class Demo1 {
	
	public static void main(String[] args) {
		System.out.println("-----函数式接口作为方法的参数----");
		method((String s) -> {
			System.out.println(s);
		});
		
	}
	
	public static void method(Toshow toshow) {
		toshow.toSee("小明");
	}
	
	interface Toshow {
		void toSee(String userName);
	}
}

2.2.2、函数式接口作为方法的返回值

在这里插入图片描述

	 
public class Demo2 {
	
	public static void main(String[] args) {
		Toshow method = method();
		method.toSee("小苗");

	}
	
	public static Toshow method() {
//        // 匿名内部类实现
//        return new Toshow() {
//            @Override
//            public void toSee(String userName) {
//                System.out.println(userName);
//            }
//        };
		
		return (String s) -> {
			System.out.println(s);
		};
		
	}
	
	interface Toshow {
		void toSee(String userName);
	}
	
}

3、Supplier<T>

3.1、介绍

package java.util.function;

/**
 * 表示结果的 supplier  
 * 不要求每次调用supplier时都返回新的或不同的结果  
 * @param <T>  表示 Supplier 提供的结果类型
 *  
 */
@FunctionalInterface
public interface Supplier<T> {

    /**
     * 返回结果
     * 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
     */
    T get();
}
  1. 这个接口 用于转换结果类型，结果类型是<T>
  2. 这个接口 被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

3.2、案例

3.2.1、案例1

package fei.zhou.lambdalearn.demo7.supplier;

import java.util.function.Supplier;

public class Test {
    public static void main(String[] args) {

        String s = getString(() -> {
            return "小苗";
        });

        System.out.println(s);
        System.out.println("---------------");

        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }

    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}

输出：
小苗
---------------
30

3.2.2、案例2

package fei.zhou.lambdalearn.demo7.supplier;

import java.util.function.Supplier;

// 用于返回一个int数组中的最大值
public class Test2 {

    public static void main(String[] args) {
        // 定义一个int数组
        int[] arr = {1, 2, 13, 4, 5};

        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

    // 返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

输出：
13

4、Consumer<T>

4.1、介绍


/**
 * 
 * 表示接受单个输入参数但不返回结果的操作 
 *   
 * @param <T> 操作输入的类型
 * 
 */
@FunctionalInterface
public interface Consumer<T> {

    /** 
     * @param t 输入单个参数,对给定的参数执行此操作
     */
    void accept(T t);

    /**
     * 返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作。 
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

被称为消费型接口，它消费的数据类型由泛型指定。

4.2、案例

4.2.1、案例

public class Demo3 {
	
	public static void main(String[] args) {
		operatorString("ABC", (String s) -> {
			System.out.println(s.toLowerCase());
		});
		
		System.out.println("-----------");
		
		operatorString("ABC", (String s) -> {
			System.out.println(s + "转小写：" + s.toLowerCase());
		}, (String s) -> {
			System.out.println("倒序：" + new StringBuilder(s).reverse().toString());
		});
	}
	
	// 定义一个方法，用不同的方式消费同一个字符串数据两次
	private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
		// con1.accept(name);
		// con2.accept(name);
		con1.andThen(con2).accept(name);
	}
	
	// 定义一个方法，消费一个字符串数据
	private static void operatorString(String name, Consumer<String> con) {
		con.accept(name);
	}
	
}

输出：
abc
-----------
ABC转小写：abc
倒序：CBA

4.2.2、案例2

1. String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
2. 字符串数组中有多条信息，请按照格式："姓名：XX,年龄：XX"的格式将信息打印出来
要求：
	把打印姓名的动作作为第一个Consumer接口的Lambda实例
	把打印年龄的动作作为第二个Consumer接口的Lambda实例
	将两个Consumer接口按照顺序组合到一起使用


package fei.zhou.lambdalearn.demo7.consumer;

import java.util.function.Consumer;

/*
    String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
    字符串数组中有多条信息，请按照格式："姓名：XX,年龄：XX"的格式将信息打印出来
    要求：
        把打印姓名的动作作为第一个Consumer接口的Lambda实例
        把打印年龄的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序组合到一起使用
 */
public class Test2 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};

        printInfo(strArray,
                (String str) -> {
                    String name = str.split(",")[0];
                    System.out.print("姓名：" + name);
                },
                (String str) -> {
                    int age = Integer.parseInt(str.split(",")[1]);
                    System.out.println(",年龄：" + age);
                });
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}


输出：
姓名：林青霞,年龄：30
姓名：张曼玉,年龄：35
姓名：王祖贤,年龄：33

5、Predicate<T>

5.1、介绍

 
/** 
 * @param <T> 输入类型 
 */
@FunctionalInterface
public interface Predicate<T> {

  
    /**
     * 具体过滤操作 需要被子类实现.
     * 用来处理参数T是否满足要求，可以理解为 条件A
     */
    boolean test(T t);

    /**
     * 调用当前Predicate的test方法之后再去调用other的test方法，相当于进行两次判断
     * 可理解为 条件A && 条件B
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

   /**
     * 对当前判断进行"!"操作，即取非操作，可理解为 ! 条件A
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    /**
     * 对当前判断进行"||"操作，即取或操作，可以理解为 条件A ||条件B
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

   /**
     * 对当前操作进行"="操作，即取等操作，可以理解为 A == B
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

  
   /**
     * 对negate方法的加强，不许target为null 
     */
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

Predicate<T> 接口通常用于判断参数是否满足指定的条件

5.2、案例

5.2.1、案例1

package fei.zhou.lambdalearn.demo7.predicate;

import java.util.function.Predicate;
 
public class Test {

    public static void main(String[] args) {
        boolean b1 = checkString("A", (String s) -> {
            return s.equals("A");
        });

        System.out.println("b1：" + b1);

        boolean b2 = checkString("A", (String s) -> {
            return s.equals("B");
        });
        System.out.println("b2：" + b2);

    }

    // 逻辑非操作
    private static boolean checkString(String s, Predicate<String> pre) {
//         return pre.test(s);
        // return !pre.test(s);
        return pre.negate().test(s);
    }
}

输出：
b1：false
b2：true

5.2.2、案例2

package fei.zhou.lambdalearn.demo7.predicate;

import java.util.function.Predicate;
 
public class Test2 {

    public static void main(String[] args) {
        boolean b1 = checkString2("A", (String s) -> {
            return s.equals("A");
        }, (String s) -> {
            return s.equals("B");
        });

        System.out.println("b1：" + b1);
        boolean b2 = checkString3("A", (String s) -> {
            return s.equals("A");
        }, (String s) -> {
            return s.equals("B");
        });
        System.out.println("b2：" + b2);
    }

    // 逻辑与运算
    private static boolean checkString2(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
    }

    // 逻辑或运算
    private static boolean checkString3(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
}

输出:
b1：false
b2：true

5.2.3、案例3

1. String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
2. 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
3. 要求：同时满足如下要求
    1:姓名长度大于2
    2:年龄大于33
4. 分析:
    1:有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
    2:必须同时满足两个条件,所以可以使用and方法连接两个判断条件

package fei.zhou.lambdalearn.demo7.predicate;

import java.util.ArrayList;
import java.util.function.Predicate;

public class Test3 {

    public static void main(String[] args) {
        String[] strArray = { "林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33" };
        ArrayList<String> array = myFilter(strArray,
                s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);

        for (String str : array) {
            System.out.println(str);
        }
    }
    // 通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        // 定义一个集合
        ArrayList<String> array = new ArrayList<>();
        // 遍历数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

输出：
张曼玉,35

6、Function<T,R>

6.1、介绍

  
T：输入参数，R：返回结果
@FunctionalInterface
public interface Function<T, R> {

    /**
     *  输入参数T，经过该函数处理得到R。  
     */
    R apply(T t);

    /**
     * 此函数有两个参数先将传进来的这个参数传入到before这个函数里面进行处理一下，然后before这个函数的返回结果再作为一个参数传递给外面的这个函数。
	 *  若before为空，则会抛出异常。 
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * 参数结构和compose雷同。但是应用方式是相反的。 
	 * 这个是先将参数应用到外层函数，然后得到的结果再传入after进行处理得到结果   
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     *  
     *  返回这个函数的参数。 
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}
  1. Function<T,R> 通常用于对参数进行处理，转换，然后返回一个新的值。

6.2、案例

6.2.1、案例1

package fei.zhou.lambdalearn.demo7.function;

import java.util.function.Function;


public class Test {

    public static void main(String[] args) {

        System.out.println("--------把一个字符串转换int类型，在控制台输出----------");
        convert("100", s -> Integer.parseInt(s));

        System.out.println("--------把一个int类型的数据加上一个整数之后，转为字符串在控制台输出----------");
        convert(100, i -> String.valueOf(i + 566));

        System.out.println("--------把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出----------");
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }

    // 把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String, Integer> fun) {
        int i = fun.apply(s);
        System.out.println(i);
    }

    // 把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }

    // 把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        // Integer i = fun1.apply(s);
        // String ss = fun2.apply(i);
        // System.out.println(ss);

        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

输出：
--------把一个字符串转换int类型，在控制台输出----------
100
--------把一个int类型的数据加上一个整数之后，转为字符串在控制台输出----------
666
--------把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出----------
666

6.2.2、案例2

1. String s = "林青霞,30";
2. 请按照我指定的要求进行操作：
    1. 将字符串截取得到数字年龄部分
    2. 将上一步的年龄字符串转换成为int类型的数据
    3. 将上一步的int数据加70，得到一个int结果，在控制台输出
3. 请通过Function接口来实现函数拼接

package fei.zhou.lambdalearn.demo7.function;

import java.util.function.Function;

 
public class Test2 {

    public static void main(String[] args) {
        String s = "林青霞,30";

        convert(s,
                (String ss) -> {
                    return s.split(",")[1];
                },
                (String ss) -> {
                    return Integer.parseInt(ss);
                },
                (Integer i) -> {
                    return i + 70;
                });

    }

    private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2,
                                Function<Integer, Integer> fun3) {
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}


输出:
100
勤径苦舟
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之函数式接口(FunctionalInterface)
我的博客
12-03 5181
Java之函数式接口 FunctionalInterface
Java的函数式接口讲解代码（ 函数式接口定义、 函数式接口实战、内置函数式接口...）
06-27
本源码资源提供了Java中的函数式接口相关内容，包括接口定义和使用示例。它涵盖了函数式编程在Java中的基本概念、重要性以及如何使用函数式接口来实现函数式编程的方法。 本源码资源适用于具备一定Java编程基础的开发人员和学习者。对于想要深入理解函数式编程并在Java项目中应用该编程风格的人群特别有用。 使用场景 1. 学习函数式编程：通过阅读本源码资源，可以了解函数式编程的核心概念和在Java中的应用方式，为进一步学习函数式编程打下基础。 2. 实践函数式编程：本源码资源提供了丰富的函数式接口示例，帮助开发人员在实际项目中运用函数式编程思维解决问题，提高代码质量和可维护性。 3. 扩展Java API：通过理解函数式接口的设计原则和使用方法，用户可以自己定义并使用函数式接口，扩展Java标准库或其他第三方库的功能。 4. 函数式库开发：本源码资源对函数式接口的设计和实现提供了参考，使得用户能够开发出自己的函数式库，为其他开发者提供便利的函数式编程工具。 本源码资源旨在帮助用户掌握以下几个方面： 1. 函数式编程基础概念：了解什么是函数式编程，为什么要在Java中使用函数式编程。
Java函数式接口（函数式编程、常用的函数式接口）
Best_Basic的博客
08-29 1501
*@FunctionalInterface注解：作用：是检测接口是否是一个函数式接口注意：如果接口中没有抽象方法或者抽象方法的个数多余1个，该注解则会报错* *///定义一个抽象方法// 同样public abstract可以省略。。由于接口当中的抽象方法//定义一个抽象方法。
Java特性函数式接口注解@FunctionalInterface浅析
最新发布
沛哥儿的专栏
04-25 2015
一个函数式接口是只有一个抽象方法（不包括继承自java.lang.Object的默认方法）的特定接口。这个抽象方法可以有任意数量的默认方法、静态方法以及覆盖Object类的方法。关键在于该接口必须确保只有一个未被实现的抽象方法。在 Java 中，函数式接口是专门为了配合 lambda 表达式和方法引用而设计的接口。单一抽象方法：函数式接口的核心特征是它只包含一个抽象方法。这意味着除了默认方法、静态方法或继承自的方法之外，它不能有其他的抽象方法。默认方法。
函数式编程（一）函数接口
半生苦涩半生酸的博客
09-01 1069
函数式接口（Functional Interface）：函数式接口是一种只包含一个抽象方法的 Java 接口。必需是Java 接口。有且只有一个抽象方法（函数式方法），但不一定只有一个方法（可包含多个非抽象方法）是可选的，但加上该标注编译器会帮你检查接口是否符合函数接口规范。就像加入@Override标注会检查是否重载了函数一样。定义的函数式接口用于帮助实现 Lambda 函数。比较函数，用于对某些对象集合进行总排序。比较器可以传递给排序方法（如或），以便精确控制排序顺序。
Java基础篇--函数式接口
weixin_61500949的博客
05-27 4324
一、函数式接口概述： 1.函数式接口：有且仅有一个抽象方法的接口，java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口有且仅有一个抽象方法，java中的Lambda才能顺利的进行推导 二、如何检测一个接口是不是函数式接口呢？ 1.@FunctionalInterface 2.放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 @FunctionalInterface public interfaceSum
Java 1.8之函数式接口
@you的博客
08-28 459
第一章 函数式接口 1.1 概念函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的fo...
Java学习 --- 函数式接口
qq_46093575的博客
07-08 615
1、一个接口中，只声明了一个抽象方法，这个接口就可以称为函数式接口。2、使用@FunctionalInterface注解，来检验当前接口是否是函数式接口实例代码，仅供参考： 三、Java函数式接口 四大接口 其他接口实例代码，仅供参考： 3.2、供给型接口 实例代码，仅供参考： 四、方法引用 1、当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用。2、方法引用本质上就是函数式接口的实例。3、类（对象）:: 方法名4、三种情况：对象 ::非静态方法 ，类 :: 静态方法 ，
java8-函数式接口.pdf
07-08
函数式接口和 Lambda 表达式是 Java 8 引入的重要功能，它们使得代码更加简洁，易于理解和维护，同时也为函数式编程提供了基础。通过熟练掌握这些概念，你可以更好地利用 Java 8 的新特性，提高代码的可读性和效率。
java-programming:练习Java
04-30
Java 8引入了多项重要特性，如lambda表达式、函数式接口、Stream API以及日期和时间API的改进，这些都极大地增强了Java的表达能力和处理集合的能力。 场景构建器（SceneBuilder）是JavaFX中的一个可视化工具，用于...
Java-Advanced:高级Java课程示例
03-21
11. **Lambda表达式**：Lambda表达式简化了函数式编程，使得编写简洁的代码成为可能，尤其是在处理集合时。了解其语法和使用场景，可以提升代码的简洁度。 12. **流（Stream）API**：流API是Java 8引入的新特性，...
java-jdk-api-1.8.rar
05-21
- **Lambda表达式**：Java 8引入了lambda表达式，使得编写函数式编程风格的代码变得更加简洁。它可以作为参数传递，也可以作为返回值。 - **默认方法**：在接口中新增了默认方法，允许接口提供默认实现，无需强制...
thinking-in-java-zh:Java 编程思想
05-14
14. **Java 8新特性**：虽然书中没有更新至Java 8，但读者可以自行探索Lambda表达式、流API、函数式接口等Java 8的新特性。 总的来说，《Thinking in Java》是一本深入浅出的Java编程宝典，它不仅教授Java语言，更...
Java教程：一文详解函数式编程
CZ-001的博客
08-05 1813
如果接口里只有一个抽象方法，那么就是函数式接口，可以使用注解(@FunctionalInterface)检测该接口是否是函数式接口，即只能有一个抽象方法。注意事项函数式接口里可以定义默认方法：默认方法有方法体,不是抽象方法,符合函数式接口的定义要求。函数式接口里可以定义静态方法：静态方法也不是抽象方法,是一个有具体方法实现的方法,同样也符合函数式接口的定义的。...
函数式接口不会用？看这篇文章就够了
一一哥
12-09 1867
如果在Java的接口中，有且只有一个抽象方法，那么这种接口就是函数式接口。函数式接口是使用Lambda表达式的前提条件。2. 为什么要使用函数式接口？在Java中不支持将函数作为一个数据，也就不能将函数作为方法的参数进行传递。因此给函数外加一层接口的声明，相当于为其穿上一件漂亮的外衣包装起来。如果需要将函数作为方法传递时，就可以传递函数所在接口的实现类对象，来间接的传递方法内容了。3. 函数式接口定义我们可以使用@FunctionalInterface注解来检查一个接口是否是一个函数式接口。
常用函数接口
LZ804526270的博客
03-25 617
函数式接口：有且只有一个抽象方法的接口称之为函数式接口 当然接口中可以包含其他的方法（默认，静态，私有） @FunctionalInterface注解 作用：可以检测接口是否是一个函数式接口 是：编译成功 否：编译失败（接口中没有抽象方法或者抽象方法的个数多余一个） 函数式接口的使用：一般可以作为方法的参数和返回值类型 创建一个main方法类： public class demo01 {//定义一个方法，参数使用函数式接口MyFunctionalInterface public static voi
java新特性-函数式接口-作为方法参数-作为方法的返回值-常用函数式接口-Supplier-Consumer-Predicate-Function
LXMXHJ的博客
03-13 2513
函数式接口
java实现多线程
luott_777的博客
09-27 267
java中提供两种方式实现线程，继承java.lang.Thread类与实现java.lang.Runnable接口 继承Thread类 public class Thread implements Runnable { 通过查看源码知道Thread类也是实现了Runnable接口 实现Runnable接口 @FunctionalInterface public interface Runnable { /** * When an object implementing interf.
JAVA-函数式接口作为函数参数的用法-概念
Python粘合剂
04-18 2064
概念： 有且仅有一个抽象方法的接口，称之为函数式接口 一般可以作为方法的参数和返回值类型 <1>定义一个函数式接口 package Demo35; @FunctionalInterface public interface Demo01MyFunctionalInterface { public abstract void method(); } <2>接口实现类，重写抽象方法 package Demo35; public class Demo...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值