JAVA基础语法

就像我们所学习的英语和语文一样，最开始所学习的并不是复杂的组合结构或者难懂的词汇语句，而是从音序音标开始。Java同样如此，要想做好一个繁琐的程序，最基础的一些指令是避免不了的。因此，接下来所学习的是Java的基本语法。

注释

注释一般用于解释代码的作用，相当于书籍里的批注。有时候我们写完代码之后，隔了很长一段时间回过头来会发现，一些自己写的代码很难一下子去回想起来并理解他们。

这个时候，注释的重要性被无限地放大了。注释并不会被执行，是给我们这些程序员看的。

Java中的注释有三种:

1. 单行注释
2. 多行注释
3. 文档注释

• 单行注释

使用两个/，即//。后面衔接所想表达的内容。

//这是一个注释。

• 多行注释

使用/**/来表达内容，两个星号之间输入文本。只要是在这个范围内，想注释多少行都可以。

/*这也是一个注释*/

这两个注释和C/C++中的操作是一样的，由此可见它们的异曲同工之处。

• 文档注释

这个需要结合JavaDoc来进行。

/**
*@author 作者名
*@version 版本号
*@since 最早JDK版本
*/

这个是用来注释文档信息的，例如类注释和方法注释。

标识符和关键字

关键字

关键字指的是一些拥有实际功能的一些单词，例如: public,class等。这些单词不能充当变量或者类名之类的名词。

类别	关键字
数据类型	byte、short、int、long、float、double、char、boolean、void
类、方法、变量修饰符	public、private、protected、static、final、abstract、synchronized、volatile、transient、native
流程控制	if、else、switch、case、default、for、while、do、break、continue、return
异常处理	try、catch、finally、throw、throws
包相关	package、import
引用相关	this、super
其他	new、instanceof、enum、assert

标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

int a= 10;

这里的a就是一个标识符。

注意点

• 所有的标识符都应该以字母(A-Z或a-z)、美元符($)、或者下划线(_)开始。
• 首字符之后可以使字母(A-Z或a-z)、美元符($)、下划线(_)或者数字的任意字符组合。
• 不能使用关键字作为标识符。
• 标识符是大小写敏感的，有一个不对就锁定不到指定的标识符。
• 合法举例: age, $abc, _w112
• 不法举例: 123a,#acsw,*qex2
• 可以使用中文命名，或者拼音命名，但是一般不建议使用。

数据类型

Java属于一种强类型语言，即要求变量的使用严格符合规定，所有变量都必须先定义后才能使用。

Java的数据类型分为两大类:

1. 基本类型
2. 引用类型

在这里我们重点讲解的是基本类型的用法。

基本数据类型又分为数据类型和boolean类型。

• boolean类型:占1位，其值只有true和false两个。
• 数据类型：

包含了三种类型：

1. 整数类型：

byte占1个字节，范围：-128-127

short占2个字节，范围：-32768-32767

int占4个字节，范围：-2147483648-2147483647

long占8个字节，

范围：-9223372036854775808-9223372036854775807

2. 浮点类型：

float占4个字节

double占8个字节

3. 字符类型：

char占2个字节

顺带提一嘴引用数据类型。

它包括三种类型：

1. 类
2. 接口
3. 数组

拓展

整数拓展：进制(以下皆为前缀)

二进制：0b

八进制：0

十进制：无

十六进制：0x

int a= 0b10;//输出为2
int b= 10;
int c= 010;//输出为8
int d= 0x10;//输出为16

浮点数扩展:银行业务如何表示？(钱)

float和double所表达的意义有时候是有区别的。

例如:

明明f和d的值都是0.1，但是他们的boolean值却是false。

问题只是这些吗？并不是

我们将用float书写两个不同的值:

d1= 13123121451512512f;

d2 = d1+1;

这时d2一定比d1多1。

但是boolean结果却是true。

这是为什么呢？

原因在于浮点数的运算能力是有限的，若是超出了范围，多余的部分就会进行舍入误差，接近但不等于。

最好的解决办法就是完全避免去使用浮点数来表示任何数据。

除去了float和double，我们可以去使用BigDecimal类这样的工具来替代浮点数进行数据的标记。

字符扩展:字符和数字之间转换

我们利用char给c1和c2定义为'a','中‘。

使用System.out.print((int)c1);

我们能得到一个数字：97;

使用System.out.print((int)c2);

我们能得到一个数字:20023。

由此可见，所有的字符本质还是数字。

这里涉及到一个编码——Unicode编码。

这种编码2个字节，字符的数量范围为0-65536（2^16）,跟Excel的最大长度是一样的。

Unicode本身会有一个编码表，里面存储了各个数字对应的某个字符，例如a = 61.

既然我们可以把字符转换成数字，当然可以把数字转换成字符。

利用char将c3=\uxxxx(x为数字)，然后输出出来，就能得到各不相同的字符了。同时，这里的\u又称为转义字符。

转义字符:

\t 制表符

\n 换行符

\r 回车符

\f 换页符

\b 退格符

这些是常用的转义字符，不仅限于以上几种。

类型转换

由于Java是强类型语言，所以遇到要进行运算时，需要类型转换、

运算中，不同类型的数据先转化为同一类型，然后进行运算。

每个数据类型都有属于自己的范围，如下所示：

byte,char,short→int→long→float→double.

这都是范围从小到大排列的。

但是为什么long明明字节比float大，还排在它的前面呢？

由于整数与浮点数的差别，后者一定比前者大。

那么问题又来了，如果超出了当前数据类型的范围，是不是只有报错这一种可能呢？

其实还有其他的可能性，这里就需要类型转换的出现了。

强制类型转换：

byte的范围是-128-127,所以如果我们写入的是i=128，是肯定报错的。

但是如果我们在数字前面加了一个(byte),可以使这个数超出范围的那部分重新拉回这个范围中运算。就像内存管理中的分页管理一样，而数据类型的范围就像一个个页，而我们定义的值就是一个页面，经过装载之后，只取出最后溢出的部分。

这是一种高范围数据类型到低范围数据类型才会有的类型转换。

自动类型转换：

这是一种低范围数据类型到高范围数据类型，不需要像上面那样做出任何改变，直接改变数据类型即可。

注意点:

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

//常见问题:运算比较大的数时，控制不了内存溢出
int h= 2000000000;
int y= 10;
int total= h*y;
System.out.println(total);
//输出结果为-1474836480
//由于内存溢出，导致最后得出的数是溢出后的
long total2= h*y;
System.out.println(total2);
//我们会发现换了数据类型结果还是一样的
long total3= (long)h*y;
System.out.println(total3);
//输出结果为20000000000
//最少要把其中一个数值转换为long才能运算成long

变量

定义：可以变化的量

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

注意事项：

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

作用域

1. 类变量

在方法外声明，在数据类型前加上static，之后的所有方法都可使用。

例如：

 static int b=1;

2. 实例变量

//实例变量：从属于对象;如果不自行初始化，这个类型的默认值。则会默认给出0,0.0,false,null
String name;
int age;
//main方法
public static void main(String[] args) {
    int a=1;
    //局部变量，存在于单个方法之内，不影响也不受影响于其他方法
    action_scope action_scope= new action_scope();
    System.out.println(action_scope.name);
    System.out.println(action_scope.age);
}

3. 局部变量

存在于某个方法之中，变量的值和其他方法无关。

常量

定义：初始化后不能再改变值！不会变动的值。

所谓常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

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

//常见常量,需要使用final作为修饰符，一定得在数据类型之前
        final int E=200;

运算符

在 Java 中，运算符号是用于执行各种操作的特殊符号。

算术运算符

用于执行基本的数学运算。

运算符	描述	示例
+	加法	int sum = 5 + 3; 结果为 8
-	减法	int diff = 5 - 3; 结果为 2
*	乘法	int prod = 5 * 3; 结果为 15
/	除法	int quot = 5 / 3; 结果为 1，因为是整数相除
%	取模（取余）	int rem = 5 % 3; 结果为 2
++	自增	int a = 5; a++; 之后 a 的值为 6
--	自减	int b = 5; b--; 之后 b 的值为 4

//拓展:多个不同数据类型的值进行运算
long num1= 100000;
int num2=10000;
short num3= 1000;
byte num4= 100;
double num5= 3.14;
System.out.println(num1+num2+num3+num4);
System.out.println(num2+num3+num4);
System.out.println(num3+num4);
System.out.println(num1+num2+num3+num4+num5);
//由此可见，在很多不同数据类型共同参与的运算中，若有long或double这样的数据类型参与，则以它们为主数据类型
//除此之外的情况，都由int充当主数据类型

自增和自减：++,--

b=a++:执行完这个代码后，先给b赋值，再自增;

c=++a:执行完这个代码前，先自增，再给c赋值。

--也是同理。

Math类

一种用于计算的类，里面收录了很多函数代码,当我们写入Math.时，会自动跳出这些选项供我们运算。

赋值运算符

用于给变量赋值。

运算符	描述	示例
=	简单赋值	int num = 10;
+=	加后赋值	int a = 5; a += 3; 相当于 a = a + 3;，a 的值变为 8
-=	减后赋值	int b = 5; b -= 3; 相当于 b = b - 3;，b 的值变为 2
*=	乘后赋值	int c = 5; c *= 3; 相当于 c = c * 3;，c 的值变为 15
/=	除后赋值	int d = 6; d /= 3; 相当于 d = d / 3;，d 的值变为 2
%=	取模后赋值	int e = 5; e %= 3; 相当于 e = e % 3;，e 的值变为 2

比较运算符

用于比较两个值，返回布尔类型（true 或 false）的结果。

运算符	描述	示例
==	等于	int a = 5; int b = 5; boolean result = (a == b); 结果为 true
!=	不等于	int a = 5; int b = 3; boolean result = (a != b); 结果为 true
>	大于	int a = 5; int b = 3; boolean result = (a > b); 结果为 true
<	小于	int a = 5; int b = 7; boolean result = (a < b); 结果为 true
>=	大于等于	int a = 5; int b = 5; boolean result = (a >= b); 结果为 true
<=	小于等于	int a = 5; int b = 7; boolean result = (a <= b); 结果为 true

逻辑运算符

用于组合布尔表达式。

运算符	描述	示例
&&	逻辑与，两个操作数都为 true 时结果才为 true	boolean a = true; boolean b = false; boolean result = (a && b); 结果为 false
			逻辑或，两个操作数中有一个为 true 结果就为 true	boolean a = true; boolean b = false; boolean result = (a		b);结果为true
!	逻辑非，对操作数取反	boolean a = true; boolean result = !a; 结果为 false

//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d); //输出为false
System.out.println(c); //输出为5
//按照理论来说c++之后输出的应该是6
//但是由于使用的是与运算，只要有一个false结果就为false,"c<4"为false，所以后面的代码不需要执行
boolean e = (c<4)||(c++<4);
System.out.println(e);
System.out.println(c);
//但是在或运算中，只要有一个true，结果就为true,所以即便前面的boolean为false,后面的需要去运算并且输出

位运算符

用于对二进制位进行操作。

运算符	描述	示例
&	按位与	int a = 5; int b = 3; int result = a & b; 结果为 1
		按位或	int a = 5; int b = 3; int result = a	b;结果为 7
^	按位异或	int a = 5; int b = 3; int result = a ^ b; 结果为 6
~	按位取反	int a = 5; int result = ~a; 结果为 -6
<<	左移	int a = 5; int result = a << 1; 结果为 10
>>	右移	int a = 5; int result = a >> 1; 结果为 2
>>>	无符号右移	int a = -5; int result = a >>> 1;

//位运算是和二进制有关的，所以值里面只能出现0和1
//A= 0101 1000
//B= 0110 0110
//A&B= 0100 0000  与： 有同位的两个值都为1,，结果才为1
//A|B= 0111 1110  或： 只要同位有一个值为1，结果就为1
//A^B= 0011 1110  异或：只有同位上的值相等时才为0，否则为1
//~B= 1001 1001   取反：同位得出的值与原来的值相反
int A= 0b01011000;
int B= 0b01100110;
System.out.println(A);
System.out.println(B);
System.out.println(A&B);
System.out.println(A|B);
//<< 左移 在二进制中，1向左移x位（x为<<后面的值） *2^x
//>> 右移 在二进制中，1向右移x位（x为<<后面的值） /2^x
System.out.println("====================");
System.out.println(2<<3);//输出为16
//2 → 0000 0010
//16→ 0001 0000

无符号右移运算符 >>> 会把一个数的二进制表示向右移动指定的位数，无论该数是正数还是负数，在右移时左边空出的位都会用 0 来填充。

与 >> 的对比

• >> 是有符号右移运算符。对于正数，它和无符号右移操作一样，左边空出的位用 0 填充；而对于负数，左边空出的位会用 1 填充，以此保证符号不变。
• >>> 无论操作数是正数还是负数，左边空出的位都用 0 填充。

三元运算符

//三元运算符
//x ? y : z
//解释:如果x==true,则结果为y，否则结果为z
int score = 80;
String pass = "及格";
String no_Pass = "不及格";
System.out.println(score>=80?pass:no_Pass);
//输出为及格

包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包的本质其实就相当于一个文件夹，我们可以将类这些文件放在里面进行归类。

包语句的语法格式为: （一般置于第一行）

package pkg1[. pkg2[. pkg3...]];

使用了包机制了的话，上面这段代码很重要，如果删除了就会报错，无法找到其位置。

一般利用公司域名倒置作为包名。

例如:

域名：www.bilibili.com

包名：com.bilibili.www

解释： 在com这个包里面有个子包名为bilibili,在bilibili包里面有个子包名为www.

在不同的包中，如果想引用另一个包中的代码。需要使用import来导入。

例如:

import com.An_Sen.base.HelloWorld

• 不同包中的名字也尽量不要相同，不然如果要导入的话会报错，显示这个名字已存在。
• 如果一个包中的名字很多，一个一个导入很麻烦。我们可以使用一个*来将所有的类导入。

import com.An_Sen.base.*

这样就可以使用这个包下所有类了。

JavaDoc生成文档

JavaDoc命令是用来生成自己API文档的

参数信息：

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• throws 异常抛出情况

加在类的上面，就是类的注释，加在类的里面，就是方法的注释。

生成文档:

• 使用cmd生成：

1. 打开想要生成的那个类
2. 打开cmd→
3. 输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java

• 使用IDEA生成：

1. 打开生成配置窗口：依次点击 Tools -> Generate JavaDoc。
2. 选择生成范围：在 Scope 区域，你可以选择生成整个项目、某个模块、某个包或者特定的文件的 JavaDoc。
3. 设置输出目录：在 Output directory 中指定 JavaDoc 文档的输出目录。
4. 配置命令行参数（可选）：在 Other command line arguments 输入框中，你可以添加额外的命令行参数。例如，若要支持中文，可添加 -encoding UTF-8 -charset UTF-8。
5. 完成上述配置后，点击 OK 按钮，IDEA 就会依据代码中的 JavaDoc 注释生成 HTML 格式的文档。
6. 生成完成后，会在指定的输出目录下看到一系列 HTML 文件，打开 index.html 文件就能查看生成的文档。

在做这两中生成文档的方法前，一定要记得先在类里面使用JavaDoc注释，这样生成的信息更加全面一些，不会有局限性。