java学习Day5

循环结构

while循环

• 最基本的循环，结构为

while(布尔表达式){
    //循环内容
}

• 只要布尔表达式为true，循环就好一直执行下去
• 大多数情况是会让循环停止下来的，少部分情况需要循环一直进行，比如服务器的请求响应监听
• 循环条件一直为true就会造成无限循环（即死循环），正常业务编程中应尽量避免，会影响程序性能或者造成程序卡死崩溃

public class WhileDemo01 {
    public static void main(String[] args) {

        //输出1~100

        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
        }
    }
}

输出结果为

public class WhileDemo02 {
    public static void main(String[] args) {
        //计算1+2+3+...+100
        int i=0;
        int sum=0;

        while (i<=100){
            sum=sum+i;
            i++;
        }

        System.out.println(sum);
    }
}

计算1+2+3+…+100

输出结果为

do…while 循环

• 对while而言，条件不满足则不会进入循环，而有时我们需要即使不满足条件，也至少执行一次，因此有了do…while，结构为

  do{
      //代码语句
  }while(布尔表达式)
  

• while与do…while的区别：

  • while先判断后执行，do…while先执行后判断
  • do…while总是保证循环体会被至少执行一次，这也是主要差别

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;

        do {
            sum=sum+i;
            i++;
        }while (i<=100);

        System.out.println(sum);
    }
}

输出结果为

public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a=0;
        while (a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("================================");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}

输出结果为

可以看出分割线以上无输出，说明while循环在条件不满足时不会进循环，分割线以下输出了一个结果，说明即使不满足条件，循环也会被执行一次

for循环

• 所有循环都可以用while/do while表示，但是for可以使一些循环结构变得简单

public class ForDemo01 {
    public static void main(String[] args) {
        int a=1;//初始化条件

        while (a<=100){//条件判断
            System.out.println(a);//循环体
            a+=2;//迭代
        }

        System.out.println("while循环结束！");

        //初始化//条件判断//迭代
        for (int i =1;i<=100;i++){
            System.out.println(i);//循环体
        }
        System.out.println("for循环结束！");
    }
}

输出结果为

• for循环执行的次数在执行前就能确定，结构为

for(初始化;布尔表达式;更新){
    //代码语句
}

• for语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构

for语句可通过.for速写

• for循环执行的顺序
  • 最先执行初始化步骤。可以声明一种类型，可初始化一个或多个循环控制变量，也可以是空语句
  • 然后检测布尔表达式的值。如果为true，循环体被执行；如果为false，循环终止，开始执行循环体后面的语句
  • 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
  • 再次检测布尔表达式。循环执行上面的过程

实例

1. 计算0~100间的奇数和偶数的和

public class ForDemo02 {
    public static void main(String[] args) {

        int oddSum=0;//奇数的和
        int evenSum=0;//偶数的和

        for (int i = 0; i <=100; i++) {
            if (i%2!=0){
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }

        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);
    }
}

输出结果为

如果是i<100，则计算的是1~99间奇数和偶数的和

2. 用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

public class ForDemo03 {
    public static void main(String[] args) {

        for (int i = 1; i <= 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");//print（输出完不换行）!=println(输出完换行)
            }
            if (i%(5*3)==0){//被15整除说明已经到了第三个数
                System.out.println();//也可以写作print(“\n”)
            }
        }
    }

}

输出结果为

• i若从0开始，则第一行会是一个单独的0
• print：输出完不换行 println：输出完自动换行。因而想在一行输出，用print；想换行，可以print("\n")或println()
• 本题中实现三个数换行，除以一个5得到一个数，所以除以5*3=15则可以做到三个三个数分开的操作

3.打印九九乘法表

public class ForDemo04 {
    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+"="+j*i+"\t" );
            }
            System.out.println();
        }
    }
}
/*最初思路流程：
1、先想从列开始打印，打印下来发现第一列完成后无法使第二列上去，因此转为行打印
2、行打印先找规律，每一行后面的数字是不变的，因此为外面的循环变量，里面的依次增大，规律为从1增大到行数，因而外面变量定为i的情况下，其范围为1~9，里面变量定为j，范围为1~i
3、输出每一个算式时，后一个乘数不变，为i，自然另一个为j，也就确定了j+“*”+i=j*i（i*j）的基本算式
4、要得到目标阶梯算式，观察可知每个算式间隔了tab，因此j*i后加“\t”，又因为每行输出完换行，因而在行变量变化，即外面的循环中加换行即可。同时注意print与println的使用区别，后者自带换行
 */

大化小，逐个解决

输出结果为

增强for循环

• 主要用于数组或集合，结构为

for(声明语句:表达式)
{
    //代码句子
}
//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
//表达式:表达式是要访问的数组名，或者是返回值为数组的方法

简单举例

public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50};//定义一个数组

        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("==========================================");
        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

分割线上下的作用相同，但底下的更为简便

输出结果为

break&continue

break

• 在任何循环语句的主体部分，均可用break控制循环的流程。
• 用于强行退出循环，不执行循环中剩余的语句
• 可理解为“辞职”

public class BreakDemo {
    public static void main(String[] args) {
        
        int i =0;
        
        while (i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }

        System.out.println("123");
        
    }
}

输出结果为

可以看出，break中止了循环（即跳出循环，不再执行循环中剩余的语句），但并没有终止整个程序

continue

• 用在循环语句体中
• 用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
• 可理解为“请假”

public class ContinueDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
        }
    }
}

输出结果为

可以看出每逢10就会跳过一次循环，但并未终止整个循环

流程控制练习

打印三角形

思路：

• 直接不好通过循环语句打印出三角形，我们可以退而求其次，打印一个梯形，将它的左上部分变为空白即可
• 目标三角形又可通过其中一半折叠而成，因而问题转换成了打印出阶梯状的代码

1. 打印左侧三角形（一会会换成空白）

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形  5行

        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >=i ; j--) {//简便操作“fori”
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

输出结果为

2. 打印目标三角形的左半部

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形  5行

        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >=i ; j--) {//简便操作“fori”
                System.out.print(" ");
            }
            for (int j = 1; j <=i ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

输出结果为

3. 打印目标三角形的右半部

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形  5行

        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >=i ; j--) {//简便操作“fori”
                System.out.print(" ");
            }
            for (int j = 1; j <=i ; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

输出结果为

方法简介（理解为函数）

• 语句的集合，在一起执行一个功能
• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

设计方法的原则

保持方法的原子性，即一个方法只完成1个功能，这样有利于我们后期的扩展

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        int sum = add(1, 2);
        System.out.println(sum);
    }

    //加法
    public static int add(int a,int b){//如果不加static，就无法调用，加之后变为类变量
        return a+b;
    }
}

方法的定义和调用

语法

• 方法包括一个方法头和一个方法体。以下为所有部分
  • 修饰符：可选。定义方法的访问类型
  • 返回值类型：返回值的数据类型。若无返回值，则为void
  • 方法名：方法实际名称。需要遵守命名规则
  • 参数类型：方法被调用时，传递值给函数。这个值称为实参或变量。参数列表指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
    • 形式参数：方法被调用时用于接收外界输入的数据（如上例中的a，b）
    • 实际参数：调用方法时实际传给方法的数据（如上例中的1, 2）
  • 方法体：包含具体的语句，定义该方法的功能

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;//void则不用return
}

方法调用

• 调用方法：对象名.方法名（实参列表）
• java支持两种调用方式，根据方法是否返回值来选择
• 当方法返回一个值的时候，方法调用通常被当做一个值。例如

int large=max（30,40）;

• 如果方法返回值是void，方法调用一定是一条语句

System.out.println(hello,gengsheng);

举例

public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
        int Max = max(10, 10);
        System.out.println(Max);
    }

    //比大小
    public static int max(int num1,int num2){
        int result=0;

        if (num1==num2){
            System.out.println("num1=num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
        }else {
            result=num2;
        }

        return result;
    }
}

输出结果为

return可用作终止方法