函数式接口概述和定义（三）

Bertha 。 2023-07-01 08:41 13阅读 0赞

# 1.定义 #

**函数式接口就是java类型系统中的接口，只包含一个方法的特殊接口  
使用语义化检测注解：@Functionallnterface**

**用户身份认证的接口**

@FunctionalInterface
    public interface UserIdentify { 
    
        /* * 通过用户的账号，验证用户身份信息的接口 * @param username 验证的用户账号 * @return 返回用户身份信息【系统管理员，用户管理员，普通用户】 * */
        String verifyUser(String username);
    }

**消息传输格式化转换接口**

@FunctionalInterface
    public interface IMsgFormat { 
        /** * 消息转换方法 * msg: 要转换的信息 * format：返回转换后的数据 */
        String format(String msg,String format);
    }

> 以上是对函数式接口的简单定义

***分别实现上述的函数式接口***  
*UserIdentifyImpl.java*

public class UserIdentifyImpl implements UserIdentify { 
    //模拟实现业务逻辑
        @Override
        public String verifyUser(String username) { 
            if("admin".equals(username)){ 
                return "系统管理员";
            }else if("manager".equals(username)){ 
                return "用户管理员";
            }
            return "普通会员";
        }
    }

*IMsgFormatImpl*

public class IMsgFormatImpl implements IMsgFormat { 
        @Override
        public String format(String msg, String format) { 
            System.out.println("消息转换...");
            return msg;
        }
    }

在用户身份认证的接口添加如下默认的方法

//默认的方法
        default String  getIdentify(String username){ 
            if("admin".equals(username)){ 
                return "admin + 系统管理员用户";
            }else  if("manager".equals(username)){ 
                return "manager + 用户管理员用户";
            }else{ 
                return  "commons+普通用户";
            }
        }

在消息传输格式化转换接口添加如下静态的方法

/** * * @param msg 要验证的信息 * @return 返回验证的结果 */
        //静态方法
        static boolean verifyMsg(String msg){ 
            if(msg != null){ 
                return true;
            }
            return false;
        }

**进行测试**

public static void main( String[] args )
        { 
          //原始的方式
          UserIdentify ui=new UserIdentifyImpl();
          System.out.println(ui.verifyUser("admin"));
          System.out.println(ui.getIdentify("admin"));
          //静态方法
          String msg="hello";
          if(IMsgFormat.verifyMsg(msg)){ 
              IMsgFormat format= new IMsgFormatImpl();
              format.format(msg,"json");
          }
          //匿名内部类实现接口的抽象方法
            UserIdentify ui2=new UserIdentify() { 
                @Override
                public String verifyUser(String username) { 
                    return "admin".equals(username)?"管理员":"会员";
                }
            };
            System.out.println(ui2.verifyUser("manager"));
            System.out.println(ui2.verifyUser("admin"));
          //lambda表达式，针对函数式接口的简单实现
          UserIdentify ui3=(String username) -> { 
              return "admin".equals(username)?"lbd管理员":"lbd会员";
          } ;
            System.out.println(ui3.verifyUser("manager"));
            System.out.println(ui3.verifyUser("admin"));

**运行结果展示**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]

> 可见函数式接口可以添加默认的方法和静态的方法

***Java类型系统内建函数式接口***

> java.util.funcation.Predicate  
> 接受参数对象T，返回一个boolean类型的结果

Predicate<String> pre=(String username) ->{ 
                return "admin".equals(username);
            };
            System.out.println(pre.test("manager"));
            System.out.println(pre.test("admin"));

> java.util.funcation.Comsumer  
> 接收参数对象T，不返回结果

Consumer<String> con=(String message) -> { 
                System.out.println("message:"+message);
                System.out.println("消息发送完成！");
            };
            con.accept("hello");
            con.accept("hello lambda expression");

> java.util.function.Function<T,R>  
> 接收参数对象T,返回结果对象R

Function<String,Integer> fun=(String gender) -> { 
                return "male".equals(gender)?1:0; 
            };
            System.out.println(fun.apply("male"));
            System.out.println(fun.apply("female"));

> java.util.function.Supplier  
> 不接受参数，提供T对象的创建工厂

Supplier<String> sup=() -> { 
                return UUID.randomUUID().toString();
            };
            System.out.println(sup.get());
            System.out.println(sup.get());
            System.out.println(sup.get());

> java.util.function.UnaryOperatorr  
> 接口参数T对象，执行业务处理后，返回更新后的新的对象

UnaryOperator<String> uo=(String img) -> { 
                img +="[100*200]";
                return img;
            };
            System.out.println(uo.apply("原图--"));

> java.util.function.BinaryOperator  
> 接受两个T对象，返回一个T对象结果

BinaryOperator<Integer> bo=(Integer i1,Integer i2) -> { 
                return i1 > i2 ? i1:i2;
            };
            System.out.println(bo.apply(12,15));

**总结**  
java.util.function提供了大量的函数式接口  
Predicate 接受参数对象T，返回一个boolean类型的结果  
Consumer 接收参数对象T,返回结果对象R  
Function 接收参数T对象返回R对象  
Supplier 不接受参数，提供T对象的创建工厂  
UnaryOperator 接口参数T对象，执行业务处理后，返回更新后的新的对象  
BinaryOperator 接受两个T对象，返回一个T对象结果

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200120164947335.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70