Skip to content

数据类型

关键字

ts
关键字一共50个,其中const和goto是保留字。 
此外,还有3个特殊值:true,false,null。它们看起来像关键字,但从技术角度,它们是特殊的布尔值和空值。

变量概念

变量就是用来存储数据的

变量定义方式

bash
三种方式

方式1: 先声明 再赋值

方式2: 连声明 带赋值 写为一条语句

方式3: 同时声明多个同类型的变量(了解) 实际开发中不推荐使用 因为阅读性较差
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        // 方式1: 先声明 再赋值
        int a;
        a = 100;
        System.out.println("变量a的取值为:" + a);
        // 方式2: 连声明 带赋值 写为一条语句
        int b = 123;
        System.out.println("变量b的取值为:" + b);
        // 未赋值的局部变量是不能使用的
        int c, d, e = 55, f, g = 66;
        System.out.println("变量e的取值为:" + e);
        System.out.println("变量g的取值为:" + g);
        System.out.println("变量c的取值为:" + c); // 报错
        System.out.println("变量d的取值为:" + d); // 报错
        System.out.println("变量f的取值为:" + f); // 报错
    }
}

数据类型

注意:Java是强类型语言,变量的类型必须与数据的类型一致。

基本数据类型

整数类型

整数类型四种

byte 1个字节8位 数值范围 -128 ~ 127(1位是正[0]负[1] 2的7次方)

short 2个字节16位 数值范围 -32768 ~ 32767 (1位是正负 2的15次方)

int 4个字节32位 数值范围 -2147483648 ~ 2147483647 (1位是正负 2的31次方)

long 8个字节64位

image-20241204142244061

ts
byte取值范围?最大取值的原因?
-128 ~127
因为一个字节占8位,每一个都只能存储一个0或者一个1,最大的取值为每一位都存储一个1。
还要注意 计算机以首位(最高位)作为符号位 0表示正数 1表示负数,
所以 最大的取值为0111 1111 转换为十进制为127

Java中的每一个数据都有其对应的数据类型

int为整数的默认类型,如需为long类型赋值

如果取值范围超出了int 则需要在值的后面追加 "L"

如果取值范围在int范围以内 则可加 可不加

shell
一个汉字 2 个字节
一个字母 1 个字节
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        byte b1 = 100;
        System.out.println("b1 = " + b1);
        byte b2 = -123;
        System.out.println("b2 = " + b2); // soutv 自动生成打印上一行变量的输出语句
        //byte b3 = -129; // 报错 超出范围
        short s1 = 8956;
        System.out.println("s1 = " + s1);
        short s2 = -23451;
        System.out.println("s2 = " + s2);
        // short s3 = -32769; // 报错 超出范围
        int i1 = 895645;
        System.out.println("i1 = " + i1);
        int i2 = -561245;
        System.out.println("i2 = " + i2);
        //int i3 = 2147483648; // 报错 超出范围

        // int为整数的默认类型,如需为long类型赋值
        // 如果取值范围超出了int 则需要在值的后面追加“L”
        // 如果取值范围在int范围以内 则可加 可不加
        long l1 = 567854651;
        System.out.println("l1 = " + l1);
        long l2 = -45127856;
        System.out.println("l2 = " + l2);
        long l3 = 2147483648L;
        System.out.println("l3 = " + l3);
        long l4 = 100;
    }
}

浮点类型

浮点类型 : 这两种类型都是近似值 不是精确值 如需精确值 使用后续学习的 BigDecimal

image-20241204142341683

float类型赋值时,需要在数值后加"F"。

double类型赋值时,超出float类型取值范围,需要在数值后加"D"

double为浮点数的默认类型,如需为float类型赋值,需要在数值后加"F"

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        float f1 = -340000000000000000000000000000000000000F;
        System.out.println("f1 = " + f1);


        float f2 = -0.0000000000000000000000000000000000000000000014F;
        System.out.println("f2 = " + f2);

        float f3 = 0.00014F;
        System.out.println("f3 = " + f3);

        float f4 = 340000000000000000000000000000000000000F;
        System.out.println("f4 = " + f4);



        // 给double类型赋值 如果取值范围超出了float的取值范围 必须在末尾加上D 推荐大写
        double d1 = 2.5;
        System.out.println("d1 = " + d1);

        double d2 = 3.6;
        System.out.println("d2 = " + d2);
    }
}

long类型和float类型取值(谁大)

为什么 float 类型的字节数 小 但是取值比long类型大

这是因为 float 和 long 的数据存储方式和编码机制不同。尽管 float 的字节数更小(4 字节),它能够表示比 long 更大的范围,主要是因为 浮点数采用了科学计数法表示,而 long 是直接存储整数的值。

为什么 float 的范围更大?
指数部分:float 的 8 位指数(加上偏移值)允许表示 $2^{-126}$ 到 $2^{127}$ 之间的数,因此可以覆盖极大范围的值。
科学计数法:使用科学计数法表示数值,可以通过指数轻松扩展数值的范围,而不需要像 long 那样每一位都直接表示具体的值。

布尔类型

boolean类型 仅能描述true 或者 false

image-20241204142424441

boolean类型可以直接赋值 true 或者 false 也可以赋值 最终结果为true或者false 的表达式

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        boolean bl1 = true;
        System.out.println("bl1 = " + bl1);
        boolean bl2 = false;
        System.out.println("bl2 = " + bl2);

        int a = 10;
        int b = 20;
        boolean bl3 = a > b;
        System.out.println("bl3 = " + bl3);

        boolean bl4 = a < b;
        System.out.println("bl4 = " + bl4);
    }
}

字符类型

char只能保存任意 一个 字符,使用 单引号 包裹一个内容

image-20241204142456387

赋值方式

shell
赋值方式1 直接使用英文的 `单引号` 包裹 一个 内容

赋值方式2 直接赋值在0~65535以内的整数

赋值方式3 使用英文单引号包括十六进制的Unicode字符值  必须以杠u开头
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        // 赋值方式1 直接使用英文的单引号包括一个内容
        char ch1 = 'a';
        System.out.println("ch1 = " + ch1);
        char ch2 = '1';
        System.out.println("ch2 = " + ch2);
        char ch3 = '中';
        System.out.println("ch3 = " + ch3);
        char ch4 = '!';
        System.out.println("ch4 = " + ch4);
        char ch5 = '~';
        System.out.println("ch5 = " + ch5);
        // 赋值方式2 直接赋值在0~65535以内的整数
        // ASCII 美国标准信息交换码  0 ~ 127
        char ch6 = 65;
        System.out.println("ch6 = " + ch6); // A
        char ch8 = 66;
        System.out.println("ch8 = " + ch8); // B
        char ch9 = 67;
        System.out.println("ch9 = " + ch9); // C
        char ch7 = 97;
        System.out.println("ch7 = " + ch7); // a
        char ch10 = 48;
        System.out.println("ch10 = " + ch10); // 0
        // 中文汉字 以及 中文标点符号 将参考Unicode编码表  Unicode编码表是一个十六进制的编码表
        // 记录了世界上绝大多数国加的语言 中文的取值范围是 : \u4e00(19968) ~ \u9fa5(40869)
        char ch11 = 20013;
        System.out.println("ch11 = " + ch11);
        char ch12 = 20320;
        System.out.println("ch12 = " + ch12);
        char ch13 = 19967;
        System.out.println("ch13 = " + ch13);
        char ch14 = 19968;
        System.out.println("ch14 = " + ch14);
        char ch15 = 19969;
        System.out.println("ch15 = " + ch15);
        char ch16 = 40869;
        System.out.println("ch16 = " + ch16);
        // 赋值方式3 使用英文单引号包括十六进制的Unicode字符值  必须以杠u开头

        char c1 = '\u4e2d';
        System.out.println("c1 = " + c1);
        char c2 = '\u4e00';
        System.out.println("c2 = " + c2);
    }
}

引用数据类型

String类型

String类型 String是JDK提供的一个类,属于引用数据类型 ,任何英文双引号包括的内容 都是字符串

image-20241204142710649

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "1234";
        String str3 = "月";
        String str4 = "Aqua";
        String str5 = "\"\"";
        char ch1 = '\''; // char只能保存任意  一个   字符

        System.out.println("str1 = " + str1);
        System.out.println("str2 = " + str2);
        System.out.println("str3 = " + str3);
        System.out.println("str4 = " + str4);
        System.out.println("str5 = " + str5);
        System.out.println("ch1 = " + ch1);
    }
}

数组

对象

集合

接口

枚举

ts

类型转换

自动提升 手动下降

自动类型提升

自动类型转换:自动类型提升

自动转换的条件

1.两种类型要相互兼容:数值与数值类型之间相互兼容。 例如short 兼容 byte 、 int兼容short等等

2.目标类型(等号左边)取值范围大于源类型(等号右边)取值范围

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        //  byte 转 short
        byte b1 = 10;
        short s1 = b1;
        System.out.println("s1 = " + s1);
        //  byte 转 int
        short s2 = 2356;
        int i1 = s2;
        System.out.println("i1 = " + i1);
        // int 转 long
        int i2 = 895645;
        long l1 = i2;
        System.out.println("l1 = " + l1);
        // long 转 float
        long l2 = 56231245L;
        float f1 = l2;
        System.out.println("f1 = " + f1);
        // float转double
        float f2 = 3.5F;
        double d1 = f2;
        System.out.println("d1 = " + d1);

        // byte 转 short int long float double
        byte b2 = 100;

        short e = b2;
        int a = b2;
        long b = b2;
        float c = b2;
        double d = b2;
    }
}

涉及运算符操作时,触发自动自动类型提升

进行算数运算时:

shell
两个操作数有一个为double,计算结果提升为double。
如果操作数中没有double,有一个为float,计算结果提升为float。
如果操作数中没有float,有一个为long,计算结果提升为long。
如果操作数中没有long,有一个为int,计算结果提升为int。
如果操作数中没有int,均为short或byte或者char,计算结果仍旧提升为int。

总结:多个操作数进行数学计算,结果提升为这些操作数中取值范围最大的类型,如果均为byte、short、char则结果提升为int类型。

特殊:任何类型与String相加(+)时,实为拼接,其结果为String。

强制类型转换

强制类型转换条件

  1. 两种类型要相互兼容:数值与数值之间相互兼容。

  2. 目标类型(等号左边)取值范围小于源类型(等号右边)。

  3. 除了将浮点类型强制转换为整数类型后,小数点之后全部抹去,其他的都能完整保存

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        // short类型 强转为 byte
        short s1 = 127;
        byte b1 = (byte)s1;
        System.out.println("short类型 强转为 byte " + b1); // 127
        // int类型 强转为 short
        int i1 = 100;
        short s2 = (short)i1;
        System.out.println("s2 = " + s2); //100
        // long类型 强转为 int
        long l1 = 123;
        int i2 = (int)l1;
        System.out.println("i2 = " + i2); // 123
        // float类型 强转为 long
        // 将浮点类型强制转换为整数类型 小数点之后全部抹去
        float f1 = 3.5F;
        long l2 = (long)f1;
        System.out.println("l2 = " + l2); // 3
        // double类型 强转为 float
        double d1 = 3.5;
        float f2 = (float)d1;
        System.out.println("f2 = " + f2); //3.5
        // double类型 强转为 long int short byte char
        double d2 = 2.5;
        long l3 = (long)d2;
        int i3 = (int)d2;
        short s3 = (short)d2;
        byte b3 = (byte)d2;

        char ch1 = (char)d2;
    }
}

强制类型转换特殊情况

强制类型转换特殊情况:将超出目标类型的数值进行转换

取值范围大强制转换取值范围小时,二进制数据会高位舍弃,低位保留

布尔类型不可与其他类型转换

示例1

java
定义一个 short类型的变量 short s1 = 257 他的二进制代码表示
short    0000 0001 0000 0001
强制类型转换为 byte类型 byte b1 = (byte) s1 
二进制数据会高位舍弃,低位保留,所以b1的十进制为1
byte 	 	 	   0000 0001

示例2

java
定义一个 short类型的变量 short s2 = 128 他的二进制代码表示
short    0000 0000 1000 0000
强制类型转换为 byte类型 byte b2 = (byte) s2
二进制数据会高位舍弃,低位保留,所以b2的十进制为 -128
byte 	 	 	   1000 0000

原码 反码 补码

计算机统一以补码的形式表示所有的整数。

定律:正数的原,反,补码都一样(三码合一)

正数补码表示不需要计算(三码合一)

负数补码表示需要计算,具体是:先将其对应的正数的二进制表示(原码),然后除符号位以外每一个都取反,然后加 1。

负数特殊情况:最小的负数是推算计算,类似于取极限,例如-128,是比最小-127还小1,即-128=-127-1

正数和负数都是通过 补码 的形式在(计算机存储)中

正数和负数的取值使用 原码(方便人类计算成十进制)

原码、反码和补码的区别

java
符号位:二进制的最高位
    
原码:一个整数的二进制表示,包括符号位和数值部分。对于正数,符号位为 0,数值部分与无符号整数相同。对于负数,符号位为 1,数值部分与无符号整数相同(0除外)。
    
反码:对于正数,反码就是它的原码。对于负数,反码是将其原码中的数值部分逐位取反(符号位不变)。
    
补码:对于正数,补码和原码、反码一样。对于负数,补码是反码加 1

示例

假设我们以 8 位为例 byte 类型 

表示数字 +5
原码:00000101
反码:00000101
补码:00000101

比如对于 -5

原码:10000101(人类计算)
反码:11111010
补码:11111011(计算机存储)

从补码的角度看负数的大小
补码 1 0000000 就是最小的负数
补码 1 1111111 就是最大的负数

-1 的原码是 1000 0001
-1 的反码是 1111 1110
-1 的补码是 1111 1111

-128的补码是由-127-1推算过来的
127的原码是 0111 1111
-127的原码  1111 1111
-127的反码  1000 0000
-127的补码  1000 0001 (计算机存储)
-128的补码  1000 0000 (计算机存储)
+128的原码  byte类型不能表示 +128,最大只有+127(0111 1111)
如果硬要 +1 则
127 + 1 = -128
127的原码是 0111 1111 
127的补码是 0111 1111 (计算机存储)
+1操作后
127 + 1 是 1000 0000 (计算机存储) => -128
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        // s1 原码 0000 0001 0000 0001
        // s1 反码 0000 0001 0000 0001
        // s1 补码 0000 0001 0000 0001
        short s1 = 257;
        // b1 原码 0000 0001
        // b1 反码 0000 0001
        // b1 补码 0000 0001
        byte b1 = (byte)s1;
        System.out.println("b1 = " + b1); // 1
        // s2 原码 0000 0000 1000 0000
        // s2 反码 0000 0000 0111 1111
        // s2 补码 0000 0000 1000 0000
        short s2 = 128;
        // b2 补码 1000 0000 (计算机存储的)
        // b2 反码 1111 1111
        // b2 原码 1000 0000 => -128 (人类计算的)
        byte b2 = (byte)s2;
        System.out.println("b2 = " + b2); // -128
        // s3 原码 0000 0000 1000 0001
        // s3 反码 0000 0000 1000 0001
        // s3 补码 0000 0000 1000 0001
        short s3 = 129;
        // b3 补码 1000 0001 (计算机存储的)
        // b3 反码 1111 1110
        // b3 原码 1111 1111 => -127 (人类计算的)
        byte b3 = (byte) s3;
        System.out.println("b3 = " + b3); // -127
    }
}

为什么Java中 byte 类型的取值 为 -128~127 而不是 -128~128

shell
Java byte 类型的取值范围是 -128 127,而不是 -128 128,原因与它的二进制表示和计算机中整数的存储方式有关。

byte 类型是一个 8 位的有符号整数类型。在计算机中,整数的表示通常使用 补码 方式。

1. 8 位二进制数的补码表示
 8 位补码中,最高位(即第 8 位)是符号位,用来表示正数或负数。
剩余的 7 位用于表示数值大小。

2. 补码表示法的原理
正数的二进制表示和无符号整数相同。
负数的表示通过补码形式来表示,具体是:先将其对应的正数的二进制表示取反(每一位取反),然后加 1

3. 字节的范围
8 位二进制数的最大值是 11111111(即 255),如果按照无符号整数来解读,则范围是 0 255
但由于 Java 中的 byte 是有符号的,因此它的值范围被拆分为负数和正数:
最大正数:01111111(127)
最小负数:10000000(-128)
这就是为什么 byte 类型的取值范围是 -128 127

运算符

算数运算符

算数运算符

java
+ - * / %

自增和自减

shell
++表示自增1
--表示自减1

注意:
++ 或者 -- 如果是单独作为一条语句书写 在前在后没有区别
如果不是单独作为一条语句书写 在前在后有区别

如果++ 或者 -- 在前, 先执行++ 或者 -- ,再执行其他的
如果++ 或者 -- 在后, 先执行其他的,再执行++或者--
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a + b); // 30
        System.out.println(a - b); // -10
        System.out.println(a * b); // 200
        System.out.println(a / b); // 0
        int c = 5;
        System.out.println(a % c); // 求余数 注意跟除法的区别

        System.out.println("-----------------------------------------------------");

        // ++ 和 --
        // ++表示自增1
        // --表示自减1
        // ++ 或者 -- 如果是单独作为一条语句书写 在前在后没有区别
        // 如果不是单独作为一条语句书写 在前在后有区别
        // 如果++ 或者 -- 在前, 先执行++ 或者 -- ,再执行其他的
        // 如果++ 或者 -- 在后, 先执行其他的,再执行++或者--
        int d = 10;
        d++; // 结果等同于 d = d + 1;
        System.out.println("d = " + d); // 11

        int e = 10;
        ++e;
        System.out.println("e = " + e); // 11

        int f = 10;
        f--;
        System.out.println("f = " + f); // 9

        int g = 10;
        --g;
        System.out.println("g = " + g); // 9

        System.out.println("-----------------------------------------------------");

        int h = 10;
        int i = h++;
        System.out.println("i = " + i); // 10
        System.out.println("h = " + h); // 11

        System.out.println("-----------------------------------------------------");

        int j = 10;
        int k = ++j;
        System.out.println("k = " + k); // 11
        System.out.println("j = " + j); // 11

    }
}

赋值运算符

shell
=	直接赋值
+=	求和后赋值
-=	求差后赋值
*=	求积后赋值
/=	求商后赋值
%=	求余后赋值
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        int a = 10;
        a += 10; // 结果 a = a + 10; 20
        System.out.println("a = " + a);
        a -= 5; // a = a - 5;  15
        System.out.println("a = " + a);
        a *= 10; // a = a * 10; 150
        System.out.println("a = " + a);
        a /= 2; // a = a / 2; 75
        System.out.println("a = " + a);
        a %= 3; // a = a % 3; 0
        System.out.println("a = " + a);

        System.out.println("-----------------------------------");

        short s1 = 10;
        s1 += 10; // 这里JVM帮我们实现 隐式 的类型转换
        System.out.println("s1 = " + s1);

        short s2 = 10;
        s2 = (short) (s2 + 10); // 这里因为是我们完整书写表达式进行计算 和 赋值 所以 需要手动类型转换

    }
}

关系运算符

关系运算符最终的结果为布尔类型, 表示两个操作数或者两个表达式之间的关系是否成立。

shell
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b); // false
        System.out.println(a < b); // true
        System.out.println(a >= b); // false
        System.out.println(a <= b); // true
        System.out.println(a == b); // false
        System.out.println(a != b); // true
    }
}

逻辑运算符

ts
&&	短路与	两个操作数同时为真,结果为真
||	短路或	两个操作数,有一个为真,即为真
!	非	取反
ts
&   与       要求两个或者多个条件同时成立 则最终结果为true
没有短路的效果 不管前边的条件结果如何 都将执行完所有的条件

&&  短路与    要求两个或者多个条件同时成立 则最终结果为true
短路与 有短路的效果 如果前边的条件不成立 则后续的条件不再执行



|   或        要求两个或者多个条件 至少有一个成立 则最终结果为true
没有短路的效果  不管前边的条件结果如何 都将执行完所有的条件

||  短路或    要求两个或者多个条件 至少有一个成立 则最终结果为true
短路或 有短路的效果 如果前边的条件 已经成立 则后续的不再执行
ts
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;

        System.out.println(a < b & b > c ); // true
        System.out.println(a < b && b > c ); // true

        System.out.println("-------------------------------------");

        System.out.println(a < b & b < c); // false
        System.out.println(a < b && b < c); // false

        System.out.println("-------------------------------------");

        System.out.println(a < b | b > c ); // true
        System.out.println(a < b || b > c ); // true

        System.out.println("-------------------------------------");

        System.out.println(a < b | b < c); // true
        System.out.println(a < b || b < c); // true

        System.out.println("-------------------------------------");

        System.out.println(a > b | b > c); // true
        System.out.println(a > b || b > c); // true

        System.out.println("-------------------------------------");

        System.out.println(a > b | b < c); // false
        System.out.println(a > b || b < c); // false


        System.out.println("-------------------------------------");

        boolean flag1 = true;
        System.out.println(!flag1);

        boolean flag2 = false;
        System.out.println(!flag2);

    }
}

三元运算符

ts
A ? B : C	A 成立,表达式的值取B,否则取C
java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        int age = 19;
        System.out.println(age >= 18 ? "成年了" : "未成年");

        int a = 1;
        int b = a > 5 ? 55 : 66;
        System.out.println("b = " + b);


    }
}

位运算符

image-20241209212544014

ts
如果最高位是1 则移动完以后 空缺位补1
如果最高位是0 则移动完以后 空缺位补0

<< 左移 : 左移几位表示乘以2的几次方 (有可能会出现负数的情况)
>> 右移 : 右移几位表示除以2的几次方
>>> 无符号右移 不管最高位是0还是1 空缺位统一以0填充 即 最终的结果都是一个正数
应用场景:比如我们要获取某个元素应该存放在数组中的位置,可以使用无符号右移,因为无符号右移绝对不可能得到一个负数,而数组的下标也不为负数
ts
&
两个数的相同二进制位进行与运算,都为1则结果为1,否则其他情况最终结果都为0。

|
两个数的相同二进制位进行或运算,只要有一个为1,或者两个都为1,则结果为1,其他的情况结果为0。

^ 异或
两个数的相同二进制位进行异或运算,不同则结果为1,相同则结果为0。

~ 取反
包括符号位在内二进制数,每一位取反,是0改为1,是1改为0。默认数字没有声明类型,则是int类型4字节32位
java
public class TestBitOperator {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a << 1); // 2
        System.out.println(a << 2); // 4
        System.out.println(a << 3); // 8
        System.out.println(a << 4); // 16
        System.out.println(a << 31); // -2147483648
        System.out.println(a << 32); // 1 相当于没有移动

        System.out.println("------------------------------------------");

        System.out.println(8 >> 1);
        System.out.println(8 >> 2);
        System.out.println(8 >> 3);
        System.out.println(8 >> 4);
        System.out.println(-20 >> 1); // -10
        System.out.println(-20 >> 2); // -5

        System.out.println("------------------------------------------");

        System.out.println(8 >>> 1);
        System.out.println(8 >>> 2);
        System.out.println(8 >>> 3);
        System.out.println(8 >>> 4);
        System.out.println(-20 >>> 1); //
        System.out.println(-20 >>> 2); //

        System.out.println("------------------------------------------");
        System.out.println(25 & 21); // 17
        System.out.println(25 | 21); // 29
        System.out.println(25 ^ 21); // 12

        System.out.println(~5);
        System.out.println(~-6);
    }
}

进制

ts
二进制以 0B开头
八进制以 0 开头
十六进制以 0X 开头

示例

java
package com.yuluochenxiao.test;

public class FunctionTest {
    public static void main(String[] args) {
        //整数的赋值方式 4种方式
        // 方式1 二进制 以0B开头
        int a = 0B11;
        System.out.println("a = " + a); // 3
        // 方式2 八进制 以0开头
        int b = 011;
        System.out.println("b = " + b); // 9
        // 方式3 十六进制 以0X开头
        int c = 0X4e2d;
        System.out.println("c = " + c); // 20013
    }
}

转义字符

转义字符 : 可以用于保存一些特殊符号 或者 实现一些 特殊的效果

javascript
\n	换行符
\t	缩进
\\	反斜线
\'	单引
\"	双引
java

标识符命名规范

凡是需要自定义名称的内容都属于标识符

注意:标识符名称定义不要与Java关键字、保留字冲突

ts
标识符的构成:

简写:(字母) (下划线) (美元符号) (人民币符号) (数字)骆驼(驼峰命名) 

详细说明:标识符名称可以以字母 、下划线、美元符号、人民币符号开头,可以包含数字,不能以数字开头。

实际开发中只推荐使用单词。

类名

ts
类名:由一个或者多个单词组成 ,每个单词首字母大写

举例: Student StringBuffer StringBuilder (大写驼峰)

变量名

ts
变量名: 由一个或者多个单词组成 ,每个单词首字母小写
方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格
举例:studentName   studentAge  personWorkAge  (小写驼峰)

规范

ts
见名知义 有意义 

实际开发中只推荐使用单词  

Java开发手册 阿里巴巴
https://www.w3cschool.cn/alibaba_java/alibaba_java-s7k33eq1.html

常量

程序中无法改变的数据 称之为常量

java
package com.yuluochenxiao.test;

/**
 *  常量: 程序中无法改变的数据 称之为常量
 */
public class TestConstant {
    public static void main(String[] args) {
        int a = 100;
        a = 1;
        System.out.println(100); // 100 就是常量
        System.out.println(1.5); // 1.5 就是常量
        System.out.println(2.5F);
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
        System.out.println("false");
    }
}

局部变量

在方法内定义的变量称为局部变量

局部变量描述
定义位置:定义在方法体内
作用范围:离当前变量最近的大括号以内
重名问题:重合的作用范围以内 不能重名
默认值:局部变量没有默认值 必须先赋值才能使用
生命周期:随着方法的入栈(压栈)而生效 随着方法的出栈(弹栈)而死亡
存储位置:基本数据类型存在栈中 ,引用数据类型 名字在栈 值在堆

image-20241209213707619

ts
方法中的局部变量:随着方法的入栈而生效,栈内会开辟一个内存空间

如果变量的类型是基本数据类型,数据存储在栈中
如果变量的类型是引用数据类型,然后会在堆中开辟一个空间,把数据存储在堆中,栈中存储的是堆中的地址。

栈中的引用,指向堆中的空间(也叫做指针)

示例

java
public class TestLocalVariable {

    public static void main(String[] args) {
        int a = 100;
        int b = 100;
//        int d ;
//        System.out.println("d = " + d);

        if(a > b){
            System.out.println(a);
            System.out.println(b);

            int c = 123;

        }else{
            int c = 123;
            System.out.println(a);
            System.out.println(b);
        }

    }
}

存储位置

ts
方法的生命周期:随着方法的入栈而生效,随着方法的出栈而死亡
变量的存储位置:基本数据类型存储在栈中,引用数据类型名字在栈中,值在堆中