Java重点循环和方法（基础篇day4）

java基础篇三（有趣的代码练习题）

while循环

while是最基本的循环,

语法

while(布尔表达式){

//循环内容

}

• 只要布尔表达式为true,循环就会一直执行下去.

• 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环，不然会产生一些问题.

• 少部分情况需要循环一直执行,比如服务器的请求响应监听等.

• 循环条件一直为true就会造成无限循环 [死循环] , 我们正常的业务编程中应该尽量避免死循环.会影响程序性能或者造成程序卡崩溃!

思考:计算1+2+3+…+100=?

public class WhileDemo01 {
    public static void main(String[] args) {
        //输入1～100

        int i= 0;
        int sum = 0;
        while (i<100){
            i=i+1;
            sum = i+sum;

        }
        System.out.println("1+2+...+99+100"+"之和为"+sum);
    }
}

死循环代码

public class WhileDemo02 {
    //伪代码,等待连接，服务器定时检查等 是一个死循环
    public static void main(String[] args) {
        while (true){

        }
    }
}

do…while 循环

注：对于 while 语句而言,如果不满足条件,则不能进入循环.但有时候我们需要即使不满足条件,也至少执行一次.

do…while 循环和while 循环相似,不同的是,do…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+=i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}

while和do···while区别

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

For循环

• for循环结构更加简单.

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

• for循环执行的次数是再执行前就确定的.

语法

for(初始化;布莱尔表达式;更新){

//代码语句

}

练习1:计算0到100之间的奇数和偶数的和.

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

练习3:打印九九乘法表.

练习1

public class ForDemo02 {
    public static void main(String[] args) {
        // 计算0～100奇数和偶数的和
        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);
    }
}

练习题2

  //1～1000之间能被5整除的数，每行输出三个
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");
            }
            if (i%(5*3)==0){  //换行
                System.out.println();
                //System.out.println("\n");
            }
        }
    }
}

练习题3(for循环嵌套)

public class ForDemo06 {
    public static void main(String[] args) {
        for (int j = 1; j <= 9; j++) {

            for (int i = 1; i <= j; i++) {
                System.out.print(i+"*"+j+"="+(j*i)+"\t");

            }
            System.out.println();
        }

    }
}

增强for循环

• Java5 引入了一种主要用于数组或集合的增强型 for 循环.

语法

for(声明语句: 表达式) {

//代码句子

}

声明语句: 声明新的局部变量, 该变量的类型必须和数组元素的类型匹配.起作用域限定再循环句块,其值与此时数组元素的值相等.

表达式: 表达式是要访问数组名,或者是返回值为数组的方法.

遍历数组

public class ForDemo07 {
    public static void main(String[] args) {
        int[] numbers = {10,10,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);
        }
    }
}

了解goto关键字

goto 关键字很早就在程序设计语言中出现,尽管 goto 认识Java 的一个保留字,但并未在语言中得到正式使用; Java 没有goto,然而,在break 和continue 这连个关键字的身上,我们仍然能看出一些 goto 的影子—带标签的break和 continue.

"标签"是指后面跟一个冒号的标识符,例如: label:

对Java来说唯一用到标签的地方是在循环语句之前.而在循环之前设置标签的唯一理由是: 我们希望在其中嵌套另一个循环,由于break和continue 关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方.

public class labelDemo {
    public static void main(String[] args) {
        //打印101～150之间的质数(只能被1或者自己整除的自然数)
        int count =0;
        outer:for (int i = 101; i < 150; i++) {
            for (int j = 2;j<i/2;j++){
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i+" ");

        }
    }
}

break和continue

• break用于强制跳出循环，不执行后面语句。
• continu用于终止某次循环，并未跳出循环，下一次循环继续执行。

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

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

练习题

打印三角形

public class TextDemo01 {
    public static void main(String[] args) {
        //打印三角形5行三角形
        for (int i = 1; i <= 5; i++) {
            for (int j =5;j>=i;j--){
                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();
        }

    }
}

方法

• Java方法是语句的集合,它们在一起执行一个功能

• 方法是解决一类问题的步骤的有序组合

• 方法包含于类或对象中

• 方法在程序中被创建,在其他地方被引用

设计方法的原则: 方法的基本意是功能块,就是实现某个功能的语句块的集合.我们设计方法的时候,最好保持方法的原子性,就是一个方法只能完成一个功能,这样利于我们后期的扩展.

定义一个add方法：

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) {

        return a+b;
    }
}

方法的定义

语法

修饰符 返回值类型 方法名 (参数类型 参数名){
…
方法体
…
return 返回值;
}

Java的方法类似于其它语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包涵以下语法:

方法包含一个方法头和一个方法体.下面是一个方法的所有部分:

• 修饰符:修饰符,这是可选的,告诉编译器如何调用该方法.定义了该方法的访问类型.

• 返回值类型 : 方法可能会返回值. returnValueType 是方法返回值的数据类型.有些方法执行所需的操作,但没有返回值.在这种情况下,returnValueType 是关键字void.

• 方法名 : 是方法的实际名称.方法名和参数表共同构成方法签名。

• 参数类型 ：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

• 形式参数：在方法被调用时用于接收外界输入的数据。

​ 实参：调用方法时实际传给方法的数据。

• 方法体：方法体包含具体的语句，定义该方法的功能

方法调用

调用方法：对象名.方法名（实参列表）

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

• 当方法返回一个值的时候，方法调用通常被当做一个值。例如：

​ int larger = max (30,40);

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

​ System.out.println(“Hello,Leeonyang!”);

注：值传递（Java） 和 引用传递。

public class Demo03 {
    public static void main(String[] args) {
       int max =max(10,10);
        System.out.println(max);
        int js = jo();
        int os = jo();
       // Demo01.jo(obj.oddsum);
        //Demo01.jo(obj.evensum);

        System.out.println(js);
        System.out.println(os);
    }
    //比大小的方法
    public static int max(int num1,int num2){
        int result = 0;
        if (num1>num2){
            result=num1;
        }else if (num1==num2){
            System.out.println("num1==num2");
            return 0;  //return的另一个左右终止方法
        }else {
            result = num2;
        }
        return result;
    }
    public  static int jo(){
        int oddsum = 0;
        int evensum = 0;
        for (int i = 0; i <=100; i++) {
            if(i%2!=0){ //判断奇数
                oddsum+=i;
            }else {  //偶数
                evensum+=i;
            }
        }
        return oddsum;
    }
}

方法的重载

定义：重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法重载的规则：

• 方法名必须相同。

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

• 方法的返回类型可以相同也可以不相同。

• 仅仅返回类型不同不足以称为方法的重载。

实现理论：

方法名相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

例子：

public class Demo04 {
    public static void main(String[] args) {
        //方法的重载
       double max =max(11.1,12.1) ;
       int i =max(10,20);
        System.out.println(max);
        System.out.println(i);
    }
    public static double max(double num1,double num2) {
        double result = 0;
        if (num1 > num2) {
            result = num1;
        } else if (num1 == num2) {
            System.out.println("num1==num2");
            return 0;  //return的另一个左右终止方法
        } else {
            result = num2;
        }
        return result;
    }

    public static int max(int num1,int num2){
            int result = 0;
            if (num1 > num2) {
                result = num1;
            } else if (num1 == num2) {
                System.out.println("num1==num2");
                return 0;  //return的另一个左右终止方法
            } else {
                result = num2;
            }
            return result;
        }
}

命令行传参（了解）

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

public class Demo03 {
    public static void main(String[] args) {
        //args.length 数组长度
        for (int i = 0; i< args.length;i++){
            System.out.println("args[" + i +"]:" + args[i]);
        }
    }
}

可变参数

• JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

• 在方法声明中，在指定参数类型后加一个省略号（…）例如：(int… i)

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

例子：

public class Demo06 {
    public static void main(String[] args) {
       Demo06 demo06 = new Demo06();
       demo06.text(1,3,6,6,7,4,5,97);
    }

    public static void text(int... i) {   //可变参数的用法
        System.out.println(i[0]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
        System.out.println(i[6]);
    }
}

递归

定义：递归就是：A方法调用A方法！就是自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象无限集合。

递归结构包括两个部分：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

• 递归体：什么时候需要调用自身方法。

练习题：利用递归思想计算阶乘

import java.util.Scanner;

public class Demo08 {
    //2! 2*2  3！ 3*2*1  4 4*3*2*1 阶乘
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int str =scanner.nextInt();
        System.out.println(f(str));
    }
    public static int f(int n){
        if (n==1){
            return 1 ;
        }else {
            return n*f(n-1); //递归调用方法f,调用自己
        }
    }
}

作业

写一个计算机，要求可以实现加减乘除，并且能够循环接收数据。

推荐方法：

• 写四个方法
• 利用循环+switch进行交互
• 传递需要操作的两个数
• 输出结果