JavaDay03

增强for循环

package com.han.struct;
​
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

package com.han.struct;
​
import java.sql.SQLOutput;
​
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");
    }
}

package com.han.struct;
​
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.println(i);
        }
    }
}

break在任何循环语句的主体部分，均可用break控制循环流程。

break用于强行退出循环，不执行循环中剩余的语句。

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

（可以比喻成一个辞职一个休假）

练习

三角形

package com.han.struct;
​
public class TestDemo01 {
    public static void main(String[] args) {
        // 外层循环控制行数，要打印 5 行，所以循环范围是从 0 到 5
        for (int i = 0; i <= 5; i++) {
            // 第一个内层循环用于打印每行前面的空格
            // 随着行数 i 的增加，空格的数量逐渐减少，初始时为 5 个，每次减少 1 个
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            // 第二个内层循环用于打印三角形左半部分的星号
            // 星号的数量随着行数 i 的增加而增加，初始时为 1 个，每次增加 1 个
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            // 第三个内层循环用于打印三角形右半部分的星号
            // 这里需要注意，因为已经有一个星号在左半部分打印过了，所以起始位置从 1 开始，且条件是 j < i
            // 星号的数量比左半部分少 1 个，以保证三角形的形状
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            // 每行打印完后换行，以便开始下一行的打印
            System.out.println();
        }
    }
}

菱形

package com.han.struct;
​
public class TestDemo01 {
    public static void main(String[] args) {
        // 外层循环控制行数，要打印10行，所以循环范围是从 0 到 10
        for (int i = 0; i <= 10; i++) {
            if(i<=5) {
                // 第一个内层循环用于打印每行前面的空格
                // 随着行数 i 的增加，空格的数量逐渐减少，初始时为 5 个，每次减少 1 个
                for (int j = 5; j >= i; j--) {
                    System.out.print(" ");
                }
                // 第二个内层循环用于打印三角形左半部分的星号
                // 星号的数量随着行数 i 的增加而增加，初始时为 1 个，每次增加 1 个
                for (int j = 1; j <= i; j++) {
                    System.out.print("*");
                }
                // 第三个内层循环用于打印三角形右半部分的星号
                // 这里需要注意，因为已经有一个星号在左半部分打印过了，所以起始位置从 1 开始，且条件是 j < i
                // 星号的数量比左半部分少 1 个，以保证三角形的形状
                for (int j = 1; j < i; j++) {
                    System.out.print("*");
                }
            }else {
                int k = 10 - i;
                for (int j = 5; j >= k; j--) {
                    System.out.print(" ");
                }
                for (int j = 1; j <= k; j++) {
                    System.out.print("*");
                }
                for (int j = 1; j < k; j++) {
                    System.out.print("*");
                }
            }
            // 每行打印完后换行，以便开始下一行的打印
            System.out.println();
        }
    }
}
​

Java方法(Java是值传递，引用类型是引用传递)

方法是语句的集合。一个方法只做一个功能。

System.out.println();--->调用System中out中的println()方法。

package com.han.method;
​
public class Demo01 {
    //main方法
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
​
    }
    //加法public int add()加static才能被main调用
    public static int add(int a,int b){
        return a+b;
    }
}

方法类似其他语言的函数；方法包含一个方法头和一个方法体。

修饰符 返回值类型 方法名（变量类型 变量名）{ ... 方法体 ... return 返回值； }

形式参数：add(int a,int b)中的a、b。

实际参数：int sum = add(1,2);中的1、2。

package com.han.method;
​
public class Demo02 {
    public static void main(String[] args) {
        //调用max（）方法，打印max
        int max = max(10, 20);
        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;
        }
        /*if(num1<num2){
            result = num2;
        }*/
        return result;
    }
}

方法重载

在一个类中，有相同的函数名称，但形参的函数不同。

public static int max(int num1, int num2){}
public static float max(float num1,int num2){}

方法名称必须相同。

参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。

命令行传参（例如dos命令行javac Demo03）

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现

可变参数/不定向参数

方法中在指定参数后加省略号（int... i）；

必须在方法的最后一个参数。

package com.han.method;
​
public class Demo05 {
    public static void main(String[] args) {
        Max(23,5,89);
​
    }
    public static void Max(double...i){
        if(i.length ==0){
            System.out.println("失败");
            return;
        }
        double result = i[0];
        for (int j = 0; j < i.length; j++) {
            if(i[j] > result){
                result = i[j];
            }
        }
        System.out.println("结果: "+result);
​
    }
}

递归（递归头+递归体）

A方法调用自己。

可以将大型复杂问题转化为小型问题。

大计算尽量不用该方法。

package com.han.method;
​
public class Demo07 {
​
    public static void main(String[] args) {
        System.out.println(f(5));
​
    }
    //1! 1
    //2! 2*1
    //5! 5*4*3*2*1
    //2 2*f(1)
    //3 3*f(2)
    public static int f(int n){
        if(n==1){
            return  1;
        }else {
            return  n*f(n-1);
        }
​
    }
}

边界条件：边界

前阶段

返回阶段n*(n-1)