代码由上至下依次加载2.选择结构 2.1 if结构
格式1:if(条件表达式){
语句;
}
执行流程:
1)当前条件表达式成立,执行语句
2)否则不成立,不执行语句;
格式2: if(条件表达式){
语句1;
}else{
语句2;
}
执行流程:
1)判断表达式是否成立,如果成立,执行语句1,
2)如果不成立,执行语句2;
应用场景:针对两种情况进行判断
格式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....
2.1.1 if语句格式2 和三元运算符的区别
if..else : 流程控制语句,不仅可以 *** 作具体数据值还可以 *** 作语句
System.out.println("提示信息...") ;
三元运算符 :是运算符的一种,它只能 *** 作具体的数据结果值,不能直接里面嵌套使用
System.out.println("提示信息...") ;
三元运算符能够实现的---一定能够使用if...else实现
而if...else...实现不一定能够使用三元运算符实现!
2.2 switch 结构
格式: switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
default:
语句n;
break ;
}
执行流程:
1)首先表达式的值和case值1进行匹配,
如果匹配成功,执行语句1,break结束
2)如果case值1不匹配,继续和case后面的值2进行比较,如果匹配,语句2执行,break结束;
...
3)如果上面的case的值都和switch中表达式的结果不匹配的,那么最终
就执行default中的语句n,然后程序默认执行到末尾结束了,break结束;
//case 穿透的相关举例
int x = 3 ;
int y = 4 ;
switch(x){//3
default ://程序case没有匹配到,所以首先执行default
y++ ;//4+1 = 5 没有break,程序向下穿透
case 4:
y ++ ;//5+1 = 6
case 5 :
y++ ;//6+1 = 7
}
System.out.println("y:"+y) ;// 最终结果y=7
switch(x){//x=3
default :
y++ ;
case 3: //匹配到先执行case3
y ++ ; //y=4+1 = 5
case 4 :
y++ ;//y=5+1 = 6 程序默认执行到末尾不进行default
}
System.out.println("y:"+y) ;//最终结果y=6
System.out.println("------------------------") ;
int a = 3 ;
int b = 4 ;
switch(a){
default ://没有匹配到case值,首先执行default
b++ ; 4+1=5 break
break ;
case 4:
b++ ;
case 5:
b++;
}
System.out.println("b:"+b) ;//最终结果b=5
switch(a){//a=3
case 3://匹配到执行 4+1=5
b++ ;
case 5: //穿透 执行5+1=6
b++;
default ://穿透 执行6+1=7break
b++ ;
break ;
}
System.out.println("b:"+b) ; //最终结果b=7
2.2.1 switch中的表达式,可以是什么样的数据类型?
基本的能够使用的数据类型: byte,short,char,int JDK5以后,可以跟枚举 (enum) JDK7以后,可以是String类型2.2.2 switch语句中的注意事项:
1)case语句后面的值只能是常量
(Java是一个强类型语言:结构和格式是非常严谨的)
(在Javascript前端语言中,是一个弱类型语言,case后面的值既可以是常量
,也可以是变量)
2)case语句中的break必须带上,否则会造成一个现象:case 穿透
由于某个case已经匹配了,此时如果没有break,那么就继续往下面执行!
case的语句进行穿透,依次执行,遇见有case中有break的,那么switch结束!
3)switch的结束条件是什么?
a)语句break结束
b)程序默认执行到末尾!
4)default语句可以在语句中的任何位置,不影响程序的执行流程!
default的执行,当前case中都没有匹配的话,执行default
day06.流程控制语句
1. for循环
格式:
for(初始化语句;条件表达式;控制体语句(++/--)){
循环体语句;
}
执行流程:
1)初始化语句进行赋值,只执行一次
2)然后判断条件表达式是否成立
如果成立,执行循环体语句;----然后执行控制体语句 (++/--)
3)继续判断条件表达式是否成立,
如果成立,执行循环体语句;----然后执行控制体语句(++/--)
...
4)执行到条件表达式不成立,for循环语句结束!
2. while 循环
格式:
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
执行流程:
1)初始化语句进行赋值
2)判断条件表达式是否成立
如果成立,执行循环体语句,控制体语句对变量进行自增或者自减
3)继续判断条件表达式是否成立
4)如果条件表达式不成立,while循环结束
2.1.1 while循环和for循环的区别
共同点:都能够描述循环的思想,将重复度高的代码进行优化,解决冗余度问题
不同点:
1)格式上不同
2)从内存角度考虑,for循环使用完毕结束后,当前这个变量就被释放掉了,而while不会,它始终
可以访问到这个变量,故for循环比较节省内存空间!
3)释放明确循环次数
明确循环次数:优先采用for循环,其次再是while
while循环:不明确循环次数的情况下使用
while循环一般都是这样使用!
while(true){ 死循环
//当达到某个条件,break;中断
}
2.1.2 do-while
格式:
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式) ;
执行流程:
1)初始化语句执行
2)执行条件表达式,如果条件表达式不成立,循环体至少执行一次!
如果条件表达式成立...然后控制体语句,依次判断;
do-while循环和其他两个循环的最大的区别:
循环体至少执行一次;
2.1.3 死循环
死循环中常见的两种格式
for(;;){
//业务 *** 作
}
while(true){//恒成立 (使用居多)
//业务 *** 作..
}
day07.for循环的嵌套(相关例题)&跳转控制语句
1.99乘法表
class ForForTest{
public static void main(String[] args){
//9行9列的*,列数在变化的*
for(int x = 0 ; x <9; x++){
for(int y = 0 ; y <=x ; y++){
System.out.print("*") ;
}
System.out.println() ;
}
System.out.println("-------------------------------") ;
//99乘法表:为了保证有数据,从1开始
for(int x = 1 ; x <= 9 ; x ++){//行数
//列数也在变化
for(int y = 1 ;y <=x ; y ++){
//Java中的转义字符
// x :X任意字符 t---"制表符"
System.out.print(y+"*"+x+"="+(y*x)+"t" ) ;
}
System.out.println() ;
}
}
}
2.跳转控制语句
跳转控制语句: break continue return break 应用场景: 1)不能单独使用,报错 2)只能在两个场景中使用 switch语句自带了break关键字 循环结构语句中 for/while循环都可以用到 contine: 一般都在循环语句中使用的; 表示结束当前循环,立即进入下一次循环了... return :返回结果 (结束方法去使用,但是很少单独使用) 一般情况:return不会单独使用(很少单独使用),结合Java中的有具体返回值类型的方法去使用day08. 方法 1.方法
定义:
在java中，方法就是用来完成解决某件事情或实现某个功能的办法
格式:
权限修饰符 static 返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){
完成你的代码的业务逻辑:根据需求来完成 *** 作
return 结果;
}
调用方法:
1)输出调用
2)赋值调用
3)单独调用
详细解释:
权限修饰符:初期固定使用public :访问权限足够大的
现在写方法:必须带上static 前期初学的写法:public static
返回值类型:就是基本数据类型
方法名: 给{}代码块起名字, 见名知意,遵循"标识符规则",小驼峰命名法
add(),求和
sum() ,求和
参数列表:
参数类型 ----:基本数数据类型
变量名 ---- :给当前形式参数起名字,见名知意,"小驼峰命名法"
return 结果: 根据你的业务方法,
返回值类型时什么类型,给你返回具体的结果
1.1有具体返回值的方法
格式:
权限修饰符 static 返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){
完成你的代码的业务逻辑:根据需求来完成 *** 作
return 结果;
}
调用方法:
赋值调用:推荐
1.1.1定义有具体返回值类型的方法注意事项
1)方法和方法是平级关系,不能嵌套,只能在里面去调用 2)定义方法的时候需要两个明确 a)明确返回值类型 b)明确参数类型以及参数个数(形式参数类型和几个参数) 3)在定义方法的时候,形式参数必须携带数据类型,因为Java 是一个强类型语言! 4)在实际参数 main中,调用方法的时候,实际参数不需要携带数据类型,因为 已经键盘录入,已经定义过了 5)实际参数和形参参数,传参时,数据类型需要一一对应!1.1.2例题
//（while循环）输入一个整数，计算它各位上数字的和。（注意：是任意位的整数）
//导包
import java.util.Scanner ;
class Test2{
public static void main(String[] args){
//定义一个最终结果变量
int sum = 0 ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您录入任意位的整数: ") ;
int n = sc.nextInt() ;
while(n!=0){
//获取低位,和sum进行求和
sum += n%10 ;
//去掉低位,将结果在赋值给n
n = n / 10 ;
}
System.out.println("任意位的整数他们各个位的数据和是:"+sum) ;
}
}
1.2没有具体返回值的方法
格式:
public static void 方法名(形式参数列表){
//完成的业务逻辑,输出等等 *** 作,
但是不能有return (必须和有具体返回值类型的方法一块使用)
}
方法调用:
单独调用
2. 方法重载(OverLoad)
当方法的功能都是相同的, 我们可以定义同名的方法,参数列表不同,跟返回值无关,可以提高这个功能的扩展性! 方法重载:---为了提供某个功能的扩展性 方法名相同,参数列表不同,与返回值无关! 参数列表不同: 1)参数个数不同 2)参数类型不同 3)考虑参数类型的顺序day09. 数组 1. 定义&格式&初始化方式
定义:
什么是数组,数组就是能够存储同一种数据类型的容器!
格式:
1)数据类型[] 数组名称; (推荐第一种方式)
2)数据类型 数组名称[] ;
初始化方式:
动态初始化:
给定数组的长度,数组的元素内容由系统默认初始化!
默认初始化:系统给定的
根据我们数组中存储的数据类型来判定
举例:int类型的默认值就是0
double的默认值0.0
格式:
数据类型[] 数组名称 = new 数据类型[数组长度] ; (推荐第一种)
数据类型 数组名称[] = new 数据类型[数组长度] ;
静态初始化:
给定元素的内容,由系统来默认分配长度
格式:
(推荐)数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
推荐使用简写格式
(推荐)数据类型[] 数组名称 = {元素1,元素2,元素3....} ;
数据类型 数组名称[] = {元素1,元素2,元素3....} ;
2. 数组中的异常类
数组中常见的异常: 运行时期异常 1)数组角标越界异常---程序运行的时候出现异常 ArrayIndeexOutOfBoundsException 类名 出现这个异常原因:我们访问了数组中不存在的索引值报错! 解决方案: 改变索引值 2)实际开发中,经常会出现 空指针异常 NullPointerException 就是当前 我们在访问某个对象的时候,对象已经是null, 然后还要使用对象中的某个功能---出现空指针了 解决方案: 对当前这个对象进行非空判断2.1空指针异常例题
//导包
import java.util.Scanner ;
class Demo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//很明显--赋值为null
sc = null ;
//提示并录入数据
System.out.println("请您输入一个数据int类型: ") ;
if(sc!=null){
int a = sc.nextInt() ;
System.out.println("您录入的数据是:"+a) ;
}else{
System.out.println("键盘录入对象为空,无法录入数据!") ;
}
}
}
3. 数组的遍历
1)遍历数组 遍历数组:就是将数组中的元素一一输出 2)遍历数组---格式 for(int x = 0 ; x4.相关例题 4.1数组的最值问题
//定义一个求数组最大值的方法
public static int getArrayMax(int[] array){
//定义参照物
int max = array[0] ;
//遍历其他元素
for(int x =1 ; x < array.length ; x ++){
//使用后面的元素依次和参照物max进行对比
if(array[x] > max){
max = array[x] ;
}
}
return max ;//返回
}
4.2数组逆序
逆序:就是将数组中的一个元素和最后一个元素互换 将数组中的第二个元素和倒数第二个元素进行互换
//调用逆序的方法(完成逆序)
public static void reverse(int[] array){
for(int x = 0 ; x < array.length/2 ; x ++){//x=0,1,2,...arr.length-1
//互换
int temp = array[x] ;
array[x] =array[array.length-1-x] ;
array[array.length-1-x] = temp ;
}
}
4.3数组的基本查表法
就是通过数组的对象名称[索引值]----获取元素内容
需求:
字符串数组
String[] weeks ={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ; 键盘录入指定的数据, (0-6的范围),通过数组查表法:通过角标查询元素!
//导包
import java.util.Scanner ;
class ArrayTest4{
public static void main(String[] args){
//字符串数组,静态初始化
String[] weeks = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据: ") ;
int n = sc.nextInt() ;
if(n>=0 && n<=6){
System.out.println("您要查找的是:"+weeks[n]) ;
}else{
System.out.println("录入的数据,不再数据表的范围内...") ;
}
}
}
4.4数组的基本元素查询
查元素第一次出现的索引值,每次从头查询到尾 这个数组: 皆可以无序,也可以有序!
方法1:
public static int getIndex(int[] array,int target){
//遍历数组
for(int x = 0 ; x < array.length ; x ++){
//获取到每个数组中的元素
//判断
//如果当前array[x] == target ----找到了元素了
if(array[x] == target){
//返回x--索引值
return x ;
}
}
//如果上面循环中找不到这个元素,就说明没有这个元素,方法调用完毕,必须结果值
return -1 ;//找不到
}
方法2:
public static int getIndex2(int[] array,int target){
//使用假设思想:
//先定义变量index:就是我们的索引值
int index = -1 ; //找不到
//遍历指定的array数组
for(int x = 0 ; x < array.length; x ++){
//获取到了所有元素,
//判断:如果当前array[x]== target 一致,找到了
if(array[x] == target){
//重新改变index 的值
index = x ;
break ;
}
}
return index ;
}
5.冒泡排序
冒泡排序思想: 两两比较,将较大的值往后方法,第一次比较完毕之后,最大值出现在最大索引处,依次这样比较! 规律: 两两比较,大的往后放 第一次比较,有0个不比 第二次比较,有1个不比.. .... 比较的次数:数组长度-1次
//冒泡排序优化前:
for(int x = 0 ; x < arr.length-1 ; x ++){//比较了四次,0,1,2,3
//里面元素进行判断比较
for(int y = 0 ; y < arr.length-1-x ; y ++){//arr.length-1-0/
//arr.length-1-1
//前面的元素比较后面的元素大,互换
if(arr[y] > arr[y+1]){
//中间变量互换
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
public static void bubbleSort(int[] array){
for(int x = 0 ; x < array.length-1 ; x ++){//比较次数
//里面元素进行判断比较
for(int y = 0 ; y < array.length-1-x ; y ++){//arr.length-1-0/
//arr.length-1-1
//前面的元素比较后面的元素大,互换
if(array[y] > array[y+1]){
//中间变量互换
int temp = array[y] ;
array[y] = array[y+1] ;
array[y+1] = temp ;
}
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）