Java核心类库之（接口组成更新、方法引用、函数式接口）

已于 2022-06-30 20:48:18 修改
阅读量1.2w 收藏 15
点赞数 9
文章标签： java
于 2021-07-27 21:50:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuan2019035055/article/details/119079677
版权
Java 同时被 2 个专栏收录
33 篇文章 50 订阅
订阅专栏
Java基础
11 篇文章 35 订阅
订阅专栏

目录

1 接口组成更新

1.1 接口组成更新概述

  • 接口的组成
    • 常量：public static final
    • 抽象方法：public abstract
    • 默认方法(Java 8)
    • 静态方法(Java 8)
    • 私有方法(Java 9)

1.2 接口中默认方法（JDK8）

  • 接口中默认方法的定义格式：
    • 格式：public default 返回值类型 方法名(参数列表){}
    • 范例：public default void show(){}
  • 接口中默认方法的注意事项：
    • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写,重写的时候去掉default关键字
    • public可以省略，default不能省略：default void show(){}

1.3 接口中静态方法（JDK8）

  • 接口中静态方法的定义格式:

    • 格式：public static 返回值类型 方法名(参数列表){}
    • 范例：public static void show(){}

  • 接口中静态方法的注意事项：

    • 静态方法只能通过接口名调用, 不能通过实现类名或者对象名调用
    • public可以省略， static不能省略：static void show(){}

  • 接口

package test;

public interface Inter {
    void show();

    default void method() {
        System.out.println("默认方法");
    }

//    public static void test(){
//        System.out.println("静态方法");
//    }

    static void test(){
        System.out.println("静态方法");
    }
}
  • 实现类
package test;

public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法");
    }
}
  • 测试类
package test;

public class Demo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show(); //show方法
        i.method(); //
//        i.test(); //报错

        Inter.test(); //静态方法,接口名调用静态方法
    }
}

1.4 接口中私有方法（JDK9）

  • 接口中私有方法的定义格式：
    • 格式1（非静态）：private 返回值类型 方法名(参数列表){}
    • 范例1：private void show() {}
    • 格式2（静态）：private static 返回值类型 方法名(参数列表){}
    • 范例2：private static void method() {}
  • 接口中私有方法的注意事项：
    • 默认方法可以调用私有的静态方法和非静态方法
    • 静态方法只能调用私有的静态方法
package test;

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结束");
    }


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

    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

2 方法引用

  • 在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作
  • 那么考虑一种情况: 如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，没有必要再写重复逻辑，如usePrintable(s -> System.out.println(s));中System.out.println(s)就是重复逻辑
  • 可以通过方法引用来使用已经存在的方案

2.1 方法引用符

  • 方法引用符

    • :: 该符号为引用运算符，而它所在的表达式被称为方法引用

  • 对比分析

    • Lambda表达式：usePrintable(s -> System.out.println(s));
      分析：拿到参数s之后通过Lambda表达式，传递给System.out.println()方法去处理
    • 方法引用：usePrintable(System.out:println);//隐含了把s参数给println方法
      分析：直接使用System.out中的println方法来取代Lambda,代码更加的简洁

  • 推导与省略

    • 如果使用Lambda,那么根据"可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
    • 如果使用方法引用，也是同样可以根据上下文进行推导
    • 方法引用是Lambda的李生兄弟（可以使用Lambda表达式就可以使用方法引用）

  • 范例

package test;

public class Demo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrintable(i -> {
            System.out.println(i); //888
        });

        //方法引用
        usePrintable(System.out::println); //888
    }

    private static void usePrintable(Printable p) {
        p.printInt(888);
    }
}

2.2 引用类方法

  • 常用方法引用

    • 引用类方法
    • 引用类的实例方法（成员方法）
    • 引用对象的实例方法
    • 引用构造器

  • 引用类方法，其实就是引用类的静态方法

  • 格式：类名::静态方法

  • 范例：Integer::parselnt
    Integer类的方法：public static int parseInt(String s)将此String转换为int类型数据

  • 练习
    在这里插入图片描述

  • 接口类

package test;

public interface Converter {
    int convert(String s);
}
  • 测试类
package test;

public class Demo {
    public static void main(String[] args) {
//        useConverter(s -> {
//            return Integer.parseInt(s);
//        });
        useConverter(s -> Integer.parseInt(s)); //666

        //引用类方法
        useConverter(Integer::parseInt); //666
        //Lambda表达式被类方法替代时，他的形式参数全部传给静态方法做参数;如s字符串传递给parseInt方法
    }

    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

2.3 引用类的实例方法（成员方法）

  • 引用类的实例方法，其实就是引用类中的成员方法

  • 格式：类名::成员方法

  • 练习
    在这里插入图片描述

  • 接口

package test;

public interface MyString {
    String mySubString(String s,int x,int y);
}
  • 测试类
package test;

public class Demo {
    public static void main(String[] args) {
//        useMyString((String s,int x,int y)->{
//            return s.substring(x, y); //llo
//        });

        useMyString((s,x,y)-> s.substring(x, y)); // //llo

        //引用类中的实例方法
        useMyString(String::substring); //llo
        //Lambda表达式中的形式参数(s,x,y)
        //第一个参数作为调用者
        //后面的参数全部传给实例方法作为参数

    }
    public static void useMyString(MyString m) {
        String s = m.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

2.4 引用对象的实例方法（成员方法）

  • 引用对象的实例方法，其实就引用类中的成员方法

  • 格式：对象名::成员方法

  • 范例："HelloWorld"::toUpperCase
    String类中的方法：public String toUpperCase()将此String所有字符转换为大写

  • 练习
    在这里插入图片描述

  • PrintString类

package test;

public class PrintString {
    //把字符串转换成大写
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}
  • 接口
package test;

public interface Printer {
    void printUpperCase(String s);
}
  • 测试类
package test;

public class Demo {
    public static void main(String[] args) {
//        usePrinter((String s ) -> {
            String result = s.toUpperCase();
            System.out.println(result); //HELLO
//            System.out.println(s.toUpperCase());
//        });

        usePrinter(s -> System.out.println(s.toUpperCase()));

        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper); //HELLO
    }

    public static void usePrinter(Printer p) {
        p.printUpperCase("hello");
    }
}

2.5 引用构造器

  • 引用构造器，就是引用构造方法

  • 格式：类名::new

  • 范例：Student::new

  • 练习
    在这里插入图片描述

  • 测试类

package test;

public class Demo {
    public static void main(String[] args) {
//        useStudentBuilder((String name,int age) -> {
            Student s  =new Student(name,age);
            return s;
//            return new Student(name,age); //
//        });

        useStudentBuilder((name, age) -> new Student(name, age));

        useStudentBuilder(Student::new); //小黑,10
        //Lambda表达式被引用构造器代替时，他的形式参数全部传递给构造器作为参数
    }

    public static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("小黑", 10);
        System.out.println(s.getName() + "," + s.getAge());
    }
}

3 函数式接口

3.1 函数式接口概述

  • 函数式接口：有且仅有一个抽象方法的接口

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

  • 如何检测一个接口是不是函数式接口呢?

    • @FunctionalInterface
    • 放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是,编译失败

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

3.2 函数式接口作为方法的参数

  • 需求
    在这里插入图片描述
package test;

public class Demo {
    public static void main(String[] args) {
        //匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了"); //Thread-0线程启动了
            }
        });

        //Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了")); //Thread-1线程启动了
    }

    public static void startThread(Runnable r) { //Runnable为函数式接口，上方有@FunctionalInterface
//        Thread t  = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}
  • 如果方法的参数是函数式接口，可以使用Lambda表达式作为参数传递
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));

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

  • 需求
    在这里插入图片描述
package test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {
        //构造使用场景
        //定义一个集合存储字符串
        ArrayList array = new ArrayList();
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("dd");

        System.out.println("排序前："+array); //排序前：[cccc, aa, b, dd]

        Collections.sort(array); //排序后:[aa, b, cccc, dd]

        Collections.sort(array,getComparator()); //排序后:[b, aa, dd, cccc]

        System.out.println("排序后:"+array);

    }
    public static Comparator<String> getComparator() {
        //匿名内部类
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comp;

//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

        //Lambda表达式
//        return (String s1,String s2) ->{
//            return s1.length()-s2.length();
//        };

        return(s1,s2) -> s1.length()-s2.length();
    }
}
  • 如果方法的返回值是函数式接口，可以使用Lambda表达式作为结果返回
public static Comparator<String> getComparator() {
	return(s1,s2) -> s1.length()-s2.length();
}

3.4 常用函数式接口

  • Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
  • 重点来学习下面的4个接口
    • Supplier [səˈplaɪər] 接口
    • Consumer [kənˈsuːmər] 接口
    • Predicate[ˈpredɪkət] 接口
    • Function接口
3.4.1 Supplier接口
  • Supplier<T>：包含一个无参的方法
  • T get()方法：获得结果
  • 该方法不需要参数， 它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
  • Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型,那么接口中的get()方法就会生产什么类型的数据供我们使用
package test;

import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "小黑";
//        });

        String s = getString(() -> "小黑");
        System.out.println(s); //小黑

        int i = getInteger(() -> 10);
        System.out.println(i); //10
    }

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

    //定义一个方法，返回整数数据
    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {22, 55, 11, 44, 33};

        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); //55
    }

    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}
3.4.2 Consumer接口
  • Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
  • Consumer ：包含两个方法
方法名说明
void accept(T t) [əkˈsept]对给定的参数执行此操作
default Consumer<T> andThen(Consumer after)返回一个组合的Consumer，依次执行此操作，然后执行after操作
  • 范例
package test;


import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {
//        operatorString("小白",(String s)->{
//            System.out.println(s); //小白
//        });

        operatorString("小白",s-> System.out.println(s)); //小白

//        operatorString("小黑",System.out::println); //小黑

//        operatorString("大熊猫",s -> {
//            System.out.println(new StringBuilder(s).reverse().toString()); //猫熊大
//        });

        operatorString("大熊猫",s -> System.out.println(new StringBuilder(s).reverse().toString())); //猫熊大
        System.out.println("---------");

        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) {
        //1,void accept(T t) [əkˈsept] 	对给定的参数执行此操作
//        con1.accept(name);
//        con2.accept(name);
        //2,Consumer<T> andThen(Consumer after) 	返回一个组合的Consumer，依次执行此操作，然后执行after操作
        con1.andThen(con2).accept(name);
    }
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小白,10", "小黑,20"};
//        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);
//        });
        //姓名:小白,年龄:10
        //姓名:小黑,年龄:20

        printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]),
                str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}
3.4.3 Predicate [predɪkeɪt] 接口
  • Predicate<T>接口通常用于判断参数是否满足指定的条件
  • 常用的四个方法
方法名说明
boolean test(T t)对给定的参数进行判断(判断逻辑由Lambda表达式实现，返回一个布尔值
default Predicate<T> negate()返回一个逻辑的否定，对应逻辑非
default Predicate <T> and(Predicate other)返回一个组合判断，对应短路与
default Predicate <T> or(Predicate other)返回一个组合判断，对应短路或
  • 范例
package test;

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) ->{
//            return s.length()>8;
//        });
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1); //1：false，2：true

        boolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15);
        System.out.println(b2); //3:false,4:true

        boolean b3 = checkString("hellojava",s->s.length()>8,s -> s.length()<15);
        System.out.println(b3); //3:true,4:true
    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        //1,boolean test(T t) 	对给定的参数进行判断(判断逻辑由L ambda表达式实现，返回一个布尔值
//        return pre.test(s);
//        return !pre.test(s); //输出相反的，不过用下一个方法

        //2,default Predicate<T> negate() 	返回一个逻辑的否定，对应逻辑非
        return pre.negate().test(s);
    }

    //同一个结果给出两个不同的判断条件，最后把这两个判断结果做逻辑与的结果作为最终结果
    private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2) {
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;

        //3,default Predicate <T> and(Predicate other) 	返回一个组合判断，对应短路与
//        return pre1.and(pre2).test(s); //源码：return (t) -> test(t) && other.test(t);

        //default Predicate <T> or(Predicate other) 	返回一个组合判断，对应短路或
        return pre1.or(pre2).test(s); //源码：return (t) -> test(t) || other.test(t);
    }
}
  • 练习
    在这里插入图片描述
package test;

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

public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小黑,50", "大熊猫,40", "小白,20", "奥特曼,100"};

        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);
//            大熊猫,40
//            奥特曼,100
        }
    }

    public static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();

        //遍历数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}
3.4.4 Function接口
  • Function<T,R> 接口通常用于对参数进行处理,转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
  • 常用的两个方法
方法名说明
R apply(T t)将此函数应用于给定的参数
default <V> Function andThen(Function after)返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
  • 案例
package test;

import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {
        convert("100", s -> Integer.parseInt(s)); //100
//        convert("100",Integer::parseInt); //100

        convert(100, i -> String.valueOf(i + 566)); //666

        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566)); //666
    }

    //定义一个方法，把一个字符串转换成int类型，在控制台输出
    public static void convert(String s, Function<String, Integer> fun) {
        //1,R apply(T t) 	将此函数应用于给定的参数
//        Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

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

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

        //2,default <V> Function andThen(Function after) 	返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
        String ss = fun1.andThen(fun2).apply(s);//源码：return (T t) -> after.apply(apply(t));相当于上两步

        System.out.println(ss);
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {
        String s = "小黑,20";

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

    public 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);
    }
}
袁袁袁袁满
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java-核心类库-集合框架自学笔记.pdf
11-28
java-核心类库-集合框架自学笔记.pdf
Java 引用接口
Hey___Man的博客
03-15 1297
Java中的引用接口，用对象实例化接口 最近遇到如下代码： import java.util.*; public class Demo{ public static void main(String[] args){ Collection c=new ArrayList(); c.add("Hello"); c.add(9527); ...
接口组成更新
august197210的博客
09-02 174
1.1接口组成更新概述接口的组成●常量　　public static final●抽象方法　　public abstract●默认方法(Java 8)●静态方法(Java 8)●私有方法(Java9) 1.2接口中默认方法接口中默认方法的定义格式:●格式: public default返回值类型方法名(参数列表){ } 范例: public default void show3(...
Java 接口组成更新
bm1998
10-09 243
文章目录1. 接口组成更新概述2. 接口中默认方法3. 接口中静态方法4. 接口中私有方法 1. 接口组成更新概述 接口的组成： 常量（public static final） 抽象方法（public abstract） 默认方法(Java 8) 静态方法(Java 8) 私有方法(Java 9) 2. 接口中默认方法 我们都知道，一个类实现一个接口，就要重写这个接口中的所有抽象方法。但现在接口中新增了一个方法，实现这个接口的类不想重写这个方法怎么办？这时就可以使用接口中默认方法，它不强制被重写，而且还
JAVA_ClassLib.rar_classlib ja_java 类库_java核心_java类库手册
09-21
java类库手册，java核心类库详尽介绍，方便大家学习编程
Java时间类库Timer的使用方法与实例详解
08-25
主要介绍了Jave时间类库Timer的使用方法与实例详解,需要的朋友可以参考下
JAVA常用类库之一-日志相关类库.docx
06-27
日志库是很常见的，因为你在每一个项目中都需要他们。打印日志是服务器端应用中最重要的事情，因为日志是你了解你的程序发生了什么的唯一途径。尽管JDK附带自己的日志库，但是还是有很多更好的选择可用，例如 Log4j ...
Java核心类库.png
08-07
java核心类库的知识点，包括字符串，网络编程，IO流，异常处理等等。比如StringBuilder,StringBuffer,BufferedOutputSream,BufferedInputStream等
Java：函数式接口、方法引用
qq_38353993的博客
09-22 1226
1、函数式接口-概念及格式 函数式接口：有且只有一个抽象方法的接口（可以有其他的方法：默认方法，静态方法，私有方法…） 2、函数式接口-@FunctionalInterface注解 1）、在定义函数式接口时，为防止发生定义错误，可使用@FunctionalInterface注解，强制按照函数式接口的语法进行检查，如果语法错误，编译器会编译错误。 @FunctionalInterface inter...
【Java】接口引用
阿瑞斯的星辰大海
06-12 911
首先区分几个概念 声明 定义一个接口 interface 接口名{...} 实例化 与new有关的语句多半是实例化的过程，实例化指创建一个具体的对象。 接口无法进行实例化。要通过实现它的具体类创建对象。接口是个抽象的概念，实例化的类重写接口的方法，实例化的对象是该类的对象而不是接口的对象 List<String> list = new ArrayList<String>(); 引用 接口是存在引用的。通过引用调用方法往往在创建框架的时候使用。而在运行时，加载的其实是实现
Java——接口组成更新概述之接口组成更新概述、接口中默认方法、接口中静态方法、接口中私有方法
smile4548656的博客
04-25 428
Java——接口组成更新概述之接口组成更新概述、接口中默认方法、接口中静态方法、接口中私有方法一、接口组成更新概述二、接口中默认方法三、接口中静态方法四、接口中私有方法 一、接口组成更新概述 接口的组成： 变量 public static final 抽象方法 public abstract 默认方法（Java 8） 静态方法（Java 8） 私有方法（Java 9） 二、接口中默认方法 1、接口方法可以用于实现接口升级 2、接口中默认方法的定义格式 public default 返回值类型 方法名(参
JAVA接口
pzllovelsy的博客
07-28 118
比如Seriallizable接口，Seriallizable接口的作用是使对象能够“序列化”，但是Seriallizable接口中却没有任何内容，也就是说，如果有一个类需要实现“序列化”的功能，则这个类必须去实现Seriallizable接口，但是却并不用实现方法（因为接口中没有方法），此时，这个Serilizable接口就仅仅是一个“标识”接口，是用来标志一个类的，标志这个类具有这个“序列化”功能。就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。...
【JAVA】接口的引用
weixin_34006965的博客
11-17 226
最近在学习java的过程中，遇到了一下代码。 代码1： public interface Handler｛ public void Hello(); ｝ 复制代码代码2： import Handler; public class OtherParser{ Handler handler; ...... } 复制代码代码1说明了Handler是一个接口了，既接口不能直接实例化，必须经过实现类...
JDK8中接口的更新组成
weixin_30629653的博客
07-30 140
接口组成在jdk8.0后不仅只有常量public static finall和抽象方法public abstract两种，在jdk8.0加入了默认方法和静待方法。jdk9.0加入了私有方法。 接口举例MyInterface.java 1 package cn.ftf.add; 2 3 //接口组成在jdk8.0后不仅只有常量public static finall和...
Java常用的函数式接口和方法引用
Vivi的博客
02-10 194
Java 的 Stream 流常用的函数式接口ConsumerSupplierFunction 常用的函数式接口 Consumer @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNul
23.Java语言函数式接口和方法引用
让我去流浪啊
10-06 261
函数式接口 函数式接口: 有且仅有一个抽象方法的接口（可以有其他方法） @FunctionalInterface注解: 和Override用法基本相同，此注解可以用于任何接口，表示函数式接口，加了注解编译器会自动检是否有且仅有一个抽象函数。不加注解满足函数式接口的条件也是函数式接口 自定义函数式接口： @FunctionalInterface interface IB {     i...
Java 接口 方法 引用
simplezhao的博客
07-10 174
默认方法可以不被具体类重写。但可以直接调用
java核心类库包括什么
最新发布
06-04
Java核心类库包括了许多常用的类和接口，例如： 1. java.lang - 提供了Java编程语言的基本类，如字符串、数字、异常处理等。 2. java.util - 提供了许多有用的工具类，如集合框架、日期和时间处理、随机数生成等。 3. java.io - 提供了输入输出相关的类和接口，如文件读写、网络连接等。 4. java.net - 提供了用于网络通信的类和接口，如URL、URLConnection、Socket等。 5. java.awt - 提供了用于图形用户界面（GUI）开发的类和接口，如窗口、按钮、标签等。 6. javax.swing - 提供了更加高级的GUI组件，如滚动条、列表、表格等。 7. java.sql - 提供了用于操作关系型数据库的类和接口，如连接、语句、结果集等。 除此之外，还有许多其他的类和接口，用于实现各种不同的功能和应用场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁袁袁袁满

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

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

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

打赏作者

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

抵扣说明：

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

余额充值