Java三大控制流程
1.顺序控制
依次执行我们的代码。
2.条件控制(对于条件控制语句,彼此可以嵌套使用,但是过多嵌套影响程序可读性,所以一般最多允许嵌套3次)
目的:对程序执行一些不可预知的流程,进行一些预先判断。
条件:具有真假的特性,而且只能为真或者假。
java条件控制有四种手段:
a、if语句
结构:if(条件){
//实现我们的逻辑
}
*if后跟的条件可以是 i:常量表达式:2*2,6-5; ii:包含变量的表达式:score>95。
返回值是Boolean类型。
花括号可以省略,当我们在条件成立的时候,仅需执行一行代码的时候,可以省略"{ }"。
package StudyDay03;
public class IfDemo {
public static void main(String[] args){
int x = 69;
int y = 65;
if(x>y){
System.out.println("x的值大于y");
}
if(x<y){
System.out.println("x的值小于y");
}
}
}
b、if……else语句
结构:
if(条件){
//实现我们的逻辑
}else{
//实现我们的逻辑
}
*if后的表达式必须是布尔类型,else后面不跟条件。
package StudyDay03;
public class IfElseDome {
public static void main(String [] args){
int math = 99;
int english = 53;
if(math>60){ //使用if语句判断if是否大于60
System.out.println("恭喜你,数学及格了"); //条件成立时输出信息
}else{
System.out.println("很遗憾,数学没及格"); //条件不成立时输出信息
}
if(english>60){
System.out.println("恭喜你,英语及格了");
}else{
System.out.println("很遗憾,英语没及格");
}
}
}
c、if……else if……(接N个)……else (只会执行第一个匹配条件然后退出条件语句)
结构:if(条件){
//实现逻辑
}else if(条件){
……
}else{
//实现逻辑
}
注意事项:
* else if后一定要接条件,与if后接的条件等价
* else if 可以有多个
* else 可以省略,但是即使没有匹配所有条件,依然建议必须有else来保证语句的完整性和可读性
* 如果满足条件只需执行一行代码,"{ }"也可以省略,但不建议这么做
package StudyDay03;
import java.util.Scanner;
public class IfElseIfDemo {
public static void main(String [] args){
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个数:");
int a = sc.nextInt();
if(a>100){
System.out.println("比100大");
}else if(a>50){
System.out.println("比50大,比100小");
}else if(a>20){
System.out.println("比20大,比50小");
}else{
System.out.println("不在规定判断范围内");
}
}
}
d、 switch case 语句
结构:
switch(判断值){
case 值1:
break;
case 值2 :
break;
case 值3 :
break;
default:
break;
}
注意:
* switch 后跟的"()"一定不能省略
* switch后面跟的必须是整型或者字符型
* case值后加":",只能是字面常量(1,2,'A','c'),常量表达式(2*3,'a'+3)
* break;跳出我们匹配到的条件,break可以省略,如果省略掉break,那么代码将会在第一个匹配条件一直向下执行 switch语句,直到遇到break 为止
* default可以省略,并且可以放在任何位置,当匹配不到任何条件时执行的内容,default若未放置在最后,其后跟的break 不可以省略
package StudyDay03;
public class SwitchDemo {
public static void main(String []args){
int day = 6;
switch(day){
case 1:
System.out.println("米饭!");
break;
case 2:
System.out.println("米饭!");
break;
case 3:
System.out.println("馒头!");
break;
case 4 :
System.out.println("馒头!");
break;
case 5 :
System.out.println("火锅!");
break;
case 6 :
System.out.println("火锅!");
break; //注意此位置break的变化带来的结果
default:
System.out.println("KFC!");
}
}
}
变动1(去掉第24行break):
package StudyDay03;
public class SwitchDemo {
public static void main(String []args){
int day = 6;
switch(day){
case 1:
System.out.println("米饭!");
break;
case 2:
System.out.println("米饭!");
break;
case 3:
System.out.println("馒头!");
break;
case 4 :
System.out.println("馒头!");
break;
case 5 :
System.out.println("火锅!");
break;
case 6 :
System.out.println("火锅!");
// break; //注意此位置break的变化带来的结果
default:
System.out.println("KFC!");
}
}
}
!!没有遇到break代码匹配条件后会继续往下执行不再判断与后面case、default后的标签是否匹配,直到遇到break;为止
变动2(更改default的位置):
package StudyDay03;
public class SwitchDemo {
public static void main(String []args){
int day = 7;
switch(day){
default:
System.out.println("KFC!");
case 1:
System.out.println("米饭!");
break;
case 2:
System.out.println("米饭!");
break;
case 3:
System.out.println("馒头!");
break;
case 4 :
System.out.println("馒头!");
break;
case 5 :
System.out.println("火锅!");
break;
case 6 :
System.out.println("火锅!");
break; //注意此位置break的变化带来的结果
}
}
}
default没有放在最后break不可以省略,否则在匹配之后还会继续执行case标签后的代码,不再判断与后面case标签的条件是否匹配,直到遇到break为止
变动3(更改default位置后加上break):
package StudyDay03;
public class SwitchDemo {
public static void main(String []args){
int day = 7;
switch(day){
default:
System.out.println("KFC!");
break;
case 1:
System.out.println("米饭!");
break;
case 2:
System.out.println("米饭!");
break;
case 3:
System.out.println("馒头!");
break;
case 4 :
System.out.println("馒头!");
break;
case 5 :
System.out.println("火锅!");
break;
case 6 :
System.out.println("火锅!");
break; //注意此位置break的变化带来的结果
}
}
}
程序优化:
package StudyDay03;
public class SwitchDemo {
public static void main(String []args){
int day = 2;
switch(day){
case 1:
case 2:
System.out.println("米饭!");
break;
case 3:
case 4 :
System.out.println("馒头!");
break;
case 5 :
case 6 :
System.out.println("火锅!");
break; //注意此位置break的变化带来的结果
default:
System.out.println("KFC!");
}
}
}
循环控制(层数没有限制,编译也不会出错,但建议最多嵌套2层)
a、while循环(先判断,后执行)
结构:
while(循环条件){
//循环实现的代码
}
循环条件可以是一个变量也可以是一个字面的常量,可以是我们的表达式(常量表达式,包含变量的表达式)
类型:布尔类型
a、while循环(先判断,后执行)
结构:
while(循环条件){
//循环实现的代码
}
循环条件可以是一个变量也可以是一个字面的常量,可以是我们的表达式(常量表达式,包含变量的表达式)
类型:布尔类型
public class WhileDemo {
public static void main(String []args){
int x = 1;
int sum = 0;
while(x<=10){
sum= sum+x;
x++;
}
System.out.println("1到10的和是:"+sum);
}
}
*while表达式的括号后面不要加";",否则程序会进入无限循环编译器不会报错,需要花费大量时间去调试。
b、do……while循环(先执行,后判断)
结构:
do{
//实现循环的代码
}while(循环条件);
*while表达式括号后面加";",不管条件是否成立,都会先执行依次do中的代码。
b、do……while循环(先执行,后判断)
结构:
do{
//实现循环的代码
}while(循环条件);
*while表达式括号后面加";",不管条件是否成立,都会先执行依次do中的代码。
package practice; public class DoWhileDemo { public static void main(String []args){ int a =100; while(a==60){ //先判断,后执行 System.out.println("ok!a等于60"); a--; } int b = 100; do{ //先执行,后判断 System.out.println("ok!b等于100"); b--; }
c、for循环:
结构:
for(循环变量初始化; 循环条件的判断(布尔类型); 循环变量的改变){
//实现我们的逻辑
}
for循环有三个组成部分,循环变量初始化,循环条件的判断,循环变量的改变,这三个部分都可以省略,但是其之间的";"不可以省略。
结构:
for(循环变量初始化; 循环条件的判断(布尔类型); 循环变量的改变){
//实现我们的逻辑
}
for循环有三个组成部分,循环变量初始化,循环条件的判断,循环变量的改变,这三个部分都可以省略,但是其之间的";"不可以省略。
package practice:
public class ForDemo {
public static void main(String[] args){
int sum =0;
for(int i = 0;i<=100;i++){
if(i%2==0){
sum += i;
}
}
System.out.println("0-100所有偶数和是:"+sum);
}
/*public static void main(String[] args){
int sum = 0;
for(int i =2;i<=100;i+=2){
sum += i;
}
System.out.println("1~100的偶数和是:"+sum);
}*/
}
package practice;
public class ForDemo {
/* public static void main(String[] args){
int sum =0;
for(int i = 0;i<=100;i++){
if(i%2==0){ //for语句和if语句互相嵌套时,特别注意花括号的位置,一旦位置出错包含错误,将会产生严重后果。
sum += i;
}
}
System.out.println("0-100所有偶数和是:"+sum);
}*/
public static void main(String[] args){
int sum = 0;
for(int i =2;i<=100;i+=2){
sum += i;
}
System.out.println("1~100的偶数和是:"+sum);
}
}
while(b==60);}}
*循环变量可以定义多个,对于循环变量的改变,我们也可以同时改变多组变量,中间用逗号隔开。
for(int i = 0,int j = 0;i<5&&j<5;i++,j++);
执行流程:
i:循环变量初始化,这个在整个循环过程中只会执行一次。
ii:进行循环条件的判断,如果满足条件,则执行,否则循环结束。
iii:当循环条件满足之后,并且执行了我们循环中定义的代码,最后就会进行循环变量的改变。
d、foreach不是java提供的常规的循环方式,只是java提供的一种语法糖,常规循环的简化方式。foreach语句并不能完全取代for语句,但所有的foreach语句都可以改写成for语句。
格式:
for(元素变量x:遍历对象obj){
//引用了x的java语句
}
foreach语句中的元素变量x不必对其进行初始化
package practice;
public class Foreach {
public static void main(String[] args){
int arr[] = {7,10,1};
System.out.println("一堆数组中的元素分别为:");
for(int x:arr){
System.out.print(x+"\t");
}
}
}
跳转语句(两个关键字)
continue和continue:
cuntinue应用到循环控制中,continue的含义是跳出当次循环,在循环代码体中遇到continue,则会跳出当次循环,循环体内continue之后的代码都不会执行,并且循环变量进行一次改变之后再次进行判断,如果满足条件,则进入循环,否则直接结束循环,跳出的仅是continue外层直接包裹的循环。
break的含义是跳出整个循环,再循环的代码体中如果遇到break,则会跳出代码块,break后的代码不会执行,并且整个循环的过程结束,break后退出的循环也是直接包围break的循环。
continue和continue:
cuntinue应用到循环控制中,continue的含义是跳出当次循环,在循环代码体中遇到continue,则会跳出当次循环,循环体内continue之后的代码都不会执行,并且循环变量进行一次改变之后再次进行判断,如果满足条件,则进入循环,否则直接结束循环,跳出的仅是continue外层直接包裹的循环。
break的含义是跳出整个循环,再循环的代码体中如果遇到break,则会跳出代码块,break后的代码不会执行,并且整个循环的过程结束,break后退出的循环也是直接包围break的循环。
package practice;
public class Continue {
public static void main(String [] args){
System.out.print("10以内的全部奇数:");
for(int i =0;i<10;i++){
if(i%2==0){
continue;
}
System.out.print(i+" ");
}
}
}
数组(用来一次性保存多个相同类型元素的这样一种数据结构)
从维度上分为:一维数组 多维数组
一维数组:
声明:数组元素类型 [ ] 数组名字;数组元素类型 数组名字 [ ];
int [] arr; String arr[];
声明数组后,还不能访问他的任何元素,因为声明数组仅仅是给出了数组名字和元素的数据类型,要想真正使用数组还要为其分配内存空间,且分配内存空间是必须指明数组长度
语法如下:
数组名字 = new 数组元素类型[数组元素的个数]
new关键字用来创建一个对象,使用new关键字为数组分配内存时,数组中各个元素的初始化值都为0。
* 对于数组来说,如果初始化一个数组,但是并没有保存任何的值,数组中会存放一些默认的值
byte、short、long、int:0
double、float:0.0
Boolean:false
char: ' '
package practice;
public class Array {
public static void main(String [] args){
int arr [] = new int [3]; //未给数组赋值系统会自动赋给数组默认值为 int 型赋值为0
for(int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
数组变量中有一个length,能够让我们拿到数组长度
eg: int [] arr = new int [3]
int size = a.length;
数组元素的访问:
arr[index] :index 表示数组元素的索引,注意索引是 0 ~ length-1。
arr[2]: 访问第三个元素。
index:可以是常量也可以是一个表达式。
一维数组初始化:
动态初始化:(在定义一个数组和对数组进行赋值的操作,分开执行)
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
package practice;
public class Array {
public static void main(String [] args){
int arr [] = new int [3];
arr[0]=1; //给数组元素赋值
arr[1]=2;
arr[2]=3;
for(int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
静态初始化:(在定义一个数组的同时,进行数组初始化)
int[] arr = new int [ ] {1,2,3}
int[] arr2 ={1,2,3,4}(初始化数组可以省略new运算符和数组长度,编译器将根据初始值的数量来自动计算数组长度,并创建数组)
package practice;
public class Array {
public static void main(String [] args){
int arr [] = new int []{1,2,3};
for(int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
* 注意 [] 里不跟数量
二维数组:
声明:类型[][] 数组名称
int [][] = arr;
二维数组初始化:
动态初始化: int [] [] arr = new int [3] [];
package practice;
public class ArrayDemo2 {
public static void main(String[] args){
int arr [][] = new int[3][4]; //声明二维数组,若不赋初始值,系统会自动存储默认值
for(int i =0;i<arr.length;i++){
for(int j = 0;j<arr[i].length;j++){ //循环遍历数组中的每个元素
System.out.print(arr[i][j]+" ");
}
System.out.println( );
}
}
}
静态初始化: int [] [] arr = mew int { {1,2} , {2,3} };
package practice;
public class ArrayDemo2 {
public static void main(String[] args){
int arr [][] = new int[][]{{1,2,5},{3,4,8},{6,1,9}};
for(int i =0;i<arr.length;i++){
for(int j = 0;j<arr[i].length;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println( );
}
}
}
数组特性:
a、数组长度一旦制定就永远无法改变
b、数组保存元素的类型一旦指定,也是不可以改变的,并且只能保存该类型的元素。