JDK新特性

最新推荐文章于 2024-07-20 13:46:19 发布
最新推荐文章于 2024-07-20 13:46:19 发布
阅读量173 收藏
点赞数
分类专栏： java复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lushizhuo9655/article/details/112756544
版权
本文介绍了Java中的Lambda表达式，展示了如何通过Lambda简化多线程程序的实现，以及如何用它来替代匿名内部类。同时，讨论了接口的默认方法，解释了它们在接口升级时的作用，避免破坏已有实现。文中通过实例详细解析了Lambda的语法和使用场景，包括方法引用和构造器引用等。
摘要由CSDN通过智能技术生成

Lambda表达式

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}


public class LambdaDemo {
    public static void main(String[] args) {
        //实现类的方式实现需求
       /* MyRunnable my=new MyRunnable();
        Thread t1=new Thread(my);
        t1.start();*/

        //匿名内部类的方式改进
    /*   new Thread(new Runnable(){
           @Override
           public void run() {
               System.out.println("多线程程序启动了");
           }
       }).start();*/

        //Lambda表达式的方式改进
        new Thread( () -> {
            System.out.println("多线程程序启动了");
        }).start();
    }
}

Lambda表达式的代码分析:

():里面没有内容,可以看成是方法形式参数为空

->:用箭头指向后面要做的事情

{}:方法里面的内容

组成lambda表达式的三要素:形式参数,箭头,代码块

Lambda表达式的使用前提

有一个接口

接口中有且仅有一个抽象方法

public interface Eatable {
    void eat();
}

public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("饭后走一走，活到九十九");
    }
}

public class EatableDemo {
    public static void main(String[] args) {
        Eatable e=new EatableImpl();
        userEatable(e);

        userEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("饭后走一走，活到九十九");
            }
        });
        
        userEatable( () ->{
            System.out.println("饭后走一走，活到九十九");
        });
    }

    private   static void userEatable(Eatable e){
        e.eat();
    }
}

public interface Flyable {
    void fly(String s);
}

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

        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("你喜欢的人那么优秀，你确定你不努力吗");
            }
        });

        useFlyable( (String s)->{
            System.out.println(s);
            System.out.println("你喜欢的人那么优秀，你确定你不努力吗");
        });
    }

    private static  void useFlyable(Flyable f){
        f.fly("看有灰机");
    }
}
 
public interface Addable {
    int add(int x,int y);
}


public class AddableDemo {
    public static void main(String[] args) {
        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });

        useAddable( (int x,int y)->{
            return  x+y;
        });


    }

    public  static  void useAddable(Addable a) {
        int x=a.add(5,6);
        System.out.println(x);
    }
}

public interface Addable {
    int add(int x,int y);
}

public interface Flyable {
    void  fly(String s);
}

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

        useAddable((int x,int y)->{
            return x+y;
        });

        //参数的类型可以省略
        useAddable((x,y)->{
            return x+y;
        });


        useFlyAble((String s)->{
            System.out.println(s);
        });

        //参数的类型可以省略
        useFlyAble((s)->{
            System.out.println(s);
        });
        //如果参数有且仅有一个，小括号可以省略
        useFlyAble(s->{
            System.out.println(s);
        });
        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyAble(s->System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号 如果有return,return也要省略
        useAddable((x,y)->x+y);
    }

   private  static  void useFlyAble(Flyable f){
        f.fly("看有灰机");
   }
   private  static  void  useAddable(Addable a){
       int i = a.add(5, 5);
       System.out.println(i);
   }
}

接口组成

public interface MyInterface {
    void show1();
    void show2();
}


public class MyInterfaceImplOne implements MyInterface{
    @Override
    public void show1() {
        System.out.println("One show1");
    }

    @Override
    public void show2() {
        System.out.println("One show2");
    }
}

public class MyInterfaceImplTwo implements MyInterface{
    @Override
    public void show1() {
        System.out.println("Two show1");

    }

    @Override
    public void show2() {
        System.out.println("Two show2");
    }
}


public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my=new MyInterfaceImplOne();
        my.show1();
        my.show2();
    }
}

随着业务的服务，这个接口的功能已经不能满足需要了，需要新增方法（所有实现抽象类都需要写抽象方法   比较麻烦）

这个方法也可以被重写

这里的public可以省略

默认方法，主要用来接口升级而不破坏现有的方法

public interface Inter {
    void  show();
    default void  method(){
        System.out.println("Inter 中的默认方法执行了");

    };
    public  static  void test(){
        System.out.println("Inter 中的静态方法执行了");
    }
}


public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法执行了");
    }
}


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

接口中的静态方法public可以省略

public interface Inter {
    default  void show1(){
        System.out.println("show1方法开始执行");
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
        System.out.println("show1方法结束执行");
    }

    default  void show2(){
        System.out.println("show2方法开始执行");
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
        System.out.println("show2方法结束执行");
    }

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


public class InterImpl implements Inter{

}

public class InterDemo {
    public static void main(String[] args) {
        Inter i=new InterImpl();
        i.show1();
        i.show2();
        Inter.method1();
        Inter.method2();
    }
}

可以写私有方法来提取相同的代码

私有的静态方法，既可以被默认方法调用，也可以被静态方法调用

方法引用符  ::

public interface Printable {
    void printString(String s);
}


public class PrintableDemo {
    public static void main(String[] args) {
        usePrintable(s->System.out.println(s));
        //方法引用符
        usePrintable(System.out::println);
    }

    public  static  void usePrintable(Printable p){
        p.printString("张三");
    }
}

public interface Converter {
    int convert(String s);
}

public class PrintableDemo {
    public static void main(String[] args) {
        useConverter(s->{
            return  Integer.parseInt(s);
        });
        useConverter(s->Integer.parseInt(s));
        //引用类方法
        useConverter(Integer::parseInt);
    }

    public static  void  useConverter(Converter c){
        int i=c.convert("10");
        System.out.println(i);
    }
}

public interface Printer {
    void printUpperCase(String s);
}

public class PrintString {
    public void printUpper(String s){
        String result=s.toUpperCase();
        System.out.println(result);
    }
}

public class PrinterDemo {
    public static void main(String[] args) {
        usePrinter(s ->System.out.println(s.toUpperCase()));
        //引用对象的实例方法
        PrintString p=new PrintString();
        usePrinter(p::printUpper);
    }

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

public interface MyString {
    String mySubString(String s,int x,int y);
}


public class MyStringDemo {
    public static void main(String[] args) {
        useMyString((s,x,y)-> s.substring(x,y));
        //引用类的实例方法
        useMyString(String::substring);
        //Lambda表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数
    }

    private static  void useMyString(MyString my){
        String s=my.mySubString("zhangsan",2,5);
        System.out.println(s);
    }
}

public class Student {
    private String name;
    private int age;
}

public interface StudentBuilder {
    Student build(String name,int age);
}

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

        useStudentBuilder((name,age)->new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
    }
    private  static  void useStudentBuilder(StudentBuilder sb){
        Student  s=sb.build("张三",20);
        System.out.println(s.getName()+","+s.getAge());
    }
}

 

 

 

 

 

 

 

 

guoyebing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
mockito mock void方法_人生苦短，我用Mockito
weixin_39618806的博客
12-05 887
人生苦短，我用Mockito没错，我~~胖虎~~今天就是要教大家怎么写单元测试！我的经(keng)历在书写Swift引擎test时，常常需要和数据库，文件系统等等一些不太稳定的独立系统打交道，比如生成Cube数据，查询Cube数据，读写配置啥的，开始都是生成真实数据，但是很不稳定，test几乎每次都挂。而且最初写test的思路是完全错误的，当时想当然地认为只要把大致流程走一遍，跑过就行。后来我转变...
Python 第八节 第一课
我是小白呀的博客
10-04 679
[toc] 方法没有重载 在其他语言中, 可以定义多个重名的方法, 只要保证方法签名的唯一即可. 方法签名包含 3 个部分: 方法名, 参数数量, 参数类型. Python 中, 方法的参数没有类型 (调用时确定参数类型 ), 参数的也可以由可变参数控制. 因此, Python 中是没有方法的重载的. 定义一个方法即可有多种调用方式, 相当于实现了其他语言中的方法的重载. 如果我们在类通中定义了多个重名的方法, 只有最后一个方法有效. 建议: 不要使用重名方法 ! Python 中方法没有重载.
2024年主流使用的JDK版本及其核心特性介绍
最新发布
CoderCoding的博客
07-20 2250
​ 在群里交流的时候，经常遇到不同同学使用的JDK版本五花八门，并且很多不知道其使用版本的特点。作为Java开发者，理解不同JDK版本的核心特性和优势不仅能提高我们的开发效率，还能帮助我们更好地选择适合自己项目的版本。
一文让你快速上手 Mockito 单元测试框架（中）
ifeves的博客
06-23 402
作者｜mghio编辑｜包包 与 Spring 框架集成Mockito框架提供了@MockBean注解用来将 mock 对象注入到 Spring 容器中，该对象会替换容器中任何现有...
Mockito 如何 mock 返回值为 void 的方法
大雄不爱吃肉
09-20 4629
最初接触 Mockito 还思考并尝试过如何用它来 mock 返回值为 void 的方法，然而 Google 查找到的一般都会说用 doThrow() 的办法 doThrow(new RuntimeException()).when(mockObject).methodWithVoidReturn(); 因为无法使用常规的 when(mockObject.foo()).then
mockito mock void方法_mockito从入门到通关
weixin_39958100的博客
12-01 787
为什么要mock？有很多朋友不愿意写单元测试，觉得写单测试比较花时间，甚至不会写单元测试，很大程度上是因为不想写或者不会写mock。mock对于单元测试来很重要。单元测试之所以名字里面有“单元”，就是因为一个测试用例只测很小的一个单元代码。但我们的代码总会有依赖，要测试的方法内部可能调用了其它类的方法，这在代码中是很常见的逻辑。所以我们经常会需要mock，用来消除依赖。所谓mock，翻译过来就是“...
最新 jdk新特性课程讲解.rar
09-09
JDK的新特性是开发者关注的焦点，因为它们通常带来了性能提升、开发效率的优化以及新的编程模型。在"最新 jdk新特性课程讲解.rar"这个压缩包中，我们期待找到关于JDK 1.8至9版本的更新内容和讲解视频。以下是这些...
JavaJDK新特性8-15详细视频讲解合集
04-27
本课程专门针对JDK8-15新特性进行一一讲解，每个新特性都进行案例演示，通俗易懂易学习。 讲解方式： 课程讲解通俗易懂，课程重点剖析模块化系统、交互式编程。 课程内容： 课程讲解通俗易懂，课程重点剖析模块化...
jdk8新特性
11-22
jdk8新特性，百度云盘。jdk8新特性，百度云盘。jdk8新特性，百度云盘。
JDK新特性笔记1
08-03
本文将重点介绍JDK 8到JDK 13的一些关键新特性，以及如何在Eclipse和IntelliJ IDEA等IDE中使用它们。 首先，JDK 8是一个重要的里程碑，它引入了`Optional`类，用于处理可能为空的对象引用，避免了空指针异常...
jdk1.8新特性.doc
04-01
JDK1.8引入了许多重要的新特性，极大地提升了Java编程的效率和性能。以下是这些特性的详细介绍： 1、**Lambda表达式**： Lambda表达式是JDK1.8的一个重大改进，它允许开发者以更简洁的方式传递代码块。在上述示例中...
Mock void 方法
qq_24850045的博客
01-06 1561
void mock Mockito.doThrow(new Exception()) .when(service) .createAAA(Mockito.mock(TTTT.class));
用Mockito来mock返回值类型为void的方法
热门推荐
明明如月的技术博客
04-10 3万+
开发中有些依赖的接口还没有开发完成、有些接口还调不通等情况，可以使用Mockito对接口进行mock，然后去测试逻辑，非常好用。 最近开发中用到对void返回值类型的方法Mock，看到一篇不错的文章，翻译出来，希望对大家有帮助。 -------------------------------------------------------华丽的分割线----------------------...
使用Mockito的Mock Void方法
最佳 Java 编程
07-09 1万+
大家好！ 在我们之前的博客关于thenReturn和thenAnswer模拟方法之间的区别之后 ，我们又回来了关于Mockito的另一个有趣的博客。 在这里，我们将讨论“如何用Mockito模拟无效方法”。 让我们开始吧！ 在编写代码时，总是至少有一种方法返回“ void”，并且在某个时间点需要模拟“ void”方法。 那么我们如何去做呢？ 让我们在下面的博客中使用Mockito一起解决...
SpringBoot 单元测试利器——Mockito
Java笔记虾
02-08 1394
Mockito 是一种 Java mock 框架，他主要是用来做 mock 测试的，他可以模拟任何 Spring 管理的 bean、模拟方法的返回值、模拟抛出异常...等，在了解 Moc...
mockito mock void方法_一文让你快速上手 Mockito 单元测试框架（上）
weixin_39956558的博客
12-05 1113
作者｜mghio编辑｜包包 前言在计算机编程中，单元测试是一种软件测试方法，通过该方法可以测试源代码的各个单元功能是否适合使用。为代码编写单元测试有很多好处，包括可以及早的发现代码错误，促进更改，简化集成，方便代码重构以及许多其它功能。使用 Java 语言的朋友应该用过或者听过 Junit 就是用来做单元测试的，那么为什么我们还需要Mockito测试框架呢？想象一下这样的一个常见...
Mock测试返回为void的方法
yshuoo的博客
09-26 1万+
1.使用doAnswer方法解决，代码如下： @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = {Application.class}) public class ControllerTest { @Test public void updateReading() throws Exc...
Mockito返回为void的方法抛出异常
weixin_45404314的博客
02-17 4417
方法有返回值： Mockito.when(mockitoTestModel.returnString()).thenThrow(new MyException()); 方法没有返回值，方法上声明了异常： Mockito.doThrow(new MyException(“TEST”)).when(mockitoTestModel).noReturn(); 方法没有返回值，并且没有声明异常 Mockito.doAnswer( invocation -> { throw new Exception(“Som
Java JDK新特性：for-each循环解析
"本文档详细介绍了JDK中的一个新特性——for-each循环，也称为增强的for循环，这是从J2SE5开始引入的一种简化集合遍历的语法结构。" 在Java编程语言中，JDK的新特性之一是引入了for-each循环，这种循环方式极大地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

guoyebing

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

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

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

打赏作者

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

抵扣说明：

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

余额充值