JAVA学习笔记 02 - 变量、数据类型、表达式和运算符

最新推荐文章于 2022-01-25 11:40:25 发布
最新推荐文章于 2022-01-25 11:40:25 发布
阅读量742 收藏
点赞数 1
分类专栏： JAVA学习笔记 文章标签： java 变量 常量 表达式 运算符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgl125167016/article/details/78228742
版权

本文是Java基础课程的第二课。主要介绍Java中的变量、数据类型、表达式和运算符、数据类型转换等基础知识

文章目录

一、标识符

1、标识符的概念

Java所有的组成部分都需要名字，如类名、变量名以及方法名，所有这些名称所使用的字符串序列即被称为标识符。

2、标识符的规则

2.1、基本规则

关于Java标识符，有以下几点强制性的规则需要注意：

  • 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始。
  • 首字符之后可以是字母（A-Z或者a-z）、美元符（$）、下划线（_）或数字的任何字符组合。
  • 关键字不能用作标识符。
  • 标识符是大小写敏感的。

2.2、常见约定

在强制性的规则之外，开发过程中，一般需要遵循以下约定：

  • 标识符要符合语义信息，即见名知意。
  • 包名所有字母小写。
  • 类名每个单词首字母大写，其它小写，如：CollegeStudent。
  • 变量和方法的第一个单词小写，从第二个单词开始首字母大写，如：collegeStudent。
  • 类名和变量通常为名词或名词性短语，方法名通常为动词或动宾短语。
  • 常量的所有字母大写，每个单词之间用下划线（_）连接。

2.3、Java中的关键字汇总

下面将列出了Java关键字（保留字），共50个，这些保留字不能用于任何标识符。

关键字说明
abstract抽象方法，抽象类的修饰符
assert断言条件是否满足
boolean布尔数据类型
break跳出循环或者label代码段
byte8-bit 有符号数据类型
caseswitch语句的一个条件
catch和try搭配捕捉异常信息
char16-bit Unicode字符数据类型
class定义类
const未使用
continue不执行循环体剩余部分
defaultswitch语句中的默认分支
do循环语句，循环体至少会执行一次
double64-bit双精度浮点数
elseif条件不成立时执行的分支
enum枚举类型
extends表示一个类是另一个类的子类
final表示一个值在初始化之后就不能再改变了，表示方法不能被重写，或者一个类不能有子类
finally为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
float32-bit单精度浮点数
forfor循环语句
goto未使用
if条件语句
implements表示一个类实现了接口
import导入类
instanceof测试一个对象是否是某个类的实例
int32位整型数
interface接口，一种抽象的类型，仅有方法和常量的定义
long64位整型数
native表示方法用非java代码实现
new分配新的类实例
package一系列相关类组成一个包
private表示私有字段，或者方法等，只能从类内部访问
protected表示字段只能通过类或者其子类访问，子类或者在同一个包内的其他类
public表示共有属性或者方法
return方法返回值
short16位数字
static表示在类级别定义，所有实例共享的
strictfp浮点数比较使用严格的规则
super表示基类
switch选择语句
synchronized表示同一时间只能由一个线程访问的代码块
this表示调用当前实例，或者调用另一个构造函数
throw抛出异常
throws定义方法可能抛出的异常
transient修饰不要序列化的字段
try表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void标记方法不返回任何值
volatile标记字段可能会被多个线程同时访问，而不做同步
whilewhile循环

二、基本数据类型

1、数据类型的概念

数据是描述客观事物的数字、字母以及能够输入到计算机中的符号。例如“武松”、“软件一班”、28、170等都是数据。数据可根据其特点进行分类，例如“武松”和“软件一班”可以归为字符串类，28和170可归为数字类。在Java中数据类型分为两大类：基本数据类型和引用数据类型。

2、基本数据类型

Java提供的基本数据类型包括八种，分别是byte、short、int、long、float、double、boolean、char，如下：
在这里插入图片描述
具体说明如下表：

数据类型占用空间保存范围使用举例
boolean 布尔型1字节，8位true或false保存性别、婚否
char 字符型2字节，16位0~65535一个单一的 16 位 Unicode 字符，
保存单个字母或汉字时使用
byte 字节型1字节，8位-128（-2^7） ~ 127（2^7 - 1）对字节操作时使用，如文件读写，
也可以用在大型数组中以节约空间
short 短整型2字节，16位-32768（-2^15） ~ 32767（2^15 - 1）保存较小的整数时使用
int 整型4字节，32位-2147483648（-2^31） ~ 2147483647（2^31 - 1）保存一般的整数时使用
long 长整型8字节，64位-9223372036854775808（-2^63） ~ 9223372036854775807（2^63 -1）保存较长的整数时使用
float 浮点型（单精度）4字节，32位-3.403e38 ~ 3.403e38符合IEEE 754标准的浮点数，
保存小数时使用
double 浮点型（双精度）8字节，64位-1.798e308 ~ 1.798e308符合IEEE 754标准的浮点数，
保存精度较高的小数时使用

3、引用数据类型

Java中，除了以上提到的8种基本数据类型外，其他的数据类型都是引用数据类型，包括数组、接口、类等。

三、字面量

字面量即我们所能看到的真实具体的字面值。如：

  • 整型字面量：10，123，2147483648L，0144，0x64
  • 浮点型字面量：3.14，6.18F
  • 布尔型字面量：true，false
  • 字符型字面量：'a'，'A'，'\u6C49'
  • 字符串型字面量："gansu"
  • Null型字面量：值为null，代表什么都没有

注意：

  1. 长整型（long）的字面量后面必须有字母l或L，为了和数字1区分，一般使用大写字母L。
  2. 单精度浮点型（float）的字面量后面必须有字母f或F，一般使用大写字母F。
  3. 字符型（char）的字面量必须使用单引号。
  4. 字符串型的字面量必须使用双引号。

四、变量

1、变量的概念

变量是指在程序运行过程中其值可以改变的量。本质上，变量就是计算机内存中存放数据的单元，定义变量的本质就是分配内存。当把数值赋给变量时，实际上就是将数值存储到变量代表的内存单元中。

2、Java中的变量

声明变量并初始化的基本语法为：

[修饰符] 数据类型 变量名称 [= 值] [, 变量名称 [= 值] ...];

例如：

public class Test {
	public static void main(String[] args) {
		int num1 = 10;
		short num2 = 15, num3 = 20;
		byte num4, num5;
		num4 = 25;
		int num6 = num2 * num3;
		long num7 = 3000000000L;
		double num8 = 2.5;
		float num9 = 6.18F;
		String str = "hello";
		System.out.println(str);
	}
}

说明：

  • 变量必须先声明，然后初始化（赋值），最后才能使用。变量只在申明它的{}内有效。
  • 初始化byte、int、long、和short类型的变量时，均可以用十进制、八进制以及十六进制的数字，前缀0表示 八进制数字，前缀0x代表 十六进制数字, 例如：
    public class Test {
	public static void main(String[] args) {
		int decimal = 100; // 十进制数100
		int octal = 0144;  // 八进制数0144，即十进制数100
		int hexa =  0x64;  // 十六进制数0x64，即十进制数100
	}
}
  • char类型是一个单一的16位Unicode字符，可以保存一个字母或汉字等，最小值是\u0000（对应的10进制数字是0），最大值是\uffff（对应的10进制数字是65535），初始化char类型变量时，可以直接使用具体的字符，另外，也支持一些特殊字符序列，例如：
    public class Test {
	public static void main(String[] args) {
		char c1 = '汉';
		char c2 = '字';
		char c3 = '\u6C49';
		char c4 = '\u5B57';
		char c5 = '\n';		// '\n'表示换行 (0x0a)
		char c6 = '\t';		// '\t'表示制表符 (0x09)
		char c7 = '\"';		// '\"'表示双引号" (0x22)
		char c8 = '\'';		// '\''表示单引号' (0x27)
		char c9 = '\\';		// '\\'表示斜杠\ (0x5c)
		char c10 = 'A';
		char c11 = 65;		// 表示字母A，使用十进制数字为char类型变量赋值
		char c12 = 0101;	// 表示字母A ，使用八进制数字为char类型变量赋值
		char c13 = '\101';	// 表示字母A ，使用\ddd的形式表示八进制数ddd
		char c14 = 0x41;	// 表示字母A，使用十六进制数字为char类型变量赋值
		char c15 = '\u0041';// 表示字母A，使用十六进制Unicode编码为char类型变量赋值

		System.out.println("c1 = " + c1);
		System.out.println("c2 = " + c2);
		System.out.println("c3 = " + c3);
		System.out.println("c4 = " + c4);
		System.out.println("c5 = " + c5);
		System.out.println("c6 = " + c6);
		System.out.println("c7 = " + c7);
		System.out.println("c8 = " + c8);
		System.out.println("c9 = " + c9);
		System.out.println("c10 = " + c10);
		System.out.println("c11 = " + c11);
		System.out.println("c12 = " + c12);
		System.out.println("c13 = " + c13);
		System.out.println("c14 = " + c14);
		System.out.println("c15 = " + c15);
	}
}

五、常量

常量是指不可改变的变量，通常用final修饰。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		public static final double E = 2.7182818284590452354;
		public static final double PI = 3.14159265358979323846;
	}
}

基本类型中数值类型的取值范围都已经以常量的形式定义在对应的包装类中了。如下面的例子：

public class PrimitiveTypeTest {
	public static void main(String[] args) {
		// byte  
		System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
		System.out.println("包装类：java.lang.Byte");
		System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
		System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
		System.out.println();

		// short  
		System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
		System.out.println("包装类：java.lang.Short");
		System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
		System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
		System.out.println();

		// int  
		System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
		System.out.println("包装类：java.lang.Integer");
		System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
		System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
		System.out.println();

		// long  
		System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
		System.out.println("包装类：java.lang.Long");
		System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
		System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
		System.out.println();

		// float  
		System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
		System.out.println("包装类：java.lang.Float");
		System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
		System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
		System.out.println();

		// double  
		System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
		System.out.println("包装类：java.lang.Double");
		System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
		System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
		System.out.println();

		// char  
		System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
		System.out.println("包装类：java.lang.Character");
		// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
		System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);
		// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
		System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
	}
}

六、表达式和运算符

1、表达式

对数据进行加工和处理称为运算，表示各种运算的符号称为运算符，参与运算的数据称为操作数。

表达式是运算符和操作数的有效组合，操作数可以是变量、常量、方法调用的返回值等。例如表达式 z = x + y中z、x、y是操作数，=、+是运算符。如图：
在这里插入图片描述

2、运算符

表示各种运算的符号称为运算符，Java中运算符大致分为赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符、复合赋值运算符等等。

2.1、赋值运算符

赋值运算符的作用即是为变量赋值，比如int a = 3。这里不再赘述。

2.2、算术元素符

算术运算符用来完成数学上的加、减、乘、除四则运算。例如：

运算符示例说明
+3 + 2加法运算符，求两个操作数的和
-3 - 2减法运算符，求两个操作数的差
*3 * 2乘法运算符，求两个操作数的积
/3 / 2除法运算符，求两个操作数的商
%3 % 2求余运算符，求两个整数的余数
++int num = 3; ++ num; num ++;自增运算符，相当于 num = num + 1
--int num = 3; -- num; num --;自减运算符，相当于 num = num - 1

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 25;
		System.out.println("num1 + num2 = " + (num1 + num2));
		System.out.println("num1 - num2 = " + (num1 - num2));
		System.out.println("num1 * num2 = " + (num1 * num2));
		System.out.println("num1 / num2 = " + (num1 / num2)); // 两个整型的操作数进行除法运算，结果也会是整型，小数部分会丢失
		System.out.println("num1 % num2 = " + (num1 % num2));
	}
}

说明

  • 两个整型的操作数进行除法运算，结果也会是整型，小数部分会丢失。

自增运算符++和自减运算符--出现在操作数前面或者后面时会有所不同。
下面是另一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 10;
		int num3 = 25;
		int num4 = 25;
		
		System.out.println("num1 ++ = " + (num1 ++));
		System.out.println("num1 = " + num1);
		
		System.out.println("++ num2 = " + (++ num2));
		System.out.println("num2 = " + num2);
		
		System.out.println("num3 -- = " + (num3 --));
		System.out.println("num3 = " + num3);
		
		System.out.println("-- num4 = " + (-- num4));
		System.out.println("num4 = " + num4);
	}
}

说明：

  • 表达式num ++和表达式++ num都会使num的值加上1，区别在于表达式num ++的返回值为num，而表达式++ num的返回值为num + 1。
  • 表达式num --和表达式-- num都会使num的值减去1，区别在于表达式num --的返回值为num，而表达式-- num的返回值为num - 1。

2.3、关系运算符

关系运算符用于操作数之间的比较。例如：

运算符示例说明
>num1 > num2如果num1 > num2成立，结果为true，否则结果为false
>=num1 >= num2如果num1 >= num2成立，结果为true，否则结果为false
<num1 < num2如果num1 < num2成立，结果为true，否则结果为false
<=num1 <= num2如果num1 <= num2成立，结果为true，否则结果为false
==num1 == num2如果num1 == num2成立，结果为true，否则结果为false
!=num1 != num2如果num1 != num2成立，结果为true，否则结果为false

下面是一个示例：

public class Test {
    public static void main(String[] args) {
        int num1 = 15;
        int num2 = 30;
        System.out.println("num1 == num2 = " + (num1 == num2));
        System.out.println("num1 != num2 = " + (num1 != num2));
        System.out.println("num1 > num2 = " + (num1 > num2));
        System.out.println("num1 < num2 = " + (num1 < num2));
        System.out.println("num2 >= num1 = " + (num2 >= num1));
        System.out.println("num2 <= num1 = " + (num2 <= num1));
    }
}

2.4、逻辑运算符

逻辑运算符是对布尔类型的操作数进行与、或、非的运算。例如：

运算符示例说明
&&true && true两个操作数均为true，结果为true，否则结果为false
||true || false两个操作数中有一个为true，结果为true，否则结果为false
!!(false)操作数为false，结果为true，否则结果为false

下面是一个示例：

public class Test {
    public static void main(String[] args) {
        // 逻辑运算符基本示例
        boolean b1 = true;
        boolean b2 = false;
        System.out.println("(b1 && b2) = " + (b1 && b2));
        System.out.println("(b1 || b2) = " + (b1 || b2));
        System.out.println("!(b1 && b2) = " + !(b1 && b2));

        // 逻辑运算符和关系运算符一起使用的例子
        int num1 = 15;
        int num2 = 10;
        int num3 = 30;
        System.out.println("(num1 > num2 && num1 > num3) = " + (num1 > num2 && num1 > num3));
        System.out.println("(num1 > num2 || num1 > num3) = " + (num1 > num2 || num1 > num3));
        System.out.println("!(num1 > num2 && num1 > num3) = " + !(num1 > num2 && num1 > num3));
    }
}

逻辑运算会出现短路的情形，即当使用&&运算符，第一个操作数为false时，不再判断第二个操作数；当使用||运算符，第一个操作数为true时，不再判断第二个操作数。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 5;
		int num2 = 5;
		boolean b1 = (num1 < 4) && (num1 ++ < 10);
		boolean b2 = (num2 > 4) || (num2 ++ > 10);
		System.out.println("b1 = " + b1);
		System.out.println("b2 = " + b2);
		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
	}
}

说明：

  • 输出结果中num1和num2的值均仍然为5，num1 ++ 和 num2 ++ 均没有被执行。

2.5、位运算符

位运算是对整数类型的操作数进行的二进制运算，总共7个，例如：

运算符说明
＆ （位与）如果相对应位都是1，则结果为1，否则为0
| （位或）如果相对应位都是0，则结果为0，否则为1
^ （位异或）如果相对应位值相同，则结果为0，否则为1
〜 (位反)按位取反运算符翻转操作数的每一位，即0变成1，1变成0
<< （左位移）左操作数按位左移右操作数指定的位数
>> （右位移）左操作数按位右移右操作数指定的位数
>>> （无符号右位移）左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 60; /* 60 = 0011 1100 */
		int num2 = 13; /* 13 = 0000 1101 */
		int num3 = 0;
		num3 = num1 & num2;       /* 12 = 0000 1100 */
		System.out.println("num1 & num2 = " + num3 );
		num3 = num1 | num2;       /* 61 = 0011 1101 */
		System.out.println("num1 | num2 = " + num3 );
		num3 = num1 ^ num2;       /* 49 = 0011 0001 */
		System.out.println("num1 ^ num2 = " + num3 );
		num3 = ~num1;          /*-61 = 1100 0011 */
		System.out.println("~num1 = " + num3 );
		num3 = num1 << 2;     /* 240 = 1111 0000 */
		System.out.println("num1 << 2 = " + num3 );
		num3 = num1 >> 2;     /* 15 = 1111 */
		System.out.println("num1 >> 2  = " + num3 );
		num3 = num1 >>> 2;     /* 15 = 0000 1111 */
		System.out.println("num1 >>> 2 = " + num3 );
	}
}

2.6、复合赋值运算符

复合赋值运算符是将算术运算和赋值运算同时进行的计算。例如（假设以下表达式中的变量a初始值为10）：

表达式等价的Java代码运行结果
num += 3num = num + 3num的结果是 13
num -= 3num = num - 3num的结果是 7
num *= 3num = num * 3num的结果是 30
num /= 3num = num / 3num的结果是 3
num %= 3num = num % 3num的结果是 1

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 10;
		int num3 = 10;
		int num4 = 10;
		int num5 = 10;
		System.out.println("(num1 += 3) = " + (num1 += 3));
		System.out.println("(num2 -= 3) = " + (num2 -= 3));
		System.out.println("(num3 *= 3) = " + (num3 *= 3));
		System.out.println("(num4 /= 3) = " + (num4 /= 3));
		System.out.println("(num5 %= 3) = " + (num5 %= 3));
	}
}

2.7、条件运算符（三元运算符）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要作用是决定哪个值应该赋值给变量。
条件运算符的语法如下：

[数据类型 变量名称 = ](布尔表达式) ? 值 if true : 值 if false;

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 , num2, num3;
		num1 = 10;
		// 如果 num1 等于 1 成立，则设置 num2 为 20，否则为 30
		num2 = (num1 == 1) ? 20 : 30;
		System.out.println( "Value of num2 is : " +  num2 );

		// 如果 num1 等于 10 成立，则设置 num3 为 20，否则为 30
		num3 = (num1 == 10) ? 20 : 30;
		System.out.println( "Value of num3 is : " + num3 );
	}
}

3、运算符的优先级

当表达式中有多个运算符参与运算时，必须为每种运算符规定一个优先级，以决定运算符在表达式中的运算次序。优先级高的先运算，优先级低的后运算，优先级相同的由结合性确定计算次序。运算符的优先级及结合性如下表所示：

运算符优先级结合性
()、[]、.（点操作符）1从左向右
+（一元运算）、-（一元运算）、++、--、!、~2从右向左
*、/、%3从左向右
+、-4从左向右
>>、>>>、<<5从左到右
>、>=、<、<=6从左到右
==、!=7从左到右
&8
^9
|10
&&11
||12
? :13从右到左
=、+=、-=、*=、/=、%=14从右到左

4、案例

下面是一个接收控制台输入数据，并综合运用表达式和运算符的案例。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int xb_java;
		int xb_html;
		int lb_java;
		int lb_html;
		System.out.println("请输入新兵的java成绩");
		xb_java = input.nextInt();
		System.out.println("请输入新兵的html成绩");
		xb_html = input.nextInt();
		System.out.println("请输入老兵的java成绩");
		lb_java = input.nextInt();
		System.out.println("请输入老兵的html成绩");
		lb_html = input.nextInt();
		System.out.println("新兵的平均成绩是：" + (xb_java + xb_html) / 2);
		System.out.println("老兵的平均成绩是：" + (lb_java + lb_html) / 2);
		System.out.println("新兵java成绩追上老兵了吗? " + ((xb_java >= lb_java) ? "是的" : "没有"));
		System.out.println("新兵html成绩超过老兵了吗? " + ((xb_html > lb_html) ? "是的" : "没有"));
		System.out.println("新兵的平均成绩追上老兵了吗? " + ((((xb_java + xb_html) / 2) >= ((lb_java + lb_html) / 2)) ? "是的" : "没有"));
		System.out.println("新兵每门课成绩都追上老兵了吗? " + (((xb_html > lb_html) && (xb_java > lb_java)) ? "是的" : "没有"));
	}
}

说明：

  • 本例中涉及了如何从键盘上输入数据。JDK中提供了很多已经开发好的类库，在程序开发过程中可以直接使用。java.util.Scanner类提供了获取用户在控制台中输入的数据的功能。使用时分为两步：
    // 1.创建Scanner对象，该对象用于接收用户在控制台中输入的数据
java.util.Scanner input = new java.util.Scanner(System.in); 
// 2.使用Scanner对象提供的方法获取用户输入的数据
int score = input.nextInt();
    java.util.Scanner类的实例拥有多种方法用于输入不同类型的数据，如下表：
    方法方法说明
    next()输入字符串
    nextInt()输入int类型整数
    nextShort()输入short类型整数
    nextLong()输入long类型整数
    nextFloat()输入float类型浮点数
    nextByte()输入byte类型数据

七、数据类型转换

Java中，整型、常量、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。转换顺序从低级到高级。如下：

低  ---------------------------------------->  高
byte,short,char —> int —> long —> float —> double

需要注意：

  • 不能对boolean类型进行类型转换。
  • 转换过程中可能导致溢出或损失精度。
  • 浮点数到整数的转换是通过舍弃小数得到。

1、自动类型转换

当将低级别的值赋给高级别的变量时，系统会自动完成数据类型的转换。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		long num1 = 333333333; // 末尾没有字母l或L的整型字面量，通常会被当作int类型，赋值给long型的变量时，会进行自动数据类型转换
		double num2 = 12.34F;  // 12.34F是一个float型的浮点数，赋值给double型的变量时，会进行自动数据类型转换
		int num3 = 52;
		float num4;
		num4 = num3; // 将int类型的变量num3的值赋值给float类型的变量num4,会进行自动数据类型转换
	}
}

2、强制类型转换

当将高级别的值赋给低级别的变量时，需要进行强制类型转换。形式如下：

 (数据类型) 待转换的值;

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		float num1 = (float) 12.34; // 末尾没有字母f或F的浮点型字面量，会被当作double类型，赋值给float型的变量时，需要强制类型转换
		int num2 = (int) 3333333L; // 3333333L是一个long类型的整数，赋值给int类型的变量时，需要强制类型转换
		float num3 = 1.6F;
		int num4 = (int) num3; // 将float类型的变量num3的值赋值给int类型的变量num4,需要强制类型转换
	}
}

3、表达式返回结果的数据类型

表达式返回结果的数据类型一般由表达式中占用字节空间最大的类型决定。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 5;
		float num2 = 6f;
		double num3 = 7.8;
		double result = num1 + num2 + num3;
		System.out.println("result = " + result);
	}
}

字符串String与其他数据类型进行+运算时，都会将其他数据类型先转换为String，然后两个字符串进行拼接。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 15;
		float num2 = 13.24F;
		String str = "hello";
		System.out.println("(num1 + num2 + str) = " + (num1 + num2 + str));
		System.out.println("(num1 + str + num2) = " + (num1 + str + num2));
		System.out.println("(str + num1 + num2) = " + (str + num1 + num2));
	}
}

byte类型的变量值之间、short类型的变量值之间、或者byte类型的变量值和short类型的变量值，它们在进行运算时，结果为int类型。
下面是一个示例：

public class Test {
	public static void main(String[] args) {
		byte num1 = 1;
		short num2 = 1;
		//short num3 = num1 + num2; // 本行会报错，因为byte类型的变量值与short类型的变量值进行+运算，结果为int类型
		int num4 = num1 + num2;
		System.out.println("num4 = " + num4);
	}
}

4、案例

4.1、案例一

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		int num1 = 15, num2 = 4, num3;
		float num4, num5;
		num3 = num1 / num2;
		num4 = num1 / num2;
		num5 = (float) num1 / num2;
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);
		System.out.println("num5 = " + num5);
	}
}

说明：

  • num3的值为3，因为两个int类型的操作数进行除法运算，结果仍然是整数，会丢失小数部分，故num1 / num2的结果为3，之后，将数值3赋值给int类型的变量num3，打印num3的结果即为3。
  • num4的值为3.0，同上，num1 / num2的结果为3，将整数3赋值给float型的变量num4时，会自动进行数据类型转换，整型的3转换为浮点型的3.0。
  • num5的值为3.75，因为表达式中先将num1进行了强制类型转换，整形的num1保存的值15在强制转换为float型后值为15.0，此时进行15.0 / num2运算，表达式返回结果的数据类型由表达式中占用字节空间最大的类型决定，故结果为float型，值为3.75，再将浮点数3.75赋值给float类型的变量num5，最终，num5的打印结果为3.75。

4.2、案例二

下面是一个示例：

public class Test {
	public static void main(String[] args) {
		short s1 = 18;
		short s2;
		//s2 = s1 + 1;  // 本行会报错，因为1会被认为是int类型，所以s1 + 1的值会是int类型，无法直接赋值给short类型的变量
		short s3;
		s3 = 18 + 1;     // 本行没有错误，表达式18 + 1在编译时确定了其值在short范围内，因此可以赋值
		System.out.println("s3 = " + s3);
	}
}

说明：

  • 表达式s2 = s1 + 1报错，因为1会被认为是int类型，所以s1 + 1的值会是int类型，无法直接赋值给short类型的变量s2。
  • 表达式s3 = 18 + 1没有报错，表达式18 + 1在编译时确定了其值19在short范围内，因此可以赋值。
chodenke
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章：数据类型、运算符与表达式-笔记总结
henyi2211的专栏
03-29 2583
JAVA ———变量和数据类型与运算符
biteqq的博客
12-24 295
数据类型基本类型引用类型 基本类型 基本类型有 8 种 byte //1字节 short //2字节 int //4字节 long //8字节 float //4字节 double //8字节 boolean //无规定 //类的名称不能出现空格或其他特殊 首字母大写 //IDEA 的快捷工具 shift+F6 //反之，凡是看到首字母大写的都是类 public class HelloWorld { public static void main(String[] args){
数据类型、运算符与表达式
前端尨猫的博客
05-12 564
数据类型、运算符与表达式 数据是程序处理的对象，是程序设计中的重要组成部分。C语言为我们提供了丰富的数据类型和运算符及语法规则。变量和常量是程序处理的两种基本数据。运算符指定将要进行的操作。表达式则把变量和常量结合起来生成新的值。数据的类型决定该数据可取值的范围以及可以对该数据进行的操作。 C语言中常用的数据类型 C语言中把程序处理的基本诗句对象分成几个集合（或分类），属于同一集合的数据具有相同的...
java字面量_java基本数据类型的字面量
weixin_28907839的博客
02-12 1186
java的基本数据类型一共有8种。其中：(每种类型后面列出了java中的该类型的字面量)四种整型：int4字节； 12 +12 -12 077 0xFF 0b101(JDK7中支持的二进制表示) 字面范围：0x800000000 --> 0x7FFFFFFFshort2字节； 2个字节内的int字面量可以认为是short类型的字面量，可以给short变量赋值 字面范围：(shor...
Java 学习笔记：第二章 数据类型和运算符
人在囧途的博客
04-06 381
Java 学习笔记：第二章 数据类型和运算符2.1 注释2.2 标识符标识符的使用规范2.3 Java中的关键字/保留字2.4.1 变量的本质变量的声明2.4.2 变量的分类局部变量（local variable）成员变量（也叫实例变量 member variable）静态变量（类变量 static variable）2.5 常量2.6 基本数据类型（primitive data type）Jav...
JAVA学习笔记1 数据类型以及作用域+运算符
mosun_zgs的博客
01-25 326
总结自JAVA狂神说+韩顺平
Java运算符和表达式--学习笔记.docx
07-05
Java运算符和表达式是编程基础中的重要组成部分，它们用于操控和组合变量，形成复杂的逻辑。在Java中，运算符大致分为六类：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符和其他运算符。 算术运算符...
Python学习笔记 第三章(变量,表达式,运算符)
12-22
在Python中会自动判断数据类型(type(变量)来输出变量类型) 支持的数字类型: int,float,complex 变量的声明: test_num = 123 #整型 test_num = 12.3 #浮点型 ...... 变量命名的规定: 必须以字母或下划线开头，其他...
javascript学习笔记整理（概述、变量、数据类型简介）
10-23
在JavaScript中，理解和掌握变量及数据类型是非常基础且重要的。 ### A. 概述 JavaScript的主要输出工具有： 1. **`document.write()`**：用于在HTML文档中输出JavaScript变量或表达式的结果。它可以插入HTML内容...
java学习笔记总结
04-02
首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本数据类型：byte、short、int、long、float、double、char和boolean。在编程中，变量是存储数据的容器，理解它们的作用域和生命...
Python字符串与正则表达式学习笔记
12-20
`type()`函数用于查看变量的数据类型。例如： ```python a = 1 b = 1.1 c = True d = False print(type(a), type(b), type(c), type(d)) ``` 布尔值在进行数值运算时，`True`相当于`1`，`False`相当于`0`： ```...
Java学习笔记02 - 变量、数据类型、表达式和运算符
yups
03-06 610
一、标识符 1、标识符的概念 Java所有的组成部分都需要名字，如类名、变量名以及方法名，所有这些名称所使用的字符串序列即被称为标识符。 2、标识符规则 2.1、基本规则 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始。 首字符之后可以是字母（A-Z或者a-z）、美元符（$）、下划线（_）或数字的任何字符组合。 关键字不能用作标识符。 标识符是大小写敏感的。 ...
Java学习——Java数据类型和运算符
qq_42587113的博客
07-17 111
黑马程序员--------------java基础语法（—）------常量，变量，数据类型和运算符
u011277761的博客
04-25 275
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
**小白的Java学习之旅**------变量 数据类型 表达式 运算符
HoneyHeart的博客
02-22 289
小白的Java学习之旅------变量 数据类型 表达式 1、什么是变量？ 概念：内存中的一块空间，可以存放数据，简单来说，就是“数据的家”。 硬盘（外存）：数据会永久的存放在计算机中。 内存条（内存）：程序运行时会加载一些数据，这些数据 一般会随着程序的结束而被释放掉，不会永久的保存在计算机中。 通俗的理解： 变量 ------&amp;amp;amp;amp;amp;amp;gt;酒店 变量名 ------&amp;amp;amp;amp;amp;amp;gt;酒店的
java章节性质习题及答案
zhangMY12138的博客
09-12 4252
第一章Java简介 4 1.1 Java发展历史 4 1.2 Java虚拟机 4 1.3 Java特点 5 1.4 Java搭建开发环境 6 1.5 编写第一个java程序 6 1.6 章节复习与训练 6 第二章变量、数据类型 7 2.1数据类型 7 2.2变量及赋值 7 2.3 标识符 8 2.4 关键字和保留字 9 2.5 类型转换 9 ...
java表达式的类型_JAVA -数据类型与表达式---表达式
weixin_31043555的博客
02-26 713
表达式由一个以上的运算符和操作数按一定规则组合而成，通常用于完成计算。计算结果一般是一个数值，但也不一定总是数值。用于计算的操作数可能是数值常量、符号常量、变量或其他某种类型的数据。计算和使用表达式的方式，是程序设计的基础。下面重点讨论使用数值运算符并产生数值结果的算术表达式。重点概念：表达式是运算符和操作数按一定规则构成的组合，用于完成计算。算术运算符算术运算符用于整型和浮点型数据的运算，包括加...
JAVA学习笔记 12 - 包装类和数字处理
codeke的博客
11-01 755
本文是Java基础课程的第十二课。本文主要介绍Java中包装类的概念及使用，Java针对数字处理所提供的一些常用的类库，如java.text.NumberFormat、java.lang.Math、java.math.BigInteger等等
JAVA SE学习笔记(七)：终章：Java程序设计基础笔记（全10万字）
12-21
本章主要介绍了Java的基础语法部分，包括数据类型、引用类型、基本数据类型转换和运算符。 数据类型是Java编程的基础，它们定义了变量可以持有的数据的类型和范围。 引用类型中的String类在Java中的使用非常广泛，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值