当前位置：首页 > article >正文

Java: 数据类型与变量和运算符

article 2024/11/17 11:34:29

一 .字面常量

二.数据类型

三.变量

1.语法格式

2.整型变量

(1).整型变量

(2). 长整型变量

(3).短整型变量

(4).字节型变量

3.浮点型变量

(1).双精度浮点型

(2).单精度浮点型

4.字符型变量

5.布尔型变量

四.类型转换

1.自动类型转换(隐式)

2.强制类型转换(显式）

编辑五.类型提升

六.字符串类型

1.int 转成 String

2.String 转成 int

七.运算符

1. 什么是运算符

2.算术运算符

1.基本四则运算符：加减乘除模+， -， *， /， %

编辑2.增量运算符 +=， -=， *=， %=

3.自增/自减运算符 ++ --

编辑

3.关系运算符

4.逻辑运算符

5.位运算符

6.移位运算

7.条件运算符

8.运算符的优先级

一 .字面常量

顾名思义常量即程序运行期间，固定不变的量称为常量。

而字面常量又有6种分类：

字符串常量：由""括起来的。
整形常量：程序中直接写的数字(注意没有小数点)。
浮点数常量：程序中直接写的小数。
字符常量：由''括起来的当个字符。
布尔常量：只有两种true和false。
空常量：null。

我们来看几个例子。

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        System.out.println(20);
        System.out.println(3.14);
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
    }
}

我们要注意的是，字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

二.数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

而基本数据类型又分为四类八种：

四类：整型、浮点型、字符型以及布尔型

八种：是根据四类所得出的。

整型分为：字节型，短整形，整型，长整型。
浮点型分为：单精度浮点数和双精度浮点数。
字符型：字符型。
布尔型：布尔型。

数据类型	关键字	内存占用	范围
字节型	byte	1 字节	-128 ~ 127
短整型	short	2 字节	-32768 ~ 32767
整型	int	4 字节	-2^31~2^31-1
长整型	long	8 字节	-2^63~2^63-1
单精度浮点数	float	4 字节	有范围，一般不关注
双精度浮点数	double	8 字节	有范围，一般不关注
字符型	char	2 字节	0 ~ 65535
布尔型	boolean	没有明确规定	true 和 false

我们发现在Java中相较于C语言多了一个字节型，并且字符型的大小变为了2个字节。

那么什么是字节呢？

我们知道字节是计算机中表示空间大小的基本单位，而计算机使用二进制表示数据，并且我们认为 8 个二进制位(bit) 为一个字节(Byte)。

但在这里我们还有一些注意事项：

在Java中：

不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节。
整形和浮点型都是带有符号的。（默认是有符号的数)
整型默认为int型，浮点型默认为double。（例如：4默认就是int型，3.14默认为double型）
字符串属于引用类型。

三.变量

在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

1.语法格式

定义变量的语法格式为：

数据类型变量名 = 初始值;

2.整型变量

(1).整型变量

public class Test {
    public static void main(String[] args) {
        int a=10;
        System.out.println(a);
    }
}

注意：在Java中变量必须初始化，如果没有合适的初始值可以先赋成0.

如果我们没有赋初值的话，我们的代码就会出现错误。

对于int类型我们还有一些注意事项：

int不论在何种系统下都是4个字节
在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
int的包装类型为 Integer

(2). 长整型变量

public class Test {
    public static void main(String[] args) {
       long a=100L;
       long b=200l;
        System.out.println(a);
        System.out.println(b);
    }
}

对于长整型变量，我们需要在我们赋的值后面加上L或者l,但更加推荐使用L，因为l,有时我们对于l和1，不好区分。

对于long类型我们还有一些注意事项：

长整型不论在那个系统下都占8个字节
long的包装类型为Long

(3).短整型变量

public class Test {
    public static void main(String[] args){
        short a=10;
        System.out.println(a);
    }
}

对于short类型我们还有一些注意事项：

short在任何系统下都占2个字节
使用时注意不要超过范围
short的包装类型为Short

(4).字节型变量

public class Test {
    public static void main(String[] args) {
        byte a=5;
        System.out.println(a);
    }
}

对于byte类型我们还有一些注意事项：

byte在任何系统下都占1个字节
字节的包装类型为Byte

3.浮点型变量

(1).双精度浮点型

public class Test {
    public static void main(String[] args) {
        double a=5.0;
        System.out.println(a);
    }
}

接下来我们看一段代码

我们发现并没有输出我们想要的2.5，这是因为在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 2.5, 需要使用 double 类型计算.

当然，我们知道int 类型的数例如5 就一定是5，而我们的浮点数类型，例如1.1就一定是1.1吗？

其实不是的，让我们来看下面这段代码。

我们发现我们得到的值其实并不是我们想的1.21，而是在后面还有值，这其实是因为浮点数类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

对于double类型我们还有一些注意事项：

double在任何系统下都占8个字节
浮点数与整数在内存中的存储方式不同，不能单纯使用 2^n的形式来计算
double的包装类型为Double

(2).单精度浮点型

public class Test {
    public static void main(String[] args) {
        float a=3.14f;
        System.out.println(a);
    }
}

对于float变量，我们需要在我们赋的值后面加上F或者f.

对于float类型我们还有一些注意事项：

float在任何系统下都占4个字节
float的包装类型为Float
同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float

4.字符型变量

public class Test {
    public static void main(String[] args) {
        char a='a';
        char b='1';//数字字符
        System.out.println(a);
        System.out.println(b);
    }
}

注意事项：

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

5.布尔型变量

布尔类型常用来表示真假,真为true,假为false.

public class Test {
    public static void main(String[] args) {
        boolean a=true;
        boolean b=false;
        System.out.println(a);
        System.out.println(b);
    }
}

对于boolean类型我们还有一些注意事项：

Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。
boolean的包装类型为Boolean。

四.类型转换

在Java中，当参与运算数据类型不一致时，就会进行类型转换。

Java中类型转换主要分为两类：自动类型转换(隐式) 和强制类型转换(显式)。

1.自动类型转换(隐式)

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

特点：数据范围小的转为数据范围大的时会自动进行。

2.强制类型转换(显式）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        a = (int)b;
        System.out.println(a);
    }
}

注意：强制类型转换不一定能成功，不相干的类型不能互相转换

对于布尔类型，不能对他进行强制类型转换，因为int类型和boolean类型不相干。

注意：将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查

public class Test {
    public static void main(String[] args) {
        int a=128;
        byte b=10;
        b=(byte)a;
        System.out.println(b);
    }
}

byte的范围为-128~127，当我们要赋得值超过这个范围时，就不会得到我们想要得值。我们发现我们超过这个范围得大小为1，我们可以把byte范围看成下面得图，我们就可以知道打印得值为-128.

五.类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

int与long之间：int会被提升为long：

byte与byte的运算：

我们发现这其实是有错误的，然而如果我们改成int类型得话就不会发生错误。

这其实是因为虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

总结：

不同类型的数据混合运算, 范围小的会提升成范围大的
对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算

六.字符串类型

在Java中使用String类定义字符串类型

public class Test {
    public static void main(String[] args) {
        String a="hello";
        String b="world";
        System.out.println(a);
        System.out.println(b);
        System.out.println(a+b);//拼接两个字符串
    }
}

在一些特殊得情况下，我们需要然int类型和String类型互相转换

1.int 转成 String

有两种方式：

public class Test {
    public static void main(String[] args) {
        //方法一：
        int a=10;
        String b=a+"";
        System.out.println(b);
        //方法二：
        System.out.println("-----------------");
        String c=String.valueOf(a);
        System.out.println(c);
    }
}

2.String 转成 int

public class Test {
    public static void main(String[] args) {
        String a = "100";
        int num1 =Integer.valueOf(a);
        int num2 = Integer.parseInt(a);
        System.out.println(num1);
        System.out.println(num2);
    }
}

但其实，valueOf和parseInt这两没有区别，我们可以找到valueOf他的原码。

他其实就是调用parseInt，所以其实我们就使用parseInt就可以了。

七.运算符

1. 什么是运算符

对操作数进行操作时的符号，不同运算符操作的含义不同。

作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。Java中运算符可分为以下：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等。

2.算术运算符

**（1）.基本四则运算符：加减乘除模+， -， *， /， %**

public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b); 
        System.out.println(a / b);
        System.out.println(a % b);
    }
}

但是，在这其中，我们得除运算，并没有得到我们想要得2.5，这样我们该怎么办呢？

其实很简单，只需要让他们其中一个数变成浮点数即可。

public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a*1.0 / b);
        System.out.println(a % b);
    }
}

（2）.增量运算符 +=， -=， *=， %=

public class Test {
    public static void main(String[] args) {
        int a = 5;
        a += 2;
        System.out.println(a);
        a -= 2;
        System.out.println(a);
        a *= 2;
        System.out.println(a);
        a /= 2;
        System.out.println(a);
        a %= 2;
        System.out.println(a);
    }
}

（3).自增/自减运算符 ++ --

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b=a++;
        System.out.println(b);
        System.out.println(a);
        a=1;
        int c=++a;
        System.out.println(c);
        System.out.println(a);
    }

}

对于前置++是先赋值后+1，后置++是先+1后赋值

其他注意事项：

如果单独使用，【前置++】和【后置++】没有任何区别
只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

3.关系运算符

关系运算符主要有六个: == != < > = ，其计算结果是 true 或者 false 。

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

    }
}

4.逻辑运算符

逻辑运算符	语法
逻辑与 &&	表达式1 && 表达式2
逻辑或 \|\|	表达式1 \|\| 表达式2
逻辑非 !	! 表达式

逻辑与 &&：两个表达式都为真，结果才是真，只要有一个是假，结果就是假。
逻辑或 ||：左右表达式至少有一个位真，则结果为真，都为假，结果就是假。
逻辑非 !：真变假，假变真。

短路求值：

&& 和 || 遵守短路求值的规则.

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

所以我们可以得到我们得结论：

对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式
对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.

5.位运算符

位运算符	语法
按位与 &	A&B
按位或 \|	A\|B
按位取反 ~	A~B
4. 按位异或 ^	A^B

按位与 &: 全1为1，有0为0
按位或 |: 有1为1，全0为0
按位取反 ~: 1转0，0转1
按位异或 ^: 相同为0，相异为1

6.移位运算

在Java中，移位运算符有三个: << , >> , >>>，都是二元运算符，且都是按照二进制比特位来运算的.

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

右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

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

注：没有“无符号左移”，“<<<”.

注意:

左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

7.条件运算符

表达式1 ? 表达式2 : 表达式3

当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;
当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

8.运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 + 和 - ，如果我们在写代码得时候不注意观察和判断，就会让我们得代码结果出现错误。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + (b - a) >> 1;
        System.out.println(c);

    }

我们知道（）的优先级最大先执行b-a等于10，而+得优先级高于>>,所以执行a+10=20，最后执行右移，根据上面我们知道右移一位相当于除上2，所以我们得结果应为10.