1.选择结构if语句
if(表达式1){
语句体1；
}else if(表达式2){
语句体2；
}else if(表达式3){
语句体3；
}
...
else{
语句体n+1；
}
执行流程：
计算出表达式1的值
如果值为true执行语句体1
如果值为false计算表达式2的值
如果值为true就执行语句体2
如果值为false就计算表达式3的值
如果只为true就执行语句体3
如果值为false就计算表达式n的值
如果值为true就执行语句体n
如果值为false，表示所有的情况都不成立，就执行else里面的语句体n+1
2.选择结构switch语句
switch(表达式){
case 常量值1：
语句体1；
break;
case 常量值2：
语句体2；
break;
case 常量值3：
语句体3；
break;
...
default：
语句体n+1；
break;
}
格式解析：
表达式：可以取char,int,short,byte,int JDK1.7可以取String值
case：拿表达式的值和case后面的常量值进行匹配
语句体：就是要干的事情，可以是一条或者多条语句
break：结束switch语句的
default：如果所有的case都不匹配，那么就执行default里面的语句体
执行流程：
首先计算表达式的值，然后和case后面的常量值进行匹配，如果匹配成功，那么就执行对应的语句体；直到遇到break或者执行
到程序的末尾才结束switch循环；如果所有的case都不匹配那么就执行default里面的语句体
注意事项：
case后面只能是常量值，不能是变量
break是可以省略的，如果省略的了，那么就会继续执行底下的语句体
default是可以省略的，如果省略了，那么就没有默认的处理语句
case的顺序可以是无序的，随意的摆放
if语句：
条件是boolean的时候更适合用if
针对范围判断的时候，更适合用if
switch语句：
更适合针对几个常量值进行匹配的
3.循环结构for语句
初始化语句：初始化一些值
判断条件语句：判断条件是否成立，语句是否可以继续执行
循环体语句：就是我们要反复执行的代码
控制条件语句：让循环在合适的时候结束，一般都是通过更改某些值决定的
for(初始化语句；判断条件语句；控制条件语句){
循环体语句；
}
执行流程：
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是true就继续执行C步骤
如果是false就结束for循环
C:执行循环体语句
D:执行控制条件语句
E:回到B步骤
注意事项：
for循环的判断条件语句的结果必须是boolean类型
for语句默认控制一条语句，如果想要控制多条语句必须有大括号
4.循环结构while语句
初始化语句；
while(判断条件语句){
循环体语句；
控制条件语句；
}
执行流程：
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是true就执行C步骤
如果是false就结束while语句
C:执行循环体语句
D:执行控制条件语句
E:回到B步骤
5.循环结构do...while语句
初始化语句；
do{
循环体语句；
控制条件语句;
}while(判断条件语句);
执行流程：
A:执行初始化语句
B:执行循环体语句
C:执行控制条件语句
D:执行判断条件语句，看其结果是true还是false
如果是true则回到B步骤
如果是false结束循环
6.三种循环语句的不同和使用场景
while和for的区别：当循环结束之后，初始化变量还需要继续访问就使用while；如果不需要继续使用就用for，因为for语句结束之后
在for循环的初始化语句初始化的变量都会消失
while和for语句的循环体语句想要执行，必须是判断条件语句返回true才可以
do...while语句不论判断条件是true还是false都会至少执行一次
for：更适合做固定范围内的循环
while：更适合求未知数的循环
do...while：更适合至少循环体语句需要被执行一次的循环
7.跳转控制语句
break：中断语句的意思，可以中断switch语句和所有的循环语句；离开使用场景没有任何意义
continue：结束本次循环，直接开始下一次循环；可以结束所有的循环语句；离开使用场景没有任何意义
return：结束当前的方法并将执行权交给上层调用者
1.方法
概述：就是完成特定功能的代码块，解决重复代码编写问题
格式：
修饰符 返回值类型 方法名(参数列表){
方法体;
return 返回值；
}
格式解析：
修饰符：先阶段就用public static
返回值类型：是由返回值类型决定的，接收方的变量类型要和返回值类型保持兼容
方法名：其实就是一个名字，为了调用特定功能代码块方便
参数列表：传递参数用的，方法体缺少什么就可以通过参数列表问调用者要什么
方法体：就是完成特定功能的代码块
return：结束方法并将返回值返回给调用者
返回值：就是最终的结果
有明确返回值的方法：你声明了对应的返回值类型，那必须返回一个对应的具体值
单独调用，没有任何意义
输出调用，意义也不大， 因为只是想输出，那么可以直接在方法体内部就输出了，不必再返回
赋值调用，意义所在，可以拿着返回值做后续的操作
没有明确返回值的方法：你可以使用return结束方法，但是不能返回一个具体的值
返回值类型是void
只能单独调用
方法注意事项：
方法和方法之间是平级存在的，不能相互嵌套
方法不调用不执行
方法参数有多个的时候，可以用,隔开
方法传递的参数要么是常量值要么是变量
你声明了对应的返回值类型，那必须返回一个对应的具体值
方法的重载：
java中允许一个类中存在多个同名的方法，但是这多个方法的参数个数和参数的对应类型不能一样
方法的重载和返回值类型是没有关系的
JVM是通过参数列表的不同来区分同名的方法
2.数组
概述：存储同一种数据类型的元素的一个集合(容器)
数组的特点：
数组一旦定义了长度，就无法更改
数组既可以存储基本数据类型的，还可以存储引用类型的值
数组的定义格式：
数据类型[] 数组名;：这样定义仅仅是声明了一个引用变量数组名，并没有开辟内存空间
数组的初始化：就是为数组中的每个元素开辟内存空间并赋初始化值
动态初始化：由我们指定数组的长度，由系统为每个数组元素赋初始化值
数据类型[] 数组名 = new 数据类型[数组的长度];
索引：从0开始编号，最大的索引是数组的长度-1
取值：数组名[索引]
赋值：数组名[索引] = 要被赋的值;
栈：存放局部变量，方法也是在栈中执行的；方法执行完毕之后局部变量要会消失，栈不会为其中的变量赋初始化值
堆：存放的都是new出来的东西；它会为里面的变量赋初始化值，基本数据类型的初始化值就是默认值，
引用数据类型的变量的初始化值都是null
静态初始化：由我们指定数组元素的值，由系统根据元素的个数决定数组的长度
数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2...};
简化格式：
数据类型[] 数组名 = {元素值1,元素值2...};
1.二维数组
概述：就是一个元素为一位数组的一个数组
格式1：
数据类型[][] 数组名 = new 数据类型[m][n];
m：表示这个二维数组有m个一维数组
n：表示每一个一维数组有n个元素
数组名[i][j]：获取第i+1个一维数组中的第j+1个元素
格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m：表示这个二维数组有m个一维数组，每一个一维数组的长度可以动态的给出
int[][] arr = new int[3][];
arr[0] = new int[1];第一个一维数组的长度是1
arr[1] = new int[2];第二个一维数组的长度是2
arr[2] = new int[3];第三个一维数组的长度是3
格式3：
数据类型[][] 数组名 = new 数据类型[][]{元素值,元素值2,元素值3},{元素值11,元素值22,元素值33}};
简化格式：
数据类型[][] 数组名 = {元素值,元素值2,元素值3},{元素值11,元素值22,元素值33}};
2.面向对象
Scanner：我们知道这个类就是java提供给我们的，它具有键盘录入的功能
面向对象思想：可以将任何一个事物都封装成类，然后通过对象来体现
面向过程思想：遇到事情想着怎么去做
面向对象思想：遇到事情想着找谁去做
面向对象是基于面向过程，因为面向对象是需要封装的，肯定先开始分析，分析完成之后然后再封装，
以后我们自己活着别人再使用的时候，直接可以调用对应的类和方法即可
类：是某一事物的属性和行为的集合，还是java中的最基本的单位
首选分析一个事物的属性和行为：
属性：就是描述信息
行为：就是可以干什么事情
对应java类中：
属性-成员变量
行为-成员方法
想使用类，就需要创建对象：
类名 对象名 = new 类名();
对象名.成员变量;
对象名.成员方法;
java中的成员(成员变量和成员方法)
1.抽象类
概述：当某一事物的功能无法在父类中给出具体的实现时，可以在父类中定义出来这个功能，但是不给出方法体的实现。在java中
规定一个没有方法体的方法应该定义成抽象的方法，在java中又规定一个具有抽象方法的类必须定义成抽象类
抽象类的格式：abstract class 类名{}
抽象类的成员特点：
成员变量：变量，常量
构造方法：有构造方法，因为抽象类中有具体的成员，子类可能会访问使用
成员方法：
具体的方法：提高代码的复用性
抽象的方法：限定子类必须完成某个功能
抽象类如何进行实例化：
抽象类无法进行实例化，可以根据多态的思想，找一个子类继承这个抽象类，然后实现所有的抽象方法；然后实例化这个子类，
调用抽象的方法，这个叫做抽象类的多态
抽象类的特点：抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类子类的特点：子类要么实现所有的抽象方法，要么继续定义成抽象类
2.接口
概述：有某一部分功能不是某一事物都具有的，这些额外的功能应该定义在接口中，体现事物的扩展性
格式：interface 接口名{}
接口的成员特点：
成员变量：只能是常量，而且有默认的修饰符：public static final
构造方法：没有，因为接口中没有具体的实现
成员方法：只能是抽象的，而且有默认的修饰符：public abstract
接口如何进行实例化？
接口也不能直接实例化，可以根据多态的思想，创建一个子类实现接口，然后实现所有的抽象方法；然后实例化该子类，
调用接口中的方法，这个叫做接口的多态
类实现接口的格式：class 子类名 implements 接口名{}
接口的子类特点：
要么实现所有的抽象方法，要么继续定义成抽象类
3.类和接口以及彼此之间的关系
类与类：继承关系，单继承，不能多继承，可以多层继承
类与接口：实现关系，可以单实现，多实现，多层实现；还可以在继承一个类的同时实现多个接口
接口与接口：继承关系，单继承，多继承，多层继承
4.包
就是一个文件夹
带包的编译和运行：
手动式：
使用javac 源文件名.java
然后手动创建对应的文件夹，然后把编译好的class文件拷贝进对应的文件夹中
使用java 包名.类名运行
自动式：
使用javac -d . 源文件名.java
使用java 包名.类名运行
导包：当一个类中想使用两个相同类名不同包名的类时，只能选择导入其中的一个类，另外一个类需要使用全路径名进行区分
5.权限修饰符
public：修饰的成员，可以在任何地方进行访问
private：修饰的成员，只能在同一个类中进行访问
protected：修饰的成员，只能在子类中进行访问
默认：修饰的成员，只要在同一个包中都可以进行访问
6.成员内部类：可以访问外部类中的所有成员包括私有的，外部类想访问内部类的成员，必须创建内部类的对象、
还可以被static修饰，为了方便内部类的访问
静态内部类中不一定有静态成员，但是有静态成员的内部类一定是一个静态的内部类
访问内部类的成员访问格式：
非静态静态内部类的非静态成员：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
对象名.成员;
静态内部类中的非静态成员：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
对象名.成员;
静态内部类中的静态成员：
外部类名.内部类名.成员;
1.局部内部类
概述：在方法的内部创建一个类
局部内部类可以使用外部类的成员，包括私有的
外部类想访问局部内部类时，只能通过在方法内部创建对象，通过对象访问内部类的成员
2.匿名内部类
概述：就是没有名字的匿名子类对象
前提：存在一个类或者接口
格式：
new 类名或者接口名(){
要重写或者实现的方法;
}
本质：其实就是继承了类或者实现接口的子类匿名对象