此篇全都是知识点，篇幅有点长，无论有没有基础，先快速的看一遍即可，基础知识要在写代码中逐渐深化理解，而不是在抠字眼中。
在看书，看课，自己敲代码中遇到问题再返回来看对应的点即可，相信那时候理解的肯定会比现在理解的更加深刻。
注意部分一般为考试的考点，在实际应用中未必有人这么用。
java程序的构成和基本语法
- 1. Java程序是怎么构成的。
- （1）类
- （2）方法
- （3）基本语句
- 2. Java基础语法
- （1）关键字
- （2）标识符
- 1）命名规范：
- 2）命名时的普遍习惯：
- （3）注释
- 1）单行注释：
- 2）多行注释：
- （4）变量
- （5）基本数据类型
- 一、基本数据类型
- `1) 整数类型（整型）`
- `2) 浮点类型（浮点型）`
- `3) 字符类型`
- `4) 布尔类型（boolean）`
- 二、基本数据类型的赋值语句
- 三、基本数据类型的转换
- （6）运算符
- 一、运算符的内容
- `1）算数运算符`
- `2）赋值运算符`
- `3）关系运算符`
- `4）逻辑运算符`
- `5) 三元运算符`
- 二、表达式
- 1. 算术表达式
- 2. 赋值表达式
- 3. 关系表达式
- 4. 条件表达式（三元运算符）
- 5. 逻辑表达式
- 三、运算符的优先级
1. Java程序是怎么构成的。
先看看我们之前写的程序。
//创建一个类 类名要和文件名一致，类名后面的大括号成对
public class HelloWorld {
//程序的入口，开始运行的位置，main方法 public static void main(String[] args)
public static void main(String[] args){
//输出一行Hello World
System.out.println("Hello World!");
}
}（1）类
我们每次编写一个.java文件，其实是java中的一个类（class）。
public class HelloWorld {
//java中的类
}因此，
- 应当保持类名与文件名一致。一般来说，类名首字母大写，java中的命名一般使用驼峰命名法，即将单词的首字母大写以区分每个单词。
- 一个.java文件中可以包含多个类，编译后仍然是每个类都各自生成对应的.class文件。换句话说，如果你在一个.java文件中写了三个类，在编译后，会生成三个.class文件，文件名与类名相同。
- 对2补充。生成的.class文件名并不是根据你的.java命名的，而是根据你.java文件中的类名。我们可以编辑的是.java文件，计算机可以读懂的是.class文件，两者命名同一，也是为了简化我们的工作量，以免后面名字乱七八糟，问题不好对应。
学都学了，不妨参照上次学的办法创建一个Test2.java。
public class Test2{
//这样一个类就写好了
}注意：
4. 类名要和文件名相同（除了后缀不要）
5. 花括号要成对出现，需要用到括号、引号时，先把它们写全了，再去写里面的东西。
（2）方法
即c/c++/python等语言中所说的函数。{}内称为方法体。一个类中，可以有零个或一个main方法，以及零个或多个普通方法。
public static void main(String[] args){
//java中的main方法
}
public static int other(){
//java中的其他方法
return 0;
}我们在我们的Test2类中也写一个main方法和普通方法：
public class Test2{
//这样一个类就写好了
public static void main(String[] args) {
//方法要写在类里面
//main方法中的语句会在运行程序的时候自动运行，普通方法只有在调用它的时候才运行。
System.out.println("main");
other(); //调用普通方法的语句
System.out.println("main end!")
}
public static void other(){
System.out.println("nomal method");
System.out.println("nomal method end!");
}
}在自己写完程序后记得先编译、再运行一下，看看最后的结果是不是和自己想的一样。
（3）基本语句
即Java中话应该怎么说，这些不要求一次全学会，因为有很多，全部罗列起来，会让人有一种望而生畏的感觉，所以不妨一边学一般了解。
唯一需要注意：每一句基础语句结束后，都要写一个英文的分号。注意，编程中使用的所有符号都是英文符号！
列如：
char ch1; //声明语句
ch1 = '9'; //赋值语句
System.out.println("Hello World!"); //同上面的other();都是方法调用语句基本语句就是Java中语句的写法，慢慢学就好，没必要一下弄懂。
2. Java基础语法
（1）关键字
定义：被Java语言赋予了特殊含义，用做专门用途的字符串。
简单来说，关键字不能用来命名的，用做其他用途的一串字符，比如class、if、for等。
特殊的，现在还没有具体使用方法，但因为未来有可能有其他用途的字符串，因而被Java占用而不能用做声明变量的字符串，称为保留字。列如goto、var、rest。其本质就是关键字。
关键字中字母都是小写。
常用关键字
（2）标识符
定义：
Java对各种变量、方法和类等要素命名时使用的字符序列。凡是自己可以起名字的地方都叫标识符。
1）命名规范：
- 可以包含字母、数字、_、$
- 不能以数字开头
- 不能使用关键字(包含保留字)命名
注：
（1）Java中严格区分大小写，长度不限制。
（2）标识符应做到见名知意。在编写大型程序时尽量避免a1，b3这种无意义的变量名
2）命名时的普遍习惯：
假设aaa、bbb、ccc分别为三个单词）
包名：无论单或多单词组成，所有字母统一小写，如aaabbbccc。
类名，接口名：多单词组成时，所有单词的首字母大写，如AaaBbbCcc。
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写，如aaaBbbCcc。
常量名：所有字母都大写。多单词时每个单词用下划线连接，如AAA_BBB_CCC。
（3）注释
定义：用于解释说明程序的文字。（注释是一个程序员必须拥有的良好习惯，先写注释再写代码。但，不要给每条语句都写代码，写注释的主要目的是增加代码可读性，这方面要在自己以后的编程中慢慢体会）
1）单行注释：
// + 要注释文字
//单行注释2）多行注释：
/* + 要注释文字（可以多行） + */
/*多行注释1*/
/*多行注释2
*多行注释
*多行注释
**/（4）变量
定义：在程序执行的过程中，在某个范围内其值可以发生改变的量。
变量是内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），Java中每个变量必须先声明，后使用，该区域的数据可以在同一类型范围内不断变化。
定义变量的格式：
数据类型 变量名 = 变量值；
比如：int min = 0;
按照数据类型分类（前阶段需要分清）：
根据声明的位置不同分类（后阶段需要分清）：
声明都发生在类内，在方法体内声明的变量称为成员变量，在方法体外声明的变量称为局部变量。
（5）基本数据类型
什么是数据类型？数据类型就是这么一类具有相同特点的数据，比方说你想要统计一个班的学生的信息，学生的信息就具有很多相同的特点，比如大家都有名字，学号，性别，出生日期…所以，学生就可以设置为一种数据类型。
有了学生这个数据类型，不同的学生就可以接受同样的操作。比如你需要知道张三，李四的性别，你不用想怎么问张三，怎么问李四，你只需要想怎么问学生的性别，然后用这一个方法，分别对张三和李四进行操作即可。
基本数据类型，就是Java所提供的，最最基础的几种具有相同特点的数据的类别。
一、基本数据类型
包括整形（byte/short/int/long）四种，浮点型（float/double）两种，字符型（char）一种，布尔类型（boolean）一种。共8种。不能将null赋值给基本数据类型。
1) 整数类型（整型）
Java中各整数类型有固定的表数范围，不受具体的OS影响，以保证Java程序的可移植性。
Java的整型常量默认为int型，声明long型常量需后加 ‘l’ 或 “L”。（这句话可能不太好理解，比如15，这就是一个整形常量，它默认就是int类型的，15是一个整形常量，因为它不可变，但不是说整形常量肯定就是一个具体的整形数字。这点不用过多纠结，后面会用到的。）
关于表数范围涉及到 二进制 的内容，无基础但有兴趣可以自行学习，没有兴趣的话就不要看啦，在初始学习的时候尽量少一些刨根问底，要相信在不断地学习中问题会自然而然的明白的。
2) 浮点类型（浮点型）
Java浮点类型也有固定的表数范围和字段长度，不受具体OS（操作系统）的影响。
Java的浮点型常量默认为double型（双精度），声明float型（单精度）常量需后加 ‘f’ 或 “F”。
浮点型常量的两种表示形式：
- 十进制数形式（最常用），如：5.12，623.0f，.512（必须有小数点）
- 科学计数法形式，如：5.12e，512E2，100E-2
3) 字符类型
字符类型数据用来表示通常意义上“字符”（2字节）
字符常量 常用的三种表现形式（了解前两种即可）：
- 单引号（一定注意Java语言中所有符合都要是英文的格式！！！）括起来的单个字符。如’a’、‘0’、’(’。
- 单引号括起来的单个转义字符——如\n表示换行（ENTER键），\t表示缩进（TAB键），有兴趣了解可自行学习。 如’\n’。
- 单引号括起来的由Unicode——\uXXXX，XXXX为十六进制的数字，所有的字符都是由一个十六进制的数字编码所代表的，将这个十六进制的数字转化成十进制，即为其ASCII码。——表示的字符。如’\u0041’表示’A’
4) 布尔类型（boolean）
boolean类型适用于逻辑运算。boolean类型的数据只能取值为true和flase，与c语言不同，Java中不可用0或者非零整数代替false和true。
二、基本数据类型的赋值语句
删掉Test2中的内容，编写以下代码。注释内容可忽略。
public class Test2{
public static void main(String[] args) {
/*
*基本数据类型的赋值语句
*为了增加代码可读性，在‘=’等运算符的前后一般都加空格
*System.out.println();用于打印将一个字符打印到控制台
**/
//定义一个long类型的变量
long num = 99999999999L; //long类型后通常跟大写或小写的L
System.out.println(num);
//定义一个float类型的变量
float f = 12.1f; //float类型后要跟F或者f
System.out.println(f);
//字符
char ch1 = '9';
char ch2 = 'a';
//转义字符
char ch3 = '\n';
//println()自身就可以换行
//print()自身不会换行
System.out.println(ch1);
System.out.print(ch3);
System.out.println(ch2);
char ch4 = '\u0041';
System.out.println(ch4);
//char类型可以参与算数运算
System.out.println(ch4 + 1);
}
}尝试在cmd界面或powershell界面编译并运行。
三、基本数据类型的转换
基本数据类型转换包括自动类型转换和强制类型转换。1) 自动类型转换
容量小的类型自动转换为容量大的数据类型，称为自动类型转换。
注意：
1）有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后进行计算（char也是由数（ascii码）表示的，计算机的所有操作本质上都是数与数的计算（有兴趣可以自行学习计算机组成原理））。
2）byte、short、char之间不会相互转换，他们三者在计算时首先转换为int类型。
3）把任何基本类型的值和字符串值进行连接运算（+）时，基本数据类型的值将自动转化为字符串类型（基本数据类型转换成字符串），从而进行字符串的拼接过程（将加号前后的字符串按顺序拼成一个字符串）。
public class Test3 {
public static void main(String[] args){
char ch = 'a';
//自动类型转换 容量小 -> 容量大
int i = ch;
byte bt = 101;
//自动类型转换
short st = bt;
//char、byte、short参与算数运算会转换为int类型
int a = ch + bt;
//short st1 = st * 2;//错误，short和int一起运算结果为int类型
//基本数据类型 与 字符串 进行的 ‘+’运算 为连接运算
//基本数据类型转换为字符串类型
int m = 100;
String str = m + "abc";
System.out.println(str);
//基本数据类型-->>字符串类型
//100-->>"100"
String str1 = m + "";
System.out.println(str1);
}
}2) 强制类型转换
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出。
注意：
1）字符串类型不能直接转换为基本数据类型，但通过基本类型对应的包装类则可以实现吧字符串转换成基本类型。
2）boolean类型不可以转换为其它的数据类型。
在Test3中继续往下写即可。注意，在更改了代码以后，要重新编译（javac Test3.java）才能运行出我们更改后的操作，因为运行是运行的.class文件，不重新编译的话，.class文件还是之前没有修改的。
//强制类型转换
int i1 = 1000; //注意，变量名不能重复！
short st1 = (short)i1;
//String类型（字符串）转换成基本数据类型，先知道能这么转换就行
String str1 = "100"; //字符使用单引号，字符串使用双引号
int i2 = Integer.parseInt(str1);（6）运算符
一、运算符的内容
运算符包括：算术运算符，赋值运算符，关系运算符，逻辑运算符，三元运算符和位运算符。
在编码中，一般用空格将运算符与前后内容分隔开，以便自己或者他人的阅读。在Java程序中（并非所有编程语言，例如Python就不可以乱用），空格和缩进（tab）不会影响程序，但使用规矩的空格和缩进可以方便自己和他人查看代码，因此在日常写代码时，尽量使用好空格和缩进。
1）算数运算符
注意：
1）对负数取模，可以把模数负号忽略不记，如：5 % -2 = 1。但被模数的负号不可忽略。
2）对于除号 “/” ，它在整型与浮点型中的运算有区别：在整形中，只保留整数部分而舍弃小数部分（不是四舍五入！）；在浮点型中，和数学中的除法一样。
3） “+” 用于基本数据类型（除布尔外）时，将发生自动类型转换；用于字符串类型和非字符串类型之间时，会把非字符串转换成字符串。
4）关于 ++i 和 i++ 的区别，是考试的重点，如果并非只是出于爱好，建议多试着敲敲代码，把它们搞清楚。
public class Test4{
public static void main(String[] args){
//模运算(%)
System.out.println(5%2); //1
System.out.println(5%-2); //1
System.out.println(-5%2); //-1
System.out.println(-5%-2); //-1
//模数(%后面的)的符号可以忽略
//除运算(/)
System.out.println(10/2); //5
System.out.println(10/3); //3
System.out.println(10.0/3); //3.3333333333333335
//除法前后有小数则最后结果也是小数，但不一定是精确结果
//自增
int a = 10;
a++;
System.out.println(a);
int b = ++a;
System.out.println(b); //++a先自增在反回结果
int c = a++;
System.out.println(c); //a++先返回结果在自增
System.out.println(a);
}
}2）赋值运算符
赋值运算符的符号为 “=” ，不是我们通常说的等于，表示将其右侧的值赋值给左侧。
注意：
1）当 “=” 两侧数据类型不一致时，可以使用 自动类型转换 或 强制类型转换 的原则来处理。
2）Java中支持连续赋值，如 x = y = 1;
3）扩展赋值运算符：+=、-=、*=、/=、%=。比如：i += 2; 等同于 i = i + 2;
3）关系运算符
见名知意，关系运算符及判断其 左侧 和 右侧 的对象的关系（大于、小于、等于…）。关系运算符的结果都是boolean类型，也就是说要么为true，要么为false。
注意：
= 与 == 是完全不同的运算符。
接着Test4写即可
System.out.println("-------------------------------");
//赋值运算
int m = 10;
m += 1;
System.out.println(m);
//关系运算
System.out.println(10 > 100);
System.out.println(100 == 100);4）逻辑运算符
逻辑元素 与 或 非 异或
- 与(&& &)：如果两侧都为真，则为真;如果一侧为假，则为假
- 或(|| |)：如果一侧为真，则为真;如果两侧都为假，则为假
- 非(!)：取反
- 异或(^)：如果两侧相同，则为假;如果两侧不同，则为真
区别：
5. & 左侧无论真假，右侧都参与运算
6. && 左侧如果为真，右侧参与运算；左侧如果为假，右侧不参与运算
7. | 左侧无论真假，右侧都参与运算
8. || 左侧如果为真，右侧不参与运算；左侧如果为假，右侧参与运算
System.out.println("-------------------------------");
//逻辑运算
System.out.println(true && true); //与
System.out.println(true && false);
System.out.println(true || false); //或
System.out.println(false || false);
System.out.println(!false); //非
System.out.println(!true);
System.out.println(true^true); //异或：两边不一样则为真，两边一样则为假
System.out.println(false^false);
System.out.println(true^false);
System.out.println("-------------------------------");
// &&与& 区别在于，&&只有在前面为真时才会执行后一条语句，&无论前面是不是真都执行后一条语句
int x = 10;
int y = 2;
if((x != 10)&&(++y > 3)){ //不执行后一条语句
}
System.out.println(y); //y=2
x = 10;
y = 2;
if((x != 10)&(++y > 3)){ //执行后一条语句
}
System.out.println(y); //y=3
// ||与| 区别在于，'||'只有在前面为假时才会执行后一条语句，'|'无论前面是不是真都执行后一条语句5) 三元运算符
(条件表达式)? 值1：值2
条件表达式为true，运算后的结果是值1
条件表达式为false，运算后的结果是值2
三元组并非简化后的if-else，三元组是运算符，返回一个值，而if-else是一种结构，并不返回任何值，而是执行一系列语句。
System.out.println("*******************************");
x = 100;
y = 101;
int max = (x<y) ? x : y;
System.out.println(max);二、表达式
根据运算符的不同，主要可分为五种：算术表达式、赋值表达式、关系表达式、条件表达式、逻辑表达式。
注：
左右结合，表示电脑在处理这个表达式的时候是从哪个方向开始对表达式进行处理。
为什么有左右结合的不同，其实把自己当成电脑去走一遍就会明白。一般编程时，对这种知识的要求不大，而且不难理解不过多赘述。
1. 算术表达式
含有加+、减-、乘*、除/、余%的表达式。
如a + b，c / d
优先级最高，左结合。
2. 赋值表达式
含有等于=（注意是一个等号）
优先级最低，右结合。
3. 关系表达式
相对于其他表达式：优先级次于算述表达式
其内部又分为两类：
（1）<、>、<=、>=优先级高
（2）==（等于）、！=（不等于）优先级低
左结合。
4. 条件表达式（三元运算符）
就仅是三元运算符。
优先级只高于赋值，右结合。
5. 逻辑表达式
包含逻辑表达符的表达式。
不同的逻辑运算符的优先级差别较大（如非运算符的优先级只低于括号，而与或确低于所有算数运算符，而与运算又高于或运算），建议除了非运算符外，含有多个逻辑运算符时，用括号标明运算次序。
表达式的概念很广泛，有时候单独的一个变量或者常量其实也可以称作是一个表达式，只不过没有进行任何运算而已。这些东西，想开点。
三、运算符的优先级
运算符的优先级，就是同一句语句中有多个运算符，谁优先级高就先算谁。
其实掌握了上一个表达式之间的优先级就已经够用了，其他的不知道优先级就加括号，其实有的时候为了代码容易读，加括号是个很好的习惯。
运算符优先级问题要详细谈很复杂，是些死记硬背的东西，初学者不建议一次全记住。
平常使用知道大多数情况下从左到右，先乘除，后加减，有括号先算括号里面的就可以了。
不太清楚的运算顺序就加括号。如有应付考试的需要，背书上的。
初学非得搞这个东西很容易劝退。
