java入门笔记
前言
我本人是一个刚涉java的一位新手，我有一天突然想着“我要进军java”。但是我本人又是那种自由，开脱一些的人，不想去系统的学习（大概以后会变吧），然后我就在csdn上面找java的教学。
但是，我翻遍了csdn，找到的都是java里面的关键词的使用介绍，对于像我这样一点基础都没有的人来说，是非常不友好的。然后我就上网找视频，然后对着视频一步一步将这个文章打出来，每一个内容，都是我亲自打出来然后解决的，里面掺杂我自己的理解，希望能对像我这样的新手能起到一点帮助。也希望java大佬们能给我这篇文章一点建议，有错误的地方也请多多包涵并指出，万分感谢。（该文章是基于bilibili的视频而创建的，如果大家觉得我这篇文章讲的不够清楚，大家可以前往下面的网页进行观看：bilibili的java学习视频）
最最最最基础的东西
1.在安装好java并配置好环境变量后，在磁盘内找一个位置创建一个文件夹，用来存放程序。（安装java和配置环境变量方法请参考：java安装和环境配置）
2.运行方法：创建好java程序(.java)后，打开cmd(命令提示符)界面，进入文件所在的文件夹目录，输入javac [文件名].java,然后会在该文件夹内创建一个.class文件，然后输入java [文件名],即可运行
一.“hello world”
程序如下：
public class math{
public static void main(String[] args){
System.out.println("hello world");
}
}
其中第一句 public class [文件名]{…}为固定格式，且文件名必须相同
第二句 public static void main(String[] args){…}其中，除args之外，都是固定格式，args可以替换，但一般不用替换
二.常见的运行报错
以“hello world”为例，列举几个常见的错误信息：
1. “类[文件名]是公共的”
在编译时，出现这种情况一般都时程序第一句的文件名对不上，如图：
像这种情况，cmd会提示你的文件名没有声明，也就是该查找不到该文件名的.java文件
2. “需要class、interface、enum或ercord”
运行时出现这种情况，通常都是第一句有问题，如图：
可以看到，在cmd第三句的“public cass math{”中，在c的下面有一个箭头，它指示我们程序中是哪个地方出错，后面的错误都是因为开头的语句有问题，才提示报错，也有可能是花括号个数不对导致的
3. “在类[文件名]中，找不到main方法…”
如图：
cmd会提示我们“找不到main方法”，那我们就看源程序中哪一句需要main，然后对着正确的改过来就行
4. 找不到“system”程序包“
在输入语句的时候，经常会把大小写搞混淆，然后有可能出现以下情况：
cmd会提示你system程序包不存在，然后看这句"math.java:4"，就代表该程序第4句有问题。但是有的同学会问：“我不就写了三句吗？怎么第4句出错”因为在java中，空行也会被识别成一句。
然后我们就把程序中的system改成System就可以了。
5. “错误：编码 UTF-8 的不可映射字符”
在进行“hello world”的编程中，有的同学可能心血来潮，想输出中文，可是把“hello world”切换成中文运行后，会弹出报错，具体情况如下：
在细看错误报错时，会发现我们打的语句和标准语句是没有差异的，但就是没法输出中文，这种情况一般都是因为java程序采用的编码方法和电脑编码不一样而导致的差异，这种情况要看自己电脑的编码方式，然后修改，具体可以去搜详细的文档，这里就不多细说（好吧，其实我自己电脑也有问题，但是在保存的时候另存为，然后修改一下编码方式应该可以，具体应该要看电脑，反正我保存的时候改为ANSI格式就可以了）
三.关于"hello world"的语法解析
1.java对大小写敏感
字面意思 在Java中，对于大小写的辨别是很强的，只要该大写的地方小写了，或者反之，在编译的时候，或者运行的时候都会出现报错，尤其是第一句:"public class [文件名]"的时候。
2.java是面向对象的语言，所有代码必须位于类里面
在java中，关键字class的意思是类，我们在一个程序中，所有的代码都必须位于类里面：
public class [文件名]
{
//类里面
}
也就是说，我们要把程序写在这两个花括号之间，否则，在编译的时候就会出错
3.编译器为每个类生成独立的字节码文件
当我们写的*.java程序编译成功后，会在当前目录下自动创建一个*.class文件，也就是所说的字节码文件
4.main是java程序的应用入口，格式固定
在1."hello world"里面说到，第二句public static void main(String[] args){…}格式是固定的，无法进行修改，只有args这个参数可变，但是一般情况下不需要变动
5.一个源文件可以包含多个类
源文件也就是我们所创建的*.java文件，类就是class，那么一个源文件可以包含多个类是什么意思，如下：
public class math{
public static void main(String[] args){
System.out.println("hello world");
}
}
class qwer{
}
可以看到，在一个源文件中我写了两个类语句，但是第二个类语句是空的，什么都没有，这种情况编译之后，会在当前目录下多创建一个qwer.class文件，但是空文件并没有什么卵用
6.每个语句必须以分号结束
在语句中，写完一个语句都要使用分号“;”来结束（英文），按下回车并不会导致语句结束，所以java只认分号，你一段语句占多行都是没有问题的，当然，也不是说你可以随便换行，只是说注意要用分号结束而已
四.在编译中的建议
1.在写代码的时候，一定要注意缩进格式
2.在写"{ }“,”( )"的时候最好是成对编写，然后再在其中输入内容
五.注释
写注释的好处：做一个人见人爱的程序员
不写注释的好处：做一个离职后，前公司还得来求你的程序员(〃‘▽’〃)
注释应该都是知道的，编译和运行的时候并不会将注释编译进去，只是起一个让别人能看懂你的源代码的用途
分类
1.单行注释：用“//”开头
2.多行注释：以“/ * ”开头，以“ * /”结尾，不能嵌套使用
3.文档注释：以“/** ”开头，以“ */”结尾，一般用于“eclipse”，“IDEA”等开发环境中
1.单行注释
如下：
public class math{
public static void main(String[] args){
//嗨嗨嗨
//嗨嗨嗨嗨
System.out.println("hello");
}
}
2.多行注释
如下：
public class math{
public static void main(String[] args){
/*嗨嗨嗨
嗨嗨哈
嗨嗨嗨嗨
*/
System.out.println("hello");
}
}
3.文档注释
由于文档注释使用的不多，所以这里不详细展开讲解，有兴趣者可以去博客上查找一番，但是大致上使用方法是大差不差的
六.标识符_关键字
标识符
1.标识符的简介
标识符是用来给变量、类、方法以及包进行命名的
4大规则
1.必须以字母、下划线_、美元符号$开头。
2.其他部分可以是字母、下划线、美元符和数字的任意组合。
3.大小写敏感，且长度无限制。
4.不可使java的关键字
使用规范
1.表示类名的标识符：每个单词的首字母大写，如Man、Task等
2.表示方法和变量的标识符：第一个单词小写，第二个单词首字母大写，即“驼峰原则”，如eat()、eatFood()
注意：java不采用ACSII码，而是采用Unicode字符集。因此，这里字母的含义不仅仅是英文，还包括汉字等等。但是不介意采用汉字做标识符
2.标识符的示例
1.合法的标识符
int a=3;
int _a=123;
int _a123=1;
int _12=1;
int $$=2;
int 变量1=55;//不建议使用
2.不合法的标识符
int 1a=1;//不能以数字开头
int a#=3;//不能使用像#这样的特殊符号
int int=3;//不能使用关键字
关键字
java提供的关键字如下表：
七.输入和输出方法
在讲变量之前，先讲一下输入和输出方法，因为在讲变量的时候，在使用值的时候，必须要让存储空间里面有值，才能使用，但是，一般来说，变量的值都是我们在运行的时候输入的，不可能一直初始化，所以就讲一下输入输出。
1.输出方法
在java中，常见的输出方法有三种：
1.换行输出
格式：System.out.println();
【实例】
System.out.println("hello");
执行完这几步后，在cmd里面会自动换行。
2.不换行输出
既然有了换行输出，那肯定也有不换行输出，格式：System.out.print();
【实例】
System.out.print("hello")
3.按格式输出
格式：System.out.printf();类似于c语言的printf
既然是按格式输出，那肯定要有格式控制符，java常见的格式控制符如下：
//%表示进行格式化输出，%之后的内容为格式的定义
格式控制符 说明
--------------------------------------------------
%d 输出int型数据
%c 输出char型数据
%f 输出浮点型数据，小数部分最多保留6位
%s 输出字符串数据
%md 输出的int型数据占m列
%m.nf 输出的浮点型数据占m列，小数点保留n位
注·：如果你在输出变量值的时候，想要加上中文，可以这么输入：
System.out.println("a变量的值是："+a);
2.输入方法
最常见的输入方法就是从键盘接收值，但是想要在java中从键盘输入值，具体方法如下：
1.scanner包输入方法（本人觉得最好用的一个）
import java.util.Scanner;//这一步写在类之外
public class [文件名]{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
System.out.println(a);
}
}
其中int a = scanner.nextInt(); 这一步中的scanner.nextInt() 表示输入一个整数，如果要输入字符串就将变量的类型切换成对应类型和后面的scanner.nextInt 替换成scanner.next
如下：
import java.util.Scanner;//这一步写在类之外
public class [文件名]{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String a = scanner.next();
System.out.println(a);
}
}
当然，输入的字符串遇到空格就会自动停止了，所以为了输入多个字符串，我们需要将scanner.next 替换成scanner.nextLine，如下：
import java.util.Scanner;//这一步写在类之外
public class [文件名]{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String a = scanner.nextLine();
System.out.println(a);
}
}
虽说Scanner scanner = new Scanner(System.in);这一步我也不知道是干嘛的，反正输就完事了啊（￣︶￣）↗
2.system功能输入
system跟上面的方法对比起来可能用处不大，但是还是应该讲一下
system输入方法如下：
public static void main(String[] args) throws IOException {
char c;
System.out.print("Please input a char:");
c = (char) System.in.read();
//从标准输入读入u一个字节的信息，并返回一盒字符型变量
System.out.println("Receive char =" + c);
}
替换c = System.in.read()c的类型就可以输入对应的数值。
说明：
虽说system功能不需要额外语句，但是它会把我们输入的空格，回车等输出出来，并且，返回值是ASCII码，所以还是不怎么好用的。
3.命令行相关设置方法
命令行相关设置方法跟scanner方法差不多，都是要加额外语句，命令行的额外语句如下：
DataInputStream din = new DataInputStream(System.in);
然后使用命令行输入的时候语句如下：
[变量名] = Double.parseDouble(din.readLine());
4.JOptionPane相关功能
关于JOptionPane相关功能的输入方法，本人觉得并不怎么好用，因为这种方法是弹窗输入输出，而且这个方式是字符型，我们需要转化为整形，所以我在这里就不展开讲解，有兴趣可以自己搜索一下相关输入方式。
八.变量
1.变量的本质
变量这个词，我估计学过编程语言的都非常熟悉，但是我在这里为了防止没有学过其他编程语言的同学们不知道变量的意思，所以我讲一下变量。
变量，顾名思义就是会变动的量。当我们在编程语言的时候呢，计算机执行到定义变量这一步，就会在内部空间，也就是内存中开辟一个空间，你定义的变量名字是什么，计算机开辟的空间的名字就是什么，然后当计算机收到一个值，检查之后看看这个数值是属于哪个空间的，就放过去，有图：
变量本质上就是代表一个“可操作的存储空间”，空间位置是确定的，但是里面放的值不确定，可以通过变量名来访问“对应的存储空间”，从而操作这个“存储空间”存储的值。
java是一种强类型语言，每个变量都必须声明其类型，例如：int a=3;
变量的类型确定了占据存储空间的大小。
2.变量声明和初始化
【实例】变量声明和初始化：
int a=3;
double b=4.1;//以上两个变量在定义的时候给了值，称为初始化
int c,d//这两个变量都是int型，但是没有初始化
关于初始化这个问题，在进行编译的时候，如果定义了一个变量，但是没有初始化的话，会出现以下结果：
所以，当我们定义变量后，如果要去使用它，那么就必须给这个变量对应的空间一个值，才能正常使用。
3.变量的分类和作用域
1.变量的类型
变量分为三种类型：局部变量、成员变量（实例变量）、静态变量（类变量）
| 类型 | 声明位置 | 从属于 | 生命周期（作用域） |
|---|---|---|---|
| 局部变量 | 方法或语句块内部 | 方法/语句块 | 从声明位置开始，直到方法或语句块执行完毕，局部变量消失 |
| 成员变量 | 类内部，方法外部 | 对象 | 对象创建，成员变量跟着创建，对象消失，成员变量跟着消失 |
| 静态变量 | 类内部，static修饰 | 类 | 类被加载，静态变量就有效，类被卸载，静态变量就消失 |
如下：
public class math{
int b;//由于定义在main之外，隶属于class里面，所以是成员变量
static int c;//静态变量
public static void main(String[] args){
int a=3;//在public static void main(...){}的花括号中定义的，作用范围截至于该花括号结束，所以是局部变量
}
}
局部变量(vocal variable)
方法或语句块内部定义的变量，生命周期（有效范围）是从声明位置开始到方法或语句块执行完毕为止。所以，局部变量必须先声明，赋值（初始化）后再使用
【实例】局部变量的声明
public void test(){
int i;
int j=1+5;//编译出错，因为i还没有初始化，无法使用
}
public void test(){
int i;
i=10;
int j=i+5;//编译成功
}
成员变量（member variable 又叫实例变量）
方法外部，类内部定义的变量。从属于对象，生命周期（有效范围）伴随对象中止。如果不进行初始化，则会自行初始化成对应类型的默认值
| 数据类型 | 默认值 |
|---|---|
| int | 0 |
| double | 0.0 |
| char | ‘\u0000’ |
| boolean | false |
静态变量
使用static定义，从属于类，生命周期（有效对象）伴随类始终，从类加载到卸载。（讲到内存分析后我们在深入）。如果不进行初始化，则会自行初始化成跟成员变量一样的默认值。
4.常量（Constant）
常量，就是只能被赋一次值的量。在java中，使用关键字final来定义。常量一旦被初始化后不能再更改。
声明格式：
final [类型] [变量名] = [初始化值]
关于只能赋一次值，下面有个程序可以看看：
可以看到，在这个程序中，我定义了一个常量a，并初始化为3。当我在下一句为其加值时，java编译是通过不了的，所以，常量只能赋一次值。
为了更好的区分和表述，一般将1 2 3 ‘a’ ‘b’ true这之类的称为字符常量，而用final修饰的称为符号常量。
5.建议
1.所有变量、方法、类名：见名知意
2.类成员变量：首字母小写和驼峰原则
3.局部变量：首字母小写和驼峰原则
4.常量：大写字母和下划线
5.类名：首字母大写和驼峰原则
6.方法名：首字母小写和驼峰原则
九.基本数据类型
大体图示：
整数占用空间
byte：1个字节
short：2个字节
int：4个字节
long：8个字节
浮点占用空间
float：4个字节
double：8个字节
提示：关于字节，它有一个英文名：byte
1byte是由8bit（比特）组成的，1bit有两种表示状态：0和1 表示计算机存储的情况
1.整数类型
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| byte | 1字节 | -27~27-1 (-128~127) |
| short | 2字节 | -215~215-1 (-32768~32767) |
| int | 4字节 | -231~231-1 （-2147483648~2147483647）约21亿 |
| long | 8字节 | -263~263-1 |
java语言整形常量的四种表示形式
十进制：99、-324、0 （正常表示）
八进制：015、043 （要求用0开头）
十六进制：0x14、0X54 （要求用0x或0X开头）
二进制：0b0101110、0B0111011 （要求用0b或0B开头）
2.浮点类型
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| float | 4字节 | -3.403E38~3.403E38 |
| double | 8字节 | -1.798E308~1.798E308 |
1.float类型又称为单精度类型，尾数可以精确到7位有效数字
2.double表示这种类型的大小是float的两倍，也叫双精度类型，绝大部分都使用double
3.java浮点类型常量有两种表示形式
(1).十进制数形式： 3.14、314.0、0.314
(2).科学计数法：3.14e0、3.14E2、3.14e-1
4.浮点型不精确，不要用于比较
浮点数存在误差，数字不能精确表示。浮点数适合普通的科学和工程运算，精度足够；但不适合精度要求非常高的商业计算，这时要用BigDecimal进行运算和比较
【示例】
可以看到，d1为0.1，d2为1.0/10，也就是0.1。但是这两个数比较的结果却是false（假），这就是为什么不要用浮点数作比较
5.浮点数类型默认是double，要改成float可以在后面加上F或f。
如图：
这里提示从double转换到float可能会有损失。因为默认的时double类型，无法直接定义成float。要想转为float，就在1.65的后面加f或F：
3.字符型
1.字符型在内存中占两个字节，在java中使用单引号来声明。比如’A’是一个字符，它与“A”不同，“A”表示含有一个字符的字符串
2.char类型用来表示Unicode编码表中的字母。Unicode编码被用来处理各种语言的文字，它占两个字符，可允许有65536个字符。
【示例】
char a = 'A';
char b = '中';
Unicode具有从0到65536之间的编码，通常用’\u0000’到’\uFFFF’之间的16进制来表示（前缀u表示Unicode）
【示例】
char c = '\u0061';
3.java语言中还允许使用转义字符’ \ '来将其后面的字符转变为其他的意义。意思如下表：
| 转义符 | 含义 | Unicode值 |
|---|---|---|
| \b | 退格（backspace) | \u0008 |
| \n | 换行 | \u000a |
| \r | 回车 | \u000d |
| \t | 制表符 (tab) | \u0009 |
| \ " | 双引号 | \u0022 |
| \ ’ | 单引号 | \u0027 |
| \ \ | 反斜杠 | \u005c |
注意
后面的String类，其实是字符序列，本质是char字符组成的数组
4.布尔型（Boolean）
1.Boolean类型有两个常量值，true和false。
2.在内存中占一个字节或四个字节，不可以用0或非0的整数代替true和false。
这种类型数据比较简单，只有真和假两种情况
十.运算符
计算机的基本用途就是执行数学运算，java提供了一套丰富的运算符来操作变量
1.算术运算符
1.+、-、*、/、%属于二元运算符。%是取模运算符，也就是求余数
2.算术运算符++（自增）、–（自减）属于一元运算符
2.二元运算符的运算规则
整数运算
- 如果两个操作数有long类型，则结果也为long类型
- 没有long类型时，结果为int类型。即使操作数全是short，byte，结果也是int型
浮点运算
- 如果两个操作数有一个为double，则结果为double
- 当只有两个操作数都是float，结果才为float
取模运算
- 其操作数可以为浮点数，一般使用整数，结果是“余数”，“余数”符号和左边操作数相同。如：7%3=1、-7%3=-1、7%-3=1
注：当浮点和整数运算时，如果需要将结果放入变量中，则该变量的类型必须为上述规定的类型
3.赋值及其扩展赋值运算符
1.赋值运算符：“=”，其作用是将赋值符右边的内容放入左边的变量中
2.扩展赋值运算符：“+=”、“-=”、“*=”、“/=”、“%=”
+=：a += 3 == a = a + 3
-= ：a -= 3 == a = a - 3
*= ：a *= 3 == a = a * 3
/= ：a /= 3 == a = a / 3
%=：a %= 3 == a = a % 3
4.关系运算符
关系运算符：“==”等于、“!=”不等于、“>”大于、“<”小于、“>=“大于或等于、”<="小于或等于
关系运算符的结果为布尔值：true和false
注意
“=”是赋值运算符，而真正判断两个操作数是否相等的运算符是“==”
“ ==”、“!=”是所有（基本和引用）数据类型都可以使用
“>”、“>=”、“<”、“<=”仅针对数值类型，即(byte/short/int/long，float/double以及char)
5.逻辑运算符
短路与和短路或采用短路的方式，从左往右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数。
6.位运算符
位运算符指的是进行二进制位的运算
位运算符：“~”取反、“&”按位与、“|”按位或、“^”按位异或、“<<”左移运算符、“>>”右移运算符
其中“&”、“|”、“^”这三种跟逻辑运算符没有差别，只不过使用0和1来操作的。
“<<”、“>>”左移和右移相当于向左/右移，相当于乘/除2
7.字符串连接符
“+”运算符两侧的操作数只要有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串然后再进行连接。注意是字符串（String），而不是字符（char）。如果是字符型则运行加法，如果是字符串，则连接。如下：
int a = 3;
int b = 4;
System.out.println(a+b);//结果为3+4=7
String c = "3";
int d = 4;
System.out.println(c+d);//结果为"3"&"4"="34"
char e = "3";
char f = "4";
System.out.println(e+f);//结果为"3"+4="7"
如果类型是char的话，会发生以下情况
char a = 'h';
char b = 'i';
System.out.println(a+b);//结果为209，也就是'h'和'i'的ASCII码值相加，即104+105
System.out.println(""+a+b);//结果为'hi'，由于前面有空字符，所以输出会将两个字符叠加起来
8.条件运算符
条件运算符是所有运算符中唯一一个三目运算符，即有三个操作数。
格式：[变量]=[判断条件]?[条件成立的结果]:[条件不成立的结果]
【实例】
int a = 3;
int b = 4;
int c;
c=a>b?1:0;//先判断?前面的式子'a>b'，如果成立，则返回1，否则，则返回0
且成立或不成立的结果的式子可以写成运算式或判断式。
附加–运算符的优先级
在写程序的时候，有的语句会出现多个运算符，一般情况下，可以使用"()"将某个计算式括起来，来先执行这步，但是运算符的优先级还是有必要拉出来讲一下的
| 优先级 | 运算符 | 类型 |
|---|---|---|
| 1 | （） | 括号运算符 |
| 2 | !、+(正)、-(负) | 一元运算符 |
| 2 | ~ | 位逻辑运算符 |
| 2 | ++ 、- - | 递增和递减运算符 |
| 3 | *、/、% | 算术运算符 |
| 4 | +、- | 算术运算符 |
| 5 | <<、>> | 位左、右移运算符 |
| 6 | > 、>= 、< 、 <= | 关系运算符 |
| 7 | ==、!= | 关系运算符 |
| 8 | & | 位运算符、逻辑运算符 |
| 9 | ^ | 位运算符、逻辑运算符 |
| 10 | ｜ | 位运算符、逻辑运算符 |
| 11 | && | 逻辑运算符 |
| 12 | ｜｜ | 逻辑运算符 |
| 13 | ?: | 条件运算符 |
| 14 | =、+=、-=、*=、/=、%= | 赋值运算符、扩展运算符 |
十一.数据类型的转换
1.自动类型转换
自动类型转换是指容量小的数据类型可以自动转换为容量大的数据类型。
如图：
在上图中，实线表示没有数据丢失的类型转换，虚线表示在转换时可能会有精度的损失。
2.强制类型转换
强制类型转换，又称为造型（cast），用于强制转换数值的类型，可能损失精度。
用法：（数据类型）变量名；
强制类型转换用于在自动类型转换时，无法转换的数据类型，可以使用。
注意，如果强制转型的时候，超出了表示的范围则会输出为其他的值。
类型转换时常见的错误和问题
- 1.操作数比较大的时候，要留意是否溢出，尤其是整数操作时
- 2.L和l的问题：
(1).不要命名名字为l的变量，字母l容易跟数字1搞混。
(2).long类型使用大写字母L，不使用小写字母l。
【示例】数据类型的溢出问题
溢出问题指当某个变量的值超出了该变量数据类型的时候，会出现结果不正确的后果。
int money = 1000000000;
int years = 20;
int toys = money*years;
System.out.println("toys="+toys);//返回值为负数，因为1000000000*20超出了int的范围，所以溢出了
十二.控制语句
- "顺序结构"代表在该语句中先执行语句a，再执行语句b的逻辑。
- "条件判断语句"代表在该语句中"如果…那么…否则…"的执行逻辑。
- "循环结构"代表"如果…则重复执行…"的执行逻辑。
图例：
-
顺序结构
-
条件判断结构
-
循环结构
1.条件判断结构（选择结构）
由于顺序结合就是正常的语句执行顺序，没必要讲，直接就从条件判断开始。
条件判断结构顾名思义就是如果某个语句满足了条件，那么就执行对应的语句。
if单选择语句
语法：
if(条件判断式1){
语句1;
} //代表如果满足(if)条件1，则执行语句1
在条件判断式内输入判断条件，如果满足该条件，则执行该if语句的包含语句。否则不执行。
注意
如果if语句后面不用"{ }"括起来，则之代表该if语句之包含后面的第一条语句
if…else双分支语句
因为if语句之有满足条件的执行式子，并没有不满足条件的执行语句，所以"if…else…"语句就诞生了
语法：
if(条件判断式1){
语句1;
}
else{
语句2;
} //代表如果满足(if)条件1，则执行语句1，否则(else)执行语句2
if…else if…else…多分支语句
在执行条件判断时，有的时候需要判断的情况有多种，光是单个的"if…else"语句是不能满足的，所以就有了"if…else if…else…"多分支语句。
语法：
if(条件判断式1){
语句1;
}
else if(条件判断式2){
语句2;
}
else{
语句3;
} //代表如果满足(if)条件1，则执行语句1，否则如果满足(else if)条件2，则执行语句2，否则(else)执行语句3
当使用多分支语句时，如果判断的情况比较多，也可以多加几个"else if…"语句
switch语句
switch语句可以看成是多分支语句的精简版，可以在switch语句中一次打出多个条件判断式以及执行语句。
语法：
switch(需要判断的式子)
{
case 满足条件:执行语句;break;
case 满足条件:执行语句;break;
case 满足条件:执行语句;break;
case 满足条件:执行语句;break;
case 满足条件:执行语句;break;
case 满足条件:执行语句;break;
...
default:执行语句；break；
}
其中，break起到的作用是，当满足这个条件并且语句执行完毕后直接跳出。如果不适用break语句的话，当满足某个条件并当该条件的执行语句完毕后，会将后面的case的满足语句一并运行，直到该switch语句执行完毕。
【不加break的示例】
可以看到，我在switch后面的判断式填写的是a，就表明我要用a的值来跟下面的case作比较，如果满足，就执行对应语句。
由于我定义的a是1，所以会进入到第一个case语句，但是由于我没加break，所以会把下面case语句的执行语句一并执行
2.循环结构
循环结构分为两大类，当类和直到类
- 当类：当布尔表达式条件为true时，反复执行该语句，当布尔表达式的值为false时才停止循环
- 直到类：先执行语句，在判断布尔表达式，如果为true，再执行语句，如此反复，直到布尔表达式条件为false时才停止循环。
while…语句
语法结构：
while(布尔表达式){循环体}
while语句属于当类的结构，也就是当布尔表达式为真的时候，才会执行循环体，为假的时候则跳出循环
注意：while语句后面循环体如果有多个语句需要用花括号括起来，原理和if一样，并且如果类似于这种函数的语句，后面如果要跟多个语句，都要加上花括号。
do…while…语句
语法结构 ：
do{循环体}while(布尔表达式);
do…while…语句属于直到类的结构，也就是先执行一遍循环体，然后再进行布尔表达式的判断
for语句
语法结构：
for(语句1;语句2;语句3){循环体}
for语句属于当类的语句，执行顺序跟while大同小异，但是由于for语句有三个语句，所以执行顺序稍微会有点不同。
解释：
- 语句1：在for语句开始执行的时候执行一次，后面的循环过程中不再执行，一般用于for循环体的变量的初始化
- 语句2：for语句的判断语句，第一次执行在语句1后面，后面的多次执行在语句3的后面，用于判断该for语句需不需要执行下去
- 语句3：for语句的执行语句，执行在循环体后面，一般用于使语句2为假，以控制循环的结束
- 循环体：是for语句的执行语句，执行于语句2之后。
注意，for语句括号内的三个语句可以不写，但是不写的话可能导致一些问题
举例：
- 当语句1不写时，不会有任何问题
- 当语句2不写时，该for语句则永为真，即无限死循环
- 当语句3不写时，则一定要在循环体内有能够使语句2为假的语句，否则为死循环
注意：在所有循环中，都必须有能够让循环结束的语句，否则将为死循环。（除非你是故意的）
循环语句的嵌套
在进行java的编程中，有的时候会用到一个循环完不成，或者该循环需要多次使用的情况，此时，就需要进行循环嵌套。
循环嵌套就是在一个循环语句中写另外一个循环语句，以达到上述要求
break和continue语句
break语句和continue语句都是用于循环内的一个语句，其中，break也可以用于switch语句内。
当break和continue语句用于循环语句中，可以起到不同的作用。
break：强行结束该循环，即跳出此循环
continue：结束本次循环，不跳出此循环，只是结束本次循环，直接执行下一次循环
十三.方法
1.
当我们学到足够多的语句之后，在一些比较长的程序中，可能有一些语句需要重复使用，但是我们为了方便，不可能把那些语句都打一遍，所以我们需要将这些语句放在一个方法里面装起来。
方法：一段用来完成特定功能的代码片段，类似于其他语言的函数，用于定义该类或该类的实例的行为特征和功能实现。
在面向过程中，函数是最基本单位，整个程序是由一个个函数调用组成。
面向对象中，整个程序的基本单位是类，方法是从属于类或对象的。
方法声明格式
[修饰符1 修饰符2 …] 返回值类型 方法名（形式参数列表 ）{
java语句…
}
方法的使用方法
普通方法：–对象名.方法名.(实参列表)；
静态方法：–类名.方法名.(实参列表)；
方法的说明
- 形式参数：在方法声明时，用于接收外界传入的数据
- 实参：调用方法时实际传给方法的数据
- 返回值：执行完毕后，返还调用给它的环境的数据
- 返回值类型：约定返回值的类型，如果无返回值，则为void
【方法的定义和调用实例】
import java.util.Scanner;
public class welcome {
public static int Max(int x,int y) {
int z;
z=x>y?x:y;
return z;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
int z = Max(a,b);
System.out.println(z);
}
}
在上述语句中，我们定义了一个方法“Max”，在方法“Max”内，我定义了两个形式参数x和y
然后我又在Max内定义一个实参z，并且执行"z=x>y?x:y"这个比大小的语句，然后将z的值返回出去
给主方法的z。也就是说，“int z = max(a,b);”这一步相当于执行的是"int z = a>b?a:b;"
注意：
在方法内的规则跟主方法的一样，且在方法后面的形参列表内的变量名不得在方法语句块内使用。
2.方法的重载
方法的重载是指在一个类中可以定义多个名字相同的方法，根据形参类型不同，形参数量不同，形参顺序不同来进行区分
【示例】
2.1 只有返回值不同的方法不构成重载：
public static int add(int x,int y) 和 public static void add(int x,int y)
2.2 只有形参的名称不同，不构成方法的重载：
public static int add(int x,int y) 和 public static int add(int a,int b)
在使用时根据传递的实参跟形参的不同来进行区分使用的是哪一个
十四.递归
在讲递归之前，我们用一个故事来进行举例：“从前有座山，山里有座庙，庙里有个老和尚和小和尚，有一天，老和尚对小和尚说：‘从前有座山…’”
递归常用在方法内，在一些方法内通常会有方法调用自己的情况，也就是“自己调用自己”
递归结构包括两部分
- 定义递归头 用于说明什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体 说明什么时候需要调用自身方法
由于递归使用起来比较麻烦，所以我们用一个例题来举例：
用递归求n的阶乘
例如，使用阶乘求54321
代码：
import java.util.Scanner;
public class welcome {
public static int add(int n){
if (n==1) {
return 1;
}
else{
return n*add(n-1);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
System.out.println(add(a));
}
}
我们求的是54321，也就是说，我们需要从5开始乘，一直乘到1，那么我们就要在方法内完成一个当前数乘下一个数的执行
【图示】
该图示左边为递归使用的顺序[n * add(n-1)]，右边是递归返回的顺序[return n * add(n-1)]
由于在本方法内有一个if，当n等于1的时候，就返回1，不在执行递归，所以该递归得以结束，否则它将一直执行n*add(n-1)
十五.数组
数组是相同类型数据的有序集合，其中，每一个数据称作一个元素，每个元素可以通过索引（下标）来进行访问，以下是数组的基本特点：
- 长度是确定的，数组一旦被创建，它的大小就无法被改变。
- 其元素的类型必须是相同类型，不允许出现混合类型
- 数组类型可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组也是对象，数组中的元素相当于对象的属性
十六.附件：java编译可视化界面——IDEA
在前面几张的操作中，都是在电脑的记事本编辑界面进行的，运行和检查错误都不方便，所以，我来推广一个非常好用的可视化界面：Intellij IDEA
进去之后如果下面显示的是“Intellij IDEA-the Leading JAVA and Kotlin IDE”就是对的，如果不是，就选择"Developer Tools"，然后在显示的界面中选择“Intellij IDEA”即可。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
