Java学习22--接口类& Lambda 表达式

Dear_喜阳阳

已于 2024-03-15 12:27:43 修改

阅读量479

点赞数 7

文章标签： java 学习开发语言

于 2024-02-15 18:34:06 首次发布

本文链接：https://blog.csdn.net/weixin_42892630/article/details/136122264

版权

接口类的定义和实现

Java接口（Interface）是Java编程语言中的一个非常重要的概念。它是一个完全抽象的类，用于定义一组方法，这些方法由类来实现。接口定义了一个契约，即规定了类应该具备哪些方法，但并不实现这些方法的具体细节。

Java接口（Interface）（接口）是一种完全抽象的类型，它只能包含abstract method和常量变量（在Java中称为常量，因为它们的值在创建后不能被修改）。接口interface不能被用来建立object，它定义了一个合约，由实现该接口的class们来遵守。

对比之前的学习：

normal class一般的类: 只有具体 method implementing执行
abstract class抽象类: 具体method implementing和abstract method implementing
interface接口类: 只有agreement没有任何implementing，专业搞约束，实现约束& method块完全分离。仅定义的是一些规则。
声明一般类用关键字class，声明接口用关键字interface。

速记：把定义class时候的关键字换成interface 定义的就是接口

tips：连接接口关键字implements

示例 TimeService接口连接了两个class文件，两个class文件内部都具体定义了TimeService接口的timer method实际执行步骤，虽然步骤不尽然一样，但都有相同的输入输出格式。


package oop.Demo09;

//定义一个名叫UserServiceImpl的class，它连接两个接口UserService和和TimeService

//add delete update query timer都是接口中要求有的method 所以在这里override 接口里不能具体写method执行过程，但一定要有其他class可以执行这些method

public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}


//建立一个名叫test的class文件，它连接了TimeService这个interface
//可以在test.java里面再次建一个执行timer method的具体程序（不用和其他class里面的timer method执行程序一样）
//注：刚才已经在UserServiceImpl.java里面做了一个timer method的具体执行程序

package oop.Demo09;
import static java.lang.Math.random;

public class test implements TimeService{

//系统后台默认这里是public abstract，所以用户不用写public abstract
//这一句其实就是public abstract void timer();
    public void timer(){
        double a = random();
    }
}

//TimeService 接口(interface)

package oop.Demo09;
import static java.lang.Math.PI;

public interface TimeService {

//系统后台默认这里是public abstract，所以用户不用写public abstract
//这一句其实就是public abstract void timer();

      public void timer(){
        double a = PI;
    }
}

//UserService 接口(interface)
package oop.Demo09;

public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    //(看下面变灰色的关键字public abstract,不写也可以)
	
    public abstract void add(String name);
	
    void delete(String name);
    void update(String name);
    void query(String name);

  //int AGE =99;看下面变灰色的关键字public static final，
	//所以这里写成int AGE =99;也可以
	//其实interface里的常量是默认public static final修饰的
	
    public static final int AGE =99;
}

Java Lambda 表达式&函数式接口

Lambda 表达式，也可称为闭包
A lambda expression is a short block of code which takes in parameters and returns a value. Lambda expressions are similar to methods, but they do not need a name and they can be implemented right in the body of a method.

用途：Lambda表达式主要用快速于实现简单功能的函数式接口，这些接口通常只有一个抽象方法。
参数和返回值：任意数量的参数输入，可以有返回值。（void函数则不需要返回）。

写法分为以下三种
parameter -> expression
(parameter1, parameter2) -> expression
(parameter1, parameter2) -> { code block }

举例，这就是一个求和的 Lambda 表达式
(a,b)->a+b;

函数式接口
如果一个接口interface只声明了一个抽象方法method，那么这个接口interface可以被称为函数式接口。

函数式接口可以使用@FunctionalInterface注解进行标注，但这个注解不是必须的，它主要是作为一种文档标记，告诉开发者这个接口是一个函数式接口。如果没有标注这个注解，但接口中确实只有一个抽象方法，那么编译器仍然会将其视为函数式接口。

举例


//这里定义了一个名叫my_interface的接口，和普通接口没有大的区别
//只是写了注释@FunctionalInterface表示这是函数式接口


package exception.demo02;
@FunctionalInterface
public interface my_interface {
    int add(int a, int b);
}


package exception.demo02;



//这里定义了一个名叫 my_lambda的文件

public class my_lambda{
    public static void main(String[] args) {
	
	//下面这句话里面的 (a,b)->a+b;就是lambda表达式
	//直接创立my_interface class类型的object x
	//同时使用lambda表达式，对my_interface class类型里唯一的method add也完成了快速逻辑构建
        my_interface x=(a,b)->a+b;
//调用x object里面的method add并给予输入值3,7
        int sum = x.add(3,7);
        System.out.println(sum);

    }

}

运算结果

10

Process finished with exit code 0

作用：
1.interface接口就是约束，不具体执行
2.定义一些method，让连接interface的不同的class(们)去具体执行这个menthod,不同的class执行同样名字的method可能方法不同，但不关interface接口的事了
3.public abstract 是interface里面每个method自带的默认修饰符
4.public static final是interface里面自定义variable自带的默认修饰，比如int a =8;其实默默写了public static final在前面
5.interface 不能用来new object，因为它没有构造method
6.用class_name implements接口interface1,interface2…可以实现同时连多个接口
7.连接接口的class必须要实现接口中的method

举例：下面用lambda表达式完成接口intface_a的加法运算，再用常规手法完成普通接口intface_b的乘法运算。


package static_study;

//注意用lambda表达式完成接口，在test程序的开头并没有implements声明intface_a接口

public class test implements intface_b{

    public static void main(String[] args) {
        
		//下面就是定义的lambda表达式，实现了接口intface_a
	
        intface_a y=(a,b)->a+b;
        System.out.println(y.mathadd(6,4));


        System.out.println("分隔线------>");
        test x= new test();
        x.mul(7,3);
        System.out.println("分隔线------>");
        new test().mul(5,6);

    }


    @Override
    public void mul(int a, int b) {

        System.out.println(a*b);
    }


}


package static_study;
@FunctionalInterface
public interface intface_a {
public abstract int mathadd(int a, int b);
}


package static_study;
public interface intface_b {
    public abstract void mul(int a, int b);

}

运行结果:

10
分隔线------>
21
分隔线------>
30

Process finished with exit code 0

总结：六种Lambda表达式

举例：(o1,o2) -> Integer.compare(o1,o2);
格式：
-> : Lambda操作符或者箭头操作符
->左边 : Lambda行参列表(其实就是接口中的抽象方法的行参列表)
->右边 : Lambda体其实就是重点的抽象方法的方法体
Lambda表达式的使用（分为六种情况）
总结：
->左边：Lambda形参列表的参数返回类型可以省略（类型推断），如果Lambda形参列表只有一个参数，其一对()也可以省略
->右边：Lambda体应该使用一对{}包裹；如果Lambda体只有一条执行语句(可能是return语句)，可以省略这一对{}和return关键字（注意，如果想省略写，return和{}要一起省略）
Lambda表达式的本质：作为函数式接口的实例
如果一个接口中，只声明了一个抽象方法，则此接口就称函数式接口(下面有详解)
所以先前那些用匿名实现类表示的现在都能用Lambda表达式来写

举例：

package LambdaTest;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest1 {
    //语法格式一：无参 无返回值
    public static void main(String[] args) {
        System.out.println("****************举例：无参 无返回值**************");
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("***********************");
        Runnable r2 = ()->{System.out.println("我爱北京天安门");};
        r2.run();

        System.out.println("****举例：Lambda需要一个参数 但是没有返回值*****");
        //语法格式二：Lambda需要一个参数 但是没有返回值
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }

        };
        con.accept("谎言和誓言有什么区别");
        System.out.println("***********************");
        Consumer<String> con1 = (String s) -> System.out.println(s);
        con1.accept("一个是听的人当真了，一个是说的人当真了");

        //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
        System.out.println("***********数据类型可以省略，因为可由编译器推断得出，称为“类型推断”************");
        Consumer<String> con2 = (s) -> System.out.println(s);
        //括号里面的String s，但是写的时候String省略了
        con2.accept("一个是听的人当真了，一个是说的人当真了");

        /*
        //类型推断举例1
        ArrayList<String> list = new ArrayList<String>();//类型推断
        ArrayList<String> list2 = new ArrayList<>();//<Sring>被省略了

        //类型推断举例2
        int [] arr =new int []{2,3,4};//类型推断
        int [] arr2 ={2,3,4};//类型推断，new int []部分被省了
        */

        //语法格式四：lambda若只需要一个参数时，参数的小括号可以省略

        System.out.println("*********lambda若只需要一个参数时，参数的小括号可以省略**************");
        Consumer<String> con3 = s -> System.out.println(s);
        //括号里面的String s，但是写的时候String省略了
        con3.accept("一个是听的人当真了，一个是说的人当真了");


        //语法格式五：lambda需要两个以及以上参数时，多条执行语句，并且可以有返回值
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                //compareTo：当o1大于o2时，得1；若当o1小于o2时，得到-1
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12,21));

        System.out.println("*********lambda需要两个以及以上参数时，多条执行语句，并且可以有返回值**************");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            //compareTo：当o1大于o2时，得1；若当o1小于o2时，得到-1
            return o1.compareTo(o2);
            };

        System.out.println(com2.compare(21,12));



        System.out.println("*********lambda体只有一条语句，return与大括号若有，都可以省略**************");
        //语法格式六：lambda体只有一条语句，return与大括号若有，都可以省略
        Comparator<Integer> com6 = (o1,o2) -> o1.compareTo(o2);
        //compareTo：当o1大于o2时，得1；若当o1小于o2时，得到-1
        System.out.println(com6.compare(21,512));

}


}

运行显示：

****************举例：无参 无返回值**************
我爱北京天安门
***********************
我爱北京天安门
****举例：Lambda需要一个参数 但是没有返回值*****
谎言和誓言有什么区别
***********************
一个是听的人当真了，一个是说的人当真了
***********数据类型可以省略，因为可由编译器推断得出，称为“类型推断”************
一个是听的人当真了，一个是说的人当真了
*********lambda若只需要一个参数时，参数的小括号可以省略**************
一个是听的人当真了，一个是说的人当真了
12
21
-1
*********lambda需要两个以及以上参数时，多条执行语句，并且可以有返回值**************
21
12
1
*********lambda体只有一条语句，return与大括号若有，都可以省略**************
-1

Process finished with exit code 0

函数式接口

只包含一个抽象方法的接口
可以通过Lambda表达式创建该接口的对象（若Lambda表达式抛出一个非运行时异常，那么该异常需要在目标接口的抽象方法上声明）
可以在接口上使用@FunctionalInterface进行注解
在java.util.function包下定义了Java8的丰富的函数式接口

比如下面就是一个函数式接口（Lambda表达式就相当于一个函数式接口的实例）

package LambdaTest;

public interface MyInterface {
    void method1();
}

Dear_喜阳阳

关注

7
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java学习22--接口类& Lambda 表达式

Java接口（Interface）是Java编程语言中的一个非常重要的概念。它是一个完全抽象的类，用于定义一组方法，这些方法由类来实现。接口定义了一个契约，即规定了类应该具备哪些方法，但并不实现这些方法的具体细节。normal class一般的类: 只有具体 method implementing执行abstract class抽象类: 具体method implementing和abstract method implementing。
复制链接

扫一扫