while循环、方法(伟大的作品，不是靠力量而是靠坚持才完成的。)

一、循环

while语句

1、格式：
初始化语句；
while(布尔表达式){
循环体语句；
初始化变量的自增；
}
2、执行流程
（1）执行初始化语句；
（2）计算布尔表达式的值，结果只有两种，如果为false，循环就不执行了，直接结束
（3）如果为true，执行循环体语句
（4）执行初始化变量的自增
（5）回到第(2)步
3、注意：
（1）条件表达式结果一定是boolean类型
（2）初始化变量的自增，也可以自减;

public class Demo_1 {public static void main(String[] args) {//      while循环
//      初始化语句；
//      while(布尔表达式){//          循环体语句；
//          初始化变量的自增；
//      }int i = 0;//初始化语句；while(i < 5) {System.out.println(i);
//          初始化变量的自增
//          i++;i+=2;}}
}

死循环

1、死循环：循环能够一直的执行下去，不会停止
2、格式：
两种
（1）for语句的死循环
for( ; ; ){
循环体语句；
}
（2）while语句的死循环（常用）
while(true){
循环体语句；
}
3、死循环的作用
（1）在格式上使用了死循环，将来可以结合跳转语句进行使用，能够结束死循环。
（2）在服务器设计中，希望服务能够永远的给我们服务下去，所以在服务器设计中需要使用死循环。

import java.util.Scanner;public class Demo_2 {public static void main(String[] args) {//      死循环
//      for语句的死循环
//      for(;;) {//          System.out.println("for语句的死循环");
//      }
//      System.out.println("hello");注意：死循环中如果没有跳转语句，那么在死循环的后面是无法跟任何代码的
//      while语句的死循环
//      while(true) {//          System.out.println("while语句的死循环");
//      }
//      死循环的简单使用Scanner sc = new Scanner(System.in);while (true) {System.out.println("请输入一个数据");int i = sc.nextInt();System.out.println(i);if (i == 5) {System.out.println("录入正确");break;} }}
}

跳转语句

1、跳转语句：在循环的循环体语句中，结束循环，控制循环使用的语句
2、continue语句：
解释：继续
作用：结束本次循环，继续下次循环
3、break语句：
解释：中断打断
swtich语句中，break；作用：结束switch语句
在循环中的break作用，结束break所在层次的循环。

public class Demo_3 {public static void main(String[] args) {//      continue语句
//      解释：继续
//      作用：结束本次循环，继续下次循环for (int i = 1; i <= 5; i++) {if (i == 3) {continue;}System.out.println(i);}System.out.println("----------------break-------------------");for (int i = 1; i <= 5; i++) {if (i == 3) {break;//将break所在循环直接给结束掉了}System.out.println(i);}}
}

计算1+2+3+4+5+…+100的和

public class Demo_4 {//  计算1+2+3+4+5+....+100的和public static void main(String[] args) {//      循环
//      定义一个变量，用来记录每次累加的结果int sum = 0;for (int i = 1; i <= 100; i++) {//          累加
//          sum = sum + i;sum += i;
//          i = 1 ,sum = 0 + 1; sum = 1
//          i = 2, sum = 0 + 1 + 2; sum = 3
//          i = 3, sum = 0 + 1 + 2 + 3,sum = 6}System.out.println(sum);}
}

列举所有的四叶玫瑰数和个数

public class Demo_5 {public static void main(String[] args) {//      列举所有的四叶玫瑰数和个数
//      定义一个变量用来统计四叶玫瑰树的个数int count = 0;for (int i = 1000; i <= 9999; i++) {//          取出i这个数字的各个位上的数字
//          7828int ge = i % 10;
//          int shi = i / 10 % 10;int shi = i % 100 / 10;
//          int bai = i / 100 % 10;int bai = i % 1000 / 100;int qian = i / 1000;
//          计算各个位上四次方的和int sum = ge * ge * ge * ge + shi * shi * shi * shi + bai * bai * bai * bai + qian * qian * qian * qian;
//          判断各个位上的和，是否和该数字本身相等if (i == sum) {System.out.println(i);count++;}}System.out.println("四叶玫瑰数的个数为:" + count);}
}

while循环练习

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

public class Demo_6 {public static void main(String[] args) {//      使用while循环，统计1-100范围内，有多少个数字可以被7整除int i = 1;
//      统计能被7整数的个数int count = 0;while (i <= 100) {//          判断i是否能被7整数if (i % 7 == 0) {System.out.println(i);count++;}
//          初始化变量的改变i++;}System.out.println("能被7整除的个数为：" + count);}
}

嵌套循环

1、在一次大的循环中，每次的循环内容（循环体语句）又是一个复杂的操作，就需要在大循环中，再去定义一个小循环，称为循环的嵌套（双重循环）
2、格式：
for(初始化语句1;条件判断表达式1;初始化语句改变表达式1){ //外层循环
for(初始化语句2;条件判断表达式2;初始化语句改变表达式2){ //内层循环
循环体语句；
}
}
3、执行流程

public class Demo_7 {//      嵌套循环public static void main(String[] args) {for (int i = 1; i <= 3; i++) {//外层循环，循环体语句是内层循环// i = 1, j = 1 --> 3
//          嵌套循环：外层循环一次，内层循环要循环完for (int j = 1; j <= 3; j++) {//内层循环  System.out.println("i = " + i + ",  j = " + j);//内层循环的循环体语句}}}
}

使用嵌套循环，打印四行五列的星星矩阵
*****
*****
*****
*****public class Demo_8 {public static void main(String[] args) {//      使用嵌套循环，打印四行五列的星星矩阵
//      外层循环控制行，内层循环控制列
//      *****
//      *****
//      *****
//      *****for (int i = 1; i <= 4; i++) {//外层循环控制行
//          内层循环控制列for(int j = 1;j <= 5;j++) {System.out.print("*");}
//          System.out.println();}}
}

使用嵌套循环，打印5行五列的直角三角形
*
**
***
****
*****public class Demo_9 {//  使用嵌套循环，打印5行五列的直角三角形
//  *            1       1列
//  **           2       2列
//  ***          。。。
//  ****
//  *****public static void main(String[] args) {//      外层循环控制行数for (int i = 1; i <= 5; i++) {//          内层循环控制列for (int j = 1; j <= i; j++) {System.out.print("*");}System.out.println();}}
}

使用嵌套循环，打印九九乘法表public class Demo_10 {public static void main(String[] args) {//      使用嵌套循环，打印九九乘法表
//      外层循环控制行数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();}}
}

二、方法

1、在java语言中，方法具有特定功能的代码段。
2、我们可以通过在程序中引用方法名称和所需的参数，实现在该程序中执行（方法的调用），可以去解决一类的问题，最终会返回一个值（不是必须的）
3、某段代码经常使用，也可以将这段代码用大括号包起来，起个名字，以后就使用这个名字来代替这段代码
4、好处：
（1）提高了代码的复用性
（2）提高了代码的封装性，大括号中的内容，其他调用看不到也无法直接访问
（3）简化了软件设计的思维难度

方法的定义

1、方法定义的格式
修饰符返回值方法名称（参数列表）{
方法体；
return 语句；
}
2、说明：
（1）修饰符：public static
（2）返回值类型：方法具有功能，有可能会有一些产出，需要将数据返回给调用者，调用者需要知道方法产生数据的类型的。
（3）方法名称：只要是一个合法的标识符即可。小驼峰命名法
（4）参数列表:这段代码要完成功能，可能就需要一些资源，资源是外界的，在参数列表中，定义一些变量，告诉调用者，方法所需要的数据。
将来调用者在调用方法的时候，就需要传入参数列表中声明的数据类型的数据。有了参数列表，方法就可以接受外界的数据，并进行使用或者处理。
（5）方法体：一些对业务逻辑的处理。对数据的处理的操作
（6）return语句：最终方法调用结束之后，可能会有数据的产出。返回给调用者，使用return语句进行返回，如果没有任何数据的产出，就可以只写一个return；或者不写。
如果没有数据的产出。返回值类型就写一个void

public class Demo_12 {//  方法的定义public static void main(String[] args) {}//    没有返回值，也没有参数列表，方法的定义public static void test() {// 就是执行一条hello这样的语句System.out.println("hello");}//    有返回值，有参数列表public static String sum(int a, int b, float f, String str) {String d = a + b + f + str;return d;}
}

方法的调用

1、格式：直接书写方法的名字即可
方法名称（实际参数）;
2、方法调用的三种形式
（1）直接调用：针对的是方法没有返回值，表示某些内容的执行
（2）输出调用：方法具有返回值，但是这个返回值不需要后续进行处理，这时候就可以使用输出调用将方法返回的结果进行打印
（3）赋值调用：针对的是方法具有返回值，将来需要使用这个方法返回的数据，定义一个变量去接收方法返回的数据。
3、方法调用的特点
方法不调用就不执行

public class Demo_12 {//  方法的定义public static void main(String[] args) {//      方法的调用
//      直接调用test();
//      输出调用,将方法的结果进行打印，没有对方法产生的结果进行后续的使用或者处理System.out.println(sum(100, 200, 2.3f, "java"));
//      赋值调用,可以对方法产生的结果进行再次的处理或者使用String str = sum(888, 666, 2.3f, "java");str += "成都";System.out.println(str);}//   没有返回值，也没有参数列表，方法的定义public static void test() {// 就是执行一条hello这样的语句System.out.println("hello");}//    有返回值，有参数列表             方法的定义public static String sum(int a, int b, float f, String str) {String d = str + a + b + f;return d;}
}

方法的注意事项

1、方法定义：
（1）方法不能嵌套定义的
（2）方法的定义，没有任何先后的区别
（3）方法的定义都是平级的关系
（4）方法是可以嵌套调用的，甚至可以自己调用自己（递归）
2、参数列表
（1）形式参数：在定义方法的时候，在参数列表中进行的只是变量的声明（只是将变量定义出来，确不赋值），各个变量之间用逗号隔开
（2）实际参数：在调用方法的时候，不能写上变量的类型，而是写具体的数据（值），各个实际参数之间，使用逗号隔开。本质上实际参数是完成对形式参数的赋值
3、return语句:
（1）一旦执行了return语句，就意味方法的结束。
（2）如果方法没有具体的返回内容，就可以写一个return；或者不写，这时候返回值类型必须是void
（3）return后返回的数据，该数据的类型决定返回值的类型。返回值类型要和return后返回的数据的类型保持一致.

public class Demo_13 {public static void main(String[] args) {System.out.println('h');
//      方法是谁先调用，谁先执行test_1();
//      test_2();int a = 123;int b = 345;
//      show(123,33);show(a, b);// 实际参数, 本质上相当于完成了对形式参数的赋值的过程//     int i = 100;
//      int j ;
//      j = i;
//      System.out.println(j);for (int i = 1; i <= 5; i++) {if(i ==3) {break;}}System.out.println("hellojava");}public static int show(int a, int b) {// 形式参数，只有变量的定义，没有赋值 a = 123,b = 345return a + b;}public static void test_2() {System.out.println("test_2");}public static void test_1() {/** public static void test_2() { 方法不能嵌套定义，一般都是定义在主方法外面 }*/test_2();// 方法可以嵌套调用System.out.println("test_1");}}

方法在内存中的理解

1、定义一个方法，键盘录入两个整数，获取两个整数的最大值import java.util.Scanner;public class Demo_15 {//  1、定义一个方法，键盘录入两个整数，获取两个整数的最大值public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入第一个数");int a = sc.nextInt();System.out.println("请输入第二个数");int b = sc.nextInt();int max = getMax(a,b);System.out.println(max);}public static int getMax(int a,int b) {if (a > b) {return a;} else {return b;}}
}

2、定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数

public class Demo_16 {public static void main(String[] args) {//      定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数printXing(100,100);}public static void printXing(int hang, int lie) {for (int i = 1; i <= hang; i++) {for (int j = 1; j <= lie; j++) {System.out.print("*");}System.out.println();}}
}

方法的重载

1、重载：overload，
2、方法的重载：
在同一个类中，方法名相同，参数列表不同，与返回值类型无关。
3、解释：
（1）在同一类中：不同无关类中，是不可能发生重载的
（2）方法名称：一模一样
（3）参数列表不同：参数的个数不同，参数的类型不同，参数类型的顺序不同。
（4）与返回值类型无关的。方法是否是重载，与返回值类型没有关系的。
4、方法重载的好处
（1）没有重载的时候，写一些相同逻辑的代码的时候需要记忆大量的方法名称，不方便
（2）有重载之后，相同功能逻辑的代码，都使用的是一个方法的名称，不需要去记忆大量方法的名称了。
5、当前学习过的重载：
println方法，可以打印任意数据类型的，println方法中重载了很多不同的数据类型

public class Demo_17 {//  方法的重载public static void main(String[] args) {//      getSum(1,2);int sum = getSum(1,3);System.out.println(sum);}//  两个数的和 ---------------------------------1public static int getSum(int a,int b) {System.out.println("int");return a + b;}//    public static double getSum(int a,int b) {//通过保证参数列表一致，让返回值类型不一致，发现编译报错，所以说明重载跟返回值没有关系的
//      System.out.println("int");
//      return a + b;
//  }// 求三个数的和---------------------------------2
//  通过1,2，参数的个数不同，就是重载的一种体现public static int getSum(int a,int b,int c) {return a + b + c;}//    求两个小数的和--------------------------------3
//  通过1.3，参数的类型不同，也是重载的一种体现public static double getSum(double a,double b) {System.out.println("double");return a + b;}//=------------------------------------------4public static double getSum(int a,double d) {return a + d;}
//=------------------------------------------5
//  通过4,5发现，参数的类型的顺序不同，也是重载的一种体现public static double getSum(double d,int a) {return a + d;}/** public static double getSum(double dd,int aa) { return a + d; }重载跟参数列表的参数的名称是无关的，只跟类型有关*/
}

练习

package com.quan.day2;public class Lianxi_6 {public static void main(String[] args) {lian(5);System.out.println("\n============\n");lian(5.0f);System.out.print("\n=============\n");char a = lian('C');System.out.println(a);}//    1、使用嵌套循环实现倒直角三角形的打印
//     *****
//     ****
//     ***
//     **
//     *public static void lian(int a) {for (int i = a; i >= 1; i--) {for (int j = i; j >= 1; j--) {System.out.print("*");}System.out.println();}}//    2、使用嵌套循环打印三角形，如下：
//          *
//         ***
//        *****
//       *******
//      *********public static void lian(float a) {int b = (int) a;for (int i = 1; i <= b; i++) {for (int j = 5 - i; j >= 1; j--) {System.out.print(" ");}for (int j = (i * 2) - 1; j >= 1; j--) {System.out.print("*");}System.out.println();}}//    3、封装一个方法，传入一个字符，如果是大写那么转化小写
//然后返回，  否则保持不变返回public static char lian(char a) {if (a >= 'A' && a <= 'Z') {return (char) (a + 32);}return a;}}