关键字与标识符、变量的使用（重点）

最新推荐文章于 2022-04-20 15:26:16 发布

Yao..

最新推荐文章于 2022-04-20 15:26:16 发布

阅读量414

点赞数 2

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/m0_46366038/article/details/106440431

版权

JAVA基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、关键字与标识符

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所字母都为小写

1.具体哪些关键字

在这里插入图片描述

2.保留字

现Java版本尚未使用，但以后版本可能会作为关键字使用。
具体哪些保留字：goto 、const
注意：自己命名标识符时要避免使用这些保留字

3.标识符的使用

定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：(必须要遵守。否则，编译不通过)
在这里插入图片描述
规范：（可以不遵守，不影响编译和运行。但是要求大家遵守）

注意点：
在起名字时，为了提高阅读性，要尽量意义，“见名知意”。
java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用

*/
class IdentifierTest{

	public static void main(String[] args){
		
		//int myNumber = 1001;
		//System.out.println(myNumber);
		int mynumber = 1002;
		System.out.println(mynumber);

		//int 学号 = 1003;
		//System.out.println(学号);
		
	
	}


}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

二、变量的使用

1.按数据类型分类

在这里插入图片描述
详细说明：
//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 值来表示字符型常量
//4.布尔型：boolean
//① 只能取两个值之一：true 、 false
//② 常常在条件判断、循环结构中使用

*/
class VariableTest1 {
	public static void main(String[] args) {
		//1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		//① byte范围：-128 ~ 127
		//
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);
		// ② 声明long型变量，必须以"l"或"L"结尾
		// ③ 通常，定义整型变量时，使用int型。
		short s1 = 128;
		int i1 = 1234;
		long l1 = 3414234324L;
		System.out.println(l1);

		//2. 浮点型：float(4字节) \ double(8字节)
		//① 浮点型，表示带小数点的数值
		//② float表示数值的范围比long还大

		double d1 = 123.3;
		System.out.println(d1 + 1);
		//③ 定义float类型变量时，变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1);
		//④ 通常，定义浮点型变量时，使用double型。

		//3. 字符型：char (1字符=2字节)
		//① 定义char型变量，通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB';
		System.out.println(c1);

		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);

		//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';//换行符
		c5 = '\t';//制表符
		System.out.print("hello" + c5);
		System.out.println("world");

		char c6 = '\u0043';
		System.out.println(c6);

		//4.布尔型：boolean
		//① 只能取两个值之一：true 、 false
		//② 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		System.out.println(bb1);

		boolean isMarried = true;
		if(isMarried){
			System.out.println("你就不能参加\"单身\"party了！\\n很遗憾");
		}else{
			System.out.println("你可以多谈谈女朋友！");
		}

	}
}

2.按声明的位置分类(了解)

在这里插入图片描述

3.定义变量的格式：

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

4.变量使用的注意点：

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

*/
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(myClass);

		//不可以在同一个作用域内定义同名的变量
		//int myAge = 22;
		
	}

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

//class VariableTest {}//逆向思维，反证法

5.基本数据类型变量间运算规则

5.1 涉及到的基本数据类型：除了boolean之外的其他7种
5.2 自动类型转换(只涉及7种基本数据类型）
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = 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;
		//char c2  = c1 + s2;//编译不通过

		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过

		//short s3 = b2 + s2;//编译不通过

		//short s4 = b1 + b2;//编译不通过
		//****************************************

	}
}

class VariableTest4 {
	public static void main(String[] args) {
		
		//1.编码情况1：
		long l = 123213;
		System.out.println(l);
		//编译失败：过大的整数
		//long l1 = 21332423235234123;
		long l1 = 21332423235234123L;


		//****************
		//编译失败
		//float f1 = 12.3;
		float f1 = (float)12.3;
		//2.编码情况2：
		//整型常量，默认类型为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败

		//float f1 = b + 12.3;//编译失败
		
	}
}

5.3 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
①.需要使用强转符：()
②.注意点：强制类型转换，可能导致精度损失。

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

	}
}

5.4 String与8种基本数据类型间的运算
① String属于引用数据类型,翻译为：字符串
② 声明String类型变量时，使用一对""
③String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
④运算的结果仍然是String类型

class StringTest {
	public static void main(String[] args) {
		
		String s1 = "Hello World!";

		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);

		//***********************
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

		//练习2
		//*	*
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');
		System.out.println('*' + "\t" + '*');
		System.out.println('*' + '\t' + "*");
		System.out.println('*' + ('\t' + "*"));


		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//int num1 = str1;
		//int num1 = (int)str1;//"123"

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}

避免：
String s = 123;//编译错误
String s1 = “123”;
int i = (int)s1;//编译错误

三、进制

/*
计算机中不同进制的使用说明

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

二进制(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

*/
class BinaryTest {
	public static void main(String[] args) {
		
		int num1 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		int num4 = 0x110A;

		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);

	}
}

Yao..

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关键字与标识符、变量的使用（重点）

一、关键字与标识符定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）特点：关键字中所字母都为小写1.具体哪些关键字2.保留字现Java版本尚未使用，但以后版本可能会作为关键字使用。具体哪些保留字：goto 、const注意：自己命名标识符时要避免使用这些保留字3.标识符的使用定义：凡是自己可以起名字的地方都叫标识符。涉及到的结构：包名、类名、接口名、变量名、方法名、常量名规则：(必须要遵守。否则，编译不通过)规范：（可以不遵守，不影响编译和运行。但是要求大家遵守
复制链接

扫一扫