java---接口组成更新及函数式接口

于 2022-06-29 17:54:37 发布
阅读量155 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 大数据 intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z2021_000000/article/details/125526798
版权 
默认方法
package 接口组成更新.默认方法;

public interface MyInterface {
    void show1();

    void show2();

//    void show3();

    public default  void show3(){

    }
}

package 接口组成更新.默认方法;

public class MyInterfaceImplOne implements MyInterface{
    @Override
    public void show1() {
        System.out.println(" one show1方法被调用");
    }

    @Override
    public void show2() {
        System.out.println(" one show2方法被调用");
    }
}

package 接口组成更新.默认方法;

public class MyInterfaceImplTwo implements MyInterface{
    @Override
    public void show1() {
        System.out.println(" two show1方法被调用");
    }

    @Override
    public void show2() {
        System.out.println(" two show2方法被调用");
    }

    @Override
    public void show3() {
        System.out.println(" two show3方法被调用");
    }
}

package 接口组成更新.默认方法;
/*
    接口中默认方法的定义格式：
        格式：public default 返回值类型 方法名 (参数列表) {}
        范例：public default void show3() {}

    注意事项：
        默认方法不是抽象方法，所以不强制被重写，但是可以被重写
        public 可以省略，default不能省略
 */

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

        MyInterface m1=new MyInterfaceImplOne();
        m1.show1();
        m1.show2();

        MyInterface m2=new MyInterfaceImplTwo();
        m2.show1();
        m2.show2();
        m2.show3();
    }
}

静态方法
package 接口组成更新.静态方法;

public interface Inter {
    void show();

    default void method(){}

    public static void test(){
        System.out.println("Inter中的静态方法被调用");
    }

}

package 接口组成更新.静态方法;

public interface Flyable{
    public static void test(){
        System.out.println("Flyable 中的静态方法被调用");
    }

}

package 接口组成更新.静态方法;

public class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("show()方法被调用");
    }

    @Override
    public void method() {
        System.out.println("method()方法被调用");
    }
}

package 接口组成更新.静态方法;
/*
    静态方法定义格式：
        格式：public static 返回值类型 方法名(参数列表) {}
        范例：public static void show(){}

    注意事项：
        静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
        public可以省略，Static不能省略

 */

public class InterDemo {
    public static void main(String[] args) {
        Inter i=new InterImpl();
        i.show();
        i.method();

//        i.test();
        Inter.test();


        Flyable.test();


    }

}

私有方法
package 接口组成更新.私有方法;

import 集合进阶.Map双列.Map集合的概述和使用;

public interface Inter {
    default void show1(){
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        show();
        method();
        System.out.println("show1结束执行");
    }
    default void show2(){
        System.out.println("show2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        show();
        method();
        System.out.println("show2结束执行");
    }
    //非静态
    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
    //静态
    private static void showw(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

    static void method1(){
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        showw();
        method();
        System.out.println("method1结束执行");
    }
    static void method2(){
        System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        showw();
        method();
        System.out.println("method2结束执行");
    }
    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

package 接口组成更新.私有方法;

public class InterImpl implements Inter {

}

package 接口组成更新.私有方法;
/*
    接口中私有方法的定义格式：
         格式：public static 返回值类型 方法名(参数列表) {}
         范例：public static void show(){}
        格式：public 返回值类型 方法名 (参数列表) {}
        范例：public void show() {}

    注意事项：
        默认方法可以调用私有的静态方法和非静态方法
        静态方法只能调用私有的静态方法

*/


public class InterDemo {
    public static void main(String[] args) {
        Inter i=new InterImpl();
        i.show1();
        System.out.println("---------");
        i.show2();
        System.out.println("---------");

        Inter.method1();
        System.out.println("---------");
        Inter.method2();


    }
}

函数式接口
package 函数.函数式接口;
/*
    函数式接口概述
        函数式接口:有且仅有一个抽象方法的接口
        Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
        只有确保接口中有目仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

    如何检测一个接口是不是函数式接口呢?
        @Functionalinterface
        放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是，编译失败

    注意
    我们自己定义函数式接口的时候，@Functionallnterface是可选的，就算我不写这个注解，
    只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
 */

public class 函数式接口概述 {
}

Supplier接口
package 函数.函数式接口;
/*
    Supplier接口
        Supplier<T>:包含一个无参的方法
        T get():获得结果
        该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
        Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，
        那么接口中的get方法就会生产什么类型的数据供我们使用
 */

import java.util.function.Supplier;

public class Supplier接口 {
    public static void main(String[] args) {
//        String s=getString(()->{
//            return "zxz";
//        });

        String s = getString(() -> "zxz");
        System.out.println(s);

        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();
    }

}

Consumer接口
package 函数.函数式接口;
/*
    Consumer接口
        Consumer<T>:包含两个方法
        void accept(T t):对给定的参数执行此操作
        default Consumer<T> andThen(Consumer after):
            返回一个组合的Consumer，依次执行此操作，然后执行after操作
            Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
 */

import java.util.function.Consumer;

public class Consumer接口 {
    public static void main(String[] args) {

        operatorString("程序员",s->System.out.println(s),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);

    }

}

Predicate接口
package 函数.函数式接口;
/*
    Predicate接口
        Predicate<T>:常用的四个方法
            boolean test(T t):对给定的参数进行判断(判断逻辑中Lambda表达式实现)，返回一个布尔值

            default Predicate <T> negate():返回一个逻辑的否定，对应逻辑非
            default Predicate <T> and(Predicate other):返回一个组合判断，对应短路与
            default Predicate <T> or(Predicate other):返回一个组合判断，对应短路或

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

import java.util.function.Predicate;

public class Predicate接口 {
/*
    public static void main(String[] args) {

        boolean b1=checkString("hello",s->s.length()>8);
        System.out.println(b1);

        boolean b2=checkString("helloworld",s->s.length()>8);
        System.out.println(b2);

    }

    //判断给定的字符串是否满足要求
    private static  boolean checkString(String s, Predicate<String> pre){
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s);
    }
*/

    public static void main(String[] args) {

        boolean b1=checkString("hello",s->s.length()>8,s->s.length()<15);
        System.out.println(b1);

        boolean b2=checkString("helloworld",s->s.length()>8,s->s.length()<15);
        System.out.println(b2);

    }

    //同一个字符串给出两个不同的判断条件，最后把这两个判断结果做逻辑与或非的运算
    private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
//        return pre2.or(pre1).test(s);
    }


}

Predicate2接口
package 函数.函数式接口;
/*
    Predicate<T>
        default Predicate<T> and (Predicate other):返回一个组合判断，对应短路与
        default Predicate<T> or (Predicate other):返回一个组合判断，对应短路或
 */

import java.util.function.Predicate;

public class Predicate2接口 {
    public static void main(String[] args) {
        boolean b1=checkString("hello",s->s.length()>8,s->s.length()<15);
        System.out.println(b1);

        boolean b2=checkString("helloworld",s->s.length()>8,s->s.length()<15);
        System.out.println(b2);
    }

    //同一个字符串给出两个不同的判断条件，最后把这两个判断条件的结果做逻辑运算
    private static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);
    }

}

 Function接口
package 函数.函数式接口;
/*
    Function<T,R>:常用的两个方法
        R apply(T t):将此函数应用于给定的参数
        default <V> Function andThen(Function after):
            返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
        Function<T，R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现现)，
            然后返回一个新的值
 */

import java.util.function.Function;

public class Function接口 {
    public static void main(String[] args) {
        convert("100",s-> Integer.parseInt(s));

        convert(100,i-> String.valueOf(i+556));

        convert("100",s-> Integer.parseInt(s),i-> String.valueOf(i+556));



    }

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

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

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


}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

放码过来a

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值