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

最新推荐文章于 2022-04-06 16:46:01 发布
最新推荐文章于 2022-04-06 16:46:01 发布
阅读量732 收藏 3
点赞数 1
分类专栏： Java学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Class013/article/details/104701069
版权

一、标识符

1、标识符的概念

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

2、标识符规则

2.1、基本规则
  • 所有的标识符都应该以字母（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、基本数据类型的概念

数据是描述客观事物的数字、字母以及能够输入到计算机中的符号。
在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种基本数据类型外，其他的数据类型都是引用数据类型，包括数组、接口、类等。

三、字面量

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

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

四、变量

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、算数运算符

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

运算符说明
+加法运算符，求两个操作数的和
-减法运算符，求两个操作数的差
*乘法运算符，求两个操作数的积
/除法运算符，求两个操作数的商
%求余运算符，求两个整数的余数
++自增运算符，相当于 num = num + 1
--自减运算符，相当于 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、复合赋值运算符

复合赋值运算符是将算术运算和赋值运算同时进行的计算。（num的初始值是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,需要强制类型转换
	}
}
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范围内，因此可以赋值。
Python学习笔记 - 探索运算符和表达式
Mr数据杨
04-24 8053
通过本教程，我们系统地探讨了Python中各种运算符和表达式的使用，从最基础的算术运算符，到复杂的逻辑运算符、比较运算符、位运算符、身份运算符，以及它们的优先级。每种运算符不仅有明确的定义和操作方式，还通过实际生活中的例子和编程示例，使这些概念更加直观和易于理解。在编程过程中，掌握这些运算符的使用，不仅能够编写出更加高效和简洁的代码，还能帮助你在面对复杂问题时，做出更清晰的逻辑判断和决策。无论是用于基础的数学计算，还是在条件控制、数据处理、逻辑判断等高级应用中，运算符都是不可或缺的工具。
Java 基本数据类型 和 运算符表达式
TheWhiteFox的博客
10-31 522
文章目录一、Java 基本数据类型二、运算符和表达式 一、Java 基本数据类型 #mermaid-svg-xnnxGqfkZOON7FtJ .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-xnnxGqfkZOON7FtJ .label text{fill:#333}#mermaid-svg-xnnxGqfkZO
java 基础JAVA中的数据类型、变量、运算符、表达式
12-07
JAVA中的关键字、标识符、注释 JAVA中的数据类型、变量、运算符、表达式 JAVA类中方法的调用
JavaSE基础，变量和数据类型，学习笔记
Smithereens的学习笔记
08-31 403
关键字：       1、全部是小写       2、变色的，有特殊含义的英文单词、不能写错。       关键字个数：40+ 数据类型：       计算机的本质是处理数据和保存数据       数字类型             可以用来计算       文本类型             不能用来计算 java当中的数据类型（关键字）： 数字类型 数字类型 中文 ...
02 数据类型转换、运算符、方法入门
朱古力的博客
05-10 268
目录Java基础语法之数据类型转换、运算符、方法入门一、数据类型转换1. 自动转换（隐式）2. 强制转换（显式）3. 注意事项4. ASCII编码表二、运算符1. 算术运算符2. 赋值运算符3. 比较运算符4. 逻辑运算符5. 三元运算符三、方法入门1. 方法的定义2. 方法的调用四、JShell简单使用五、编译器的两点优化1. 对于`byte/short/char`三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器将会自动隐含的为我们补上一个`(byte)/(short)/(char)`。
JAVA学习笔记 02 - 变量、数据类型、表达式和运算符
codeke的博客
10-13 847
本文是Java基础课程的第二课。主要介绍Java中的变量、数据类型、表达式和运算符、数据类型转换等基础知识
**小白的Java学习之旅**------变量 数据类型 表达式 运算符
HoneyHeart的博客
02-22 329
小白的Java学习之旅------变量 数据类型 表达式 1、什么是变量？ 概念：内存中的一块空间，可以存放数据，简单来说，就是“数据的家”。 硬盘（外存）：数据会永久的存放在计算机中。 内存条（内存）：程序运行时会加载一些数据，这些数据 一般会随着程序的结束而被释放掉，不会永久的保存在计算机中。 通俗的理解： 变量 ------&amp;amp;amp;amp;amp;amp;gt;酒店 变量名 ------&amp;amp;amp;amp;amp;amp;gt;酒店的
Python学习笔记 第三章(变量,表达式,运算符)
12-22
在Python中会自动判断数据类型(type(变量)来输出变量类型) 支持的数字类型: int,float,complex 变量的声明: test_num = 123 #整型 test_num = 12.3 #浮点型 ...... 变量命名的规定: 必须以字母或下划线开头，其他...
Java运算符和表达式--学习笔记.docx
07-05
Java运算符和表达式是编程基础中的重要组成部分，它们用于操控和组合变量，形成复杂的逻辑。在Java中，运算符大致分为六类：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符和其他运算符。 算术运算符...
c语言运算符 %3c%3c4,C语言学习笔记二---数据类型运算符与表达式
weixin_32424555的博客
05-22 2859
一.C的基本语法单位1.标识符：有效长度：31(DOS环境下)2.关键字：main不是3.分隔符：空格符，制表符，换行符，换页符4.注释符：a./*.....*/ b.//二.C的常用输入/输出函数1.printf:a.格式：printf("输出格式"，输出项序列)例子：printf("%d",5,6); //输出结果为5，但格式错误，不建议这样写类型格式字符串输出形式整型%d%o%x或%X...
Powershell学习笔记--使用正则表达式查找文件
10-25
它提供了丰富的命令和函数，其中包括使用正则表达式进行字符串匹配和文件查找的功能。正则表达式是一种定义搜索模式的文本模式，能够对字符串进行复杂的匹配和操作，广泛应用于各种编程和脚本语言中。 在PowerShell...
Java学习——Java数据类型和运算符
qq_42587113的博客
07-17 172
java入门-标识符，数据类型，运算符，表达式概述
深思
03-31 320
一、java标识符 1.标识符是编程时使用的名字：Java对包、类、接口、方法、变量、常量（不包括项目名）等命名时使用的字符序列称为标识符。 2.Java标识符有如下命名规则： 1、标识符由字母、数字、 “_”、 “$”组成，且首字母不能是数字； 2、不能把Java关键字作为标识符； 3、标识符没有长度限制； 4、标识符对大小写敏感。 3....
java入门基础笔记——数据类型与运算符（一）
weixin_44694200的博客
02-28 319
java入门基础笔记——数据类型与运算符（一） 1、数据类型 实体的属性在程序中用数据来表达，这些数据可分为常量和变量。无论是常量数据还是变量数据，都会有其特定的数据类型，这些类型决定了常量和变量的表达方式、取值范围，以及可执行的操作。 （1）基本数据类型——共有8个 类型名称 符号 占用字节 封装类型 布尔型 boolean 1字节 Boolean 字符型 char 2字节 ...
JavaSE-变量、数据类型、表达式、运算符
YDSoong的博客
03-24 236
变量、数据类型、表达式、运算符 一、数据类型（基础重点） 1.基本数据类型 （1）整数类型 byte 1B -128~127 short 2B -32768~32767 int 4B -2147483648~2147483647 long 8B -922京 ~ 922京-1 注意： 字面值：程序中可以赋值的数据。 long字面值后面需要加l或是L，建议加L，用于区分数 字1和字母l。 Java...
数据类型、运算符与表达式
前端尨猫的博客
05-12 724
数据类型、运算符与表达式 数据是程序处理的对象，是程序设计中的重要组成部分。C语言为我们提供了丰富的数据类型和运算符及语法规则。变量和常量是程序处理的两种基本数据。运算符指定将要进行的操作。表达式则把变量和常量结合起来生成新的值。数据的类型决定该数据可取值的范围以及可以对该数据进行的操作。 C语言中常用的数据类型 C语言中把程序处理的基本诗句对象分成几个集合（或分类），属于同一集合的数据具有相同的...
c_lang_Reference_040809_02
计算机的fans
08-09 1148
文字来源 VC世界--C语言教室自我存档，也献给和我一样的DElphi程序员Ｃ语言的数据类型变量的说明可以包括三个方面：·数据类型·存储类型·作用域所谓数据类型是按被说明量的性质，表示形式，占据存储空间的多少，构造特点来划分的。在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。1.基本数据类型　　基本数据类型最主要的特点是，其值不可以再分解为其它类
js的表达式，运算符，与优先级
_米粒儿_的博客
08-21 441
表达式 表达式与数学中的定义相似，表达式是指具有一定的值、用操作符把常数和变量连接起来的代数式。一个表达式可以包含常数或变量。 。。。与其他语言相同的省略。。。 比较操作符中有一个比较特殊的，“===”，在此解释一下：    ==：等于，如果两个操作数相等，则返回true，主要强调内容相等；            ===：全等于，值相等，数据类型也相等，强调内容和地址都相等 操作符之
三、变量与运算符
pass_x的博客
04-06 396
博客说明： 仅是作为学习过程中的记录笔记，便于后期复习并不断修改完善 欢迎阅读、沟通和指正，谢谢 资料来源：包括但不限于B站、博客、淘宝、书籍等 变量 一、关键字（keyword） 关键字概念 被java赋予了特定涵义的英文单词 关键字的特点 关键字的字母全部小写 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观 注：main不是关键字，但是JVM在执行代码的时候，只会识别该单词 二、字面常量 概念 常量：在程序的执行过程中，其值不会发生改变的量（数据）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值