java怎么实现环绕通知 java循环跳转语句

4-java学习-循环语句、控制跳转语句、方法-案例代码

一、for循环语句

1.用for循环语句在控制台输出10次"北冥有鱼"

public class MyTest {
    public static void main(String[] args) {
        // 1. int i=0; 循环的起始值 只执行一次
        // 2. i<10 循环是否继续执行的条件 i<10 是true 循环执行 是 false 循环结束
        // 3. {System.out.println("我爱你们");}  {} 大括号里面的代码就是循环体，需要重复执行的代码，就放到循环体里面
        //4. i++ 控制循环的语句 每循环一次 i自增1
        for(int i=0;i<10;i++){
            System.out.println("北冥有鱼");
        }
    }
}

2.用for循环语句在控制台输出数据1 - 10、10 - 1

public class MyTest2 {
    public static void main(String[] args) {
       //请在控制台输出数据1 - 10
       for(int i=1;i<=10;i++){
           System.out.println(i);
       }
        System.out.println("-----------------------------");
        //请在控制台输出数据10 - 1
       for(int i=10;i>=1;i--){
           System.out.println(i);
       }
    }
}

3.用for循环语句求出1 - 10 之间数据之和

public class MyTest3 {
    public static void main(String[] args) {
        int sum = 0; //定义一个变量，用来接收结果
        for (int i = 1; i <= 10; i++) {
            sum = sum + i;
        }
        System.out.println("和是" + sum);
    }
}

4.用for循环语句求1—100之间的奇数和 和 偶数和

public class MyTest4 {
    public static void main(String[] args) {
        int sum=0; //定义一个变量来接收最后的结果
        int ou=0;
        int ji=0;
        for (int i=1;i<=100;i++){
            sum=sum+i;
            if(i%2==0){//是偶数
                ou=ou+i;
            }else{
                ji=ji+i;
            }
        }
        System.out.println("和是"+sum);
        System.out.println("奇数和是" + ji);
        System.out.println("偶数和是" + ou);
    }
}

5.用for循环语句在控制台输出所有的”水仙花数”(水仙花数是指一个三位数，其各位数字的立方和等于该数本身。)

public class MyTest {
    public static void main(String[] args) {
        //定义一个统计变量
        int count=0;
        for(int i=100;i<=999;i++){
            int ge=i/1%10;
            int shi=i/10%10;
            int bai=i/100%10;
            int flowerNum=ge*ge*ge+shi*shi*shi+bai*bai*bai;
            if(i==flowerNum){
                System.out.println("水仙花数是"+i);
                count++;
            }
        }
        System.out.println("水仙花数有"+count+"个");
    }
}

6.用for循环语句输出一个4行5列的星星( *)图案

public class MyTest {
    public static void main(String[] args) {
        /*
        如图：
		*****
		*****
		*****
		*****
		*/
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*"); //打印不换行
            }
            System.out.println();//只是为了换行
        }
        //两层循环的嵌套特点：1.外层循环控制的是行数 2.内层循环控制列数
    }
}

7.用for循环语句输出三角形状

public class MyTest2 {
    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();
        }
    }
}

8.用for循环语句打印九九乘法表

public class MyTest3 {
    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");
            // \t 转义字符 空一格 table位
            }
            System.out.print("\n"); // \n 转义字符 \n 也可换行
        }
    }
}

二、while循环语句

1.用while循环语句在控制台输出数据1 - 10、10 - 1

public class MyTest3 {
    public static void main(String[] args) {
        //while
        //输出1---10
        int i = 1;
        while (i <= 10) { 
            System.out.println(i);
            i++;
        }
        System.out.println("-------------------");
        int j = 10;
        while (j >= 1) {
            System.out.println(j);
            j--;
        }
    }
}

2.用while循环语句求1—100之间的奇数和 和 偶数和

public class MyTest4 {
    public static void main(String[] args) {
        int ou = 0;
        int ji = 0;
        int i = 1;
        while (i <= 100) {
            if (i % 2 == 1) {
                ji += i;
            } else {
                ou += i;
            }
            i++;
        }
        System.out.println("奇数和"+ji);
        System.out.println("偶数和" + ji);
    }
}

3.用while循环语句在控制台输出所有的”水仙花数”(水仙花数是指一个三位数，其各位数字的立方和等于该数本身。)

public class MyTest5 {
    public static void main(String[] args) {
        int i=100;
        int count=0;
        while (i<1000){
            int ge = i / 1 % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            int flowerNum = ge * ge * ge + shi * shi * shi + bai * bai * bai;
            if (i == flowerNum) {
                System.out.println("水仙花数是" + i);
                count++;
            }
            i++;
        }
        System.out.println("水仙花数有" + count + "个");
    }
}

三、do…while循环语句

1.用do…while循环语句在控制台输出10次"北冥有鱼"

public class MyTest {
    public static void main(String[] args) {
        //do{循环体} while(条件)
        //先执行do里面的代码一次，然后去判断条件是否成立，如果成立就继续循环，如果不成立，循环结束
        int i = 1;
        do {
            System.out.println("北冥有鱼");
            i++;
        } while (i < 10);
        // 你知道循环次数一般选for
        // 你不知道循环次数选while循环，但是你要知道循环的结束条件
    }
}

四、控制跳转语句

1. break:用在switch语句或循环语句中，离开这个场景没有意义

用在用在switch语句,用来结束switch语句,用在循环语句是结束循环的

public class MyTest {
    public static void main(String[] args) {
        for (int i = 0; i <10; i++) {
            System.out.println("北冥有鱼");
            if(i==4){
               break; //结束这个循环语句
            }
        }
        System.out.println("-------------------------------");
        int j=1;
        while (true){
            if(j>10){
               break;
            }
            System.out.println("11");
            j++;
        }
        System.out.println("22");
    }
}

运行结果：

2. continue:用在循环语句中，用来跳出一次循环，继续下次循环 用在循环场景中，离开循环场景没有意义

public class MyTest2 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if(i==5){
                continue;
            }
           System.out.println(i);
        }

        System.out.println("------------------------");
        for (int i = 1; i <= 10; i++) {
            if (i%2==1) {
                continue;
            }
            System.out.println(i);
        }
    }
}

运行结果：
1
2
3
4
6
7
8
9
10
------------------------
2
4
6
8
10

3. break 加在哪层循环，那么结束的就是哪层循环,如果有多层循环嵌套，我们可以给循环加个标记，然后可以根据标去结束某个循环

public class MyTest3 {
    public static void main(String[] args) {
        wc:for (int i = 0; i < 5; i++) {
            nc:for (int j = 0; j < 5; j++) {
                if(j==2){
                  break wc; //根据标记去结束哪层循环
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

4.在控制台输出2次:“北冥有鱼“

public class MyTest4 {
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
                break;
            }
            System.out.println("北冥有鱼");
        }
    }
}

5.在控制台输出7次:“北冥有鱼“

public class MyTest4 {
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
                continue;
            }
            System.out.println("北冥有鱼");
        }
    }
}

6.在控制台输出13次:“北冥有鱼“

public class MyTest4 {
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
            }
            System.out.println("北冥有鱼");
            continue;
        }
    }
}

五、方法

1.方法：对一段功能代码的封装，以实现多次调用，提高代码的复用性

方法定义的语法:
1.方法定义在类中
2.方法跟方法是平级关系，不能嵌套定义
3.方法的语法：权限修饰符 状态修饰符 返回值类型 方法名(参数类型 参数名){ 方法体 }
4.方法不调用不执行

public class MyTest {
    //主方法 是程序的入口。JVM来调用的
    public static void main(String[] args) {
        System.out.println("主方法调用了");
        //main方法由JVM 调用，我们可以在main方法中，调用我们自己定义的方法
        //通过方法名 调用方法执行
        sendBullet();
        sendBullet();
        sendBullet();
        sendBullet();
        sendBullet();
        sendBullet();
        sendBullet();
    }
    public static void sendBullet(){
        //发射子弹的功能
        System.out.println("发射子弹");
    }
}

2.调用有参数的方法时，必须对应形参的类型和个数一一传入与形参类型对应的参数，那么传入的参数，我们叫做实际参数，简称实参，这个方法如果有返回值，我们可以接收这个返回值，方法返回什么类型，你就用什么类型收

public class MyTest2 {
    public static void main(String[] args) {
        //调用我们自己的方法
       add();
       int result= add2();
        System.out.println(result);
        
        System.out.println("===================");
        //调用有参数的方法
        int sum2=add3(5,9);
        System.out.println(sum2);

        int sum3=add3(50,50);
        System.out.println(sum3);

        System.out.println("====================");
        double sum4= add3(2,3.4,20);
        System.out.println(sum4);
        return;
    }
    //无参数，无返回值
    //void 表示无明确类型的返回值
    public static void add(){
        int num1=10;
        int num2=20;
        int sum=num1+num2;
        System.out.println(sum);
        return; //结束方法，方法上是void 那么return可以省略不写
    }
    //无参有返回值 一旦一个方法明确返回值类型。就必须由return 关键字 带回一个与返回值类型一致的结果
    public static int add2(){
        int num1 = 10;
        int num2 = 20;
        int sum = num1 + num2;
        return sum;  //return 结束方法，并返回结果
    }
    //有参有返回值的方法
    public static int add3(int a,int b){
        int sum=a+b;
        return sum;
    }
    //方法括号中定义的参数，叫做形式参数，简称形参 多个形参你用逗号隔开
    public static double add3(double a, double b,int c) {
        double sum=a+b+c;
        return sum;
    }
    public static void add4(double a, double b, int c) {
        double sum = a + b + c;
        return;
    }
}

3.调用 一个方法，求两个数的最大值

定义方法时得明确两个东西：

1.方法要不要参数以及参数的类型和个数，

2.方法要不要返回值。

public class MyTest3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        //alt+Enter 万能神键
        int a = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int b = scanner.nextInt();
        int max= getMax(a,b);
        System.out.println("最大值是"+max);
    }
    public static int getMax(int num1,int num2){
        int max=0;
        if(num1>=num2){
            max=num1;
        }else{
            max=num2;
        }
        return max;
    }
}

4.调用 一个方法，判断两个数是否相等

public class MyTest4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int a = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int b = scanner.nextInt();
        
        //返回值 boolean
        boolean equals = isEquals(a, b);
        if(equals){
            System.out.println("相等");
        }else{
            System.out.println("不相等");
        }
    }

    public static boolean isEquals(int a,int b){
       // boolean  flag=a==b?true:false;
        return a==b;
    }
}

5.调用 一个方法，求两个数之和

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

      //这个方法由返回值，就可以输出调用
        System.out.println(add(30,60));
    }
    public static int add(int a,int b){
        return a+b;
    }
}

6.调用 一个方法，打印星型,行数和列数让用户输入

public class MyTest6 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数");
        int hs = scanner.nextInt();
        System.out.println("请输入列数");
        int ls = scanner.nextInt();
        //定义方法：参数 参数类型 几个参数  返回值 返回类型
        //调用方法
        showStar(hs,ls);
    }
    public static void showStar(int a,int b){
        for (int i = 1; i <= a; i++) {
            for (int j = 1; j <= b; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

7.方法重载：允许一个类中，存在多个同名方法，只要他们的形参个数或形参类型不同即可,注意不拿返回值类型来区分

public class MyTest {
    public static void main(String[] args) {
        double sum1 = add(1, 2.0);
        int sum2 = add(1,2, 3);
        int sum3 = add(1, 2, 3, 4);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
    }
   public static int add(int a, int b) {
        System.out.println("两个int调用了");
        return a + b;
    }
    public static double add(int a, double b) {
        System.out.println("一个int调用了，一个double调用了");
        return a + b;
    }
    public static int add(int a, int b,int c) {
        return a + b+c;
    }
    public static int add(int a, int b, int c,int d) {
        return a + b + c+d;
    }
}