第二次总结

if 语句

格式1：
if（关系表达式）{
   语句体；
}

执行流程：

1.首先计算关系表达式的值

2.如果关系表达式的值为true就执行语句体

3.如果关系表达式的值为false就不执行语句体

4.继续执行后面的语句内容

格式2：
if（关系表达式）{
    语句体1；
}else{
    语句体2；
}

执行流程：

1.首先计算关系表达式的值

2.如果关系表达式的值为true就执行语句体1

3.如果关系表达式的值为false就执行语句体2

4.继续执行后面的语句内容

if格式2的嵌套方式
if(关系表达式){// a >b 
	if(关系表达式1){ //a>c
		语句体1;
	 }else{
		语句体2;
	}
}else{ 
			
	if(关系表达式2){//b>c
		语句体3;
	}else{
		语句体4;
	}
}

执行流程:

1.先判断表达式是否成立,如果成立

2.执行里面的if语句

2.1.判断表达式1是否成立,如果成立,执行语句1

2.2不成立,执行语句2

3.如果第一次进行比较表达式如果不成立,执行else中的if语句

3.1.判断表达式2是否成立,如果成立,执行语句3

3.2.否则不成立,执行语句4

格式3
if(关系表达式1){
	语句体1;
}else if(关系表达式2){
	语句体2;
}else if(关系表达式3){
	语句体3;
	...
	...
}else{
	语句体n ;
}

执行流程:
1)判断表达式1是否成立,如果成立,则执行语句1;

2)如果不成立,继续判断表达式2是否成立,如果成立,执行语句2;

3)如果表达式2不成立,继续判断表达式3是否成立,如果成立,执行语句3

​ …

​ …

4)如果上面的条件表达式都不成立,则执行else中的语句n…

​

if语句格式2 和三元运算符的区别

if…else:流程控制语句,范围比较广泛,不仅可以操作具体 数据值还可以操作语句

System.out.println(“提示信息…”) ;

而三元运算符–是运算符的一种,它只能操作具体的数据结果值,不能直接里面嵌套使用

System.out.println(“提示信息…”) ;

三元运算符能够实现的—一定能够使用if…else实现

而if…else…实现不一定能够使用三元运算符实现。

Switch语句

格式：
switch(表达式){
   case值1：
       语句体1；
       break；
   case值2：
       语句体2；
       break；
       ……
   default： 
       语句体n+1；
       break；
}

格式说明：

表达式：取值为byte，int，short，char，JDK5以后可以是枚举（enum）,JDK以后可以是string。

case：后边跟的是要和表达式进行比较的值。

break：表示中断，结束的意思，用来结束Switch语句。

default：表示所有情况都不匹配的时候，就执行该处内容，和if语句的else相似。

switch语句中的注意事项:

1.case语句后面的值只能是常量

​ (在Java语言中,Java是一个强类型语言:结构和格式是非常严谨的)

​ (在JavaScript前端语言中,是一个弱类型语言,case后面的值既可以是常量,也能够是变量;)

2.case语句中的break 必须带上,否则会造成一个现象:case 穿透

​ 由于某个case已经匹配了,此时如果没有break,那么就继续往下面中

​ case的语句进行穿透,依次执行,遇见有case中有break的,那么switch结束!

3)switch的结束条件是什么?

a.语句break结束

b.程序默认执行到末尾!

for循环语句

格式：
for（初始化语句；条件判断语句；条件控制语句）{
	循环体语句；
}

执行流程：

1.执行初始化语句

2.执行条件判断语句，看结果是true还是false

​ 如果是false，循环结束

​ 如果是true，循环继续

3.执行循环体语句

4.执行条件控制语句

5.回到步骤继续

for循环秋水仙花数

class ShuiXianHua{
	public static void main(String[] args){
		System.out.println("水仙花数有");
		//求出所有水仙花数
		for(int i=100;i<=999;i++){
			//获取到x的数据，需要确定每个位上的数据本身
			//定义三个变量，ge,shi,bai 
			int ge=i%10;//获取个位上的数据
			int shi=i/10%10;//获取十位的数据
			int bai=i/10/10%10;//获取百位上的数据
			//满足条件
			if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
				System.out.println(i);
			}
			
			
		}
	}
}

while循环语句

格式：
初始化语句；
while（条件判断语句）{
	循环体语句；
	条件控制语句；
}

执行流程：

1.执行初始化语句

2.执行条件判断语句，看其结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

3.执行循环体语句

4.执行条件控制语句

5.回到步骤2继续

while循环和for循环的区别

共同点:都是循环体语句,将重复度高的代码进行优化,解决冗余度问题

不同点:

1.格式上不同

for(初始化语句;条件表达式;控制体语句){

​ 循环体语句;

​ }

初始化语句;

​ while(条件表达式){

​ 循环体语句;

​ 控制体语句;

​ }

2.从内存角度考虑,for循环使用完毕结束后,当前这个变量就被释放掉,而while不会,它始终

​ 可以访问到这个变量,所以相对来说说,for循环比较节省内存空间!

3)释放明确循环次数

明确循环次数:优先采用for循环,其次再是while

while循环:不明确循环次数使用

do-while语句

格式：
do{
    循环体语句；
    条件控制语句；
}while（条件判断语句）；

执行流程：

1.执行初始化语句

2.执行循环体语句

3.执行条件控制语句

4.执行条件判断语句，看结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

5.回到步骤2继续

do-while循环和其他两个循环的最大的区别:循环体至少执行一次;

循环嵌套

语句结构：
顺序语句：以分号结尾，表示一句话的结束
分支语句：一对大括号表示if的整体结构，整体描述一个完整的if语句
        一堆大括号表示switch的整体结构，整体描述一个完整的switch语句
循环语句：一对大括号表示for的整体结构，整体描述一个完整的for语句
		一对大括号表示while的整体结构，整体描述一个完整的while语句
		do..while以分号结尾，整体描述一个完整的do..while语句

Random的作用和使用步骤

作用：产生一个随机数

使用步骤：

1.导包

import java.util.Random;

2.创建对象

Random r=new Random;的数
r是变量名可以变化，其他都不允许变化

3.获取随机数

int number=r.nextInt();//随机获取一个范围为[0.0,1.0)的数。

跳转控制语句：break，continue，return

break：中断，结束。

break应用场景:

1.不能单独使用,报错

2.只能在两个场景中使用

contine:属于跳转控制语句中的一种，一般都在循环语句中使用的。表示结束当前循环,立即进入下一次循环。

return :返回结果 (结束方法去使用,但是很少单独使用)

方法

有具体返回值类型的方法

方法：是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集。

格式:固定写法

定义方法	

权限修饰符 static  返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){

完成你的代码的业务逻辑:根据需求来完成操作

return 结果;

}

权限修饰符:现在固定使用public :访问权限足够大的

返回值类型:就是数据类型

方法名: 给{}代码块起名字, 遵循"标识符规则",小驼峰命名法

参数列表:

参数类型 ----:数据类型,现在使用的就是基本数据类型

变量名 ---- :给当前形式参数起名字,“小驼峰命名法”

return 结果: 根据你的业务方法,返回值类型时什么类型,给你返回具体的结果 。

在有具体返回值类型的方法中推荐使用赋值调用

定义方法是心中必须要有两个明确

1.明确返回值类型（数据类型）：基本使用基本数据类型int

2.明确参数类型以及参数个数

没有具体返回值类型的方法

格式：
public static void 方法名(形式参数列表){
				//完成的业务逻辑,输出等等操作,
				但是不能有return (必须和有具体返回值类型的方法一块使用)
			}

在没有具体返回值类型的方法中推荐单独调用

方法重载

方法重载：多个方法在同一个类中

​ 多个方法具有相同的方法名

​ 多个方法的参数不相同，类型不同或者数量不同

数组

数组：就是能够存储同一种数据类型的容器

格式1：数据类型[] 变量名
范例：int[] arr
定义了一个int类型的数组，数组名是arr
格式2：数据类型 变量名[]
范例：int arr[]
定义了一个int类型的变量，变量名是arr

数组 初始化有两种方式：

第一种：动态初始化

第二种：静态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
格式：数据类型[] 变量名=new 数据类型[数组长度]；
范例：int[] arr=new int[3];
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：数据类型[] 变量名=new 数据类型[]{数据1，数据2，数据3，...}；
范例： int[] arr=new int[]{1,2,3};
简化格式：数据类型[] 变量名={数据1，数据2，数据3，...}；
范例： int[] arr={1,2,3}；

数组中常见的异常: 运行时期异常

1.数组角标越界异常—程序运行的时候出现异常

ArrayIndeexOutOfBoundsException 类名

出现这个异常原因:我们访问了数组中不存在的索引值报错。

解决方案:改变索引值

2.空指针异常 NullPointerException

就是当前 我们在访问某个对象的时候,对象已经是null,然后还要使用对象中的某个功能—出现空指针了

解决方案:对当前这个对象进行非空判断

获取数组元素数量

length:可以很快获取数组长度 数组名称.length
for(int x = 0 ; x < arr.length ; x ++){//最大的角标值= 数组的长度-1 ;
			System.out.println(arr[x]) ;
		}

冒泡排序

冒泡排序:两两比较,将较大的值往后方法,第一次比较完毕之后,最大值出现
在最大索引处,依次这样比较。

import java.util.Scanner;
class MaoPao{
	public static void main(String[] args){
		int[] arr=new int[6];
		Scanner sc=new Scanner(System.in);
        //使用for循环提示输入元素
		for(int n=0;n<arr.length;n++) {
			System.out.println("请输入第"+(n+1)+"个元素:");
			arr[n]=sc.nextInt();
		}
		sort(arr);
		printArr(arr);
		System.out.println("排序后的数组为");
		printArr(arr);
	}
    //使用方法进行冒泡排序
	public static void sort(int[] arr){
		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 ;
				}
			}
    //定义遍历的方法
	public static void printArr(int[] arr){
        //输出左中括号
		System.out.print("[") ;
        //遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			if(x == arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				System.out.print(arr[x]+", ") ;
			}
		}
	}
}