Java基础篇学习笔记之基本语法（上）

最新推荐文章于 2024-07-18 20:13:39 发布

愤怒且自私22

最新推荐文章于 2024-07-18 20:13:39 发布

阅读量170

点赞数 2

分类专栏： Java学习笔记文章标签： java

本文链接：https://blog.csdn.net/qq_33317597/article/details/116407338

版权

Java学习笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

4、基本语法（上）

4.1、关键字和保留字

关键字（keyword）:

定义：

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

特点：关键字中所有字母都为小写
在这里插入图片描述

在这里插入图片描述

灰色：严格不算关键字，但可以当作关键字使用

保留字（reserved word）:

Java保留字：现有版本尚未使用但以后版本可能会被作为关键字使用

命名标识符时注意避免使用保留字

goto、const

4.2、标识符（Identifier）以及命名规则

标识符：

Java对各种变量、方法类等要素命名时使用的字符序列既是标识符
技巧:凡是自己可以起名字的地方都叫标识符
- 例如:类名、变量名、方法名、接口名、包名…等等

定义合法标识符规则：—>不遵守，编译不通过

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

Java中的名称命名规范：—>不遵守，编译可以通过，建议遵守。
可点击以下链接，详细了解！（来自网络！！！）
java命名规范

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

xxxyyyzzz

类名、接口名：多单词组成时，所有单词首字母大写：

XxxYyyZzz

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

xxxYyyZzz

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

XXX_YYY_ZZZ

注意：

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

4.3、变量

4.3.1、变量定义、作用、注意点

内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元，包含变量类型、变量名和存储的值

变量的作用：

用于在内存中保存数据

使用变量需要注意：

Java中每个变量必须先声明再使用
使用变量名来访问这块区域的数据
变量的作用域:
- 其定义所在的一对{}中
变量只有在其作用域中才有效
- 出了作用域就会失效
同一作用域内，不能定义重名的变量

变量的使用

Java定义变量的格式：
- 数据类型变量名 = 变量值；

public static void main(String arg[]) {
		
		int myAge = 12;
		System.out.print(myAge);
	}


public static void main(String arg[]) {
		
		int myAge;
		System.out.print(myAge);
	}

//未初始化变量，没有默认值,未被赋值过
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The local variable myAge may not have been initialized

4.3.2、变量的分类

在这里插入图片描述

变量在类中声明的位置：

成员变量 VS 局部变量

在这里插入图片描述

1、整型

在这里插入图片描述

整型：byte(1字节等于8bit)

short(2字节)

int(4字节)

long(8字节)

byte范围：-128~127
声明long型变量，必须以”l“或者”L“结尾

long s1 = 123L;
		System.out.print(s1);


//输出123

通常，定义整型变量时，使用int型。

2、浮点型

在这里插入图片描述

浮点型：float(4字节)\double(8字节)

浮点型表示带小数点的数值
float表示数值的范围比long还大
定义float类型变量时，变量要以"f"或者”F“结尾

float f1 = 12.34f;
		System.out.print(f1);


//运行结果: 12.34

通常定义浮点型变量时，使用double型

3、字符型

在这里插入图片描述

字符型：
- char(1字符=2字节)
定义char型变量，通常使用一对**‘ ’** 单引号！

		char c1 = 'C';
		System.out.print(c1);

//运行结果:C

注意：
- 不能赋值两个字符
表示方式：
- 声明一个字符
- 转义字符
- 直接使用Unicode值来表示字符型常量

		char c1 = '\n';
		System.out.print(c1);
//  \t制表符
//输出换行符

	public static void main(String arg[]) {
		char c1 = '\u0123';
		System.out.print(c1);
	}

//输出 ？ 未显示

char c1 = '\u0043';
		System.out.print(c1);


//输出 C

了解：

在这里插入图片描述

ANSI GBK

4、布尔型

boolean

只能取两个值之一：
- true
- false
常常在条件判断、循环结构中使用

4.3.3、自动类型提升

基本数据类型之间的运算规则：

前提：这里讨论的只是7种基本数据类型变量间的运算，不包含boolean类型的

自动类型提升
- 范围小的和范围大的运算，需要用范围大的接受
- 用范围更大的也可以
- byte–> short -->int–> long–> float --> double
结论：

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

说明：

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

byte b1 = 2;
		int i1 =12;
		//byte b2 = b1 + i1;错误！不兼容的类型，从int转换到byte可能会有损失。

short s1 = 123;
		double d1 = s1;
		System.out.print(d1);

char c1 = 'a';//97
		int i1 = 10;
		int i2 =c1+i1;
		System.out.print(i2);

//结果:107

byte、char、 short -->int–> long–> float --> double

特别的byte、char、 short三个做运算，结果都得是int型（包括两种相同的类型做运算）

4.3.4、强制类型转换

自动类型提升的逆运算
需要使用强转符：（）

注意：

强制类型转换可能导致精度损失！

//精度损失---例1
double d1 = 12.3;//无论是12.9
		int i1 = (int)d1;//截断操作，都会被转为12
		System.out.print(i1);

	
		long l1 = 123;
  		short s2 = (short)l1;
  		System.out.print(s2);
//没有精度损失

	//精度损失---例2

		int i2 = 128;
		byte b = (byte)i2;
		
		System.out.print(b);
//结果: -128

特殊情况：

编码情况：
- long l = 123;//123是int型
- 自动类型提升了。故此时没加L也不会报错！
- 赋值一个超过int型的数字就会报错！！！此时必须加L

float f = 12.3;

会报错！必须加F

编码情况2：
- 整形常量，默认为int型
- 浮点型常量，默认为double型
- byte b = 12;
  
  byte b1 = b +1;

4.3.5、字符串类型String

在这里插入图片描述

String类型变量的使用：

String属于引用数据类型，翻译为：字符串
声明String类型变量时，使用一对”“

String s1 = "Hello World!";
System.out.println(s1);
String s2 = "a"
String s3 = ""
//都可以

注意：char型的必须在单引号内加字符！！
String可以和8种基本数据类型变量做运算！
且运算只能是连接运算： +

计算的结果仍然是String类型！

练习：

1、

char c = 'a';
		int num = 10;
		String str = "hello";
//a -- 97
//A -- 65
		System.out.println(c+num+str);
		System.out.println(c+str+num);
		System.out.println(c+(num+str));
		System.out.println((c+num)+str);
		System.out.println(str+num+c);





/*
107hello
ahello10
a10hello
107hello
hello10a
*/

2、

System.out.println("*	*");
		
		System.out.println('*'+'\t'+'*');
		
		System.out.println('*'+"\t"+'*');
		
		
		System.out.println('*'+'\t'+"*");
		
		System.out.println('*'+("\t"+"*"));

/*
*	*
93
*	*
51*
*	*
*/

String s1 = 123;
编译不通过，无法int转换为String

String也无法强转为int

String str = 123 + "";
		System.out.println(str);
		
		int num1 = Integer.parseInt(str);
		//转换为int
        System.out.println(num1);

4.3.6、进制与进制的转换！

世界上有10种人，认识和不认识二进制的

在这里插入图片描述

	int num = 0b110;
		int num1 = 110;
		int num2 = 0127;
		int num3 = 0x110A;
		
		System.out.println(num);
		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
		


//结果输出十进制:
6
110
87
4362

二进制？十进制转换

4.4、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符很少用
三元运算符

在这里插入图片描述

4.4.1、算术运算符

运算符之一：算术运算符

±*/ % (前)++ （后）++ (前)–（后）-- +连接运算符

除号： /

int num1 = 12;
		int num2 = 5;
		int result = num1/num2;
		System.out.println(result);

//结果：2

int result2 = num1/num2 *num2;
//结果：10


double result3 = num1/num2;
//结果：2.0
右边先运行出来，已经是int了。再赋值给double
    
   
 double resule4 = num1/num2+0.0; //2.0

 double resule4 = num1/(num2+0.0); //2.4

 double resule4 =(double) num1/num+0.0); //2.4

取余运算

结果的符号和被模数符号相同。

		int m1 = 12;
		int n1 = 5;
		System.out.println(m1%n1);
		
		int m2 = -12;
		int n2 = 5;
		System.out.println(m2%n2);
		
		int m3 = 12;
		int n3 = -5;
		System.out.println(m3%n3);
		
		
		int m4 = -12;
		int n4 = -5;
		System.out.println(m4%n4);


//结果
2
-2
2
-2

开发中，经常使用%取余来判断能否被除尽的情况

(前)++ 例如：++a
    结论:
	先自增1，后运算

（后）++ 例如：a++
 	结论:
	先运算，后自增1

	int a1 = 10;
		int b1 = ++a1;
		System.out.println(a1+"\t"+b1);
		
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println(a2+"\t"+b2);


//结果:

11	11
11	10

自增1不会改变本身变量的数据类型！


 (前)--  例如：--a
结论:
	先自减1，后运算
（后）-- 例如：a--
结论:
	先运算，后自减1

小练习：

Java:随意给出一个整数(3位数)，打印显示他的个位数，十位数，百位数的值:

package teat01;

public class Test03 {

	public static void main(String[] args) {
		int num = 169;
		int h = num/100;
		
		int t = num%100/10;
		//num/10%10
		
		int o = num%10;
		//num%100%10
		
		System.out.println("百位："+h);
		System.out.println("十位："+t);
		System.out.println("个位："+o);
		
	}

}

4.4.2、赋值运算符

符号 =

当" = "两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值

//赋值符号
		int i1 = 10;
		int j1 = 10;
		
		int i2,j2;
		//连续赋值
		int i3 = 10,j3 = 20;

扩展赋值运算符：
- +=
- -=
- *=
- /=
- %=

		int num1 = 10;
		num1 += 2;
		//num1 = num1 + 2;
		
		
		int num2 = 12;
		num2 %= 5;
		//num2 = num2 % 5;	
		}

区别：

short s1 = 10;
s1 = s1 + 2;
//编译失败

s1 += 2;
//编译通过，不会改变变量本身的数据类型！！！！

开发中，如果希望变量实现+2的操作，有几种方法？

(前提： int num =10;)

num = num + 2;
num += 2;(推荐！！！不会改变类型)

开发中，如果希望变量实现+1的操作，有几种方法？

(前提： int num =10;)

num = num + 1;
num += 1;
num ++ ;(推荐！！！j简洁)

4.4.3、比较运算符

在这里插入图片描述

结论：

比较运算符的结果是boolean类型！
区分 == 和 =


		int i = 10;
		int j = 20;
		System.out.println(i==j);
		System.out.println(i=j);

//结果：
false
20

	boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1==b2);
		System.out.println(b1=b2);


//结果:
false
false

4.4.4、逻辑运算符

只适用于boolean类型
在这里插入图片描述

异或：

可记为相同为false
不同为true

逻辑运算符

& && | || ！ ^

说明：

逻辑运算符操作的都是boolean类型的变量

//区别& 与 &&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)) {
			System.out.println("正确");
		}else {
			System.out.println("错误");
		}
		
		System.out.println(num1);
		//区别& 与 &&
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)) {
			System.out.println("正确");
		}else {
			System.out.println("错误");
		}
				
		System.out.println(num2);



//结果：
错误
11
错误
10

相同点：
- &与&&的运算结果相同
- 当符号左边是true时，二者都会执行符号右边的运算。
不同点：
- 当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算。

区分： | 与|| 触类旁通

相同点：
- |与||的运算结果相同
- 当符号左边是false时，二者都会执行符号右边的运算。
不同点：
- 当符号左边是true时，|继续执行符号右边的运算，||不再执行符号右边的运算。

开发中，推荐使用||

4.4.5、位运算符（了解）

在这里插入图片描述

每向左移一位，就是它十进制的数乘以2的一次幂

int i = 21;
		System.out.println("i << 2："+(i << 2));
		System.out.println("i << 3："+(i << 3));


//结果：
i << 2：84
i << 3：168

		System.out.println("i << 27：" + (i << 27));

//结果
i << 27：-1476395008

结论：

位运算符操作的都是整型的数据

<< : 在一定范围内，每向左移一位，相当于*2

    
>>: 在一定范围内，每向右移一位，相当于/2

最高位看原来是0还是1来补

面试题：

最高效的计算2*8？

2<<3或者8<<1

& | ^ ~:与、或、异或、非

底层二进制。。。了解即可。。。

lse {
System.out.println(“错误”);
}

	System.out.println(num1);
	//区别& 与 &&
	boolean b2 = true;
	b2 = false;
	int num2 = 10;
	if(b2 && (num2++ > 0)) {
		System.out.println("正确");
	}else {
		System.out.println("错误");
	}
			
	System.out.println(num2);

//结果：
错误
11
错误
10


- 相同点：
  - &与&&的运算结果相同
  - 当符号左边是true时，二者都会执行符号右边的运算。
- 不同点：
  - 当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算。







区分： | 与|| 触类旁通

- 相同点：
  - |与||的运算结果相同
  - 当符号左边是false时，二者都会执行符号右边的运算。
- 不同点：
  - 当符号左边是true时，|继续执行符号右边的运算，||不再执行符号右边的运算。

**开发中，推荐使用||**



##### 4.4.5、位运算符（了解）

[外链图片转存中...(img-rl6B7rKW-1620143836817)]

每向左移一位，就是它十进制的数乘以2的一次幂

```java
int i = 21;
		System.out.println("i << 2："+(i << 2));
		System.out.println("i << 3："+(i << 3));


//结果：
i << 2：84
i << 3：168

		System.out.println("i << 27：" + (i << 27));

//结果
i << 27：-1476395008

结论：

位运算符操作的都是整型的数据

<< : 在一定范围内，每向左移一位，相当于*2

    
>>: 在一定范围内，每向右移一位，相当于/2

最高位看原来是0还是1来补

面试题：

最高效的计算2*8？

2<<3或者8<<1

& | ^ ~:与、或、异或、非

底层二进制。。。了解即可。。。

4.4.6、三元运算符

结构：

(条件表达式)？表达式1 : 表达式2

说明:

条件表达式结果为boolean类型
根据条件表达式真或假，决定执行表达式1还是表达式2
如果表达式为true,则执行表达式1
如果表达式为false,则执行表达式2

//获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m>n)?m:n;
		System.out.println(max);	

//结果
12

表达式1 和表达式2 要求是一致的。

double num = (m>n)?2:1.0;
		System.out.println(num);
 


//(m>n)?2:"n大";编译错误，要求接收结果的值，可以同时接收表达式1 和 表达式2

//结果
2.0

三元运算符可以嵌套使用

int m = 5;
		int n = 12;
		String maxStr = (m > n)?"m大":((m == n)?"相等":"n大");
		
		System.out.println(maxStr);

//结果：
n大

练习：

获取三个数的最大值：

		int m = 5;
		int n = 12;
		int q = -13;
		
		
		int max1 = (m>n)?m:n;
		int max2 = (max1>q)?max1:q;
		
		System.out.print(max2);
		//int max = (((m>n)?m:n)>q)?((m>n)?m:n):q;

//不建议使用后面这种！可读性太差！！！
//效率并未提高！！！

结论：
- 凡是可以使用三元运算符的地方，都可以改写为if-else

int m = 12;
		int n = 5;
		if(m>n) {
			System.out.println("m大");
		}else {
			System.out.println("n大");
		}

反之，不成立。

如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。

原因：简洁、执行效率高！

4.4.7、运算符的优先级

在这里插入图片描述

没必要记，了解优先计算的加（）即可。

愤怒且自私22

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java基础篇学习笔记之基本语法（上）

文章目录4、基本语法4.1、关键字和保留字4.2、标识符（Identifier）以及命名规则4.3、变量4.3.1、变量定义、作用、注意点4.3.2、变量的分类1、整型2、浮点型3、字符型4、布尔型4.3.3、自动类型提升4.3.4、强制类型转换4.3.5、字符串类型String4.3.6、进制与进制的转换！4.4、运算符4.4.1、算术运算符4.4.2、赋值运算符4.4.3、比较运算符4.4.4、逻辑运算符4.4.5、位运算符（了解）4、基本语法4.1、关键字和保留字关键字（keyword）:定义
复制链接

扫一扫