目录
选择结构语句之if
（三种格式）
1）if （条件表达式）{
语句：
}
2）if （条件表达式）{
语句1；
}else{
语句2；
}
3）if （条件表达式1）{
语句1；
}else if（条件表达式2）{
语句2；
. ...
}else{
语句n；
}
if格式一的执行流程：
if （条件表达式）{
语句：
}
条件表达式成立，则执行语句，否则不执行；
if格式一应用场景：针对三个条件进行判断！
if格式二执行流程：
if （条件表达式）{
语句1；
}else{
语句2；
}
执行流程：
1）首先判断条件表达式是否成立，如果成立则执行语句1；
2）否则不成立，执行语句2；
注意：else后面不带（）
if语句格式2的一种嵌套格式：
if（表达式1）{
if（表达式2）{
语句1；
}else{
语句2；
}
}else{
if（表达式3）{
语句3；
}else{
语句4；
}
}
if...else...格式和三元运算符的区别：
三元运算符只是运算符号，不是流程语句，在三元中不能输出打印值，可以操作具体的数据值
（结果最终是数据值）；
而if..else...流程控制语句，范围远远大于三元运算符：既可以使用具体数据值，也可以打印内容
三元运算符能使用的if...else...一定能够使用，反之if...else...能使用的不一定能够使用三元运算符实现！
if格式3
if（表达式1）{
语句1；
}else if（表达式2）{
语句2；
......
} else{
语句n；
}
场景：针对多种进行判断！
执行流程：
1）先判断表达式1是否成立，成立，则执行语句1；
2）不成立，则判断表达式2是否成立，成立，执行语句2；否则依次...进行判断...
3）如果上面都不成立，则执行else语句，最终结束；
switch语句格式
switch（表达式）{
case 值1：
语句1；
break；
case 值2：
语句2；
break；
......
default：
语句n；
break;
}
执行流程：
1）表达式中的值先和case值1比较，如果匹配，执行语句1，语句break，语句结束；
2）case值1不匹配，继续和case值2进行比较，如果一致，执行语句2，switch结束；
3）如果上面的case值和表达式中的结果值都不匹配，执行default语句，执行语句n，
switch语句结束。
switch语句注意事项：
1）case语句里面有break，如果没有书写break，会造成“case穿透”；
2）case语句后面的值只能是常量值，不能是变量值（java是强类型语言：语法结构很严谨）；
3）关于default语句：
它可以在语句中的任何位置，不影响switch语句的执行流程！
但是如果在语句中，那么break语句不要省略（考点）；
如果default语句它在语句的末尾，break可以省略；
4）switch语句结束条件：
1）语句break结束；
2）程序默认执行到末尾！（顺序结构语句都是依次由上而下，末尾结束！）
switch语句语句后面的表达式可以是：
表达式：基本数据类型：byte、short、char、int
jdk5以后可以跟枚举类型enum（引用类型）
jdk7以后可以跟String类型
case穿透：
case语句没有携带break，会造成case穿透，当某个case的值已经匹配了
如果没有break，继续往下执行，一直执行到见到break为止！
for循环
java提供循环结构语句之for循环：
for（初始体语句；条件表达式；控制体语句或步长语句）{
循环体语句；
}
执行流程：
1）先初始化语句进行赋值；
2）判断条件表达式是否成立，如果成立，执行循环体语句；
2.1)继续执行控制台语句或步长语句，对初始化语句的变量进行自增或自减；
2.2）继续判断条件表达是否成立，如果成立，按照上面这种方式执行；
2.3）如果变量自增或自减到表达式不成立为止，循环语句结束!
for循环的嵌套
for（初始化语句；条件表达式；控制体语句）{
for（初始化语句2；条件表达式2；控制体语句2）{
内层循环的循环体......
}
}
while循环
格式：
基本格式：
while（条件表达式）{
循环体语句；
控制体语句或步长语句；
}
扩展格式（使用多）：
初始化语句：
while(条件表达式){
循环体语句；
控制体语句或步长语句；
}
执行流程：
1）初始化语句进行变量赋值；
2）判断条件表达式是否成立：
成立，执行循环体语句，依次执行控制体语句（对变量控制）
（继续回到2）进行判断
......
3）条件表达式不满足，循环结束！
do_while循环
格式：
初始化语句；
do{
循环体语句；
控制体语句；
}while（条件表达式）；
执行流程：
1)初始化语句进行赋值
2）循环体语句---->完成条件判断---->控制体语句
继续判断，当条件不满足，循环结束！
如果条件直接不满足，循环体至少执行一次，这也是for/while最大的区别
while循环和for循环的区别：
共同点：都是使用循环思想解决一些问题。
不同点：
1）格式本身不同：
for循环：
for（初始化语句；条件表达式；控制体语句）{
循环语句；
}
while循环：
初始化语句；
while（条件表达式）{
循环体语句；
控制体语句；
}
2）是否明确循环次数
for循环：明确循环次数，有限for循环；
while循环：不明确循环次数，使用while循环；
3）从内存角度考虑，消耗不同：
for循环结束，里面的变量及时释放了，所以不能再访问for循环中的变量；
while循环结束，依然可以访问里面变量，所以消耗资源相对for循环大一些！
常见的两种死循环格式：
for（；；）{
循环体...
}
while(true){
循环体...
}
利用死循环解决一些问题！
死循环：肯定需要利用一些条件，当达到某种条件的时候，结束循环（break；中断，结束！）
跳转控制语句
跳转控制语句之break（结束中断）：
两种应用场景：
1）循环体语句中使用，结束循环用的
2）switch语句中使用，结束switch
不能单独使用，不能脱离上面两种场景！
早期使用：break 标签名称； 结束指定的循环
在for循环嵌套中,给for循环的前面加上一个 "标签名称:"
wc:代表外层循环
nc:代表内层循环
wc:for(初始化语句;条件表达式;控制体语句){
nc:for(初始化语句2;条件表达式2;控制体语句2;){
//循环体;
//当达到我指定的条件,
break wc;//结束外层循环了
}
}
跳转控制语句之continue（继续执行：结束当前循环，立即进入下一次循环）：
不能单独使用！
跳转控制语句之return（返回）：
应用场景：
在java中的方法（函数）中去使用，目的就是结束这个方法，并且还有返回结果；
很少单独使用（不建议），后面一般都会有返回结果值；
方法
方法：就是一个代码块{}，给{}器一个名字（方法名），然后方法中逻辑书写。
以后见到同样一个功能代码块，直接调用方法名即可！
方法重载：
指在一个类中定义多个方法名，但要求每个方法具有不同的参数类型或参数个数
java中定义方法的格式：
1）有返回值类型的方法的定义
public static 返回值类型 方法名（形式参数类型1 参数名1，形式参数类型2 参数名2......）{
完成方法逻辑
return 结果；
}
解释上面这个格式：
前面固定 public static
返回值类型：也就是数据类型（现在研究基本数据类型）
方法名：就是满足标识符的命名规则：见名知意（小驼峰命名法）
形式参数类型：也是数据类型（目前：基本数据类型）
参数名：就是变量名
有返回值的方法如何调用：
1）单独调用----方法名（实际参数列表）；（有返回值类型的方法不能使用）
2）输出调用---System.out.println(方法名(实际参数列表));
输出调用：可以，写死了，如果相对结果值在进行操作，就不能用了
3）赋值调用：（推荐）
在java中有返回值类型的方法的定义以及调用格式中注意事项：
1）方法和方法平级关系，不能在一个方法中去定义另一个方法！
2）定义方法的返回值类型和main方法中调用方法的时候，接收结果类型不匹配！
3）java是强类型语言，在定义方法的时候：形式参数名前面必须有参数类型
4）必须有return语句，没有就会编译报错！
5）定义方法的时候，有{号的地方不能有分号；有分号；不能有{左大括号
2）没有返回值类型的定义格式：（没有return语句）
public static void 方法名（参数类型1 参数名1，参数类型2 参数名2...）{
完成方法体逻辑
输出内容...
}
调用方法：
1）赋值调用和输出调用都使用不了
2）推荐：单独调用
jvm内存结构（栈，堆，方法区，本地方法区，pc寄存器（程序计数器））
栈内存：
存储的是局部变量（在方法定义中以及方法声明上的变量）
局部变量生命周期：随着调用而存在， 随着方法调用结束而消失。
堆内存：
new出来的东西（实例--也称为“对象”）都存储在堆中
方法区：
字节码文件区域 --里面就存储很多方法
每一个方法（加载进栈内存---“栈帧”）
静态区域：static相关的
常量区
本地方法：
跟系统有关
pc寄存器（程序计数器）:
跟系统相关以及cpu都有关系
数组
数组：是可以存储同一种数据类型的容器
数组定义格式以及初始化
定义格式：
1）数据类型[] 数组名称；
2）数据类型 数组名称[]；
初始化：
1）动态初始化
给定数组长度，系统（jvm）默认分配数组元素内容；
格式：
数据类型[] 数组名称 = new 数据类型[数组长度]；
数据类型 数组名称[] = new 数据类型[数组长度]；
在数组如何确定元素的内容
数组名称[索引值（角标值）]：从0开始
2）静态初始化：
给定数组元素，长度由系统来定
原本格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
简写格式：
数据类型[] 数组名称 = {元素1、元素2、元素3....}
数据类型 数组名称[] ={元素1、元素2、元素3....}
注意事项：
不能即动态初始化，又静态初始化（动静结合）
数组应用：
数组遍历
将数组的元素一 一输出打印
定义一个遍历数组的方法
两个明确：
1）明确返回值类型
2）明确参数类型以及参数个数
数组的遍历代码体现
public static void printArray(int[] arr){
System.out.println("[");
for(int x= 0 ; x<arr.length ;x++){
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
System.out.println(arr[x]+", ");
}
}
}
数组最值得代码体现
public static int getArrayMax(int[] arr){
int max = arr[0];
for(int x= 1; x<arr.length ; x++){
if(arr[x]>max){
max = arr[x];
}
}
return max;
}
数组的元素查询表法
通过数组名称[索引值]:查询元素
分析：
定义一个字符串数组
数据类型[] 数组名称 = {元素内容}；
冒泡排序
冒泡排序的思想以及核心代码体现
冒泡排序思想：
两两比较，将大的值放后防置，第一次比较完毕，最大值处在再大索引处；依次比较，可以得到排好序的数组；
核心代码体现：
for(int x = 0; x< arr.length-1 ;x++){
for(int y = 0;y<arr.length-1-x;y++){
if（arr[y]>arr[y+1]）{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
形式参数基本数据类型与引用数据类型的区别
形式参数如果是基本数据类型，形式参数的改变不会影响实际参数----特殊的引用类型String和这个效果一致!
形式参数如果是引用数据类型(除过String),形式参数的改变直接影响实际参数(实际参数需要传递空间地址值)
面向对象
面向对象的思想特点：
1）更符合现实生活中的思想行为习惯
2）让复杂的事情简单化
3）角色转换---由执行者变成指挥者（指挥对象做事情）
面向对象的三大特征
封装
继承
多态
类（java中最基本单元）
类是描述现实世界“事物”的一组“属性”和“行为”的集合！
类和事物：一 一对应，相辅相成！
一个事物-------->定义一个类
成员变量：类中方法外
事物中的行为
成员方法：（去掉static）
创建类对象
类名 对象名 = new 类名（）；
对象名.成员变量 = 赋值；
对象名.方法名（）；如果有返回值，直接使用具体返回值类型接收；
没有返回值，直接输出！
java封装概念
将一个事物的属性私有化（对外界隐藏，private）---->保证数据的安全性
对外提供公共的成员访问方法：setxxx（传参）/getxxx（），来对成员属性进行操作！
private关键字
private关键字的特点：
1）被private修饰的成员变量/成员方法（非静态）
只能在本类中访问外界类不能访问！
2）虽然被私有修饰的成员变量以及成员方法（非静态）不能直接访问，但是都可以间接的通过
“public”公共访问访问！
局部变量与成员变量的区别
区别：
1）类中的书写位置不同
成员变量:在类中，方法外
局部变量：在方法定义中或方法声明上
2)jvm内存位置不同
成员变量：在堆内存中
局部变量：在栈内存中
3）生命周期不同：
成员变量:随着对象的创建而存在，随着对象的创建完毕并且使用完等待垃圾回收器
回收（不会立即回收）而消失！
局部变量：随着方法调用而存在，随着方法调用结束而消失
4）初始化值不同
成员变量：存在系统默认初始化，也可以显示初始化
局部变量：总之，在使用局部变量之前，必须赋值，不赋值不行！
构造方法
一个类成员：成员变量/成员方法(非静态)/构造方法
构造方法：
1）方法名和类名一致
2）没有具体返回值类型
3）连void都没有
构造方法的作用：
给类的成员进行数据初始化！
注意事项：
1）一个类中，如果没有任何构造方法，那么系统（jvm）自动会给我们提供无参构造方法！
2）一个类中，只提供有参构造方法，那么系统就不会提供无参构造方法，此时，建议我们永远给出无参构造方法！否则，就会出现问题！
创建对象的时候固定格式：
类名 对象名 = new 类名（）；
扫一扫
3829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
