Java 基础语法

Java基础语法学习

学习每一种语言都需要我们先去学习语法，就像我们在学习中文，英文的时候，我们都会涉及到语法，因为语法是一门语言的基础，如果没有掌握一门语言的语法，你说出来的话可能没人听得懂，学习编程语言，你如果不会语法，那么机器将听不懂你想要它帮助你实现什么功能，所以说语法是入门的基础。

目录

1. 注释、标识符、关键字
2. 数据类型
3. 类型转换
4. 变量、常量
5. 运算符
6. 包机制、JavaDoc

注释、标识符、关键字

• 注释
  注释是用来告诉看代码的人，这些代码实现了什么功能，有什么注意事项等等之类的，它并不会被程序所执行，平时我们写代码的时候，如果代码量不多，我们自己看自己的代码还是能看懂的，但是如果项目结构复杂起来，这个时候不仅别人可能看不懂你的代码，甚至有可能你写完过后回头再看一次代码，就不知道自己的代码到底是干嘛用的了

注意： 注释并不会被执行，它是给我们写代码的人看的，并且书写注释是一个特别好的习惯
当然，网络上也有一句很好玩的话：程序员都讨厌那些不写注释的人，然而他们也讨厌写注释
但是但是但是，注释还是得写的，不仅方便自己也方便别人，当你和其他人协同开发一个项目的时候，书写注释有时候可以达到事半功倍的效果，，所以不要嫌写注释麻烦

注释

• 单行注释
  单行注释使用 //后面加上自己的注释即可
  代码演示

//这是单行注释
System.out.print("HelloWorld!");

可以看到用单行注释的内容是灰色的，而没有被注释的输出语句仍然是有颜色的。

• 多行注释
  多行注释使用 /* */里面加上自己的注释即可
  代码演示

/*
这是多行注释
这是多行注释
这是多行注释
System.out.print("HelloWorld!");
*/
System.out.print("HelloWorld!");

通过多行注释我们可以对代码进行编写更多的注释，而不是将很长的注释写在一行上，这样会使得注释难以理解，也不容易去看，这里也可以看到在注释里面的输出语句也是灰色的，和注释外面的输出语句颜色不同，当程序执行时，只会执行注释外面的代码。

• 文档注释
  文档注释使用 /** */里面加上自己的注释即可
  代码演示

/**
*	@Description HelloWorld
*	@Author Zyyyyu_
*/
System.out.print("HelloWorld!");

文档注释中的@xxx其实是有功能的，不过后面JavaDoc会讲到所以这里就不过多讲述了，而且平时使用单行注释和多行注释就够了

标识符

Java中所有的组成部分都需要名字，类名、变量名、方法名之类的都被称为标识符
注意点：

• 所有的标识符都应该以字母（A-Z或者a-z），$，或者下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z），$，或者下划线（_）或者数字的任何字符组合
• 不能使用关键字作为变量名或方法名
• 标识符是对大小写敏感的，意思就是 Apple 和 apple 是两个不同的名字
• 符合标识符举例：age、$money、_country、__2_data
• 不符合标识符举例：123age、-money、#country
• 可以使用中文命名，但是一般不建议这样使用，也不建议使用拼音，实在不知道英文单词是什么就翻译一下，当然这只是我的个人建议

关键字

关键字简单理解就是你使用IDE编写代码时，高亮的单词，一般来说就是关键字了

//比如
public、class、void、int、case、catch、try、static
//等等之类的单词都是关键字 

关键字大全

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

引用自百度百科

数据类型

强类型语言

强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言，要求变量的使用要严格符合定义，所有变量都必须先定义后使用。

而我们要学习的Java就是一种强类型语言

java、.NET、C/C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。

弱类型语言

弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php、javascript等就属于弱类型语言·

Java数据类型分类

可能这样看有点笼统，我们可以举一下生活中的例子，比如我们平时生活中也会用到数据类型，像我们会用到数字，数字就对应了数值类型，而数字也会划分为整数和小数，在Java里面我们称为整数类型和浮点类型，然后我们平时最经常用到的就是字，不管是中文还是英文，我们都统一称为字符，也就对应着字符类型了，然后boolean类型是用来表示真假的，对应着计算机的1和0，多用于判断里面，这样理解起来就更加容易了。

基本类型

//八大数据类型
//整数类型
int num1 = 1;  //最经常使用
byte num2 = 2;
short num3 = 3;
long num4 = 4L;  //Long类型需要在数字后加上L表示用的是Long类型
//浮点类型
float num5 = 5.1F;  //float类型需要在数字后加上F表示用的是float类型
double num6 = 6.1;
//字符类型
char str1 = 'A';  //一个char只能存一个字符
String str2 = "我爱Java";  //注意String不是关键字，而是一个类
//布尔类型
boolean flag1 = "true";
boolean flag2 = "false";

什么是字节

• 位（bit）：是计算机内部数据储存的最小单位，
• 字节（byte）：是计算机中数据处理的基本单位
• 1B（byte，字节） = 8bit（位）
• 字符：是指计算机中使用的字母、数字、字和符号
• 1bit表示1位
• 1Byte表示一个字节 1B = 8b
• 1024B = 1KB
• 1024KB = 1M
• 1024M = 1G

引用类型

暂时不讲，因为目前大家还没接触到类和接口

类型转换

• 由于Java是强类型语言，所以要进行某些运算的时候，需要使用到类型转换

低------------------------------------->高
byte，short,char->int->long->float->double

• 运算中，需要将不同类型的数据转换为相同的数据类型才能进行运算

强制类型转换

格式： (类型)变量名

int i = 50;
byte j = (int)i;

像这样子通过在变量前面加一个转换类型就是强制类型转换

自动类型转换

自动类型转换就跟它的名字一样会自动进行转换

int i = 50;
double j = i;

那么就引出来一个问题，什么时候需要强制类型转换，什么时候是自动类型转换呢？一般来说，从根据上面从低到高的排序，如果是高–>低需要强制类型转换，而从低到高就可以自动类型转换。
注意点：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题

变量、常量

变量

• 变量：可以变化的量
• Java是一门强类型语言，每一个变量都必须声明其类型
• Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域

就像上面数据类型和数据转换举例子时定义的都是变量

定义一个变量相当于在内存中开辟一个空间，这个空间用于存储数据，变量名相当于地址，当要输出这个变量的时候，就会去到指定的内存中去读取数据并输出出来。

而在我自己的理解就是，定义一个变量就好像有一面墙上面有许多小柜子，当你定义一个变量时，你会打开一个柜子，在里面存放东西，然后给它贴上一个名字，当你下次要用它的时候就可以根据这个名字去找到这个柜子拿出里面的东西。

定义变量的格式为 数据类型 变量名 = 值

作用域

• 类变量：写在类里面的变量，前面要加static关键字
• 实例变量：和类变量相似，不需要static关键字
• 局部变量：写在方法中的变量

	public class demo {
		static int num1 = 0;  //类变量
		String str = "Hello World"; //实例变量 从属于对象，如果不初始化默认为 0 或null
		public void method() {
		int i = 0; //局部变量 必须声明和初始化值
		}
	}

注意事项：

• 每个变量都有类型，类型可以是基本类型也可以是引用类型
• 变量名必须是合法的标识符
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

常量

• 常量（Constant）：初始化后不能再修改它的值（不可变动的值）
• 常量可以理解为一种特殊的变量，它的值被设置之后，在程序运行过程中不允许被改变。

final 常量名 = 值;
final double PI = 3.1415926；

• 常量名一般使用大写字符

变量命名规范

• 所有变量、方法、类名都要见名知意
• 类成员变量：首字母小写和驼峰原则：studentName
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Student、Teacher
• 方法名：首字母小写和驼峰原则：searchById()、list()

运算符

• Java语言支持以下运算符：
  假设变量 A 的值为 10，变量 B 的值为 20

算术运算符

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

关系运算符

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 为假。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 为假。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

逻辑运算符

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

位运算符（了解即可）

运算符	描述	实例
&	按位与操作，按二进制位进行"与"运算。运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;	(A & B) 将得到 12，即为 0000 1100
|	按位或运算符，按二进制位进行"或"运算。运算规则：0|0=0; 0|1=1; 1|0=1; 1|1=1;	(A | B) 将得到 61，即为 0011 1101
^	异或运算符，按二进制位进行"异或"运算。运算规则：0^0=0; 0^1=1; 1^0=1; 1^1=0;	(A ^ B) 将得到 49，即为 0011 0001
~	取反运算符，按二进制位进行"取反"运算。运算规则：~1=-2; ~0=-1;	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。	A >> 2 将得到 15，即为 0000 1111

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |= 2 等同于 C = C | 2

三元运算符

为什么要讲三元运算符呢，因为三元运算符在平时写代码的时候经常会成为很实用的工具，让你的代码更加简洁，通过下面的例子来了解一下三元运算符。

//(关系表达式) ? 表达式1 : 表达式2;
int num1 = 10;
int num2 = 5;
int result;
/*
如果num1 大于num2 则是true，将nm1赋值给result ；
如果num1 不大于num2 则是false，将num2赋值给result ；
*/
result = (num1 > num2) ? num1 : num2;
System.out.println("result = " + result);

先判断条件，如果为真执行表达式1，反之执行表达式2
其实很像我们平时的说话的语法
疑问句？陈述句1：（否则）陈述句2

运算符的优先级

maybe考试会考？
反正需要了解一下

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,	从左到右

包机制、JavaDoc

包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
• 包语句的语法格式为：
  package pkg1[. pkg2[. pkg3...]];

比如我在写包名一般都会是
com.zy.entity
com.zy.controller
com.zy.mapper
等等之类的包

• 一般公司会利用公司域名的倒置来作为包名
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，只需要使用import语句将该包中的成员导入
• importe pkg1[. pkg2[. pkg3...]].(classname|*);

JavaDoc

• javadoc命令是用来生成自己的API文档
• 参数信息
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

JavaDoc命令怎么使用可以跳转到系统分析与设计（IBM共建）实验环境配置这篇博客中的JavaDoc部分进行查看或者百度查找更多关于JavaDoc的内容进行学习

总结

跟开头所说的一样，每一门语句的学习都离不开它的语法，所以要学好Java就必须掌握它的语法，才能写出更好的代码，避免出现各种bug（减少没必要的bug）基础语法只是入门，后面还有许多有趣的挑战等着我们去探索。