java入门学习总结_04

1、循环结构

2、方法

循环结构

概述

1、对于某些需要重复执行的，相同或者相似的语句，使用某种格式来完成对代码的简化。

2、实现的语句：

• for语句【常用】

• while语句【常用】

• do...while语句

for语句

1、格式

for (初始化语句1 ; 循环的条件表达式2; 初始化变量的自增3 ) {

循环体语句;4

}

模拟执行时会出现的情况：（从左边开始）

1

2 false for语句结束

2true -4-3-2true-4-3-2true-4-3-2false-结束

2、执行流程：

• 1、执行初始化语句
• 2、计算循环的条件表达式
• 3、如果计算为false，就结束for循环
• 4、如果计算为true，就执行循环体语句
• 5、执行初始化变量的自增
• 6、回到第2步

3、说明：

• 1、初始化语句，声明一个变量，用于记录循环次数
• 2、循环的条件表达式，控制循环的条件
• 3、初始化变量的自增，将初始化语句中声明的变量，进行变化，一般是向着循环不能执行的方向变化
• 4、循环体语句，就是那个要重复执行的内容

代码示例

for语句格式的注意事项

• 1、初始化语句，声明一个变量，用于记录循环次数，只执行一次。
• 2、条件表达式，必须是boolean类型的运算结果
• 3、循环体语句，在初始化变量自增之前，执行的
• 4、初始化变量的自增，可以是自增、也可以是自减，也可以一次自增多步
• 5、左大括号之前，不要有分号，否则for循环无法控制大括号中的语句。
• 6、循环体语句，如果只有一句，那么大括号可以省略。建议所有时候都加上大括号

并且：（偏门用法）

• * for循坏的三个参数，需要注意的问题，
  * 第一个初始语句，初始数据时可以初始多个变量，
  * 第二个判断表达式，可以多条件判断使用关系运算符连接，
  * 第三个自增表达式：可以同时递增多个或者进行取模或算式操作等
  * 以上三个参数符合各自要求的表达式就可以了

代码示例

class Demo_3 {

//for语句的注意事项

public static void main(String[] args) {

//初始化变量只执行一次

for(int i = 1,j=6;i < j/*必须是boolean类型的*/;i = i +3,j=j - 1)/*;*/{

//如果循环体语句中只有一条语句，我们可以省略大括号

//循环体语句

System.out.println(i+" "+j);//循环体语句是在初始化变量自增前执行

}

}

}

for循环练习

练习1

打印数字1-5

练习2

打印数字5-1

练习3

计算1+2+3+...+100的和

练习4

计算1-100的偶数和

练习5

列举所有的“四叶玫瑰数”，并统计四叶玫瑰数的个数

四叶玫瑰数：是一个四位数，各个位的数字的四次方的和，为该数字本身

嵌套循环

1、在一次大的循环中，每次的循环内容（循环体语句）又是一个复杂的操作，是重复的操作，就需要在大的循环体语句中，定义小的循环，称为循环的嵌套（在打印矩形或其他形状的图案时，如果使用两层for嵌套，外层循坏表示行数，内层循环表示列的个数）

2、格式：

for（初始化语句1  （1）;  循环条件表达式1（2）；初始变量的自增1（3））{

for（初始化语句2（4）；循环条件表达式2（5）；初始变量自增2（6））{

循环体语句7

}

}  

模拟语句运行的流程如下：

1->2false 结束

1 -> 2true ->4  -> 5 false 内层循环结束->3->2 直到2为false 循环结束

1 -> 2true  -> 4 -> 5 true -> 7 -> 6 ->5 true(回到7) false-> 3 -> 2(true)回到4 ，2为false结 束

3、执行流程

• 1、初始化语句1
• 2、循环条件表达式1 ，计算结果是false，结束
• 3、循环条件表示式1，计算结果为true，初始化语句2，
• 4、计算循环条件表达式2的结果，false，内层循环结束，初始变量的自增1

   循环条件表达式1，true，初始化语句2，循环条件表达式2，true，循环体语句，初始变量自增2，循环条件表达式2，false，

代码示例

class Demo_2 {

public static void main(String[] args) {

//嵌套循环

/*

for(初始化语句1;循环条件表达式1;初始化变量自增1){

for(初始化语句2;循环条件表达式2;初始变量自增2){

循环体语句;

}

}

*/

for(int i = 1;i < 6 ;i++){//外层循环循环一次，内层循环是要执行完

for(int j = 1;j < 4;j++){

System.out.println("i = " + i +";j = " + j);

}

}

}

}

练习1

使用嵌套循环，打印四行五列星星矩形

*****

*****

*****

*****

提示：打印不换行，使用print方法，不要加ln

class Demo_7 {

public static void main(String[] args) {

/*

使用嵌套循环，打印四行五列星星矩形

*****

*****

*****

*****

提示：打印不换行，使用print方法，不要加ln

*/

//外层循环控制行数，内层循环控制列数

for(int i = 1;i < 5;i++){

//内层循环控制列数

for(int j = 1;j < 6;j++){

System.out.print("*");

}

//换行

System.out.println();

}

}

}

练习2

使用嵌套循环，打印5行5列的直角三角形

*

**

***

****

class Demo_8 {

public static void main(String[] args) {

/*

使用嵌套循环，打印5行5列的直角三角形

*         1行 打印1列，内层循环1次         

**   2行 打印2列，内层循环2次

***   3行 打印3列，内层循环3次

****

*****

*/

for(int i = 1;i < 6;i++){

for(int j = 1;j <= i;j++){

System.out.print("*");

}

System.out.println();

}

}

}

练习3

打印99乘法表

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

........................................

1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81

class Demo_9 {

public static void main(String[] args) {

/*

打印99乘法表

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

........................................

1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81

*/

for(int i = 1; i<=9 ; i++){

for(int j = 1; j <= i; j++){

System.out.print(j + "*" + i + "=" + i*j +"\t");

}

System.out.println();

}

}

}

while语句

1、格式：

初始化语句

while(条件表达式) {

循环体语句;

初始化变量的自增;

}

2、执行流程：

• 1、初始化语句
• 2、计算条件表达式，如果为false，循环直接结束
• 3、如果为true，执行循环体语句
• 4、执行初始化变量的自增
• 5、回到第二步

3、注意事项：

• 1、条件表达式必须为boolean类型
• 2、初始化变量的自增，不要忘记

代码示例

class Demo_10 {

public static void main(String[] args) {

//while语句

/*

初始化语句

while(条件表达式){

循环体语句；

初始变量的自增;

}

*/

int i = 1;

while(i < 6){

System.out.println("爱你一万年");

//初始变量的自增

// i++;//i = i * 2;

System.out.println(i++);

}

}

}

练习

使用while循环，统计1-100范围内，有多少数字可以被7整除

class Demo_11 {

public static void main(String[] args) {

//使用while循环，统计1-100范围内，有多少数字可以被7整除

int i = 1;

//定义一个辅助变量用来统计被7整除的个数

int count = 0;

while(i <= 100){

//判断是否可以被7整数

if(i % 7 == 0){

count++;

}

//初始变量的自增

i++;

}

System.out.println(count);

}

}

do...while语句

1、格式：

初始化语句;

do {

循环体语句;

初始化变量的自增;

} while (循环条件表达式);

2、执行流程：

• 1、初始化语句
• 2、循环体语句
• 3、初始化变量的自增
• 4、计算循环条件表达式的值，如果为false，循环结束
• 5、如果为true，回到第二步

3、注意事项：

• 1、循环条件表达式必须是boolean类型
• 2、while循环条件后面，要有一个分号

代码示例

class Demo_12 {

public static void main(String[] args) {

//do while 语句

//初始化变量

int i = 1;

do{

System.out.println("do while虚幻");

//初始化变量的自增

++i;

}while(i < 5);

//常用的循环语句，for语句，while语句

}

}

三种循环语句的区别for, while,do..while

1、do while语句和其他两种语句的区别：

• do while语句至少可以执行一次，另外两种有可能一次都执行不了

2、while语句和for的区别：

• 1、代码层面：while语句声明的初始化变量，在while结束之后，还能继续使用；for中声明的初始化变量，在for结束之后，就无法使用了。
• 2、设计层面：while语句一般用于描述相对模糊的范围，其他的条件；for用于描述相对准确，知道循环次数的循环

死循环

1、死循环：无限循环。循环永远都不停止。

2、格式：

1、for语句的死循环：

  for ( ; ; ) {

循环体语句;

}

2、while语句的死循环：【常用】

  while (true) {

循环体语句;

}

注意：

//破坏循环的方法：使条件变为false
//方式：1.直接使判断表达式条件变为false 2.通过修改自增表达式（不一定使用a++这种），使判断表达式失效即为false 3.使用break，continue，return，system.exit（0）结束循环/方法/虚拟机

3、死循环的作用：

• 1、在格式上使用了死循环，但是在循环体中，可能出现了需要循环结束的情况，准备了一些跳出、终止循环的跳转语句。
• 2、在服务器的设计中，希望服务器永远给我们服务下去，所以需要使用死循环。

代码示例

import java.util.Scanner;

class Demo_14 {

public static void main(String[] args) {

//死循环

//for语句的死循环

/* for(;;){

System.out.println("死循环");

}

*/

//System.out.println("我能执行到吗，好好想想");

//while语句的死循环

//while (true){

// System.out.println(true);

// }

Scanner sc = new Scanner(System.in);

System.out.println("选择你心仪的战队");

while(true){

int a = sc.nextInt();

if(a == 1){

System.out.println("I like RNG");

break;

}else if(a == 2){

System.out.println("I like IG");

break;

}else if(a == 3){

System.out.println("I like FPX");

break;

}else if(a == 4){

System.out.println("I like SKT");

break;

}else if(a == 5){

System.out.println("I like DWG");

break;

}else{//不加else有可能一个语句体都不执行，加上后要执行一个语句体

System.out.println("你输入的战队不存在，请重新输入");

}}

}}

跳转语句

1、跳转语句：在循环的循环体语句中，结束循环，控制循环，使用的语句。

2、continue语句：

• 结束本次循环，继续下次循环

3、break语句：

• 结束当前层次的循环

4、return语句：

• 结束当前的方法

5、System.exit(0);

• 用于结束虚拟机

代码示例

class Demo_15 {

public static void main(String[] args) {

//跳转语句

for(int i = 1;i<=10;i++){

//continue

if(i == 5){

continue;//结束本次循环，继续下次循环

}

System.out.println(i);

}

System.out.println("----------==================");

// break语句

for(int i = 1;i<=10;i++){

if( i == 5){

break;//  把整个循环结束了

}

System.out.println(i);

}

System.out.println("------------------------------------");

//return

for(int i = 1;i<=5;i++){

for(int j = 1;j < 8;j++){

if( j == 5){

return;//  直接把方法结束了

//break; //结束的是内层循环，外层循环不受影响

//System.exit(0);//把虚拟机结束了

}

System.out.println("i = "+i +";j="+j);

}}}}

方法概述:

1、具有某种特定功能的代码段

2、某段代码经常使用，所以使用大括号，将这段代码包起来，起个名字。以后就使用这个名字来代替这段代码。

3、好处：

• 1、提高了代码的复用性
• 2、提高了代码的封装性，大括号中的内容，其他调用者看不到也无法直接访问
• 3、简化了软件设计的思维难度

方法的定义

1、方法定义的格式

修饰符 返回值类型 方法名称 (参数列表) {

方法体语句;

return语句;//使用void时，return后面不接东西，表示结束这个方法，其他返回值类型，return返回对应类型数据作为这个方法的一个结果输出

}

2、详细解释：

• 1、修饰符：现在全都写成public static(静态方法)

  注：静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

• 2、返回值类型：方法具有功能，有可能会有一些产出，就需要将数据返回给调用者。调用者需要知道生产出来的数据的数据类型。（int double，float，char,String void等）
• 3、方法名称：给这段代码起的名字。只要是一个合法的标识符即可。第一个单词的首字母小写，从第二个单词开始首字母大写。动词、动宾结构。（小驼峰写法）
• 4、参数列表：这段代码要完成功能，可能会需要一些资源。在参数列表中，需要定义一些变量，内存中表示为容器，在调用本方法的时候，会由外界传入数据，存储到这些变量容器中。使用变量符号，表示那些将来可能传入的数据。
• 5、方法体语句：真正要完成该方法功能的执行逻辑。
• 6、return语句：最终生产出来的结果，要返回给调用者，使用return语句返回。如果没有任何生产内容，就可以写一个return;，用于表示方法结束。

方法的调用

1、格式：直接书写方法名称即可（在不使用面向对象编程的时候）

方法名称(实际参数);

2、方法调用的三种形式：

• 1、直接调用：表示某些内容的执行，而没有生产结果的情况
• 2、输出调用：方法的返回值，需要打印。如果这个结果只打印一次，不做其他的操作。
• 3、赋值调用：方法的返回值，使用某个变量来接收。如果这个结果需要反复使用。

3、方法调用总体特点：

方法不调用，就不执行。

代码示例

class Demo_17 {

public static void main(String[] args) {

//方法的调用

//直接调用

method_1();

method_2(/*实际参数*/5,8);

//输出调用

method_3(1,2);//sum

System.out.println(method_3(3,4));

//赋值调用

int a = method_3(2,3);

System.out.println(a);

}

//无参数列表，无返回值

public static void method_1(){

System.out.println("method_1 方法被调用了");

}

//有参数列表的，无返回值

public static void method_2(/*定义诺干个变量*/int i ,int j){

System.out.println("method_2 方法被调用了"+ "i= "+i +";j="+ j );

}

//有参数列表，有返回值的

public static int method_3(/*定义诺干个变量*/int i ,int j){

System.out.println("method_3");

int sum = i + j;

return sum;

}

}

方法注意事项

1、方法定义：

• 1、方法不能嵌套定义，方法都是定义在主方法的下面。
• 2、方法的先后没有区别
• 3、方法的定义是平级关系
• 4、方法可以嵌套调用，甚至可以自己调用自己

2、参数列表：

• 1、形式参数：在定义方法时使用，需要加上数据类型的参数，也就是对于变量进行声明。各个变量之间，使用逗号分隔。
• 2、实际参数：在方法调用时使用，不能加上数据类型的参数，也就是对于变量进行赋值。各个实际参数之间，也使用逗号分隔。顺序必须和定义的方法的形式参数的顺序一致。

3、return语句：

• 1、语句表达方法结束了；表示方法的产出内容。
• 2、如果方法没有具体的返回内容，可以写成return; 此时的return语句可以省略。返回值类型必须写成void。
• 3、如果方法有具体的返回内容，那么return后面就需要加上返回的那个数据。返回值类型必须和return语句后面的数据的数据类型一致。
• 4、return语句返回数据，返回给调用者。谁来调用当前方法，当前方法就将数据返回给谁。

方法在内存中的理解：main方法运行时，创建main方法内存块，main方法调用到test_1()，test_1()创建内存进栈，test_1()运行调用test_2（），test_2()创建内存空间同时进栈，当test_2()运行完所有代码，this出栈,此时test_1()运行完最后的代码，也this出栈，最后main代码运行完也，this出栈，程序结束，栈空

方法的重载

1、重载：Overload，超载

2、方法的重载：（只有参数的数据类型，个数，参数的位置这三个改变，才算方法重载）

• 在同一个类中，方法名相同，参数列表不同，与返回值类型无关

3、说明：

• 1、在同一个类中。不同无关类中，不可能发生方法的重载的。
• 2、方法名称相同：一模一样。
• 3、参数列表不同：参数类型不同；参数个数不同；参数类型的顺序不同；
• 参数的名称不同（不算）
• 4、与返回值类型无关。方法是否是重载，与返回值类型没有关系。
• 如果方法的名称和参数列表都一样，即使返回值类型不同，也不算重载，属于方法 的重复定义。

4、方法重载的好处：

• 1、没有重载的时候，相同逻辑相同功能的代码，需要定义很多个方法名称。调用者在记忆方法名称的时候，就有很大的负担。
• 2、有重载之后，相同功能逻辑的方法，只需要记忆一个名字。

5、当前学习过的常见重载：

println方法，任意类型的数据，都可以放到这个方法中打印

在System.out类型中，将各种数据类型的打印方法，都定义出来了，都起了println方法的名称

代码示例

class Demo_20 {

public static void main(String[] args) {

//方法的重载

int a = 1;

int b = 2;

System.out.println(sum(a,b));

double m = 1.2;

double n = 1.3;

System.out.println(sum(1.2,1.3));

//重载

System.out.println(1);//PrintStream

System.out.println(1.2);

System.out.println("asdf");

}

//在同一个类中，方法名字一样，参数列表不同（参数的数据类型不一样，参数的顺序不一样，参数的个数不一样）与返回值类型无关

public static int sum(int a,int b){

return a + b;

}

public static double sum(double a,double b){

return a + b;

}

/*public static double sum(double aa,double bb){

return aa + bb;不是方法的重载

}*/

public static double sum(double a,int b){

return a + b;

}

public static double sum(int a,double b){

return a + b;

}

public static int sum(int a,int b,int c){

return a + b + c;

}

}

方法练习

练习1

定义一个方法getMax，可以获取两个整数的较大值

在主方法中，键盘录入两个整数，调用方法获取两者最大值

练习2

定义一个方法isEqual，可以判断两个小数是否相等

在主方法中，键盘录入两个整数，自动提升为小数，调用方法比较两者是否相等

练习3

定义一个方法，可以打印指定行数和列数的矩形

在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应规模的矩形import java.util.Scanner;class Practice {

public static void main(String[] args) {
        /*
        练习1
        定义一个方法getMax，可以获取两个整数的较大值
        在主方法中，键盘录入两个整数，调用方法获取两者最大值

        练习2
        定义一个方法isEqual，可以判断两个小数是否相等
        在主方法中，键盘录入两个整数，自动提升为小数，调用方法比较两者是否相等

        练习3
        定义一个方法，可以打印指定行数和列数的矩形
        在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应规模的矩形
        */
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        //boolean boo = isEqual_1(a,b);
        //System.out.println(boo);
        //int max = getMax(a,b);
        //System.out.println(max);
        printJuXing(a,b);

    }
    //获取两个整数的最大值
    public static int getMax(int x,int y){
        if(x > y){
            return x ;
        }else{
            return y;
        }
        //int z = x > y ? x : y;
        //return z;
    }

    //比较两个数是否相等
    public static void isEqual(double d1,double d2){
        String str = d1 == d2 ? "相等":"不相等";
        System.out.println(str);
    }

    //比较两个数是否相等
    public static boolean isEqual_1(double d1,double d2){
        return  d1 == d2 ? true:false;
    }
    //可以打印指定行数和列数的矩形
    public static void printJuXing(int hang,int lie){
        //嵌套循环
        //外层循环控制行，hang
        for(int i = 1 ;i <= hang;i++){
            //内层循环控制列数
            for(int j = 1 ;j <= lie; j++){
                System.out.print((char)3+" ");
            }
            System.out.println();
        }
        return ;
    }

}