java入门学习总结_04

时间 2019-11-20

标签 java 入门学习总结栏目 Java 繁體版

原文原文链接

一、循环结构

二、方法

循环结构

概述

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

二、实现的语句：

for语句【经常使用】
while语句【经常使用】
do...while语句

for语句

一、格式java

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

循环体语句;4服务器

}学习

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

1spa

2 false for语句结束设计

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

二、执行流程：对象

一、执行初始化语句
二、计算循环的条件表达式
三、若是计算为false，就结束for循环
四、若是计算为true，就执行循环体语句
五、执行初始化变量的自增
六、回到第2步

三、说明：blog

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

代码示例

for语句格式的注意事项

一、初始化语句，声明一个变量，用于记录循环次数，只执行一次。
二、条件表达式，必须是boolean类型的运算结果
三、循环体语句，在初始化变量自增以前，执行的
四、初始化变量的自增，能够是自增、也能够是自减，也能够一次自增多步
五、左大括号以前，不要有分号，不然for循环没法控制大括号中的语句。
六、循环体语句，若是只有一句，那么大括号能够省略。建议全部时候都加上大括号

而且：（偏门用法）

* 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

列举全部的“四叶玫瑰数”，并统计四叶玫瑰数的个数

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

嵌套循环

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

二、格式：

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结束

三、执行流程

一、初始化语句1
二、循环条件表达式1 ，计算结果是false，结束
三、循环条件表示式1，计算结果为true，初始化语句2，
四、计算循环条件表达式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语句

一、格式：

初始化语句

while(条件表达式) {

循环体语句;

初始化变量的自增;

}

二、执行流程：

一、初始化语句
二、计算条件表达式，若是为false，循环直接结束
三、若是为true，执行循环体语句
四、执行初始化变量的自增
五、回到第二步

三、注意事项：

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

代码示例

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语句

一、格式：

初始化语句;

do {

循环体语句;

初始化变量的自增;

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

二、执行流程：

一、初始化语句
二、循环体语句
三、初始化变量的自增
四、计算循环条件表达式的值，若是为false，循环结束
五、若是为true，回到第二步

三、注意事项：

一、循环条件表达式必须是boolean类型
二、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

一、do while语句和其余两种语句的区别：

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

二、while语句和for的区别：

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

死循环

一、死循环：无限循环。循环永远都不中止。

二、格式：

一、for语句的死循环：

for ( ; ; ) {

循环体语句;

}

二、while语句的死循环：【经常使用】

while (true) {

循环体语句;

}

注意：

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

三、死循环的做用：

一、在格式上使用了死循环，可是在循环体中，可能出现了须要循环结束的状况，准备了一些跳出、终止循环的跳转语句。
二、在服务器的设计中，但愿服务器永远给咱们服务下去，因此须要使用死循环。

代码示例

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("你输入的战队不存在，请从新输入");

}}

}}

跳转语句

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

二、continue语句：

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

三、break语句：

结束当前层次的循环

四、return语句：

结束当前的方法

五、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);

}}}}

方法概述:

一、具备某种特定功能的代码段

二、某段代码常用，因此使用大括号，将这段代码包起来，起个名字。之后就使用这个名字来代替这段代码。

三、好处：

一、提升了代码的复用性
二、提升了代码的封装性，大括号中的内容，其余调用者看不到也没法直接访问
三、简化了软件设计的思惟难度

方法的定义

一、方法定义的格式

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

方法体语句;

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

}

二、详细解释：

一、修饰符：如今全都写成public static(静态方法)

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

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

方法的调用

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

方法名称(实际参数);

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

一、直接调用：表示某些内容的执行，而没有生产结果的状况
二、输出调用：方法的返回值，须要打印。若是这个结果只打印一次，不作其余的操做。
三、赋值调用：方法的返回值，使用某个变量来接收。若是这个结果须要反复使用。

三、方法调用整体特色：

方法不调用，就不执行。

代码示例

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;

}

}

方法注意事项

一、方法定义：

一、方法不能嵌套定义，方法都是定义在主方法的下面。
二、方法的前后没有区别
三、方法的定义是平级关系
四、方法能够嵌套调用，甚至能够本身调用本身

二、参数列表：

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

三、return语句：

一、语句表达方法结束了；表示方法的产出内容。
二、若是方法没有具体的返回内容，能够写成return; 此时的return语句能够省略。返回值类型必须写成void。
三、若是方法有具体的返回内容，那么return后面就须要加上返回的那个数据。返回值类型必须和return语句后面的数据的数据类型一致。
四、return语句返回数据，返回给调用者。谁来调用当前方法，当前方法就将数据返回给谁。

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

方法的重载

一、重载：Overload，超载

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

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

三、说明：

一、在同一个类中。不一样无关类中，不可能发生方法的重载的。
二、方法名称相同：如出一辙。
三、参数列表不一样：参数类型不一样；参数个数不一样；参数类型的顺序不一样；
参数的名称不一样（不算）
四、与返回值类型无关。方法是不是重载，与返回值类型没有关系。
若是方法的名称和参数列表都同样，即便返回值类型不一样，也不算重载，属于方法的重复定义。

四、方法重载的好处：

一、没有重载的时候，相同逻辑相同功能的代码，须要定义不少个方法名称。调用者在记忆方法名称的时候，就有很大的负担。
二、有重载以后，相同功能逻辑的方法，只须要记忆一个名字。

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

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 ; } }

java入门学习总结_04

一、循环结构

二、方法

循环结构

概述

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

二、实现的语句：

for语句【经常使用】

while语句【经常使用】

do...while语句

for语句

for语句格式的注意事项

for循环练习

嵌套循环

while语句

do...while语句

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

死循环

跳转语句

方法概述:

方法的定义

方法的调用

方法注意事项

方法的重载

方法练习