循环语句（for，while，do……while），方法概述

循环结构

分类：for，while，do……while

（1）for语句

格式：

• for（初始化表达式；条件表达式；循环后的操作表达式）{
•                          循环体；
• }

执行流程：

a.执行初始化语句

b.执行判断条件语句，看其返回值是true还是false

• 如果是true，就继续执行
• 如果是false，就结束循环

c.执行循环体语句

d.执行循环后的操作表达式

e.回到b继续

 1 //例子
 2 //在控制台输出10次“helloworld”
 3 for（int i=0；i<10; i++）{
 4           system.out.println("helloworld");
 5 }
 6 
 7 
 8 //练习1，在控制台输出数据1-10
 9 //练习2，在控制台输出数据10-1
10 
11 for(int i=1;i<=10;i++){
12             system.out.println("i="+i);
13 }
14 
15 for(int i=10;i>=1;i--){
16             system.out.println("i="+i);
17 }

for语句的求和思想：

 1 //练习一：求出1-10之间数据之和
 2 
 3     int sum = 0;
 4     for(int i=1;i<=10;i++){
 5          sum = sum+i;
 6      }
 7     system.out.println("sum="+sum);
 8 }
 9 
10 //练习二：求出1-100之间偶数和
11 
12     int sum = 0;
13     for(int i=1;i<=10;i++){
14        if(i%2==0){
15          sum = sum+i;
16          }
17     }
18     system.out.println("sum="+sum);
19 }
20 
21 //练习三：求出1-100之间奇数和 
22 
23     int sum = 0;
24     for(int i=1;i<=10;i++){
25       if(i%2!=0){
26          sum = sum+i;
27          }
28     }
29     system.out.println("sum="+sum);
30 }

练习：在控制台输出所有的水仙花数

 1 //在控制台输出所有的水仙花数
 2 //所谓的水仙花数就是指一个三位数，其各位数字的立方和等于该数本身
 3 //举例：153
 4 //153=1*1*1+5*5*5+3*3*3=1+125+27=153
 5 
 6  /*
 7 第一步：100-999
 8 第二步：获取每一个位数的值，百位，十位，个位
 9 第三步：判断各个位上的立方和是否等于这个数，如果等于，则输出
10 */
11 
12 for(int i =100;i<=999;i++){    //获取100到999之间的数
13       int ge = 1%10;                 //123%10
14       int shi = 1/10%10;           //12%10
15       int bai = 1/10/10%10;      //1%10
16 
17        if(ge*ge*ge+shi*shi*shi+bai*bai*bai){
18             system.out.println(i);
19          }
20 }
21 
22 //统计水仙花数一共有多少个
23 
24 /*
25 第一步：需要有一个变量记录水仙花个数
26 第二步：获取到所有的3位数
27 第三步：判断是否满足水仙花数
28 第四步：如果满足条件，计数器就自增
29 */
30 
31 int count = 0;
32 for(int i =100;i<=999;i++){    
33       int ge = 1%10;                 
34       int shi = 1/10%10;           
35       int bai = 1/10/10%10;      
36 
37        if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai){
38              count++;
39          }
40     }
41             system.out.println(count);
42 }    

while语句的基本格式和使用

基本格式：

• while（判断条件语句）{
• 　　循环体语句；
• }

完整格式：

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

 1 //例子
 2 //在控制台输出1-10
 3 int x=1;
 4 while(x<=10){
 5        system.out.println("x="+x);
 6         x++;
 7 }
 8 
 9 //练习一：求和思想,求1-100之和
10 int sum=0;
11 int i=1;
12 while(i<=100){
13        sum+=i;            //sum=sum+i;
14         i++;                 //让变量i自增
15     }
16 system.out.println("sum="+sum);
17 }
18 
19 //练习二：统计思想,统计水仙花个数
20 int count = 0;              //计数器
21 int i =100;
22 while(i<=999){
23       int ge = i%10;
24       int shi = i/10%10;
25       int bai = i/10/10%10;
26 
27       if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai){
28              count++;
29         }
30             i++;
31     }
32 system.out.println("count"+count);
33 }

do......while语句基本格式和使用

格式：

• do{
• 　　循环体语句；
• }while（判断条件语句）；

完整格式：

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

1 //例子
2 //在控制台输出数据1-10
3 int i = 1;
4 do{
5         system.out.println("i="+i);
6         i++;
7 }while(i<=10);

三种循环语句的区别：

•  do……while：至少执行一次循环体
• 而for，while必须先判断条件是否成立，然后决定是否执行循环体
• for语句执行后变量会被释放，不能再使用
• while语句执行后，初始化变量还可以继续使用

两种简单的死循环结构：

（1）while（true）{……}

（2）for（；；）{……}

循环嵌套题目：

 1 //输出一个正三角形
 2 /*
 3           *
 4           **
 5           ***
 6           ****
 7           *****
 8 */
 9 
10 for（int i =1;i<=5;i++）{             //外循环决定行数
11         for(int j =1;j<=i;j++){        //内循环决定列数
12              system.out.println("*"); 
13         }
14      system.out.println();                 //换行
15 }

1 //输入一个4行5列的图案
 2 /*
 3               *****
 4               *****
 5               *****
 6               *****
 7 */    
 8 //外循环控制行数，内循环控制列数
 9 for（int i=1；i<=4；i++）{            //外循环
10        for(int j=1;j<=5;j++){             //内循环
11             system.out.print("*");
12     }
13           system.out.println();                      //换行
14 }                               

1 //在控制台输出九九乘法表
2 
3 for(int i=1;i<=9;i++){           //行数
4      for(int j=1;j<=i;j++){      //列数
5            system.out.print(j+"*"+i+"="+(i*j)+'\t');
6           }
7        system.out.println();
8 }

控制跳转语句：

• 1、break
• 使用场景：只能在switch中和循环中使用，停止循环
• 2、continue
• 使用场景：只能在循环中
• 3、return
• 作用：返回，不是结束循环，而是结束方法

三者的区别：

• return是结束方法
• break是跳出循环
• continue是终止本次循环，继续下次循环

控制跳转语句标号

 1 //例子
 2 
 3 outer:for(int i =0;i<=10;i++){   
 4  //outer就是标号，只要是合法的标识符即可
 5       system.out.println("i="+i);
 6        inner:for(int j=1;j<=10;j++){
 7               system.out.println("j="+j);
 8                  break outer;
 9           }
10 }

 1 //练习
 2 //在控制台输出2次“java基础班”
 3 //在控制台输出7次“java基础班”
 4 //在控制台输出13次“java基础班”
 5 
 6 
 7 for（int x=1；x<=10;x++）{
 8       if(x%3==0){
 9          //break;                     //输出2次
10          //continue;                 //输出7次
11           system.out.println("java基础班");        //输出13次
12        }
13        system.out.println("java基础班");
14 }

java的方法

概述：完成特定功能的代码块，提高代码的复用性

格式：

• 修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2……）{
• 　　　　方法体语句；
• 　　　　return 返回值；
• }

参数：

• 实际参数：就是实际参与运算的
• 形式参数：就是方法定义上的，用于接收实际参数的

 1 //例子
 2 //用方法求两个整数的和
 3 
 4 public static void main(string[] args){
 5           int sum = add(10,20);         //实际参数
 6 }
 7 
 8 public static int add(int a,int b){      //形式参数
 9        int sum = a+b;
10        return sum;
11 } 

方法的调用：

（1）单独调用，没有意义，例：add（10，20）；

（2）输出调用，不够好，例：system.out.println（add（10，20））；

（3）赋值调用，推荐

 1 //练习1：键盘录入两个数据，返回两个数中的较大值
 2 //练习2：判断两个整数是否相等 boolean
 3 
 4 public static void main(string[] args) {
 5     scanner sc  = new scanner(system.in);
 6         system.out.println("请输入第一个整数：");
 7     int x= sc.nextint();
 8         system.out.println("请输入第二个整数：");
 9     int y = sc.nextint();
10 
11         int max = getmax(x,y);
12         system.out.println(max);
13 
14          boolean b = isequals(x,y);
15          system.out.println(b);
16 
17  }
18 
19 /*
20    返回两个整数的较大值
21    1、明确返回值类型
22    2、明确参数列表 int a，int b 
23 */
24 
25 public static int getmax(int a,int b){
26       return a>b?a:b;
27 }
28 
29 
30 /*
31    判断两个整数是否相等 
32    1、明确返回值类型
33    2、明确参数列表 int a，int b
34 */
35 
36 public static boolean isequals(int a,int b){        isequals 是否相等
37        return a==b;
38 }

 1 //在控制台输出矩形星形
 2 
 3 public static void main(){
 4        scanner sc = new scanner(system.in);
 5         system.out.println("请输入行数");
 6         int row = sc.nextint();
 7         system.out.printin("请输入列数");
 8          int column = sc.nextint();
 9 
10           print(row,column);
11 }
12 
13 
14 /*
15    1、明确返回值类型，经分析没有具体的返回值类型，void
16    2、明确参数列表int a，int b 
17 */
18 
19 public static void print(int a,int b){
20     for(int i = 1;i<=a;i++){       //行数
21         for(int j=0;j<=i;j++){     //列数
22              system.out.print("*");
23           }  
24       system.out.println();
25       }
26 }

方法的练习：

 1 //打印乘法表
 2 
 3 public static void main(string[] args){
 4     scanner sc = new scanner(system.in);
 5     system.out.println("请输入一个整数");
 6      int num = sc.nextint();
 7 }
 8 
 9 /*
10    1、返回值类型void
11    2、参数列表，int a
12 */
13 
14 public static void print(int a){
15      for(int i=1;i<=a;i++){
16        for(int j=1;j<=i;j++){
17            system.out.print(j+"*"+i+"="+(i*j)+"\t");
18          }
19         system.out.println();
20      }
21 }

方法重载（overload）：方法名相同，参数列表不同，与返回值类型无关

重载的分类：

• 1、参数个数不同
• 2、参数类型不同（顺序不同）

 1 //方法的重载练习
 2 //比较两个数据是否相等，参数类型分别为两个int类型，两个double类型，并在main方法中进行测试
 3 
 4 
 5     boolean b1 = isequals(10,10);
 6        system.out.println(b1);
 7 
 8         boolean b2 = isequals(10.5,10.6);
 9          system.out.println(b2);
10 
11 /*
12     1、返回值类型boolean
13     2、参数列表int a，int b
14 */
15 
16 public static boolean isequals(int a,int b){
17       return a==b;
18 }
19 
20 
21 /*
22     1、返回值类型boolean
23     2、参数列表double a，double b
24 */
25 
26 public static boolean isequals(double a,double b){
27       return a==b;
28 }