java入门学习总结_04

zoukankan html css js c++ java

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 +" "); } 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 ; } }
查看全文

相关阅读:
Asp.Net MVC Control向View传值
 初学MyBatis.net
win10更新后，可以远程桌面ping也没问题，但是无法访问共享文件夹的解决方法
 我的常用自定义函数
 获取图片大小
 python获取文件路径、文件名、后缀名的实例
 Python-Selenium中chromeDriver限制图片和Javascript加载
 精华 selenium_webdriver(python)调用js脚本
 安装程序无法使用现有分区因为它没有包含所需的空间？怎么办？
我们无法创建新的分区也找不到现有的分区已解决【亲测有效】

原文地址：https://www.cnblogs.com/pwj-StudyCode/p/11774044.html

java入门学习总结_04

1、循环结构

2、方法

循环结构

概述

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

2、实现的语句：

for语句【常用】

while语句【常用】

do...while语句

for语句

for语句格式的注意事项

for循环练习

嵌套循环

while语句

do...while语句

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

死循环

跳转语句

方法概述:

方法的定义

方法的调用

方法注意事项

方法的重载

方法练习