Java-Day03 变量、关键字、标识符、数据类型及数据类型之间的转换、运算符

Golang_HZ

已于 2022-07-25 10:02:30 修改

阅读量399

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2022-07-10 19:16:51 首次发布

本文链接：https://blog.csdn.net/weixin_51612062/article/details/125702029

版权

Java 专栏收录该内容

21 篇文章 2 订阅

订阅专栏

2.2 保留字 (reserved word)

4.1.1 基本数据类型（8种primitive type）

4.1.2 引用数据类型（reference type）

6.6.2 计算机底层到底是如何保存数据的

6.6.3 进制之间的转换问题

1. Java的变量

1.1 什么是变量

变量：Variable，可以在程序运行时(runtime)发生变化的量，叫做变量；

站在存储方式的角度：具有名称的内存空间，叫做变量

变量是内存中的一个存储区域。该区域的数据可以在同一类型范围内不断变化

变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。

常量：恒量，在程序运行时(runtime)值不能变化的量，叫做常量

1.2 编程语言中为什么使用变量：

编程中使用变量的目的就是为了降低编程的维护成本和开发成本，提高代码的灵活性

1.3 Java如何定义变量

变量初始化：

在定义变量的同时，初始化一个值

java定义变量的格式：

数据类型变量名称 = 变量值;

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

int a = 30;
double b;
b = 3.14；

Java中每个变量必须先声明，后使用。

变量必须先声明，后使用
变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
同一个作用域内，不可用声明两个同名的变量

class VariableTest {
	public static void main(String[] args) {
		//变量的定义
		int myAge = 12; 
		//变量的使用
		System.out.println(myAge);

		//编译错误：使用myNumber之前并未定义myNumber
		//System.out.println(myNumber);

		//变量的声明
		int myNumber;

		//编译错误：使用myNumber之前并未赋值过myNumber
		//System.out.println(myNumber);

		//变量的赋值
		myNumber = 1001;

		System.out.println(myNumber);
		
		//编译错误：使用的myClass不在该作用域内
		//System.out.println(myClass);

		//编译错误：不可用在同一个作用域内定义同名的变量
		//int myAge = 22;
	}

	public void method() {
		int myClass = 1;
	}
}

2. 关键字和保留字

2.1 关键字（keyword）

被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母小写

官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

用于定以数据类型的关键字：byte、short、int、long、float、double、char、boolean、void、class、interface
用于定义数据类型值的关键字：true、false、null
用于定义流程控制语句的关键字：if、else、switch、case、default、whlie、do、for、break、continue、return
用于定义访问权限修饰符的关键字：public、protected、private
用于定义继承关系的关键字：extends、implements
用于定义实例对象的关键字：new、this、super、instanceof
用于定义函数类型的关键字：static、final、abstract、syschronized
用于异常处理的关键字：try、catch、finally、throw、throws
用于包定义的关键字：package、import
其他的一些修饰关键字：native、assert、volatile、transient

2.2 保留字 (reserved word)

现有Java版本尚未使用，但以后版本可能会作为关键字使用。命名标识符时要避免使用保留字 goto 、const

3. 标识符

标识符：Java中对各种变量、方法和类等要素命名时使用的字符序列（单词）

技巧：凡是自己起名字的地方都可以叫标识符

3.1 定义合法标识符规则

注意：如果不遵守如下规则，编译不通过

由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

3.2 Java中的名称命名规范

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz（大驼峰式）

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz（小驼峰式）

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意：1. 如果不遵守如上规范，编译也可以通过！建议大家遵守

2. 在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

2. java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

4. Java的数据类型(强类型语言)

在生活中，使用的数据有大有小，有整数，也有小数，同时也会使用字母，或者汉字表示特定含义。在Java中根据数据的不同特点，数据也分为不同的类型。

Java、C语言、C++、C#这些语言都是强数据类型语言值的类型是确定，也是不能随意改变的；python、PHP、JavaScript这些语言都是弱数据类型语言，类型可以随意变化。

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

4.1 变量按照数据类型来分

4.1.1 基本数据类型（8种primitive type）

1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
① byte范围：-128 ~ 127
② 声明long型变量，必须以"l"或"L"结尾
③ 通常，定义整型变量时，使用int型。
④ 整型的常量，默认类型是：int型

2. 浮点型：float(4字节) \ double(8字节)
① 浮点型，表示带小数点的数值
② float表示数值的范围比long还大
③ 定义float类型变量时，变量要以"f"或"F"结尾
④ 通常，定义浮点型变量时，使用double型。
⑤ 浮点型的常量，默认类型为：double

3. 字符型：char (1字符=2字节)
① 定义char型变量，通常使用一对'',内部只能写一个字符
② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量

转义字符	说明
\b	退格符
\n	换行符
\r	回车符
\t	制表符
\"	双引号
\'	单引号
\\	反斜线

4. 布尔型：boolean
① 只能取两个值之一：true 、 false
② 常常在条件判断、循环结构中使用

整数常量默认：int 小数，常量默认：double

A：变量； 'A'：字符串; "A"：字符串

4.1.2 引用数据类型（reference type）

类（class，字符串String是类类型的）
接口（interface）
数组（array[ ]）

String类型变量

1.String属于引用数据类型

2.声明String类型变量时，使用一对""

3.String可以和8种基本数据类型变量做运算，且运输只能是连接运算：+

4.运算结果仍然是String类型

String类型和基本数据类型之间的转换

基本类型转换为字符串有三种方法：

1. 使用包装类的 toString() 方法

2. 使用String类的 valueOf() 方法

3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

再来看，将字符串转换成基本类型有两种方法：

1. 调用包装类的 parseXxx 静态方法

2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱

4.2 变量在类中声明的位置

成员变量 vs 局部变量

5. Java的数据类型的转换

前提：这里讨论的只是七种基本数据类型变量直接的运算。不包含boolean类型的。

5.1 自动类型提升

整数和浮点型运算，整形会自动向浮点型转换

当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

char、byte 、short ==> int ==> long ==> float ==> double ==> String(数值型字符串)

此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

如果是整数，默认转换的类型是int ！！！

如果是浮点型，默认的类型是double

class VariableTest2 {
	public static void main(String[] args) {
		byte b1 = 2;
		int i1 = 129;
		//编译不通过:不兼容的类型
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l2 = b1 + i1;
		System.out.println(i2);

		float f = b1 + i1;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);   //123.0

		//***************特别地********************
		char c1 = 'a';  //97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);
		
		short s2 = 10;
		//short s3 = c1 + s2;//编译不通过
		//char c2 = c1 +s2;//编译不通过
		
		byte b2 =10;
		//char c3 = c1 + b2;//编译不通过
		
		//short s3 = b2 + s2;//编译不通过
		
		//short s4 = b1 + b2;//编译不通过
	}
}

5.2 强制类型转换

自动类型提升运算的逆运算。不包含boolean类型、String的

1.需要使用强转符：()

2.注意点：强制类型转换，可能导致精度损失。

3.boolean型不能进行强制类型转换

class VariableTest3 {
	public static void main(String[] args) {
		double d1 = 12.9;
		//精度损失举例1
		int i1 = (int)d1; //截断操作
		System.out.println(i1); //结果：12
		
		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);  //结果：-128
	}
}

6. 运算符

Java中常见的运算符：算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符

6.1 算术运算符

算术运算符就是数学中的四则运算

算术运算符	运算	范例	结果
+	加	5 + 5	10
-	减	6 - 4	2
*	乘	3 * 4	12
/	除	4 / 2	2
%	取余(模)	7 % 5	2
++a	自增(前)：先自增1，后运算	a = 2; b = ++a	a = 3; b = 3
a++	自增(后)：先运算，后自增1	a = 2; b = a++	a = 3; b = 2
--a	自减(前)：先自减1，后运算	a = 2; b = --a	a = 1; b = 1
a--	自减(后)：先运算，后自减1	a = 2; b = a--	a = 1; b = 2

注意：

1. 对于++、-- 自增自减运算符而言，不管前还是后，对于变量的本身而言肯定要进行加1或者减1操作；

2. 在自加、自减运算中，前加加或者前减减优先级别非常高，仅次于括号。后加加和后减减的优先级别非常低，甚至比赋值符(=)还低

public class SignTest {
    public static void main(String[] args) {
        System.out.println(5 + 5);  // 10
        System.out.println(6 - 4);  // 2
        System.out.println(3 * 4);  // 12
        System.out.println(4 / 2);  // 2
        System.out.println(7 % 5);  // 2
        int a, b;
        a = 2;
        b = ++a;
        System.out.println("a = " + a + ", b = " + b); 
        // a = 3, b = 3
        a = 2;
        b = a++;
        System.out.println("a = " + a + ", b = " + b);
        // a = 3, b = 2
        a = 2;
        b = --a;
        System.out.println("a = " + a + ", b = " + b);
        // a = 1, b = 1
        a = 2;
        b = a--;
        System.out.println("a = " + a + ", b = " + b); 
        // a = 1, b = 2
    }
}

6.2 关系(比较)运算符

关系运算符	运算	范例	结果
==	相等于	4 == 3	false
!=	不等于	4 != 3	true
<	小于	4 < 3	false
>	大于	4 > 3	true
<=	小于等于	4 <= 3	false
>=	大于等于	4 >= 3	true
instanceof	检查是否是类的对象	"Hello" instanceof String	true

比较运算符的结果是boolean型，也就是要么是true，要么是false。

比较运算符“==”不能误写成“=”，“=”是赋值符。

class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;
		
		System.out.println(i == j);//false
		System.out.println(i = j);//20，先将j赋值给i，然后输出i
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}
}

6.3 逻辑运算符

两个或者更多条件之间的关联关系，逻辑运算符操作的都是boolean类型的变量

与：有false则false；或：有true则true；异或：同为false，异为true

下面表格中 a = 1, b = 1

逻辑运算符	运算	范例	结果
&	逻辑与：&左右两边都为true，则为true，有false则false	a > 0 & b > 0 ==> true & true	true
&&	短路与：和&一样。但是当&&左边为false时，则&&右边的不执行	a < 0 && b++ > 0 ==> false & 不执行	false
\|	逻辑或：\| 左右两边有true，则为true	a < 0 \| b > 0 ==> false & true	true
\|\|	短路或：和 \| 一样。但是当 \|\| 左边为true时，则 II 右边的不执行	a > 0 \|\| b++ > 0 ==> true & 不执行	true
!	逻辑非：! true => false；! false => true	!(a > 0) ==> !true	false
^	逻辑异或：^左右两边同为true或false时，为fasle，不同，则为true	a > 0 ^ b > 0 ==> true ^ true	false

注意：&&和||，如果前面的条件已经可以得到结果，则不会继续向后判断，效率更高。

而单&、|，即便是已经得到结果，还是会继续完成所有的判断，再返回结果

在开发中，一般推荐使用&&、||

public class LogicTest {
    public static void main(String[] args) {
        int a = 1, b = 1;
        System.out.println(a > 0 & b > 0);  // true
        System.out.println(a < 0 && b++ > 0);  // false
        System.out.println(b); // 1
        System.out.println(a < 0 | b > 0);  // true
        System.out.println(a > 0 || b++ > 0);    // true
        System.out.println(b); // 1
        System.out.println(!(a > 0)); // false
        System.out.println(a > 0 ^ b > 0); // false
    }
}

6.4 赋值运算符

赋值运算符	运算	范例	结果
=	赋值符	a = 1	a = 1
+=	加法赋值操作符	a += 2	a = 3
-=	减法赋值操作符	a -= 1	a = 2
*=	乘法赋值操作符	a *= 4	a = 8
/=	除法赋值操作符	a /= 2	a = 4
%=	取模赋值操作符	a %= 2	a = 0

赋值运算符只能用在变量身上。

public class SetValueTest {
    public static void main(String[] args) {
        int a = 1;
        System.out.println("a = " + a); // a = 1
        a += 2;
        System.out.println("a = " + a); // a = 3
        a -= 1;
        System.out.println("a = " + a); // a = 2
        a *= 4;
        System.out.println("a = " + a); // a = 8
        a /= 2;
        System.out.println("a = " + a); // a = 4
        a %= 2;
        System.out.println("a = " + a); // a = 0
    }
}

6.5 三目(木)运算符

1. 结构：

数据类型 变量名 = 布尔表达式 ? 值1：值2;

2. 说明：

①条件表达式的结果为boolean类型
②根据条件表达式都真或假，决定执行表达式1，还是表达式2
如果表达式为true，则执行表达式1；如果表达式为false，则执行表达式2。
③表达式1和表达式2要求是一致的
④三元运算符可以嵌套使用

3. 凡是可以使用三元运算符的地方，都可以改写成if-else；反之，不成立。

4. 如果程序可以使用三元运算符，又可以使用if-else结构，那么优先使用三元运算符。原因：简洁、效率高

6.6 位运算符

位运算符	运算	范例	结果
&	按位与：相同位都为1，则为1，若有0，则为0	3 & 2	0000 0011 0000 0010 0000 0010 ==> 2
\|	按位或：相同位若有1，则为1	3 \| 2	0000 0011 0000 0010 0000 0011 ==> 3
^	按位异或：相同位同为1或0，则为0，若不同，则为1	3 ^ 2	0000 0011 0000 0010 0000 0001 ==> 1
~	按位取反：所有位都进行取反，注意和反码不一样	~3	0000 0011 1111 1100 =>1111 1011 ==> 1000 0100 ==> -4
<<	左移运算：二进制向左移动，末尾补0	3 << 2	12 ==> 3 * 2^2
>>	右移运算：有符号二进制向右移动，补符号位0/1	-3 >> 1	-2 ==> -3 * 2^1
>>>	无符号右移：无符号二进制向右移动，补0	-3 >>> 1	2147483646

位运算是直接对整数的二进制进行的运算，注意：没有<<<，无符号右移只是对32位和64位的值有意义。

public class BitTest {
    public static void main(String[] args) {
        System.out.println(3 & 2);  // 2
        System.out.println(3 | 2);  // 3
        System.out.println(3 ^ 2);  // 1
        System.out.println(~3);    // -4
        System.out.println(3 << 2); // 12
        System.out.println(-3 >> 1); // -2
        System.out.println(-3 >>> 1);// 2147483646
    }
}

移位运算的一些规则，在运算中的使用：
   1. &运算符
       a. 判断奇偶
           num % 2 == 0
           num & 1 == 0
       b. 判断一个数是否是2的幂次方
           num & (num - 1)

   2. 异或运算
       任何数和0异或，值不会发生变化
       两个相同的值（同一个数），做异或，结果为0

6.6.1 进制

机器语言只能识别二进制：所有数字在计算机底层都以二进制形式存在。

对于整数，有四种表示方式：

二进制(binary)：0,1 ，满2进1，以0b或0B开头。
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1，以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1，以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0

6.6.2 计算机底层到底是如何保存数据的

计算机底层以二进制（数据的补码）进行数据保存和运算

bit(位)：简写b，计算机中最小单位

byte(字节)：简写B，计算机中的基本单位

符号位：计算机为了描述数字的正负，而设计的位置，是二进制数据的最高位

如果最高位是0，则表示该数是正数

如果最高位是1，则表示该数是负数

问题：如果直接使用二进制进行计算，当引入了负数时，我们发现结果出现了错误

计算机为了解决这个问题，引入了如下的三个概念：

原码：数据被转换为二进制后的数值
反码：符号位不变，其余各位取反
补码：反码 + 1

-3的原码、反码、补码：

    原码：1000 0011
    反码：1111 1100
    补码：1111 1101

正数的原码、反码、补码一致(三码合一)，或者说正数只有原码

计算机中所有数据都是基于补码进行运算和存储的！

6.6.3 进制之间的转换问题

十进制转二进制

53 ÷ 2 = 26 余 1
26 ÷ 2 = 13 余 0
13 ÷ 2 = 6 余 1
6 ÷ 2 = 3 余 0
3 ÷ 2 = 1 余 1
1 ÷ 2 = 0 余 1

所以53的二进制就是11101（余数从下到上）

二进制转八进制

10010101 => 010 - 010 - 101 => 0225 = 5 * 8^0 + 2 * 8^1 + 2 * 8^2 = 5 + 16 + 128 = 149

二进制转十六进制

10010101 => 1001-0101 => 0x95 = 5 * 16^0 + 9 * 16^1 = 5 + 144 = 149

二进制转六进制

10010101 => 149

149 ÷ 6 = 24 余 5
24 ÷ 6 = 4 余 0
4 ÷ 6 = 0 余 4

所有149的六进制为405 ==> 5 * 6^0 + 0 * 6^1 + 4 * 6^2 = 5 + 0 +144 = 149

Golang_HZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录