数据类型与变量，以及运算符的大篇章详细内容总结和感受（什么居然有一万多字！！！）

已于 2023-12-10 22:54:43 修改
阅读量107 收藏 5
点赞数 8
文章标签： java 学习
于 2023-12-10 22:50:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qwe_Jjh/article/details/134865007
版权

JAVASE--NO.3day(为期三个月的成长过程)

  数据类型与变量，以及运算符的大篇章详细内容总结和感受

1. 字面常量

   1.1什么是常量

      System.Out.println("Hello World") ； 语句，不论程序何时运行，输出的都是 Hello
World ，其实 "Hello World" 就是字面常量。 
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");  //这个就是字面常量
    }
}

   1.2字面常量的分类

  1. 字符串常量：由 "" 括起来的，比如 “12345”、“hello”、“你好” 。
  2. 整形常量：程序中直接写的数字 ( 注意没有小数点 ) ，比如： 100、 1000。
  3. 字符常量：由 单引号 括起来的当个字符，比如： ‘A’、 ‘1’。
  4. 布尔常量：只有两种 true 和 false 。
  5. 浮点数常量：程序中直接写的小数，比如： 3.14、 0.49。

2. 数据类型

   2.1基本数据类型和引用数据类型

       2.11基本数据类型分为四类八种

       1. 四类：整型、浮点型、字符型以及布尔型
       2.八种

注意：
  • 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
  • 整形和浮点型都是带有符号的
  • 整型默认为int型，浮点型默认为double
  • 字符串属于引用类型

详细笔记在Gitee：https://gitee.com/jing-junhao/java-se/tree/master/%E6%9D%BF%E4%B9%A6 

新问题：这里会有一个新的问题字节是什么？
字节是计算机中表示空间大小的基本单位 .
计算机使用二进制表示数据 . 我们认为 8 个二进制位 (bit) 为一个字节 (Byte).
我们平时的计算机为 8GB 内存 , 意思是 8G 个字节 .
其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
所以 8GB 相当于 80 多亿个字节 .

3.变量

    3.1变量的概念

     * 对 于这些经常改变的内容，在 Java 程序中，称为变量 。 而数据类型就是用来定义不同种类变量的 。

定义变量的语法格式为： 数据类型 变量名 = 初始值 

public class Test {
    public static void main(String[] args) {
        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
        double d = 3.14;
        char c = 'A';
        boolean b = true;
        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(b);
        a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
        System.out.println(a);
// 注意：在一行可以定义多个相同类型的变量
        int a1 = 10, a2 = 20, a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

    }
}

输出结果如图： 

    3.2整型变量

注意事项：
  1.  int不论在何种系统下都是4个字节
  2.  推荐使用方式一定义，如果没有合适的初始值，可以设置为0
  3.  在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
  4.  变量在使用之前必须要赋初值，否则编译报错
  5.  int的包装类型为 Integer（特殊）

代码如下： 

public class Test {
    public static void main(String[] args) {
        // 方式一：在定义时给出初始值
        int a = 10;
        System.out.println(a);
// 方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b = 10;
        System.out.println(b);
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
//        int c;
//        System.out.println(c);
//        c = 100;
// int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Integer.MAX_VALUE);// 2147483647
// 注意：在定义int性变量时，所赋值不能超过int的范围
      //  int d = 12345678901234; // 编译时报错，初值超过了int的范围
    }

方法二报错： 

   3.3长整型变量

注意事项：
  1.  长整型变量的初始值后加L或者l，推荐加L（不然容易将l看成1，所以推荐L）
  2.  长整型不论在那个系统下都占8个字节
  3.  长整型的表示范围为：-2的63次方 ~ 2的63次方减一
  4.  long的包装类型为Long

代码如下： 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 10; // long定义的长整型变量
        long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
        long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
        System.out.println(Long.MIN_VALUE);//-9223372036854775808
        System.out.println(Long.MAX_VALUE);//9223372036854775807
    }

   3.4短整型变量

注意事项：
  1.  short在任何系统下都占2个字节
  2.  short的表示范围为：-32768 ~ 32767
  3.  使用时注意不要超过范围(一般使用比较少)
  4.  short的包装类型为Short

代码如下： 

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);//输出10
// short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);//-32768
        System.out.println(Short.MAX_VALUE);//32767

    }

   3.5字节型变量

注意事项：
  1.  byte在任何系统下都占1个字节
  2.  byte的范围是：-128 ~ 127
  3.  （byte）字节的包装类型为Byte

代码如下： 

public class Test {
    public static void main(String[] args) {
        byte b = 10;
        System.out.println(b);
// byte型变量所能表示的范围：
        System.out.println(Byte.MIN_VALUE);//-128
        System.out.println(Byte.MAX_VALUE);//127

    }
    byte，short，long，int都可以定义整形变量那为什么要给4种不同的类型呢？

因为存在即合理，就如同逛超市，需要什么买什么，不浪费，物尽其用！！！

3.6浮点型变量

   3.61双精度浮点型
注意事项：
  1.  double在任何系统下都占8个字节
  2.  浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算
  3.  double的包装类型为Double
  4.  double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势 必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

代码如下： 

public class Test {
    public static void main(String[] args) {
        double d = 3.14;
        System.out.println(d);//输出3.14
        int a = 1;
        int b = 2;
        System.out.println(a / b); // 输出 0.5嘛？
        //在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 0.5, 需要使用 double 类型计算.
        double e = 1.0;
        double f = 2.0;
        System.out.println(e / f);//输出0.5
    }
    3.62单精度浮点型
  • float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数 都优先考虑 double, 不太推荐使用 float.
  • float的包装类型为Float。

代码如下：  

public class Test {
    public static void main(String[] args) {
        float num = 1.0f; // 写作 1.0F 也可以
        System.out.println(num);//输出1.0
    }

   3.7字符型变量

  1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
  2.  计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.
  3. char的包装类型为Character

代码如下： 

public class Test {
    public static void main(String[] args) {
        char c1 = 'A'; // 大写字母
        char c2 = '1'; // 数字字符
        System.out.println(c1);
        System.out.println(c2);
// 注意：java中的字符可以存放整形
        char c3 = '张';
        System.out.println(c3);
    }
}

   3.8布尔型变量

  1.  boolean 类型的变量只有两种取值, true 表示真, false 表示假.
  2.  Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
  3.  Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。（当面面试官闻问boolean占几个字节时，可以说没有规定）
  4.  boolean的包装类型为Boolean。
public class Test {
    public static void main(String[] args) {
        boolean b = true ;
        System.out.println(b);
        boolean c = false;
        System.out.println(c);
    }

4.类型转换

    在 Java 中，当参与运算数据类型不一致时，就会进行类型转换。 Java 中类型转换主要分为两类：自动类型转换 (隐式) 和 强制类型转换(显式) 。 
public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // 可以通过编译
        System.out.println(b);//输出10
        //a = b; // 编译失败 java: 不兼容的类型: 从long转换到int可能会有损失
    }
    4.1自动类型转换(隐式)
  1. 自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
  2. 特点：数据范围小的转为数 据范围大的时会自动进行。 
public class Test {
    public static void main(String[] args) {
        System.out.println(1024); // 整型默认情况下是int
        System.out.println(3.14); // 浮点型默认情况下是double
        int a = 100;
        long b = 10L;
        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        System.out.println(b);
        //a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
        float f = 3.14F;
        double d = 5.12;
        d = f; // 编译器会将f转换为double，然后进行赋值
       // f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
       // byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失
    }
    4.2强制类型转换(显式)  
  1. 强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。
  2. 特点：数据范围大的到数据范围小的。
  public static void main4(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
      //  a = d; // 报错，类型不兼容
        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
        boolean flag = true;
}

注意事项：
  1.     不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
  2.     如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
  3.     将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
  4.     强制类型转换不一定能成功，不相干的类型不能互相转换  

类型提升这里提醒一下 ：不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。（int与long之间：int会被提升为long .对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.  ）

重点如下：

代码演示： 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        //int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
        byte e = 10;
        byte f = 20;
        byte g = (byte)(e + f);
        System.out.println(g);//输出30
    }

5.运算符

        作为一门计算机语言， Java 也提供了一套丰富的运算符来操纵变量。 Java 中运算符可分为以下：算术运算符 (+ - * /)、关系运算符 (< > ==) 、逻辑运算符、位运算符、移位运算符以及条件运算符等。
注意：运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可.

   5.1算术运算符

   1. 基本四则运算符：加减乘除模  (+ - * /)（%）
public class Test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
        System.out.println(a / b);
// 如果要得到数学中的结果，可以使用如下方式
        double d = a*1.0/ b;
        System.out.println(d);//输出1.5
//        int a = 1;
//        int b = 0;
//        System.out.println(a / b)
// 运行结果
   //     Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.main(Test.java:5)
//        int a = 20;
//        int b = 10;
//        double c = 11.5;
//        double d = 2.0;
//        System.out.println(a + b); // 30
//        System.out.println(a - b); // 10
//        System.out.println(a * b); // 200
//        System.out.println(a / b); // 2
//        System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数
//        System.out.println(c % d);//   %  求余数输出  1.5
    }
注意：
  1. 都是二元运算符，使用时必须要有左右两个操作数
  2. int / int 结果还是int类型，而且会向下取整
  3. 做除法和取模时，右操作数不能为0
  4. % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的
  5. 两侧操作数类型不一致时，向类型大的提升
   2.增量运算符 += -= *= %= 
  • 该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。
  • 注意：只有变量才能使用该运算符，常量不能使用。 
    public static void main(String[] args) {
        int a = 1;
        a += 2; // 相当于 a = a + 2
        System.out.println(a); // 输出3
        a -= 1; // 相当于 a = a - 1
        System.out.println(a); // 输出2
        a *= 3; // 相当于 a = a * 3
        System.out.println(a); // 输出6
        a /= 3; // 相当于 a = a / 3
        System.out.println(a); // 输出2
        a %= 3; // 相当于 a = a % 2
        System.out.println(a); // 输出2
    }
    3. 自增/自减运算符 ++ --
注意：
  1. 如果单独使用，【前置++】和【后置++】没有任何区别
  2. 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1
  3. 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改 
    public static void main(String[] args) {
        int a = 1;
        a++; // 后置++ 表示给a的值加1，此时a的值为2
        System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
        System.out.println(a); // 输出3
        ++a; // 前置++ 表示给a的值加1
        System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
        System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似
    }

   5.2关系运算符  

   关系运算符主要有六个 : == != < > <= >= ，其计算结果是 true 或者 false 。
   注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

   

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
        System.out.println(a == b); // false
        System.out.println(a != b); // true
        System.out.println(a < b); // true
        System.out.println(a > b); // false
        System.out.println(a <= b); // true
        System.out.println(a >= b); // false
    }

   5.3逻辑运算符(重点)  

   逻辑运算符主要有三个 : && || ! ，运算结果都是 boolean 类型。
    5.3.1. 逻辑与 &&
  1. 语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
  2. 相当于现实生活中的且，比如：如果是学生，并且 带有学生证 才可以享受半票。
  3. 两个表达式都为真，结果才是真，只要有一个是假，结果就是假

 

  public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
    }
    5.3.2. 逻辑 ||
  1. 语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。
  2. 相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，
  3. 否则站一边去。
  4. 注意：左右表达式至少有一个位真，则结果为真
表达式1表达式2结果
真真真
真假真
假真真
假假假
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
    }
   5.3.3. 逻辑非 !
  1. 语法规则：! 表达式
  2. 真变假，假变真

 

   public static void main(String[] args) {
        int a = 1;
        System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
        System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
    }
    5.3.4. 短路求值

  • && 和 || 遵守短路求值的规则.
  • 我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.
注意 :
  1. 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
  2. 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
  3. & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值. 
   public static void main(String[] args) {
        System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
        System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
       //输出： Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.main(Test.java:5)
    }
    5.3.5. 位运算符
  • 位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
  • 位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算
  • Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据
1. 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.  
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);//输出0
    }

进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100 

 

这个怎么看呢？？怎么将变量转化为二进制？   

2. 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
  public static void main(String[] args) {
      int c = 10;
        int d = 20;
        System.out.println(c | d);//输出30
  }
注意 : 当 & 和 | 的操作数为整数 (int, short, long, byte) 的时候 , 表示按位运算 , 当操作数为 boolean 的时候 , 表示逻辑运算
3. 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0 
    public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);//输出fffffff0
    }
注意 :
  • 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位.
  • 0xf 表示 10 进制的 15, 也就是二进制的 1111
  • printf 能够格式化输出内容, %x 表示按照十六进制输出.
  • \n 表示换行符
4. 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.（注意：如果两个数相同，则异或的结果为0 ）
    public static void main(String[] args) {
        int a = 0x1;
        int b = 0x2;
        System.out.printf("%x\n", a ^ b);//输出3
    }
5. 移位运算
移位运算符有三个 : << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

1. 左移 <<: 最左侧位不要了, 最右侧补 0.

int a = 0x10 ;
System . out . printf ( "%x\n" , a << 1 );
// 运行结果 ( 注意 , 是按十六进制打印的 ) 20

注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数 

2. 右移 >> : 最右侧位不要了 , 最左侧补符号位 ( 正数补 0, 负数补 1)
int a = 0x10 ;
System . out . printf ( "%x\n" , a >> 1 );
// 运行结果 ( 注意 , 是按十六进制打印的 )
8
int b = 0xffff0000 ;
System . out . printf ( "%x\n" , b >> 1 );
// 运行结果 ( 注意 , 是按十六进制打印的 )
ffff8000

3. 无符号右移 >>>: 最右侧位不要了, 最左侧补 0. 

int a = 0xffffffff ;
System . out . printf ( "%x\n" , a >>> 1 );
// 运行结果 ( 注意 , 是按十六进制打印的 )
7f ffffff
注意 :
  • 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
  • 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
  • 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
  • 移动负数位或者移位位数过大都没有意义.
6. 条件运算符  
  • 表达式1 ? 表达式2 : 表达式3
  • 当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
  • 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
  • 也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法
    public static void main(String[] args) {
        // 求两个整数的最大值
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);//输出20
    }

好啦，看到这里是不是该点赞关注啦，谢谢啦！！！

Responsibility-Q
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
整理大厂高频核心前端面试题，五万多字，面试必考
猫老板的豆
09-13 2404
如果 Vue 组件中的 data 是个对象，那么所有复用这个组件的地方，都在使用这个组件里面唯一的一个 data，所有使用组件的地方的 data 都会指向栈内这一个 data 的地址，那么会造成。等待执行栈和微任务队列都执行完毕才会执行，并且在执行完每一个宏任务之后，会去看看微任务队列有没有新添加的任务，如果有，会先将微任务队列中的任务清空，才会继续执行下一个宏任务。异步：是指不进入主线程，而进入任务队列的任务，只有任务队列通知主线程，某个异步任务可以执行了，该任务才会进入主线程。
c++综合知识代码//游戏 寻宝猎人5！//一万三千多行哟 点个赞吧！
09-04
这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是一个寻宝游戏，一万多行！这是...
【简单地过一遍C语言基础部分】所有知识点，点到为止！（仅一万多字）
热门推荐
曾用名：柠檬叶子C
09-24 3万+
就在前几天，C语言入门到进阶部分的专栏——《维生素C语言》终于完成了。全文共计十八个章节并附带三张笔试练习篇，美中不足的是，第一章和第二章是以截图形式展现的。由于本人一开始是在有道云笔记上写的初稿，当时想方便省事（有道云排版个人感觉确实比较美观）就直接以截图的形式完成了第一章和第二章。本人考虑到因为是截图，不能复制文中出现的代码，不方便读者进行复制粘贴，所以我打算重新写一下第一章和第一章的内容，并且重新进行了排版。
猿创征文｜C语言操作符（运算符）一万多字的详细解析
ANNE_fly的博客
09-02 531
猿创征文｜C语言操作符（运算符）一万多字的详细解析
【简单地过一遍C语言基础部分】所有知识点，点到为止！（仅一万多字(2)
2401_84538612的博客
05-06 757
🔨 编译 + 链接 + 运行代码快捷键：Ctrl + F5VS2013[调试] -> [选择' 开始执行（不调试）']❓ “是不是有什么一闪而过了？因为程序执行得太快，所以没有看到结果。为了看到结果，我们需要设置一下VS2013的属性 （VS2019不需要设置项目属性 ）[解决方案资源管理器] -> [右键项目名称] -> [属性] -> [链接器] -> [系统]-> [子系统] -> [选择' 控制台(/SUBSYSRTEM:CONSOLE) ']❓ 什么是算数操作符？
【软件工程】软件安全技术 全章节 两万字总结！
Mr.zwX
06-20 1122
Typora要搭图床才能很方便地移植图片，考虑到这次总结的内容比较繁杂，那么这次软件安全的整理就直接在博客上写。 . 软件安全技术 . 文章目录CH01 软件与软件安全1.1 计算环境与软件1.1.1 计算环境1.1.2 二进制1.1.3 指令与指令集1.1.4 软件的形式和概念1.1.4.1 软件概念1.1.4.2 软件主要内容1.1.4.3 软件的形式1.2 信息安全与软件安全1.2.1 信息与信息安全1.2.2 软件安全概念1.3 软件安全的几个重要概念1.3.1 漏洞和脆弱性1.3.2 软件质量与安
四万多字的SpringMVC学习总结,带你领略不一样的SpringMVC
weixin_47303191的博客
04-01 390
SpringMVC是SSM框架控制视图的一层,该框架可以和一些前端的模板解析引擎结合,灵活地进行一些视图数据处理工作.
c++指针最全总结(附源码和详细总结)
我的博客
04-08 1万+
哈喽，我又来啦😄 hello😄 我是「 YR_T 」 众所周知 c++相对于其它语言的 优势就在与c++有「 指针 」 可能你之前有学习过指针 可是 你真的把指针彻底搞懂了吗🤔 如果还没有，那再来复习一下💡 ...
近三万字长文！让你懂透编译原理(三)——第三章 词法分析
小哨的博客
03-29 5213
独家思维导图！让你秒懂编译原理(三)——第三章 词法分析 文章目录独家思维导图！让你秒懂编译原理(三)——第三章 词法分析3.1 对于词法分析器的要求3.1.1 词法分析器的功能和输出形式3.1.1 词法分析器作为一个独立子程序3.2 词法分析器的设计3.2.1 输入、预处理过程3.2.2 单词符号的识别:超前搜索3.2.3 状态转换图1) 概念2) 例子3) 状态转换图的实现全局变量与过程4) 词法分析器的实现识别标识符（0→1→2）识别整常数，=，+（0→3→4，0→5，0→6）识别* | , | (
适用于图像分类识别-医学OCT视网膜疾病识别分类数据集(一万多张，已划分训练、验证、测试数据).zip
04-07
适用于图像分类识别-医学OCT视网膜疾病识别分类数据集(一万多张，已划分训练、验证、测试数据).zip 适用于图像分类识别-医学OCT视网膜疾病识别分类数据集(一万多张，已划分训练、验证、测试数据).zip 适用于图像分类...
从大公司到创业公司，技术人转型怎样转变思路与处事之道？
02-25
本文作者将从自己的工作经历出发，从工程师择业的角度，与观众产生共鸣，从大公司到创业公司，需要转变的思路与做事情的方法，有原则性的东西，也有真实案例与身边的故事，还会穿插一些工程师的软技能。注：本文整理...
c++小游戏中级终端（一万多行）（原创）
07-26
大家快来看！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ 我天天编，希望大家可以快乐一下...我天天编，希望大家可以快乐一下大家
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1625
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
java环境部署
JiuMeilove的博客
06-04 389
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 574
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1431
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1260
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
easyexcel导出限制在6六万多数据
03-25
如果数据量过大，会导致内存溢出或者程序运行速度缓慢。因此，为了避免这种情况的发生，EasyExcel对导出的数据量设定了最大限制。 如果需要导出更大量的数据，可以考虑使用其他的Excel导出工具，或者对数据进行分批...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Responsibility-Q

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

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

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

打赏作者

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

抵扣说明：

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

余额充值