javabasic-day04

最新推荐文章于 2024-08-30 18:40:43 发布
最新推荐文章于 2024-08-30 18:40:43 发布
阅读量395 收藏
点赞数 13
文章标签： java jvm 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64370841/article/details/140644664
版权

method_01MethDemo

package com.basic.day04.method;

/**
 * 方法的定义结构：
 * [访问权限修饰词][其他修饰词]返回值类型 方法名(参数列表){
 * //方法体
 * [return]
 * }
 */

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

    //定义一个方法：返回两个int类型里面变量中最大值
    public static int max(int a, int b) {
        if (a > b) {
            return a;
        } else  {
            return b;
        }
    }
   //定义一个方法，打印两个变量a(int) 和b(long) 的最大值
    public static void print(int a,long b){
        System.out.println(a+b);
    }
}

method_02MethDemo

package com.basic.day04.method;

/**
 * 方法的返回值：
 * 1. 方法在定义时，必须规定方法的返回值类型是什么
 * 2. 方法的返回值类型位置可以书写两大类型
 * 第一种方法： void，无类型，表示方法在执行完毕后，不需要返回任何数据
 * 第二种类型： java中的任意类型，包括程序员自定义的类型
 * 3. return关键字：
 * -- 返回，归还的含义
 * -- 在方法中，表示结束方法，因此，return后不能有代码，不执行
 * -- void类型的方法，return 可加可不加
 * -- 返回值类型是其他类型的方法，return后必须跟一个该返回值类型的变量
 * 或者表达式。表示方法执行完毕，最终数据返回给调用者。
 * <p>
 * 注意：谁是调用者 调用该方法的所在处就是调用者
 */

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

    }

    // 定义一个void形式的方法 m1，
    public static void m1() {
        int a = 1;
        int b = 2;
        int c = a + b;
        return;  //return关键字表示方法结束，可加可不加
    }

    public static int m2() {
        int a = 1;
        int b = 2;
        byte c = (byte) (a + b);//隐式转换
        return c;
    }

    public static String m3() {
        int a = 1;
        int b = 2;
        int c = a + b;
        return c+"";
    }
}

method_03MethDemo

package com.basic.day04.method;

/**
 * 方法的参数列表：
 * 1. 参数列表具体指的是定义期间方法名后的参数类型列表
 * 类型非常重要，列表指的是从左到右的顺序
 * 名字不重要
 * 2. 参数列表的语法： 是0个以上的变量的声明语法。没有初始化操作
 * 3. 参数列表里的参数名，称为形式参数，简称形参。
 * 4. 形式参数用于规定调用者在调用期间需要传入的数据的具体类型
 * m1(int a, long b ,String c);
 * <p>
 * <p>
 * <p>
 * 拓展知识点：
 * 方法签名： 方法名+参数类型
 * 比如  m1(int a, long b ,String c)的方法签名： m1(int, long,String)
 * 在同一个类体重，不能存在方法签名相同的方法
 * m1( String a,long b,int c)      m1(String,long,int)
 * <p>
 * 5. 方法的重载：
 * 同一个类中，方法名相同，参数类型列表不同(方法签名不同)
 */

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


    }

    //案例1：
    public static void m1() {
        System.out.println("m1方法");
    }

    //案例2：方法签名 ： m2(int)
    public static void m2(int a) {
        System.out.println("m2方法" + a);
    }

    //案例3：方法签名 ： m3(long)
    public static void m3(int a) {
        System.out.println("m3方法" + a);
    }

    //是上面m3的重载方法
    public static void m3(int a, int b) {
        System.out.println("m3方法" + a);
    }

    //定义方法：计算三个数中的最大值
    public static int max(int a, int b, int c) {
        int max = Integer.MIN_VALUE; //int 的最小值
        if (a > b && a > c) {
            max = a;
        } else if (b > a && b > c) {
            max = b;
        } else {
            max = c;
        }
        return max;

    }
}

method_04MethDemo

package com.basic.day04.method;

/**
 * 方法的调用： 没有学习面向对象之前 方法都用static修饰。
 * 1. 调用语法： 方法名(有参传参)。
 * 注意： viod修饰的方法，一般都是上述语法调用
 * 其他返回值类型的方法，一般都是如下形式
 * 返回值类型 变量 = 方法名(有参传参)
 */

public class _04MethDemo {
    public static void main(String[] args) {
        /* 先演示没有形参列表的方法调用*/
        // void 形式的方法调用
        System.out.println("前");
        myMeth1();
        System.out.println("后");

        // 返回值是java类型的方法调用
        int sum = myMeth2();
        System.out.println("sum = " + sum);
        System.out.println( myMeth2());
    }

    public static void myMeth1() {
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println("a + b = " + c);
    }

    //计算1~100的和
    public static int myMeth2() {
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            sum += i;
        }
        return sum;
    }
}

branch_Exercise01

package com.basic.day04.branch;

import java.util.Scanner;


/**
 * 开启控制台扫描功能，扫描两个数字
 * year ：表示年份
 * month ：月份
 * <p>
 * 打印 输入的年份 是否闰年还是平年
 * 打印 输入的月份 是多少天。
 * 样式:
 * "2004是闰年，8月份有31天"
 * <p>
 * 闰年条件： 被4整除，不能被100整除
 */

public class Exercise01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个年份");
        int year = sc.nextInt();
        System.out.println("请输入一个月份");
        int month = sc.nextInt();

        //return： 用于结束当前方法，也不用再继续执行后续代码
        if (year % 4 == 0 && year % 100 != 0) {
            System.out.println(year + "闰年");
        } else {
            System.out.println(year + "平年");
        }
        switch ((int) month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month + "有31天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month + "有30天");
                break;

        }
        if (year % 4 == 0 && year % 100 != 0) {
            System.out.println(month + "有29天");
        } else {
            System.out.println(month + "有28天");
            sc.close();

        }
    }

}

branch_Exercise02

package com.basic.day04.branch;

import java.util.Scanner;

/**
 * 开启控制台扫描功能，扫描两个数字
 * year:表示年份
 * month:月份
 * <p>
 * 打印 输入的年份 是闰年还是平年
 * 打印 输入的月份 是多少天
 * <p>
 * 样式： "2004是闰年，8月份有31天"
 */
public class Exercise02 {
    public static void main(String[] args) {
        //开启控制台扫描功能
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个有效年份:");
        int year = sc.nextInt();
        System.out.println("请输入一个有效月份:");
        int month = sc.nextInt();
        if (month < 1 || month > 12) {
            System.out.println("输入不合理");
            return; //关键字 用于结束所在的方法，也就是不再继续执行后续的代码
        }

        String str = "";
        //定义一个变量flag，初始化为false，默认认为是平年
        boolean flag = false;
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            str = "闰年";
            flag = true;//表示闰年
        } else {
            str = "平年";

        }

        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(year + "是" + str + "," + month + "有31天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(year + "是" + str + "," + month + "有30天");
                break;
            case 2:
                if (flag == true) { //括号里的表达式整体的返回值是true
                    System.out.println(year + "是" + str + "," + month + "有29天");
                } else {
                    System.out.println(year + "是" + str + "," + month + "有28天");
                }
                sc.close();

        }
    }
}

loop_01ForDemo

package com.basic.day04.loop;

/**循环三要素：
 *    1. 循环因子的定义和初始化
 *    2. 循环条件
 *    3. 循环步长：循环因子要向着循环结束的方向而改变
 * 循环结构之for循环：
 *             1                2        3
 *    for(循环因子的声明和初始化;循环条件;循环步长){
 *        4循环体
 *    }
 *
 *   执行逻辑：
 *             成立              成立               不成立
 *      1 --> 2 --> 4 --> 3 --> 2 -->4 --> 3 --> 2 -->结束
 */

public class _01ForDemo {
    public static void main(String[] args) {
        /*使用for循环 打印10次 hello world*/
        for (int i = 1; i < 11; i++) {
            System.out.println("hello world");
        }

        /*使用for循环 打印1-10*/
        for (int x = 1; x <= 10; x++) {
            System.out.println(x);
        }
        /*使用for循环 打印2-20的偶数*/
        for (int i = 2; i <= 20; i += 2){
            System.out.println(i);
        }



    }

}

loop_02ForDemo

package com.basic.day04.loop;

/**
 * *****
 * *****
 * *****
 * *****
 * *****
 */

public class _02ForDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("*****");
        }
        /*使用for循环计算1~100的和*/
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            sum = sum+i;

        }
        System.out.println(sum);

    }
}

loop_03ForDemo

package com.basic.day04.loop;

/**
 *    for循环的其他写法
 *           1. for循环的小括号里除了分号，其他都可以省略
 *           2. 循环因子的声明和初始化，可以写在for循环之前
 *           3. 循环步长可以写在循环体里
 *           4. 循环条件可以不写，默认为true
 *
 */


public class _03ForDemo {
    public static void main(String[] args) {
        //三部分和循环条件都省略，相当于true，死循环 程序避免死循环
     /*   for( ;; ) {
            System.out.println("hello world");
        }*/

        //循环因子的声明和初始化写在了for循环之前
        int i= 1;
        for( ; i<10;i++ ) {
            System.out.println(i);
        }

        //循环步长，写在循环体内
        for(int m =1;m<10;) {
            System.out.println(m);
            m+=3; //循环步长

            //循环体里面只有一行代码，可以省略花括号
         for (int n = 1;n<10;n++)
             System.out.println(n);//缩进且一行

            //if分支只有一行代码 也可以省略花括号
         int x = (int) (Math.random()*2);
         int y = (int) (Math.random()*2);

            if (x == y)
                System.out.println("x==y");
            else
                System.out.println("x!=y");


        }

    }
}

loop_04WhileDemo

package com.basic.day04.loop;

/**
 * 循环结构之while循环
 * 语法：
 * while (循环条件){
 * 循环体
 * }
 */

public class _04WhileDemo {
    public static void main(String[] args) {
//        使用while循环打印5次的hello world
//        int i = 0; //循环要素声明初始化卸载while之前
//        while(i<5){
//            System.out.println("hello world");
//            i++;//写在循环体里面的循环步长
//        }

        //2 使用while循环 打印1~100以内能被5整除的数字
        int i = 1;
        while (i < 100) {
            if (i % 5 == 0) {
            }
            i++;
            System.out.println(i);
        }

        //3 使用while循环，计算1~100以内的能被3整除的数字之和
        int sum = 0;
        int x = 1;
        while (x < 100) {
            if (x % 3 == 0) {
                sum = sum + x;
                x++;
                System.out.println(sum);
            }
        }
            /*4使用while循环，判断一个整数，是几位数
                19876 /10   1987  5
                1987 /10    198   4
                198 /10     19    3
                19 /10      1     2
                1 /10       0     1
            */
        int num = 19876;
        int count = 1; // 统计循环的次数，除10的次数
        while (num /10 != 0) {//判断num是不是一位数，如果不是一位数就可以进入循环，是一位数则输出
            num = num / 10;
            count++;
        }
        System.out.println("是" + count + "位数");


    }

}

loop_05DoWhileDemo

package com.basic.day04.loop;

import java.util.Scanner;

/**
 * 循环结构之do-while循环
 * 语法：
 * do{
 * 循环体
 * }while(循环条件);
 * <p>
 * 特点：
 * 先执行一次循环体，然后再判断循环条件是否成立
 * 成立再次执行循环
 */

public class _05DOWhileDemo {
    public static void main(String[] args) {
        //使用for/while，来模拟一次ATM机输入密码操作，五次不正确结束循环。
        String realPWD = "123456";
        Scanner sc = new Scanner(System.in);

        boolean flag = false;//定义一个开关

        for (int i = 0; i < 5; i++) {
            System.out.println("请输入密码：");
            String inputPWD = sc.next();
            if (inputPWD.equals(realPWD)) {
                System.out.println("密码正确，欢迎进入！");
                flag = true;
                break;
            }
        }
        if (flag) {
            System.out.println("密码正确");
        } else {
            System.out.println("密码错误5次");
        }


    }
}

loop_06DeWhileDemo

package com.basic.day04.loop;

import java.util.Scanner;

/**
 * 用do-while循环完场——05内容
 *
 *   总结：for while do-while 的应用场景或者区别
 *     1. for循环适合知道循环次数的场景
 *     2. while循环适合不知道循环次数的场景
 *     3. do-while循环适合先执行循环体，再判断条件的场景，  比如 做一件事直到什么时候结束
 */

public class _06DoWhileDemo {
    public static void main(String[] args) {
        String str = "123456";
        Scanner sc = new Scanner(System.in);
        String inputPWD = "";
        do {
            System.out.println("请输入密码：");
            inputPWD = sc.nextLine();
        } while (!str.equals(inputPWD));
        System.out.println("密码正确");


    }
}

loop_07BreakDemo

package com.basic.day04.loop;

import java.util.Scanner;

/**
 * 循环结构中的关键字之 break
 * <p>
 * break：打断，毁坏
 * 在循环结构中，表示打断，结束循环，继续向下执行后续代码。
 * <p>
 * 注意，break只能打断当前所在的那一层循环，不能打断其他循环
 */

public class _07BreakDemo {
    public static void main(String[] args) {
        //从1开始打印到100，遇见10截止，结束循环
        for (int i = 1; i <= 100; i++) {
            if (i == 10) {
                break;
            }
            System.out.println(i);
        }

        //猜数字游戏的模拟
        Scanner sc = new Scanner(System.in);
        //模拟输入的数字
        int answer = (int) (Math.random() * 10);
        while (true) {
            System.out.println("猜数字");
            int guess = sc.nextInt();
            if (guess == answer) {
                System.out.println("猜对了");
                break;//打断跳出
            } else if (guess > answer) {
                System.out.println("猜大了");
            } else {
                System.out.println("猜小了");
            }

        }
    }


}

loop_08ContinueDemo

package com.basic.day04.loop;

/**
 * 循环结构中关键字只continue
 * <p>
 * 单词含义：继续
 * 在循环结构里面表示终止打断本次循环，继续下一次的循环
 */

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

        //需求1 计算100以内的偶数和，排除50
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i == 50) {
                continue;
            }
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

loop_09NextOfLoop

package com.basic.day04.loop;

/**
 * 循环的嵌套
 * 1. 循环结构是可以进行多层次嵌套的
 * 2. 在生产环境中，尽量不要嵌套，因为非常耗性能
 * <p>
 * <p>
 * <p>
 * 执行逻辑：
 * 外层循环执行一次，内层循环执行一遍(从开始到结束)
 */

public class _09NextOfLoop {
    public static void main(String[] args) {
        //案例
        for (int i = 0; i < 10; i++) {
            System.out.println("i=" + i);
            for (int j = 0; j < 10; j++) {
                System.out.println("j=" + j);
            }
        }
        System.out.println("---------------------------------");

        //使用输出语句打印一个*
        //打出图形如下  五行五列的*
        /*
         *****
         *****
         *****
         *****
         *****
         */
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println("*");
        }

        //判断 57是不是质数   质数只能被1和本身整除
        int num = 47;
        boolean found = false;//设置为false
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                found = true; //不是质数
                break;
            }
        }
        if (found == true) {
            System.out.println(num + "不是质数");
        } else {
            System.out.println(num + "是质数");

        }

        //打印100以内的所有质数
        for (int x = 2; x < 101; x++) {
            boolean temp = false;   //设置为false
            for (int i = 2; i < x; i++) {
                if (x % i == 0) {
                    temp = true; //不是质数
                    break;
                }
            }
            if (temp == false) {
                System.out.println(x + "是质数");
            }
        }


    }


}

luoyiang
关注
  • 13
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaBasic-抽象类-练习题
Arron博客
06-18 1736
抽象类练习题要求: * 定义一个抽象类Fruit * 抽象类中编写抽象方法 void eat(); * 定义两个子类, Apple, Orange * Apple 中重写eat 输出"苹果削皮吃" * Orange 中重写 eat 输出 "橘子剥皮吃" * 在 main 方法中 * 声明长度为 4 的 Fruit 数组 * 向数组中填入子类对象, 遍历输出 代码块 抽象类 Fruit.java ...
javabasic-day03
m0_64370841的博客
07-23 582
【代码】javabasic-day03。
黑马头条-day04&day05
hmmmgo的博客
02-12 1462
点击这里进行学习。1、定义feign接口2、定义跟feign接口对应的controller接口3、调用feign接口。
XX教育 - basic - day01
weixin_44354035的博客
08-13 88
XX教育1、day10）day1 day1.txt1）day1 helloword.java 1、day1 0）day1 day1.txt 1）day1 helloword.java package day01; //声明包day01 public class HelloWorld { //声明类HelloWorld //主方法，为程序的入口 //程序的执行从main开始，main结束则程序结束 public static void main(String[] args) { //输出Hell
Java EE企业级开发学习 -- day1
Cat God 007的博客
09-07 466
它是基于Java语言的一种软件设计体系结构，它是一种标准中间件体系结构。它的作用在于能标准化企业级多层结构应用系统的部署，并且简化开发环境。
JavaAPI操作HBase-Day2
m0_73450879的博客
04-03 840
使用Java代码实现HBase的新增，查询，删除命名空间以及表数据的CRUD。
Day11 - Day15
清影的博客
06-11 376
Day11 - Day15
java学习 day01_basic
weixin_43385930的博客
06-10 1456
①初识Java 文章目录①初识Java1. Java历史1.1 Java语言的诞生1.2 Java语言的发展历程2. Java主要用途3. JDK和JRE4. Java程序的运行原理5. Java语言的跨平台性6. Java语言的编译性和解释性7. Java开发工具②IDEA的使用1. 基础使用1.1 IDEA创建project1.2 IDEA创建module1.3 project和module的关系1.4 IDEA的src目录1.5 导入IDEA项目2. 必要设置2.2 去掉代码提示的大小写限制2.3 修
Day26-Java基础之正则表达式
m0_46053885的博客
04-28 2079
语法示例："." ： 匹配任何字符。"\d"：任何数字[0-9]的简写；"\D"：任何非数字[^0-9]的简写；"\s"： 空白字符：[ \t\n\x0B\f\r] 的简写"\S"： 非空白字符：[^\s] 的简写"\w"：单词字符：[a-zA-Z_0-9]的简写"\W"：非单词字符：[^\w]代码示例：//.表示任意一个字符System.out.println("你".matches(".."));//false。
2021-02-26java学习第四天：IDEA使用，方法的复习和重载
qq_41179957的博客
02-26 124
学习目标： 掌握 Java 入门知识 学习内容： java学习第四天：IDEA使用，方法的复习和重载 1、IDEA使用 Integrated Development Environment IDE 集成开发环境 开发java程序步骤： 编写代码 启动cmd 调用javac编译 调用java运行 IDEA的项目结构： 项目-Project 模块-Module 包-Package 文件.Java IdeaProjects\basic-code Module: day04 src:可以建立包，packag
CMS-day04
demoBigChen的博客
05-28 216
CMS-day04 一、使用freemaker（比较流行的模板技术） 步骤： 1.导包(freemarker是一个小框架) 2.创建一个配置对象Configuration(加个版本) Configuration cfg = new Configuration(Configuration.VERSION_2_3_28); 3.设置加载路径 String realPath = req.get...
Java开发工具IntelliJ IDEA的安装、配置与常用快捷键，方法的定义、调用、格式与注意事项，方法的重载-day04
ShuYY的博客
08-07 675
目录第一节 开发工具IntelliJ IDEA1.1 开发工具概述1.2 IDEA软件安装1.3 IDEA破解1.4 新建Java项目新建包和类1.5 字体设置1.6 IDEA的项目目录1.7 IDEA常用快捷键【非常常用】1.8 IDEA修改快捷键1.9 IDEA导入和关闭项目第二节 方法2.1 方法的定义和调用2.2 定义方法的格式详解2.3 定义方法的两个明确2.4 调用方法的流程图解2.5 定义方法练习练习一 ：比较两个整数是否相同练习二 : 计算1+2+3...+100的和练习三 :实现不定次数打
JSD-2204-使用Idea启动Nacos-创建csmall项目-Dubbo-Day03
TheNewSystrm的博客
08-22 717
JSD-2204-使用Idea启动Nacos-创建csmall项目-Dubbo-Day03
蓝桥杯——BASIC-5——基础练习 查找整数
qq_54631286的博客
03-04 645
问题描述： 给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。 输入格式： 第一行包含一个整数n。 第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。 第三行包含一个整数a，为待查找的数。 输出格式： 如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。 数据规模与约定：1 <= n <= 1000。 代码如下： package day; import java.util.Scanner; public
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 477
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 5874
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 6186
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 3963
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2487
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
Java核心技术：day034 反射入门 - Class类与异常处理
在Java学习day034中，我们深入探讨了反射（Reflection）这一核心概念，特别是与Class类、异常处理以及利用反射分析类的能力相关的知识点。反射库是Java提供的一种强大的工具集，它允许开发者在运行时动态地操纵和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值