Java基础知识之函数以及break和continue关键字的使用

一、break和continue关键字的使用

1.break
应用范围：分支结构【针对switch语句】和循环结构
作用：跳出整个switch语句或者直接跳出整个循环语句，结束循环

//演示break的使用
        for(int i = 0;i < 10;i++) {

            if(i == 5) {
                //直接跳出整个循环，导致循环结束
                break;
            }

            System.out.println(i);
        }


        //需求：实现嵌套for循环
        for(int i = 0;i < 3;i++) {
            for(int j = 0; j < 5;j++) {
                System.out.println("i = " + i + ",j = " + j);
                //默认跳出的是当前的循环：就近原则
                break;
            }
        }


        //标签----主要是相当于给每层循环起一个名字，一般用于多层循环嵌套中，一般结合break使用
        out:for(int i = 0;i < 3;i++) {
            in:for(int j = 0; j < 5;j++) {
                System.out.println("i = " + i + ",j = " + j);
                //表示指明break需要跳出的是外层循环
                break out;
            }
        }
        //i = 0,j = 0

2.continue
应用范围：循环语句
作用：表示结束当前循环，继续下一次循环，并不会结束整个循环

//演示continue的使用
for(int i = 0;i < 10;i++) {

            //当遇到偶数的时候，结束循环，代码不往下继续执行，但是遇到奇数的话，没有任何影响
            if(i % 2 == 0) {
                //结束当前循环，继续下一次循环
                break;
                //continue;
            }

            System.out.println(i);
        }


        for(int i = 0;i < 3;i++) {
            for(int j = 0;j < 5;j++) {
                System.out.println("i = " + i + ",j = " + j);
                //一般会和if语句结合使用
                //continue;
            }

            continue;
        }


        //需求：输出100~200之间能被3整除的数
        for(int i = 100;i <= 200;i++) {
            if(i % 3 == 0) {
                continue;
            }
            System.out.println(i);

        }

总结： a.明确break和continue的应用范围
b.当出现break和continue语句时，他们的后面将不能再出现其他的语句，否则编译不通过
c.break直接结束整个循环，但是continue结束的是当前循环 d.标签的出现，可以让break作用于执行的范围

二、函数

1.什么是函数
对于功能相同的代码，为了简化代码的书写，可以将功能相同的代码提取出来，为了可以方便多次重复使用，在Java中，使用函数【方法】来体现

函数就是对一段具有特殊功能代码段的抽取，又被称为方法

函数存在的意义：提高程序的复用性和可读性

2.函数的声明【定义】

语法
访问权限修饰符     其他修饰符 返回值数据类型 函数名称（参数类型1 参数名称1，参数类型2 参数名称2....）{
    //具有特殊功能的代码段

    return 一个常量或者变量【返回值】；
}

举例：

public static void main(String[] args){

    }

说明：
a.函数的定义包含两部分：声明部分和实现部分
b.目前接触到的访问权限修饰符只有public【公开的】，定义函数都加上public
c.其他的修饰符只有一个static【静态的】要么不写，要么写上
d.返回值数据类型:函数在运行之后所得到的结果，void【空】表示没有返回值
e.函数名称；符合命名规则就可以【小驼峰】，尽量做到顾名思义【函数名称代表了函数所实现的功能】
f.参数列表：如果在抽取函数的时候，涉及到未知项参与运算，未知项就可以被设置为参数
实际参数：【实参】，实际参与运算的数据
形式参数：【形参】，在方法中定义，用于接收实际参数的变量

g.具有特殊功能的代码段:函数体
h.return：结束整个方法
返回值：功能实现之后的结果，由return返回给调用者

3.提取一个函数的注意事项

a.明确实现的功能的结果是什么？【是否需要有返回值---是否需要设置返回值类型】
b.明确是否有未知项参与运算【是否需要设置参数，需要设置几个参数，并且每个参数的类型是什么】

4.函数的调用
如果要使用一个函数中的功能的时候，就需要手动调用这个函数
格式：函数名称（参数）；
如果没有参数，格式：函数名称();

class TestDemo
{
    public static void main(String[] args) 
    {
        //需求：求一个数和80的和
        int a = 10;
        int sum = a + 80;


        int b = 20;
        int sun1 = b + 80;


        int num = 100;
        add(num);

    }

    public static void add(int num) {
        int sum = num + 80;
        System.out.println(sum);
    }



}

注意：
a.main函数作为一个程序的入口，要想自定义的函数被执行，应该在main函数中直接或者间接的进行调用
b.main函数中只能调用其他的函数，不能定义函数
c.在自定义的函数之间也是可以进行相互的调用的，但是在自定义的函数中不能调用main函数

5.函数的调用的时候各个函数的执行顺序
a.JVM首先去调用main函数，所以main函数作为程序的入口函数第一个被执行
b.main函数中的代码从上往下依次执行
c.如果main函数在执行的过程中，遇到了被调用的函数，main函数中的代码会暂停在这个地方，会进入到自定义的函数中，当自定义中的代码执行完成之后，再次返回到原来暂停的地方，接着向下执行

//演示函数的调用的顺序
class FunctionDemo
{
    public static void main(String[] args) 
    {
        //直接
        show1();
    }

    public static void show1() {
        System.out.println("show1方法被调用");

        //间接
        show2();

    }

    public static void show2() {
        System.out.println("show2方法被调用");

        //在自定义的函数中调用main函数，会造成死循环
        //String[] arr= {"32","43"};
        //main(arr);
    }
}

---

class FunctionDemo
{
    public static void main(String[] args) 
    {
        System.out.println("start");

        //直接调用函数
        print();

        System.out.println("end");

    }
    //1.目前定义函数定义在类中，只能与main函数平级
    //2.函数中不能定义函数【函数之间不能嵌套】

    //需求：打印九九乘法表

    /**
    *@function:打印九九乘法表
    *@return :不需要设置返回值
    *@param：不需要设置参数
    */
    public static void print() {
        for(int  i = 1;i <= 9;i++) {
            for(int j = 1;j <= i;j++) {
                System.out.print(j + "x" + i + "=" + i * j + " ");
            }

            System.out.println();
        }
    }
}

6.static修饰一个方法
被static修饰的方法被称为静态方法，反之，被称为非静态方法
main函数本身是一个静态方法

//演示静态和非静态
class FunctionDemo
{
    //非静态全局变量
    int num;
    //静态全局变量
    static String str;


    public static void main(String[] args) 
    {
        //局部变量,必须要有初始值
        int a = 10;

        //结论三：在静态的方法中不能访问非静态全局变量,可以访问静态全局变量
        /*
        //错误演示
        System.out.println(num);
        num = 10;
        System.out.println(num);
        */

        System.out.println(str);//null
        str = "hello";
        System.out.println(str);//hello


        //结论一：在静态方法中只能调用静态方法，不能调用非静态方法
        show();
        //错误: 无法从静态上下文中引用非静态 方法 display()
        //display();
    }

    //静态方法
    public static void show() {
        System.out.println("show");
    }

    //非静态方法
    public void display() {
        System.out.println("display");
    }

    //非静态方法
    public void check() {
        //结论二：在非静态的方法中，既可以调用静态方法，也可以调用非静态方法
        //调用静态方法
        show();
        //调用非静态方法
        display();

        //结论四：在非静态方法中，既可以访问静态全局变量，也可以访问非静态全局变量
        System.out.println(num);
        num = 10;
        System.out.println(num);

        System.out.println(str);
        str = "hello";
        System.out.println(str);
    }
}

穿插：局部变量和全局变量

局部变量:在方法内部或者语句内部定义的变量【局部变量对应的方法或者语句执行结束之后，局部变量会自动被释放从而销毁】

注意：在定义局部变量的时候一定要有初始值

全局变量：直接在类中定义，和函数平级，它在整个类中有效

    注意：全局变量在定义的时候，可以不用赋初始值，在不初始化的情况下，系统会默认给全局变量分配初始值
    分配默认初始值的规则：  
                整型：0
                浮点型：0.0
                char：\u0000【有时是一个空格，有时是方框【口】】
                boolean：false
                引用数据类型：null


静态全局变量:被static修饰的全局变量，本质上还是一个全局变量
非静态全局变量：没有static修饰的全局变量 

7.参数
a.分类：实际参数【实参】和形式参数【形参】
b.在调用函数的时候，实际上是实参给形参赋值的过程，这个过程称为传参
形参其实就是一个变量，实参其实就是一个数值，传参就是把一个数值给一个形参赋值

    传参的时候注意事项：实参的数量和类型必须和形参保持完全的一致【一一对应】

//演示参数的使用
        int num1 = 10;
        int num2 = 20;

        //在函数的功能实现部分，实际参与运算的是形参，不管形参如何变化，对实参没有任何的影响
        exchange(num1,num2);

        System.out.println("main交换结束之后，num1 = " + num1 + ",num2 = " + num2);
    }

    //需求：交换两个变量的值
    /**
    *@param:参与交换的两个变量
    *@return:不需要
    */
    //num1 = 10 num2 = 20
    public static void exchange(int num1,int num2) {
        int temp = num1;
        num1 = num2;
        num2 = temp;

        System.out.println("exchange交换结束之后，num1 = " + num1 + ",num2 = " + num2);

注意：在命名的时候，实参和形参变量名称可以一致【局部变量】

8.方法压栈
栈：是内存中一块空间【理解为一个开口向上的容器】
栈的特点：先进后出，后进先出【举例：羽毛球的筒】

方法的调用的顺序，其实就是方法入栈的过程，当执行完毕之后，会依次出栈

对应的方法当出栈之后，对应的空间就会被释放【在方法中定义的局部变量也被释放】

9.方法的返回值—return
a.方法的返回值指的是一个方法执行完成之后的结果
void：表示返回值为空
使用return返回方法的执行结果，用于结束方法

b.return关键字的使用
1>在没有返回值的方法中使用return
作用：结束整个方法，该方法出栈

//演示return的使用
class ReturnUsageDemo
{
    public static void main(String[] args) 
    {
        show();

        //在调用有返回值的函数时，想要使用返回值，可以用一个变量将结果接出来
        int result = add(3,6);
        System.out.println(result);
        System.out.println(add(10,20));

        //错误: 此处不允许使用 '空' 类型
        //没有返回值的函数，不能直接打印
        //System.out.println(show());


        int result1 = compare(100,200);
        System.out.println(result1);

    }

    //1.没有返回值，但是使用return
    public static void show() {



        for(int i = 0;i < 3;i++) {
            for(int j = 0;j < 5;j++) {
                System.out.println("i =" + i + ",j = " + j);

                //结束方法
                //不管return处于多少层循环之中，只要遇到return语句，都会直接结束整个方法
                return;
                //break;
                //continue;

            }
        }
    }

    //2.有返回值，必须使用return来进行返回
    //需求：求两个数的和
    public static int add(int num1, int num2) {
        int sum = num1 + num2;
        //注意：有返回值的函数中，return后面必须跟一个具体的变量或者常量，而且类型一定要和返回值类型保持一致
        return sum;
    }

    //3.有返回值，而且在方法中有分支结构，那么每一个分支都需要有返回值 
    //需求：比较两个数的大小，返回较大的一个
    public static int compare(int a,int b) {
        if(a > b) {
            return a;
        } else if(a < b) {
            return b;
        } else {
            return a;
        }
    }

}

注意：return后面就不能跟具体的数值，只能return单独使用

2>有返回值，必须使用return来进行返回
    注意：有返回值的函数中，return后面必须跟一个具体的变量或者常量，而且类型一定要和返回值类型保持一致

3>有返回值，而且在方法中有分支结构，那么每一个分支都需要有返回值 

10.递归
概念：在一个方法体中调用方法本身，称为方法的递归
方法递归中其实包含了一种隐式的循环，他会重复的执行某段代码【函数的函数体】，这种重复无须使用循环语句来进行控制

//演示递归
class DiGuiUsageDemo
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");

        //sum(1);
        //sum(10);
        int result = sum(100);
        System.out.println(result);
    }

    //需求：使用递归计算1~某个数之间所有数的和
    /*
    int sum = 0;
    for(int i = 1;i <= 100;i++) {
        sum += i;//sum = sum + i;
    }
    sum = 1;
    sum = 1 + 2;
    sum = 1 + 2 + 3;
    ....
    sum = 1 + 2 + 3 + 4.....+ 100;

    计算1~100之间的和-----》用前99个数的和+ 100
    前99个数的和 ----》前98个数的和 + 99
    前98个数的和 -----》前97个数的和 +98

    sum(100) ----》sum(99) + 100
    sum(99)----》sum(98) + 99

    .....

    sum(n) ----》sum(n - 1) + n
    */
    public static int sum(int n) {
        if(n == 1) {
            return 1;
        } else {
            return sum(n -1) + n;
        }

    }
}

---

class DiGuiUsageDemo02
{
    public static void main(String[] args) 
    {
                    //  1,2,3,4,5,6,7,8,9,10
        //斐波那契数列：1,1,2,3,5,8,13,21,34,55....
        //需求：随便报个数，然后获取对应的值

        /*
        分析：
        1.第一个位置和第二个位置上的数是固定的，是1
        2.第n个位置上的数：第n-1 的数 + n- 2的数

        fun(3) = fun(1) + fun(2); 1 + 1 = 2
        fun(4) = fun(3) + fun(2);
        .....

        fun(9) = fun(8) + fun(7);
        fun(10) = fun(9) + fun(8);

        ......
        fun(n) = fun(n - 1) + fun(n -2);
        */

        int result = fun(6);
        System.out.println(result);

    }

    public static int fun(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }else {

            return fun(n - 1) + fun(n -2);
        }

    }
}