首页 > 编程语言 >Java 变量和运算符

Java 变量和运算符

时间：2024-12-24 23:30:32浏览次数：3  
标签：Java 变量 int System 运算符 println out

Java 变量和运算符

万物皆数 ——— 毕达哥拉斯

1. 变量（Variable）

1.1 何为变量

方程 $y = x^2 + 1 $ 中的 \(y,x\) 就是变量，计算机中的变量不是简单出现在纸面上，需要存储在内存中。计算机的内存就像一栋酒店，酒店有许多房间，每个房间都可以用于存储数居，这些数据就叫做变量，并且是可以人为修改的（所以叫变量）。变量有不同类型，比如整数、小数、字符等，所以根据不同类型就需要划分变量类型，以适配不同大小的存储空间。另外，为了使用变量，就要给变量赋予变量名（类似房间的门牌号）。

  • 变量构成三要素：变量类型、变量名、变量值
  • 变量声明的格式：数据类型 变量名 = 变量值
  • 变量的作用：用于在内存中保存数据
变量_JVM内存

使用变量注意：

  • 每个变量必须先声明，后使用
  • 使用变量名来访问某区域的数据
  • 变量的作用域：其定义所在的一对{ }内
  • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用
  • 同一个作用域内，不能定义重名的变量

1.2 数据类型（Data Types）

每个变量一定有数据类型。Java中数据类型分为两大类：

  • 基本数据类型： 整型、浮点数类型、字符类型、布尔类型

  • 引用数据类型：数组、 类、接口、枚举、注解、记录

Java数据类型

1.2.1 整型：byte、short、int、long

byte_short_int_long

  • 定义long类型的变量，赋值时需要以"l"或"L"作为后缀。

  • Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

  • Java的整型常量默认为 int 型。

  • Java各整数类型有固定的表示范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

  • C语言中没有byte类型
  • C语言中的数居类型可能会随着计算机字长不同而改变，例如指针和long型在32位系统中占4个字节，在64位系统中占8个字节

1.2.2 浮点类型：float、double

float_double

  • Java 浮点类型有固定的表数范围和字段长度，不受具体操作系统的影响。

  • 浮点型常量有两种表示形式：

    • 十进制数形式。如：5.12 、 512.0f 、 .512 （必须有小数点）
    • 科学计数法形式。如：5.12e2 、 512E2 、 100E-2

  • float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

  • double：双精度，精度是float的两倍。通常采用此类型。

  • 定义float类型的变量，赋值时需要以"f"或"F"作为后缀。

  • Java 的浮点型常量默认为double型。

关于浮点型精度的说明

因为在计算机中，浮点数采用的是IEEE 754 标准表述。然而，并不是所有的小数都能可以精确的用二进制浮点数表示。如果一个分数使用基数（2）的质因数（即2）来表示，那么它可以被精确地表示。例如，1/2、1/4 和 1/8 可以被精确地表示。而 1/5 (0.2) 或 1/10 (0.1) 是二进制中无限循环的小数，因为分母使用了 5 或 10 的质因数。既然是无限循环小数，在计算机中就存在截断，使用有限位数的小数来近似表示。

    //测试1：
    System.out.println(0.1 + 0.2);// 0.30000000000000004
    System.out.println(0.1f + 0.2f);// 0.3
    System.out.println(6 * 0.1);// 0.6000000000000001
    System.out.println(0.11 + 0.12);// 0.22999999999999998 
    System.out.println(0.1 + 0.7);// 0.7999999999999999
    System.out.println(0.3 + 0.6);// 0.8999999999999999

    //测试2：
    float ff1 = 123123123f;
    float ff2 = ff1 + 1;
    System.out.println(ff1);// 1.2312312E8
    System.out.println(ff2);// 1.2312312E8
    System.out.println(ff1 == ff2);// true

1.2.3 字符类型：char

  • char 型数据用来表示通常意义上“字符”（占2字节）

  • Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

  • 字符型变量的三种表现形式：

    • 形式1： 使用单引号(' ')括起来的单个字符。

      例如：char c1 = 'a'； char c2 = '中'； char c3 = '9';

    • 形式2： 直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

      例如：\u0023 表示 '#'。

    • 形式3： Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

      例如：char c3 = '\n'; // '\n'表示换行符

转义字符 说明 Unicode表示方式
\n 换行符 \u000a
\t 制表符 \u0009
\" 双引号 \u0022
\' 单引号 \u0027
\\ 反斜线 \u005c
\b 退格符 \u0008
\r 回车符 \u000d
  • char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

1.2.4 布尔类型：boolean

  • boolean 类型用来判断逻辑条件，一般用于流程控制语句中

  • boolean类型数据只有两个值：true、false

    • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
    • 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》

  • 举例：

    boolean isFlag = true;

    if(isFlag){
        //true分支
    }else{  
        //false分支
    }

1.3 变量的使用

1.3.1 步骤1：变量的声明

    //整数类型：月份
    int month; 

    //浮点类型：价格
    double price;

    //单字符类型：性别
    char gender;

    //布尔类型：婚姻状态
    boolean isMarried;

    //字符串类型：姓名
    String name;

    //声明多个同类型的变量
    int a,b,c; //表示a,b,c三个变量都是int类型。

1.3.2 步骤2：变量的赋值

方式1：声明的同时赋值

    int age = 18;

    float salary = 100.45f;

方式2：将合适类型的常量值给已经声明的变量赋值

    int month;
    month = 10;

    double price;
    price = 199.75;

    char gender;
    gender = '女';

方式3：用其他变量或者表达式给变量赋值

    int m = 1;
    int n = m;
            
    int x = 1;
    int y = 2;
    int z = x + y;

方式4：变量可以反复赋值

    //先声明，后初始化
    char gender;
    gender = '女';

    //给变量重新赋值，修改gender变量的值
    gender = '男';
    System.out.println("gender = " + gender);//gender = 男

1.4. 基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（char、byte、short、int、long、float、double）变量经常需要进行相互转换。这就涉及到了“向上转换”和“向下转换”两种转换方式。本质上是对数值精度的取舍。

转换的方式有两种：自动类型提升和强制类型转换。

1.4.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

类型转换

（1）当把存储范围小的值赋值给存储范围大的变量时，自动完成提升

  int i = 'A';// char自动升级为int，其实就是把字符A的编码值（65）赋值给变量i
  double d = 10;// int自动升级为double
  long num = 1234567; // 右边的整数常量值在int范围，编译和运行都可以通过，这里涉及到数据类型转换int升级为long

  //byte bigB = 130;// 错误，右边的整数常量值超过byte范围（最大127）
  long bigNum = 12345678912L;// 右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

  int i = 1;
  byte b = 1;
  double d = 1.0;

  double sum = i + b + d;// 混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

  byte b1 = 1;
  byte b2 = 2;
  byte b3 = b1 + b2;// 编译报错，b1 + b2自动升级为int

  char c1 = '0';
  char c2 = 'A';
  int i = c1 + c2;// 至少需要使用int类型来接收
  System.out.println(c1 + c2);// 48 + 65 = 113

1.4.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？肯定无法赋值。

  int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值，这将必然带来精度的损失或者溢出。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型需要手动完成。

转换格式：

  数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

（1）当把存储范围大的值强制转换为存储范围小的变量时，可能会损失精度或溢出。

  int i = (int)3.14;//损失精度 i = 3

  double d = 1.2;
  int num = (int)d;//损失精度

  int i = 200;
  byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

  int i = 1;
  int j = 2;
  double num1 = (double)(i/j);// num1 = 0.0 这是由于i/j=0，再强制转换成double后num1就变为0.0

  int num2 = i/j;// num2 = 0

  double k = 2;// 或者 k = 2.0
  double num3 = i/k;// num3 = 0.5

  System.out.println(1./2);// 0.5
  System.out.println(1/2.);// 0.5

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

  long l1 = 123L;
  long l2 = 123;//此时可以看做是int类型的123自动类型提升为long类型

  //long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
  long l4 = 123123123123L;


  //float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
  float f2 = 12.3F;
  float f3 = (float)12.3;

1.5 基本数据类型与String的运算

  • String不是基本数据类型，属于引用数据类型。
  • 使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
  • 声明方式与基本数据类型类似。例如：String str = “Java教程”;

运算规则

（1）任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

  System.out.println("" + 1 + 2);//字符类型12

  int num = 10;
  boolean b1 = true;
  String s1 = "abc";

  String s2 = s1 + num + b1;
  System.out.println(s2);//abc10true

  //String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
  String s4 = num + (b1 + s1);//编译通过

（2）String类型不能通过强制类型()转换，转为其他的类型

  String str = "123";
  int num = (int)str;//错误的

  int num = Integer.parseInt(str);//正确，包装类

2. 运算符（Operator）

有了变量就可以进行运算了。运算符就是变量之间运算、比较、赋值等操作的符号。
运算符可以按照不同种类进行分类：

  • 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符
分类 运算符
算术运算符（7个） +、-、*、/、%、++、--
赋值运算符（12个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
比较(或关系)运算符（6个） >、>=、<、<=、==、!=
逻辑运算符（6个） &、|、^、!、&&、||
位运算符（7个） &、|、^、~、<<、>>、>>>
条件运算符（1个） (条件表达式)?结果1:结果2
Lambda运算符（1个） ->
  • 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
分类 运算符
一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~
二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符） (条件表达式)?结果1:结果2

2.1 算数运算符

+、-、*、/、%（取模）没什么好说的。主要理解++（自加）、--（自减）运算符

  • ++与--是连体操作符，中间不能有空格
  • ++ 运算，表示自增1
  • -- 运算，表示自减1

（1）单独使用

  • 变量在单独运算的时候，变量i++和变量++i没有区别
public class AddTest1{
    public static void main(String[] args) {
      
        int i = 3;
        //++i;
        i++;
        // 无论是变量前++还是变量后++，结果都是4
        System.out.println(i);
    }
}

（2）复合使用

和其他变量放在一起使用或者和输出语句放在一起使用，++和--的位置不同所代表的含义也不同

  • j = i++ 等价于 j = i, i = i + 1，即先将i的值赋给j，然后i再自增
  • j = ++i 等价于 i = i + 1, j = i，即先将i自增，再将自增结果赋给j
public class AddTest2{
    public static void main(String[] args) {
        
        int x = 3;
        //int y = ++x; // y的值是4，x的值是4，
        int y = x++; // y的值是3，x的值是4
        
        System.out.println(x);
        System.out.println(y);
        System.out.println("==========");
            
        // 和输出语句一起
        int z = 5;
        //System.out.println(++z);// 输出结果是6，z的值也是6
        System.out.println(z++);// 输出结果是5，z的值是6
        System.out.println(z); 
    } 
}

一个小坑：i = i++

public class AddTest3{
    public static void main(String[] args) {
        
        int i = 10;
        i = i++;
        System.out.println(i);// i = 10
    }
}

我们可以通过Java的字节码文件查看更加仔细的操作


 0 bipush 10       // 生成整数 10
 2 istore_1        // 将整数10赋值给1号存储单元，即 i = 10
 3 iload_1         // 将1号存储单元的值加载到数据栈，即i = 10，栈顶值为10
 4 iinc 1 by 1     // 1号存储单元的值+1，此时i = 11
 7 istore_1        // 将数据栈的值（10）取出来赋给1号存储单元，即i = 10
 8 getstatic #7 <java/lang/System.out : Ljava/io/PrintStream;>
11 iload_1
12 invokevirtual #13 <java/io/PrintStream.println : (I)V>
15 return

Java中i++和++i都只能是右值，不能是左值。这和C语言不同，C语言中i++只能是右值，++i可以是左值，也可以是右值。当两者操作无异时，一般建议使用++i。

2.2 赋值运算符

  • 符号：=

    • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
    • 支持连续赋值。

  • 扩展赋值运算符： +=、 -=、*=、 /=、%=

  • 原理：$ A x= B $ 相当于 $ A = AxB \( 即将符号`左边的值`和`右边的值`进行\)x$操作，最后将结果赋值给左边的变量

public class SetValueTest{
    public static void main(String[] args) {
        int i1 = 10;
        long l1 = i1; //自动类型转换

        byte bb1 = (byte)i1; //强制类型转换

        int i2 = i1;

        //连续赋值的测试
        //以前的写法
        int a1 = 10;
        int b1 = 10;
        
        //连续赋值的写法
        int a2,b2;
        a2 = b2 = 10;
        
        int a3 = 10,b3 = 20;

        //举例说明+=  -=  *=  /=   %=  
        int m1 = 10;
        m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
        System.out.println(m1);//15
        
        
        // 加2操作
        //写法1：推荐
        short s1 = 10;
        s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
        System.out.println(s1);//12
        //写法2：
        short s2 = 10;
        //s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
        s2 = (short)(s2 + 2);
        System.out.println(s2);


        // 加一操作
        //写法1：推荐
        int num1 = 10;
        num1++;
        System.out.println(num1);

        //写法2：
        int num2 = 10;
        num2 += 1;
        System.out.println(num2);

        //写法3：
        int num3 = 10;
        num3 = num3 + 1;
        System.out.println(num3);

    }
}

2.4 逻辑运算符

2.4.1 基本语法

逻辑表

  • 逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。

  • 运算符说明：

    • & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
    • | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
    • ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
    • ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
      • 理解：异或，追求的是“异”！

  • 逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。

  • 区分“&”和“&&”：

    • 相同点：如果符号左边是true，则二者都执行符号右边的操作

    • 不同点：& ： 如果符号左边是false,则继续执行符号右边的操作

    ​ && ：如果符号左边是false,则不再继续执行符号右边的操作

    • 建议：开发中，推荐使用 &&

  • 区分“|”和“||”：

    • 相同点：如果符号左边是false，则二者都执行符号右边的操作

    • 不同点：| ： 如果符号左边是true，则继续执行符号右边的操作

      ​ || ：如果符号左边是true，则不再继续执行符号右边的操作

    • 建议：开发中，推荐使用 ||

代码举例：

public class LoginTest {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        // & 与，且；有false则false
        System.out.println((a > b) & (a > c)); //false
        System.out.println((a > b) & (a < c)); //false
        System.out.println((a < b) & (a > c)); //false
        System.out.println((a < b) & (a < c)); //true
        System.out.println("===============");

        // | 或；有true则true
        System.out.println((a > b) | (a > c)); //false
        System.out.println((a > b) | (a < c)); //true
        System.out.println((a < b) | (a > c)); //true
        System.out.println((a < b) | (a < c)); //true
        System.out.println("===============");

        // ^ 异或；相同为false，不同为true
        System.out.println((a > b) ^ (a > c)); //false
        System.out.println((a > b) ^ (a < c)); //true
        System.out.println((a < b) ^ (a > c)); //true
        System.out.println((a < b) ^ (a < c)); //false
        System.out.println("===============");

        // ! 非；非false则true，非true则false
        System.out.println(!false); //true
        System.out.println(!true); //false
            
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); //false
        System.out.println("a = " + a); // a = 4
        System.out.println((a > b) && (a++ > c)); //false
        System.out.println("a = " + a); // a = 4
        System.out.println((a == b) && (a++ > c)); //false
        System.out.println("a = " + a); // a = 5
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); //true
        System.out.println("a = " + a); // a = 6
        System.out.println((a > b) || (a++ > c)); //true
        System.out.println("a = " + a); // a = 6
        System.out.println((a == b) || (a++ > c)); //true
        System.out.println("a = " + a); // a = 7
    }
}

2.5 位运算符

位运算
  • 位运算符的运算过程都是基于二进制的补码运算

2.6 条件运算符

2.6.1 基本语法

  • 条件运算符格式：
(条件表达式)? 表达式1:表达式2
  • 说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
条件表达式.png
  • 如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    
    boolean marry = false;
    System.out.println(marry ? "已婚" : "未婚"  );//未婚
    
    int num = 12;
    System.out.println(num > 0? true : "num非正数");//true

案例1： 获取两个数中的较大值

public class ConditionExer1 {
    public static void main(String[] args) {
        //获取两个数的较大值
        int m1 = 10;
        int m2 = 20;

        int max1 = (m1 > m2)? m1 : m2;
        System.out.println("m1和m2中的较大值为" + max1);
    }
}

案例2： 获取三个数中的最大值


public class ConditionExer2 {
    public static void main(String[] args) {
        int n1 = 23;
        int n2 = 13;
        int n3 = 33;
        //写法1：
        int tempMax = (n1 > n2)? n1:n2;
        int finalMax = (tempMax > n3)? tempMax : n3;
        System.out.println("三个数中最大值为：" + finalMax);

        //写法2：不推荐，可读性差
        int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3;
        System.out.println("三个数中最大值为：" + finalMax1);
    }
}

2.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。

上一行中的运算符总是优先于下一行的。

优先级 运算符说明 Java运算符
1 括号 ()、[]、{}
2 正负号 +、-
3 单元运算符 ++、--、~、！
4 乘法、除法、求余 *、/、%
5 加法、减法 +、-
6 移位运算符 <<、>>、>>>
7 关系运算符 <、<=、>=、>、instanceof
8 等价运算符 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 |
12 条件与 &&
13 条件或 ||
14 三元运算符 ? :
15 赋值运算符 =、+=、-=、*=、/=、%=
16 位赋值运算符 &=、|=、<<=、>>=、>>>=

开发建议：

  1. 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。
  2. 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如：
    ​ (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

标签：Java,变量,int,System,运算符,println,out
From： https://www.cnblogs.com/miaotechisland/p/18628903

相关文章

  • 直击要害！Java反序列化
                                 免责声明本系列工具仅供安全专业人员进行已授权环境使用，此工具所提供的功能只为网络安全人员对自己所负责的网站、服务器等（包括但不限于）进行检测或维护参考，未经授权请勿利用工具中的......
  • Java设计模式 —— 【结构型模式】组合模式（透明组合模式、安全组合模式）详解
    文章目录一、概述二、结构三、案例实现四、安全组合模式五、优缺点一、概述组合模式又名整体-部分模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形......
  • Java中的五种引用方式底层详解
        在GC算法的可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在，普通对象就不会被回收，而在Java中一共有五种引用关系。目录 强引用 (Strong Reference)软引用 (SoftReference)使用软引用实现简单缓存 一个实......
  • 运算符重载（一）
    知识图谱一.需要重载的原因正常情况下，C++的运算符(+、-、*、/等)只能用于对基本类型的常量或变量进行运算，而不能用于类对象之间的运算。类的对象直接的运算虽然可以通过成员函数或全局函数去实现，如date.Add(1)，但这样的写法有时不易理解。C++的提供了重载运算符的特性，......
  • JAVA面向对象（二）封装
    数据的守护者封装是面向对象编程的重要特性之一，它将数据和操作数据的方法紧密地结合在一起，并对外部隐藏了数据的具体实现细节。这样做的好处是多方面的。一方面，它保护了数据的完整性。例如，在Person类中，如果我们直接将age成员变量暴露给外部，那么可能会出现不合理的赋值情况，比如设......
  • JavaDay2
    JavaDay2选择结构Switchpackageshujia.day02.ketang;importjava.util.Scanner;/*Switch选择语句：语句定义格式：switch(表达式){case常量值1:表达式1;break;case......
  • 【开源免费】基于SpringBoot+Vue.JS保密信息学科平台系统（JAVA毕业设计）
    本文项目编号T112，文末自助获取源码\color{red}{T112，文末自助获取源码}......
  • 【开源免费】基于SpringBoot+Vue.JS学生网上请假系统（JAVA毕业设计）
    本文项目编号T111，文末自助获取源码\color{red}{T111，文末自助获取源码}......
  • java反射详讲
    好的！以下是关于Java反射的详细讲解（约5000字左右）。内容包括基础概念、反射的优缺点、基本用法，以及典型案例。Java反射详解反射是Java中的一项强大机制，允许程序在运行时动态获取类的相关信息，并对其进行操作。这项特性使得Java程序具备了极大的灵活性，适用于框架开发、工......
  • 2025年Java面试合集，终于整理好了
    进大厂是大部分程序员的梦想，而进大厂的门槛也是比较高的，所以这里整理了一份阿里、美团、滴滴、头条等大厂面试大全，其中概括的知识点有：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、SpringBoot、SpringCloud、RabbitMQ、Kafka、Linux......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99