Java函数编程语法：函数类型、6种方法引用、闭包等知识点总结

于 2024-05-14 16:23:59 发布
阅读量345 收藏 4
点赞数 4
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itcast_cn/article/details/138859822
版权

函数编程语法

一、表现形式

在 Java 语言中，lambda 对象有两种形式：lambda 表达式与方法引用

lambda 对象的类型是由它的行为决定的，如果有一些 lambda 对象，它们的入参类型、返回值类型都一致，那么它们可以看作是同一类的 lambda 对象，它们的类型，用函数式接口来表示

二、函数类型

练习：将 lambda 对象分类，见 PPT

函数接口的命名规律

  • 带有 Unary 是一元的意思，表示一个参数
  • 带有 Bi 或 Binary 是二元的意思，表示两个参数
  • Ternary 三元
  • Quatenary 四元
  • ...

方法引用也是类似，入参类型、返回值类型都一致的话，可以看作同一类的对象，也是用函数式接口表示

三、六种方法引用

1）类名::静态方法名

如何理解：

  • 函数对象的逻辑部分是：调用此静态方法
  • 因此这个静态方法需要什么参数，函数对象也提供相应的参数即可
public class Type2Test {
    public static void main(String[] args) {
        /*
            需求：挑选出所有男性学生
         */
        Stream.of(
                        new Student("张无忌", "男"),
                        new Student("周芷若", "女"),
                        new Student("宋青书", "男")
                )
                .filter(Type2Test::isMale)
                .forEach(student -> System.out.println(student));
    }

    static boolean isMale(Student student) {
        return student.sex.equals("男");
    }

    record Student(String name, String sex) {
    }
}
  • filter 这个高阶函数接收的函数类型（Predicate）是：一个 T 类型的入参，一个 boolean 的返回值
  • 因此我们只需要给它提供一个相符合的 lambda 对象即可
  • isMale 这个静态方法有入参 Student 对应 T，有返回值 boolean 也能对应上，所以可以直接使用

输出

Student[name=张无忌, sex=男]
Student[name=宋青书, sex=男]

2）类名::非静态方法名

如何理解：

  • 函数对象的逻辑部分是：调用此非静态方法
  • 因此这个函数对象需要提供一个额外的对象参数，以便能够调用此非静态方法
  • 非静态方法的剩余参数，与函数对象的剩余参数一一对应

例1：

public class Type3Test {
    public static void main(String[] args) {
        highOrder(Student::hello);
    }

    static void highOrder(Type3 lambda) {
        System.out.println(lambda.transfer(new Student("张三"), "你好"));
    }

    interface Type3 {
        String transfer(Student stu, String message);
    }

    static class Student {
        String name;

        public Student(String name) {
            this.name = name;
        }

        public String hello(String message) {
            return this.name + " say: " + message;
        }
    }
}

上例中函数类型的

  • 参数1 对应着 hello 方法所属类型 Student
  • 参数2 对应着 hello 方法自己的参数 String
  • 返回值对应着 hello 方法自己的返回值 String

输出

张三 say: 你好

例2：改写之前根据性别过滤的需求

public class Type2Test {
    public static void main(String[] args) {
        /*
            需求：挑选出所有男性学生
         */
        Stream.of(
                        new Student("张无忌", "男"),
                        new Student("周芷若", "女"),
                        new Student("宋青书", "男")
                )
                .filter(Student::isMale)
                .forEach(student -> System.out.println(student));
    }

    record Student(String name, String sex) {
        boolean isMale() {
            return this.sex.equals("男");
        }
    }
}
  • filter 这个高阶函数接收的函数类型（Predicate）是：一个 T 类型的入参，一个 boolean 的返回值
  • 因此我们只需要给它提供一个相符合的 lambda 对象即可
  • 它的入参1 T 对应着 isMale 非静态方法的所属类型 Student
  • 它没有其它参数，isMale 方法也没有参数
  • 返回值都是 boolean

输出

Student[name=张无忌, sex=男]
Student[name=宋青书, sex=男]

例3：将学生对象仅保留学生的姓名

public class Type2Test {
    public static void main(String[] args) {
        Stream.of(
                        new Student("张无忌", "男"),
                        new Student("周芷若", "女"),
                        new Student("宋青书", "男")
                )
                .map(Student::name)
                .forEach(student -> System.out.println(student));
    }

    record Student(String name, String sex) {
        boolean isMale() {
            return this.sex.equals("男");
        }
    }
}
  • map 这个高阶函数接收的函数类型是（Function）是：一个 T 类型的参数，一个 R 类型的返回值
  • 它的入参1 T 对应着 name 非静态方法的所属类型 Student
  • 它没有剩余参数，name 方法也没有参数
  • 它的返回值 R 对应着 name 方法的返回值 String

输出

张无忌
周芷若
宋青书

3）对象::非静态方法名

如何理解：

  • 函数对象的逻辑部分是：调用此非静态方法
  • 因为对象已提供，所以不必作为函数对象参数的一部分
  • 非静态方法的剩余参数，与函数对象的剩余参数一一对应
public class Type4Test {
    public static void main(String[] args) {
        Util util = new Util(); // 对象
        Stream.of(
                        new Student("张无忌", "男"),
                        new Student("周芷若", "女"),
                        new Student("宋青书", "男")
                )
                .filter(util::isMale)
                .map(util::getName)
                .forEach(student -> System.out.println(student));
    }

    record Student(String name, String sex) {
        boolean isMale() {
            return this.sex.equals("男");
        }
    }

    static class Util {
        boolean isMale(Student student) {
            return student.sex.equals("男");
        }
        String getName(Student student) {
            return student.name();
        }
    }
}

其实较为典型的一个应用就是 System.out 对象中的非静态方法，最后的输出可以修改为

.forEach(System.out::println);

这是因为

  • forEach 这个高阶函数接收的函数类型（Consumer）是一个 T 类型参数，void 无返回值
  • 而 System.out 对象中有非静态方法 void println(Object x) 与之一致，因此可以将此方法化为 lambda 对象给 forEach 使用

4）类名::new

对于构造方法，也有专门的语法把它们转换为 lambda 对象

函数类型应满足

  • 参数部分与构造方法参数一致
  • 返回值类型与构造方法所在类一致

例如：

public class Type5Test {
    static class Student {
        private final String name;
        private final int age;

        public Student() {
            this.name = "某人";
            this.age = 18;
        }

        public Student(String name) {
            this.name = name;
            this.age = 18;
        }

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    interface Type51 {
        Student create();
    }

    interface Type52 {
        Student create(String name);
    }

    interface Type53 {
        Student create(String name, int age);
    }

    public static void main(String[] args) {
        hiOrder((Type51) Student::new);
        hiOrder((Type52) Student::new);
        hiOrder((Type53) Student::new);
    }

    static void hiOrder(Type51 creator) {
        System.out.println(creator.create());
    }

    static void hiOrder(Type52 creator) {
        System.out.println(creator.create("张三"));
    }

    static void hiOrder(Type53 creator) {
        System.out.println(creator.create("李四", 20));
    }
}

5）this::非静态方法名

算是形式2的特例，只能用在类内部

public class Type6Test {
    public static void main(String[] args) {
        Util util = new UtilExt();
        util.hiOrder(Stream.of(
                new Student("张无忌", "男"),
                new Student("周芷若", "女"),
                new Student("宋青书", "男")
        ));
    }

    record Student(String name, String sex) {

    }

    static class Util {
        boolean isMale(Student student) {
            return student.sex.equals("男");
        }

        boolean isFemale(Student student) {
            return student.sex.equals("女");
        }

        void hiOrder(Stream<Student> stream) {
            stream
                    .filter(this::isMale)
                    .forEach(System.out::println);
        }
    }
}

6）super::非静态方法名

算是形式2的特例，只能用在类内部（用在要用 super 区分重载方法时）

public class Type6Test {

    //...

    static class UtilExt extends Util {
        void hiOrder(Stream<Student> stream) {
            stream
                    .filter(super::isFemale)
                    .forEach(System.out::println);
        }
    }
}

7）特例

函数接口和方法引用之间，可以差一个返回值，例如

public class ExceptionTest {
    public static void main(String[] args) {
        Runnable task1 = ExceptionTest::print1;
        Runnable task2 = ExceptionTest::print2;
    }

    static void print1() {
        System.out.println("task1 running...");
    }

    static int print2() {
        System.out.println("task2 running...");
        return 1;
    }
}
  • 可以看到 Runnable 接口不需要返回值，而实际的函数对象多出的返回值也不影响使用

四、闭包（Closure）

何为闭包，闭包就是函数对象与外界变量绑定在一起，形成的整体。例如

public class ClosureTest1 {
    interface Lambda {
        int add(int y);
    }

    public static void main(String[] args) {
        int x = 10;

        highOrder(y -> x + y);
    }

    static void highOrder(Lambda lambda) {
        System.out.println(lambda.add(20));
    }
}
  • 代码中的 $y \rightarrow x + y$ 和 $x = 10$，就形成了一个闭包
  • 可以想象成，函数对象有个背包，背包里可以装变量随身携带，将来函数对象甭管传递到多远的地方，包里总装着个 $x = 10$
  • 有个限制，局部变量 x 必须是 final 或 effective final 的，effective final 意思就是，虽然没有用 final 修饰，但就像是用 final 修饰了一样，不能重新赋值，否则就语法错误。
  • 意味着闭包变量，在装进包里的那一刻，就不能变化了
  • 道理也简单，为了保证函数的不变性，防止破坏成道
  • 闭包是一种给函数执行提供数据的手段，函数执行既可以使用函数入参，还可以使用闭包变量

例

public class ClosureTest2 {

    // 闭包作用：给函数对象提供参数以外的数据
    public static void main(String[] args) throws IOException {
        // 创建 10 个任务对象，并且每个任务对象给一个任务编号
        List<Runnable> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            int k = i + 1;
            Runnable task 
                = () -> System.out.println(Thread.currentThread()+":执行任务" + k);
            list.add(task);
        }

        ExecutorService service = Executors.newVirtualThreadPerTaskExecutor();
        for (Runnable task : list) {
            service.submit(task);
        }
        System.in.read();
    }
}

五、柯里化（Carrying）

柯里化的作用是让函数对象分步执行（本质上是利用多个函数对象和闭包）

例如：

public class Carrying1Test {
    public static void main(String[] args) {
        highOrder(a -> b -> a + b);
    }

    static void highOrder(Step1 step1) {
        Step2 step2 = step1.exec(10);
        System.out.println(step2.exec(20));
        System.out.println(step2.exec(50));
    }

    interface Step1 {
        Step2 exec(int a);
    }

    interface Step2 {
        int exec(int b);
    }
}

代码中

  • $a \rightarrow ...$ 是第一个函数对象，它的返回结果 $b \rightarrow ...$ 是第二个函数对象
  • 后者与前面的参数 a 构成了闭包
  • step1.exec(10) 确定了 a 的值是 10，返回第二个函数对象 step2，a 被放入了 step2 对象的背包记下来了
  • step2.exec(20) 确定了 b 的值是 20，此时可以执行 a + b 的操作，得到结果 30
  • step2.exec(50) 分析过程类似

六、高阶函数（Higher-Order Functions）

1) 内循环

2) 遍历二叉树

3) 简单流

4) 简单流-化简

5) 简单流-收集

七、综合练习

✅❌

1）判断语法正确性

interface Lambda1 {
    int op(int a, int b);
}

interface Lambda2 {
    void op(Object obj);
}
  1. Lambda1 lambda = a, b -> a - b ❌
  2. Lambda1 lambda = (c, d) -> c * d ✅
  3. Lambda1 lambda = (int a, b) -> a + b ❌
  4. Lambda2 lambda = Object a -> System.out.println(a) ❌

2）写出等价的 lambda 表达式

static class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}
  1. Math::random

()->Math.random()

  1. Math::sqrt

(double number)->Math.sqrt(number)

  1. Student::getName

(Student stu)->stu.getName()

  1. Student::setName

(Student stu, String newName) -> stu.setName(newName)

  1. Student::hashCode

(Student stu) -> stu.hashCode()

  1. Student::equals

(Student stu, Object o) -> stu.equals(o)

假设已有对象 Student stu = new Student("张三");

  1. stu::getName

()->stu.getName()

  1. stu::setName

(String newName)->stu.setName(newName)

  1. Student::new

(String name)->new Student(name)

3）使用函数接口解决问题

把下列方法中，可能存在变化的部分，抽象为函数对象，从外界传递进来

static List<Integer> filter(List<Integer> list) {
    List<Integer> result = new ArrayList<>();
    for (Integer number : list) {
        // 筛选：判断是否是偶数，但以后可能改变判断规则
        if((number & 1) == 0) {
            result.add(number);
        }
    }
    return result;
}
static List<String> map(List<Integer> list) {
    List<String> result = new ArrayList<>();
    for (Integer number : list) {
        // 转换：将数字转为字符串，但以后可能改变转换规则
        result.add(String.valueOf(number));
    }
    return result;
}
static void consume(List<Integer> list) {
    for (Integer number : list) {
        // 消费：打印，但以后可能改变消费规则
        System.out.println(number);
    }
}
static List<Integer> supply(int count) {
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        // 生成：随机数，但以后可能改变生成规则
        result.add(ThreadLocalRandom.current().nextInt());
    }
    return result;
}

4）写出等价的方法引用

Function<String, Integer> lambda = (String s) -> Integer.parseInt(s);
BiPredicate<List<String>, String> lambda = (list, element) -> list.contains(element);
BiPredicate<Student, Object> lambda = (stu, obj) -> stu.equals(obj);
Predicate<File> lambda = (file) -> file.exists();
Runtime runtime = Runtime.getRuntime();

Supplier<Long> lambda = () -> runtime.freeMemory();

5）补充代码

record Color(Integer red, Integer green, Integer blue) { }

如果想用 Color::new 来构造 Color 对象，还应当补充哪些代码

6）实现需求

record Student(String name, int age) { }

static void highOrder(Predicate<Student> predicate) {
    List<Student> list = List.of(
            new Student("张三", 18),
            new Student("张三", 17),
            new Student("张三", 20)
    );
    for (Student stu : list) {
        if (predicate.test(stu)) {
            System.out.println("通过测试");
        }
    }
}

传入参数时，分别用

  • 类名::静态方法名
  • 类名::非静态方法名

来表示【学生年龄大于等于18】的条件

黑马程序员官方
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
博客
自学前端需要达到什么水平才能去找工作？来看看这套前端学习路线图
11-26 2万+
自学前端需要达到什么水平？当然是水平越高，越容易找到工作。在竞争这么激烈的2020年，就需要更加的努力，充实自己，让自己不被代替！看了好多的回答，大家都是再说学到什么水平能找到工作，我就来分享干货吧！祝看到这篇干货的小伙伴，工作步步高升！黑马程序员学习路线图及能掌握的能力（总，以下会分阶段，加上配套学习视频，小伙伴可继续往下看！）第一阶段：HTML5+css配套学习视频：前端小白零基础入门HTML5+CSS3完整视频：http://yun.itheima.co.
博客
软件测试全套教程，2020年全新软件测试学习路线图
05-04 1万+
2020年全新的软件测试学习路线图来袭，零基础入行入职必备学习教程，高质量免费资源在线学习！还在等什么，想学习软件测试的小伙伴，快来点击进入学习状态吧！一、基础入门课程亮点1. 熟悉计算机相关概念。2. 掌握基础的测试理论。3. 熟练掌握HTML常用标签input。4. 掌握使用CSS选择器。配套学习视频：软件测试基础入门之HTML基础​软件测试基础入门......
博客
Java多线程编程，来看这篇就够了！全新Java多线程教程！
06-25 6826
对于Java程序员来讲，Spring全家桶几乎可以搞定一切，Spring全家桶便是精妙的招式，多线程就是内功心法很重要的一块，线上出现性能问题，多线程更是不可回避的问题。因此多线程基础知识对于高级程序员的重要性不必言语！很多公司在面试高级程序员时候，多线程相关知识也必定是考核的标准之一。那我们为什么要学习多线程呢？掌握Java多线程可以：应对面试、优化之路、深入理解。应对面试在面试中，求职...
博客
QT教程，QT从入门到实战教程完整版
06-17 6万+
Qt是一个跨平台开发框架，可以使用C++和Qml开发，同时它又不仅仅只是开发框架，它也是一种技术策略，可以让你快速、高效地设计、开发、部署和维护软件，同时在所有设备上提供无缝的用户体验。因而，对于C/C++工程师而言，QT是必须要学习的一个跨平台开发框架，今天分享一个QT教程！课程亮点1，知识体系完备，内容精炼2，脉络清晰，讲解过程把握知识主线。3，结合工作实践及分析应用，培养...
博客
软件测试人员应该如何介绍自己测试过的项目
05-09 4万+
测试人员在找工作的过程中，通常有一个问题是很难绕开的。就是要如何向别人介绍自己之前做过的项目。下面我们就这个问题简单的做一些分析。要解决这个问题，大体上可以分为如下几个步骤：1、对项目进行基本介绍2、说明自己负责测试的模块3、针对部分模块展开进行说明一. 对项目进行基本介绍以下就以一个简单的项目进行介绍说明：最近测试的Tpshop项目是一个B/S架构的Web项...
博客
软件测试全套教程，软件测试自学线路图
07-09 19万+
软件测试：软件测试是为了发现程序中的错误而执行程序的过程。通俗的说，软件测试需要在发布软件之前，尽可能的找软件的错误，尽量避免在发布之后给用户带来不好的体验，并要满足用户使用的需求。现在市面上这么多软件，每个软件背后都有软件测试工程师的功劳，这也造就了软件测试行业前景非常好，今天我就分享一下自学线路图，及全套教程！软件测试学习线路图点击查看大图第一阶段：该...
博客
Python入门教程完整版（懂中文就能学会）
09-28 18万+
今天本宝宝给大家带来了干货，Python入门教程完整版，完整版啊！完整版！言归正传，我来给大家介绍一下这套教程，希望每个小伙伴都沉迷学习，无法自拔！本套教程学习时间15天1-3天内容：为Linux基础命令4-13天内容：为Python基础教程14-15 天内容：为飞机大战项目演练第一阶段（1-3天）：该阶段首先通过介绍不同领域的三种操作系统，操作系统的发展简史以及...
博客
Java学习路线图，全套Java基础视频教程
09-07 23万+
深知广大爱好Java的人学习是多么困难，没视频没资源，上网花钱还老被骗。为此我呕心沥血整理了这套Java教程，不管你是不懂电脑的小白，还是已经步入开发的大牛，这套路线路你都值得拥有，小白看上面的视频可以成功学会Java并且顺利工作，大神看了上面的资源肯定会谆谆乐道，教程的宗旨就是分享，专业，便利，让喜爱Java的人，都能平等的学习。首先建立好开发环境非常重要，工欲善其事，必先利其器。做任何开发.........
博客
从零开始学习Java编程
05-28 514
Java是被广泛应用的编程语言，具有强大的跨平台功能和丰富的库支持。对于想要学习编程的人来说，掌握Java是一个不错的选择。本文将为大家提供一个全面的指南，帮助你开始学习Java编程。
博客
本科，60k*13薪，外包到新疆！你会去吗？
05-27 194
在论坛中，还有不少网友分享了自己的求职经历，称大数据开发岗位“拿offer很顺畅”、“点击就送”。在这里工作，不仅能享受到高薪资带来的物质满足，还能体验到新疆独有的风土人情，享受生活与工作的完美平衡。帖子一发出，就碰撞出不少火花，网友们纷纷留言，有人打趣说：“这薪资，外派到月球也值了！”，这让这位原本生活在上海的同学犯了难，毕竟从繁华都市到边陲，这跨度不是一般的大。”也有的说：“长期外派，要考虑清楚，毕竟离家远，回来可能不容易。在这样的背景下，大数据开发人才越来越受欢迎，薪资自然跟着水涨船高。
博客
鸿蒙星河版笔记来袭！界面开发、组件的属性和方法
05-27 203
语法：Image(图片数据源) 支持 网络图片资源 和 本地图片资源。语法：Image(图片数据源) 支持 网络图片资源 和 本地图片资源。ArkUI（方舟开发框架）是一套 构建 鸿蒙应用 界面 的框架。学习界面开发：build 里面写代码，预览器 看效果。注意：build有且只能有一个根元素，且是容器组件。注意：需要配合 .maxLines(行数) 使用。需求：美化组件外观效果——>组件的属性方法。语法：.lineHeight(数字)构建页面的最小单位就是 "组件"。布局思路：先排版，再放内容。
博客
2024春招“大洗牌”，抖音霸榜高薪公司Top1，华为跌出前10！
05-24 422
播妞建议，即将步入职场的大学生，可密切关注行业报告和市场趋势，综合考虑行业前景、竞争压力、福利待遇和上升空间等因素，做出更加明智的决策。（PS：想要深入研究《报告》的学生，可关注“黑马程序员”公众号，后台发送“春招报告”，领取报告全文~）一直以来，任正非一直是“最肯给钱的老板”，华为也一直是那个“最会奖励人的公司”，薪资向来遥遥领先！有人说，今后职场上只有两种人，一种是熟练使用AI的人，另外一种是创造AI工具的人。从招聘网站上可以发现，还是那句话，未来取代你的，不是人工智能，而是比你更会用人工智能的人！
博客
Python基础语法到高级概念
05-24 322
Python 是一种高级解释型编程语言，强调代码的可读性和简洁性。由 Guido van Rossum 创建，于 1991 年首次发布。Python 的设计理念注重代码的可读性，其语法清晰、富有表现力，易于学习和使用。今天就介绍到这里。未来我们将逐步深入介绍 Python 的其他知识，希望在日常的 Linux 开发中，多用 Python 开发脚本实现自动化，达到事半功倍的效果。本文介绍了 Python 编程的基础知识，包括设置环境、基本语法和数据类型、控制流语句、函数和模块。
博客
鸿蒙星河版笔记来袭！对象、联合类型、枚举类型学习
05-22 360
联合类型是一种灵活的数据类型，它修饰的变量可以存储不同类型的数据。枚举类型是一种特殊的数据类型，约定变量只能在一组数据范围内选择值。1. 通过 interface 接口约定 对象结构类型。let 对象名称: 对象结构类型 = 值。作用：用于描述一个物体的特征和行为。对象：是一个可以存储多个数据的容器。定义对象并使用（通过、访问）方法作用：描述对象的具体行为。1、定义枚举类型（常量列表）2、使用枚举类型，约束变量。2、添加方法（箭头函数）2. 定义对象并使用。
博客
鸿蒙星河版笔记来袭！开发环境准备到基础函数的学习
05-20 230
如果找不到可以到备用下载地址：OpenHarmony官网 → 开发者 → 了解OpenHarmony → 指定版本 → 配套关系（下载）普通函数和箭头函数，在后面开发中会有不同的使用场景，所以两种语法都需要掌握。编程语言：是用来控制计算机工作的，可以告诉计算机我们要做的事情。函数：是可以被重复使用的代码块“包裹”起来，有利于代码复用。根据我们传入不同的数据，进行处理，返回处理后的结果。作用：函数可以把具有相同或者相似逻辑的代码。注意：先定义，后使用（变量、函数都是如此）变量：专门用来存储数据的容器（可变）
博客
Java入门到精通22本经典书籍推荐
05-20 538
这本书采用互动和幽默的风格，通过丰富的插图和示例，使初学者能够轻松地掌握Java基础。它用简单易懂的方式介绍了Java的核心概念和语法，非常适合刚刚接触编程的读者。
博客
鸿蒙开发培训，海底捞、中通快递等30多款应用启动华为鸿蒙应用
05-20 232
2019年，HarmonyOS正式面世，截止2023年8月，鸿蒙生态设备数量超过7亿台，已有220万开发者投入到鸿蒙生态的开发。自9月25日华为宣布鸿蒙原生应用全面启动以来，多家互联网公司如美团、网易、今日头条、钉钉、小红书、招商银行、携程旅行、58同城等发布了多个与鸿蒙有关的岗位。据估计，鸿蒙开发的人才缺口或将达到百万规模。不完全统计显示，已宣布启动鸿蒙原生应用开发的App有：同程旅行、开心消消乐、美团、去哪儿、新浪微博、新浪新闻、石墨文档、钉钉等。
博客
SpringBean的配置万字详解
05-17 809
通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中，但是 getObject() 方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject() ， 此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池 中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例。
博客
Spring框架的诞生，BeanFactory 快速入门，说说Spring中BeanFactory 接口和ApplicationContext接口的区别？
05-16 794
3）Bean创建的主要逻辑和功能都被封装在BeanFactory中，ApplicationContext不仅继承了BeanFactory，而且 ApplicationContext内部还维护着BeanFactory的引用，所以，ApplicationContext与BeanFactory既有继承关系，又 有融合关系。1）BeanFactory是Spring的早期接口，称为Spring的Bean工厂，ApplicationContext是后期更高级接口，称之为 Spring 容器；
博客
传统Javaweb开发的困惑是什么？IoC、DI和AOP思想是什么意思？
05-15 233
（1）loC控制反转，是将程序创建Bean的权利反转给第三方（2）DI依赖注入，某个完整Bean需要依赖于其他Bean（或属性）的注入（3）AOP面相切面编程，用横向抽取方法（属性、对象等）思想，组装成一个功能性切面。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值