第2章 Java语言基础

是小柒吖359

已于 2022-04-30 15:49:35 修改

阅读量807

点赞数

文章标签： java 开发语言后端

于 2022-03-05 16:38:52 首次发布

本文链接：https://blog.csdn.net/weixin_65582406/article/details/123272684

版权

2.1代码注释与编码规范

2.1.1代码注释

1.单行注释
        “//”为单行注释标记，从符号“||”开始直到换行为止的所有内容均作为注释而被编译器忽略。
语法如下:
//注释内容
2.多行注释

        “*/**/”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。
语法如下:
/*
注释内容1
注释内容2
…
*/
3.文档注释
        “/** */”为文档注释标记。符合“/**”与“*/”之间的内容均为文档注释内容。当文档注释出
现在声明(如类的声明、类的成员变量的声明、类的成员方法声明等)之前时，会被Javadoc 文档
工具话取作为Javadoc文档内容。文档注释的格式与多行注释的格式相同。对于初学者而言，文档
注释并不重要，了解即可。

2.1.2 编码规范

在学习开发的过程中要养成良好的编码习惯，因为规整的代码格式会给程序的开发与日后的维
护提供很大方便。在此对编码规则做了以下总结，供读者学习。

（1）每条语句要单独占一行，一条命令要以分号结束。
（2）在声明变量时，尽量使每个变量的声明单独占一行，即使是相同的数据类型也要将其放
置在单独的一行上，这样有助于添加注释。对于局部变量应在声明的同时对其进行初始化。
（3）在Java代码中，关键字与关键字之间如果有多个空格，这些空格均被视作一个。
多行空格没有任何意义，为了便于理解、阅读，应控制好空格的数量。
（4）为了方便日后的维护，不要使用技术性很高、难懂、易混淆判断的语句。由于程序的开
发与维护不是同一个人，所以应尽量使用简单的技术完成程序需要的功能。
（5）对于关键的方法要多加注释，这样有助于阅读者了解代码结构。

2.2 变量与常量

2.2.1 标识符和关键字

1.标识符
标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组名等有效的字符
序列。
Java语言规定标识符由任意顺序的字母、下划线(_)、美元符号($)和数字组成，并且第一
个字符不能是数字。标识符不能是Java中的保留关键字。
在Java语言中标识符中的字母是严格区分大小写的，如good和Good是不同的两个标识符。
Java语言使用Unicode标准字符集，最多可以标识65535个字符，因此，Java语言中的字母不仅包
括通常的拉丁文字 a、b、c 等，还包括汉字、日文以及其他许多语言中的文字。
编写Java代码有一套公认的命名规范，如下。
(1)类名:通常使用名词，第一个单词字母必须大写，后续单词首字母大写。
(2)方法名:通常使用动词，第一个单词首字母小写，后续单词首字母大写。
(3)变量:第一个单词首字母小写，后续单词首字母大写。
(4)常量:所有字母均大写。
(5)单词的拼接:通常使用"userLastName"方式拼接单词，而不是"user_last_name"
2.关键字
关键字是Java语言中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。简
单理解为凡是在Eclipse变成红色粗体的单词，都是关键字。

2.2.2 变量

（1）变量名必须是一个有效标识符。

（2）变量名不可以使用java 中的关键字。

（3）变量名不能重复。

（4）应选择有意义的单词作为变量名。

2.2.3 常量

过程中一直不会改变的量称为常量，通常也被称为“final变量”。常量在整个程序中只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。常量名通常使用大写字母，但这并不是必须的。很多Java程序员使用大写字母表示常量，是为了清楚地表明正在使用常量。

例2.1 声明double 型常量,并给常量赋值,使用常量进行计算。

public class ConstantTest {//创建主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		final double PI = 3.14;// 声明常量PI的值
		System.out.println("常量PI的值为:"+ PI); // 输出常量PI的值
		System.out.println("半径为3的圆的周长为:"+ (PI* 2* 3)); // 使用常量 输出半径为3的圆的周长
		System.out.println("半径为4的圆面积为："+ (PI* 4* 4)); // 使用常量 半径为4的圆面积
	}

}

运行结果如下：

2.3 基本数据类型

例2.2 给int型变量按照十进制、八进制、十六进制赋值

public class li {//创建li主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int a = 11;  			//十进制整数
		System.out.println(a);  //输出十进制表示的整型值
		int b = 011;			//八进制整数
		System.out.println(b);	//输出八进制表示的整型值
		int c = 0x11;			//十六进制整数
		System.out.println(c);	//输出十六进制表示的整型值
	}

}

运行结果如下：

2.3.2 浮点类型

例2.3 展示4.35*100的错误结果，并给出解决方案。

public class DoubleUnAccurate1 {//创建DoubleUnAccurate1主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		double a = 4.35 * 100;		   //用double计算4.35*100的结果
		System.out.println("a = " + a);//输出这个double值
		int b = (int) a;			   //将double类型强制转换成int类型
		System.out.println("b = " + b);//输出int值
		System.out.println("a的四舍五入值 = " + Math.round(a));//使用四舍五入
	}

}

运行结果如下：

例2.4 计算2.0—1.9的结果，与0.1进行比较，展示错误结果，并给出解决方案。

public class DoubleUnAccurate2 {//创建DoubleUnAccurate2主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		double a = 0.1;//定义double型变量a的值为0.1
		double b =2.0 - 1.9;//定义double型变量b的值为2.0-1.9
		System.out.println("a = "+ a);//输出“"a = "+ a”的结果
		System.out.println("b = "+ b);//输出“"b = "+ b”的结果
		System.out.println("a==b 的结果 ："+ (a == b));//a=-b的结果是false
		/*
		 * Math.abs)是取绝对值的方法，1e-6表示1*10的-6次方，是计算机中最小数的概念
		 * 如果两数之差的绝对值小于最小数，则认为这两个数是相等的。
		 */
		//boolean bool = Math.abs(a -b)<(1e-6);
		System.out.println("两数之差绝对值小于最小数的结果: " + bool);//输出结果
	}

}

运行结果：

2.3.3 字符类型

1、char型

字符类型(char)用于存储单个字符，占用16位(两个字节)的内存空间。在声明字符型变量时，要以单引号表示，如's’表示一个字符。同 C、C++语言一样，Java 语言也可以把字符作为整数对待。由于 Unicode 编码采用无符号编码，可以存储 65536 个字符(0x0000~0xfmf)，所以 Java 中的字符几乎可以处理所有国家的语言文字。

2、转义字符

转义字符是一种特殊的字符变量，其以反斜杠“\”开头，后跟一个或多个字符。转义子付具有
特定的含义，不同于字符原有的意义，故称“转义”。

转义字符	含义
\’	单引号字符
\”	双引号字符
\\	反斜杠字符
\t	垂直制表符，将光标移到下一个制表符的位置
\r	回车
\n	换行
\b	退格
\f	换页

例2.5 使用转义字符

public class EscapeCharacter {//创建主类
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
	char c1 = '\\';                    //反斜杠转义字符
	char c2 ='\'';                     //单引号转义字符
	char c3 ='\"';                     //双引号转义字符
	char c4 ='\u2605';                 //16进制表示的字符
	char c5 ='\101';                   //八进制表示的字符
	char c6 ='\t';                     //制表符转义字符
	char c7 ='\n';                     //换行转义字符
	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转义字符的值
	}
}

运行结果：

2.3.4 布尔类型

布尔类型又称逻辑类型，只有true和false两个值，分别代表布尔逻辑中的“真”和“假”。布尔值不能与整数类型进行转换。布尔类型通常被用在流程控制中作为判断条件。
通过关键字boolean 来声明布尔类型变量。

例2.6 声明boolean型变量

public class Boolean {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		boolean b;//声明布尔型变量b
		boolean bl,b2; // 声明布尔型变量bl、b2
		boolean b3=true,b4=false;//声明布尔型变量b1赋给初值true,b2赋给初值false
		boolean b5=2<3,b6=(2 == 4);//声明布尔型变量赋与逻辑判断的结果 
		System.out.println("b5的结果是:"+b5);
		System.out.println("b6的结果是:"+b6);
	}

}

运行结果：

2.4 数据转换类型

        类型转换是将一个值从一种类型更改为另一种类型的过程。例如，不仅可以将String类型数据“457”转换为一个数值型，而且可以将任意类型的数据转换为String 类型。
        如果从低精度数据类型向高精度数据类型转换，则永远不会溢出，并且总是成功的:而把高精度数据类型向低精度数据类型转换则必然会有信息丢失，有可能失败。
        数据类型转换有两种方式，即隐式转换与显式转换。

2.4.1 隐式转换

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这种类型的转换称为隐式转换，也可以称为自动转换。下列基本数据类型会涉及数据转换，不包括逻辑类型。这些类型按精度从“低”到“高”排列的顺序为byte<short < int < long < float < double。

例2.7 创建不同数值类型的变量，进行隐式转换。

public class ImplicitConversion {//创建ImplicitConversion主类

	public static void main(String[] args) {//主方法
		//声明byte型变量mybyte,并把byte型变量允许的最大值赋给mybyte 
		byte mybyte =127;//定义byte型变量mybyte为127
		int myint=150; //明int型变量myint，并赋值150 
		float myfloat=452.12f; //明float型变量myfloat，并赋值 
		char mychar =10; //声char型变量mychar，并赋值 
		double mydouble=45.46546;//声明double型变量，并赋值
		/*将运算结果输出*/
		System.out.println("byte型与float型数据进行运算结果为:"+(mybyte+myfloat)); //输出结果
		System.out.println("byte型与int型数据进行运算结果为:"+ mybyte * myint); //输出结果
		System.out.println("byte型与char型数据进行运算结果为:"+ mybyte / mychar); //输出结果
		System.out.println("double型与char型数据进行运算结果为:"+(mydouble + mychar));//输出结果
	}

}

运行结果：

2.4.2 显式转换

当把高精度的变量赋值给低精度的变量时，必须使用显示类型转换运算（又称强制类型转换），当执行显示类型转换时可能会导致精度损失。

例2.8 将不同的数据类型进行显式类型转换。

public class ExplicitConversion {//创建ExplicitConversion主类
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int a=(int) 45.23; // double类型强制转化成int类型
		long b=(long)456.6F;//float类型强制转化成long类型 
		char c =(char) 97.14;//double型强制转换成char型
		System.out.println("45.23强制转换成int的结果:"+a);
		System.out.println("456.6F 强制转换成long的结果:"+b); 
		System.out.println("97.14 强制转换成 char的结果"+c);
	}

}

运行结果：

2.5 运算符

运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。Java中提供了丰富的运算符，如赋值运算符、算术运算符和比较运算符等。

2.5.1 赋值运算符

赋值运算符以符号"="表示，它是一个双目运算符（对两个操作数做处理），其功能是将右边操作数所含的值赋给左边的操作数。

例2.9 使用赋值运算符为变量赋值，实例代码如下:

public class EqualSign {                      //创建类

	public static void main(String[] args) {  //主方法
		// TODO Auto-generated method stub
		int a, b,c=11;						  //声明整型变量a、b、c
		a = 32;								  //将32赋值给变量a
		c = b = a + 4;						  //将a与4的和先赋值给变量b,再赋值给变量c
		System.out.println("a = " + a);//输出"a = " + a的结果
		System.out.println("b = " + b);//输出"b = " + b的结果
		System.out.println("c = " + c);//输出"c = " + c的结果
	}

}

运行结果：

2.5.2 算术运算符

Java中的算术运算符主要有+(加号)、-(减号)、*(乘号)、/(除号)、%(求余)，它们都是双目运算符。

运算符	说明	实例	结果
+	加	1.45f+15	27.45
-	减	4.56-0.16	4.4
*	乘	*5L12.45f**	62.25
/	除	7/2	3
%	取余	12%10	2

例2.10 使用算术运算符将变量的计算结果输出。

public class ArithmeticOperator {//创建ArithmeticOperator主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		float num1 = 45.2f;   //声明浮点型变量num1
		int num2 = 120;    //声明整型变量num2
		int num3 =17, num4=10;   //声明整型变量num3,将10赋值给变量num4
		System.out.println("num1+num2的和为:"+(num1+num2));    //输出“num1+num2的和”的结果
		System.out.println("num1-num2的差为:"+(num1-num2));    //输出“num1-num2的差”的结果
		System.out.println("num1*num2的积为:"+(num1*num2));    //输出“num1*num2的积”的结果
		System.out.println("num1/num2的商为:"+(num1 /num2));   //输出“num1/num2的商”的结果
		System.out.println("num3/num4的余数为:"+(num3%num4));  //输出“num3/num4的余数”的结果
	}

}

运行结果：

2.5.3 自增自减运算符

例2.11 在循环中使用自增运算符，查看自增的效果。

public class AutoIncrementdecreasing {//创建主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int a =1;//创整型量初始值为1
		System.out.println("a="+a);//输出此时a的值 
		a++;// a自增+1
		System.out.println("a++="+a);//输出此时a的值 
		a++;// a自增+1
		System.out.println("a++="+a);// 输出此时a的值 
		a++;//a自增+1
		System.out.println("a++="+a);// 输出此时a的值 
		a--;//a自减-1
		System.out.println("a--="+a);// 输出此时a的值
	}
}

运行结果：

2.5.4 关系运算符

运算符	说明	实例	结果
==	等于	2==3	false
<	小于	2<3	true
>	大于	2>3	false
<=	小于等于	5<=6	true
>=	大于等于	7>=7	true
!=	不等于	2!=3	true

例2.12 使用关系运算符对变量进行比较运算。

public class RelationalOperator {//创建RelationalOperator主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int num1 =4,num2=7;   //将4和7分别赋值给整型变量num1和num2
		int num3 =7;		  //将7赋值给整型变量num3
		System.out.println("numl<num2 的结果:"+(num1 < num2)); 	 //输出numl<num2 的结果
		System.out.println("numl>num2 的结果:"+(num1 > num2)); 	 //输出numl>num2 的结果
		System.out.println("num1==num2的结果:"+(num1 ==num2)); 	 //输出num1==num2的结果
		System.out.println("numl!=num2 的结果:"+(num1 != num2)); //输出numl!=num2 的结果
		System.out.println("numl<=num2的结果:"+(num1 <= num2)); 	//输出numl<=num2的结果
		System.out.println("num2>=num3的结果:"+(num2>= num3));  //输出num2>=num3的结果
	}
}

运行结果：

2.5.5 逻辑运算符

假定某面包店，在每周二的下午7点至8点和每周六的下午5点至6点，对生日蛋糕商品进行折扣让利活动，那么想参加折扣活动的顾客，就要在日时间上满足这样的条件，周二并且7:00 PM~8:00PM或者周六并且5:00PM~6:00PM，这里就用到了逻辑关系。
逻辑运算符是对真和假这两种逻辑值进行运算，运算算后的结果仍是一个逻辑值。逻辑运算符包括&&(逻辑与)、(逻辑或)、!(逻辑非)。逻辑运算符计算的值必须是 boolean 型数据。在逻辑运算符中，除了“!”是单目运算符之外，其他都是双目运算符。

运算符	含义	举例	结果
&&	逻辑与（并且）	A&&B	(对)与（错）=错
\|\|	逻辑或（或者）	A\|\|B	(对)或（错）=对
！	逻辑非（相反）	!A	不（对）=错

例2.13 使用逻辑运算符和关系运算符对变量进行运算。

public class LogicalAndRelational {//创建LogicalAndRelational主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int a = 2;						//声明int型变量a
		int b =5;						//声明int型变量b
		boolean result =((a >b) && (a != b));//声明boolean型变量，用于保存应用逻辑运算符“&&”后的返回值
		boolean result2 = ((a > b) || (a !=b));// 声明boolean 型变量，用于保存应用逻辑运算符“||”后的返回值
		System.out.println(result); 		// 将量result 输出 
		System.out.println(result2);		//将变量result2输出
	}

}

运行结果：

2.5.6 位运算符

运算符	含义	举例
&	与	a&b
\|	或	a\|b
~	取反	a~b
^	异或	a^b
<<	左位移	a<<b
>>	右位移	a>>b
>>>	无符号右移	a>>>b

1、位逻辑运算符

例2.14 使用逻辑运算符进行运算

public class LogicalOperator {//创建LogicalOperator主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		short x = ~123;       //给short x 赋值
		System.out.println("12与8的结果为: " + (12 & 8));  //位逻辑与计算整数的结果
		System.out.println("4或8的结果为: " + (4|8));      //位逻辑与计算整数的结果
		System.out.println("31异或22的结果为: " + (31^ 22));  //位逻辑异与计算整数的结果
		System.out.println("123取反的结果为: " + x);          //位逻辑取反与计算整数的结果
		System.out.println("2>3与4!-7的与结果: " + (2 >3 &4 != 7));   //位逻辑与计算布尔值的结果
		System.out.println("2>3与4!-7的或结果: " + (2 > 3 | 4 != 7));  //位逻辑与计算布尔值的结果
		System.out.println("2<3与4!=7的与异或结果: " + (2 < 3 ^ 4 != 7));  //位逻辑与计算布尔值的结果
	}
}

运行结果：

2、位移运算符

位移运算符有三个，分别是左移<<、右移>>和无符号右移>>>，这三个运算符都是双目的。

例2.15 使用位移运算符对变量进行位移运算

public class BiwiseOperator1 {//创建BiwiseOperator1主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
			int a = 24;//定义a的值
			System.out.println(a +"右移两位的结果是:"+ (a >> 2)); //输出a右移两后的值
			int b = -16;//定义b的值为负数
			System.out.println(b+"左移三位的结果是:"+ (b << 3));//输出b左移三后的值
			int c = -256;//定义c的值为负数
			System.out.println(c+"无符号右移2位的结果是:"+ (c >>> 2));//输出c无符号右移2位的结果
	}
}

运行结果：

例2.16 让byte、short两种类型的变量做无符号右移操作。

public class BiwiseOperator2 {//创建BiwiseOperator2主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
			byte a = (byte)(-32 >>> 1);//yete无符号右移
			System.out.println("byte无符号右移的结果:" + a);//输出结果
			short b=(short) (-128 >>> 4);//short无符号右移
			System.out.println("short无符号右移的结果:" + b);//输出右移之后的结果
	}
}

运行结果：

2.5.7 复合赋值运算符

和其他主流编程语言一样，Java中也有复合赋值运算符。所谓的合赋值运算符，就是将赋值运算符与其他运算符合并成一个运算符来使用，从而同时实现两种运算符的效果。

运算符	说明	举例	等价效果
+=	相加结果赋予左侧	a+=b;	a=a+b;
-=	相减结果赋予左侧	a-=b;	a=a-b;
*=	相乘结果赋予左侧	*a=b;**	*a=ab;**
/=	相除结果赋予左侧	a/=b;	a=a/b;
%=	取余结果赋予左侧	a%=b;	a=a%b;
&=	与结果赋予左侧	a&=b;	a=a&b;
\|=	或结果赋予左侧	a\|=b;	a=a\|b;
^=	异或结果赋予左侧	a^=b;	a=a^b;
<<=	左移结果赋予左侧	a<<=b;	a=a<<b;
>>=	右移结果赋予左侧	a>>=b;	a=a>>b;
>>>=	无符号右移结果赋予左侧	a>>>=b;	a=a>>>b;

2.5.8 三元运算符

三元运算符的使用格式为:条件式?值1:值2
三元运算符的运算规则为:若条件式的值为truc，则整个表达式取值1，否则取值 2

2.5.9 圆括号

圆括号可以提升公式中计算过程的优先级，在编程中常用。

2.5.10 运算符优先级

Java中的表达式就是使用运算符连接起来的符合Java过程的式子。运算符的优先级决定了表达式中运算执行的先后顺序。通常优先级由高到低的顺序依次是增量和减量运算、算数运算、比较运算、逻辑运算、赋值运算。
如果两个运算有相同的优先级，那么左边的表达式要比右边的表达是先被处理。

技巧:
在编写程序时尽量使用括号“()”运算符来限定运算次序，以免产生错误的运算顺序。

是小柒吖359

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第2章 Java语言基础

1.单行注释“//”为单行注释标记，从符号“||”开始直到换行为止的所有内容均作为注释而被编译器忽略。语法如下://注释内容2.多行注释“*/**/”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。语法如下:/*注释内容1注释内容2…*/3.文档注释“/** */”为文档注释标记。符合“/**”与“*/”之间的内容均为文档注释内容。当文档注释出现在声明(如类的声明、类的成员变量的声明、类的成员方法声明等)之前时，会被Javadoc 文档工
复制链接

扫一扫