JAVA学习内容

return关键字

return关键字表示结束方法 并且 返回内容

方法返回值的位置 可以写任何的数据类型 八种基本数据类型 或者 引用数据类型

总结：你需要当前方法执行完以后返回什么数据 那么就定义什么返回值类型即可

只要方法声明返回值不是void 那么必须在方法体中使用return关键字返回对应的结果

如果返回值声明是void 也可以使用return 此时return只表示结束方法 不能返回内容

return 之后的数据 必须 和方法声明返回值的类型相匹配

return关键字返回结果情况1：返回值类型不是void 使用return返回结果

	public class TestReturnedValue {
    public static void addition(int a, int b) {
        System.out.println("a与b之和是：" + (a + b));
    }

    public static int add(int a, int b) {
        System.out.println("有返回值的add方法获取最终的和：" + (a + b));
        return a + b;
    }


    public static void main(String[] args) {
        addition(12321320, 23213211);

        // 从第18行代码开始 需要获取到之前代码的数据 两段代码之间需要一个数据 实现逻辑连接
        int result = 31;

        System.out.println(result % 2 == 0 ? "偶数" : "奇数");

        System.out.println("----------------------------------------------------");

        int sum = add(11, 21);

        System.out.println(sum  % 2 == 0 ? "偶数" : "奇数");

    }


}

return关键字返回结果情况2：

在分支结构中使用return返回结果 那么必须保证每一条分支都有正确的返回值

需求：编写方法根据用户传入的整数判断是奇数还是偶数

	public class TestReturnedValue1 {
    public static String isEven(int num){
        if(num % 2 == 0){
            // 偶数
            return "偶数";
        }else{
            // 奇数
            return "奇数";
        }
    }

    public static boolean isEvenWithNumber(int number){
        if(number % 2 == 0){
            return true;
        }else{
            return false;
        }
    }



    public static void main(String[] args) {
        String result = isEven(12);
        System.out.println("result = " + result);

        System.out.println("--------------------------------------------");

        System.out.println(isEven(666));

        System.out.println("--------------------------------------------");

        boolean flag = isEvenWithNumber(111);

        System.out.println(flag == true ? "偶数" : "奇数");




    }


}

return关键字返回结果情况3：在返回值类型为void的方法中 也可以使用return 此时只表示结束方法 不能返回内容

	public class TestNoReturnedValue {
    public static void m1(){
        for(int i = 1;i <= 10;i++){
            if(i == 5){
                return; // 注意和break的区别
            }
            System.out.println("i = " + i);
        }

        System.out.println("m1 方法执行完毕");
    }

    public static void main(String[] args) {
        m1();
    }




}

多级调用

方法多级调用：静态方法与静态方法之间可以互相直接调用，遇到调用方法的代码 会先将方法内的代码执行完毕 再继续向下执行

	public class TestMethodInvoke {
    public static void m1(){
        System.out.println("m1 method start");
        m2();
        System.out.println("m1 method end");
    }

    public static void m2() {
        System.out.println("m2 method start");
        System.out.println("m2 method end");
    }

    public static void main(String[] args) {
        m1();
    }


}

方法重载

方法重载：同一个类中的方法 名称相同 参数列表不同(参数的个数、类型、顺序至少有一个)

即可称之为方法重载 跟返回值 以及 访问权限修饰符无关

好处：屏蔽使用差异 统一程序结构 灵活 方便

需求：编写方法实现加法计算器

	public class TestMethodOverload {
    public static void add(int a,int b){
        System.out.println( a + b);
    }

    public static void add(int a,String b){
        System.out.println( a + b);
    }

    public static void add(String b,int a){
        System.out.println( a + b);
    }
    public static void main(String[] args) {
        add(100, 200,30,55,66);

        add(10,20);
        add(10,"20");
        add("20",10);
    }

    public static int add(int a,int b,int c){
        return a + b + c;
    }

    public static double add(int a,int b,int c,int d){
        return a + b + c + d;
    }

    public static void add(int a,int b,int c,int d,int e){
        System.out.println(a + b + c + d + e);
    }
    // ……

}

递归

递归：可以简单的理解为自己调自己

递归：递进和回归

递归的两个前提：

1.有一个大的问题 可以拆分为若干个小的问题(递进)

2.必须有正确的出口(回归)

	public class TestRecursion {
    public static void m1(){
        m1();
    }

    public static int getNum5(int num){
        return num + getNum4(num - 1);
    }
    public static int getNum4(int num){
        return num + getNum3(num -1);
    }
    public static int getNum3(int num){
        return num + getNum2(num -1);
    }
    public static int getNum2(int num){
        return num + getNum1(num -1);
    }
    public static int getNum1(int num){
        return num;
    }


    public static int getNum(int num){
        if(num == 1){
            return 1;
        }
        return num + getNum(num -1);
    }

    public static int getFactorial(int num){
        if(num == 1){
            return 1;
        }
        return num * getFactorial(num -1);
    }




    public static void main(String[] args) {
        System.out.println(getNum5(5));

        System.out.println(getNum(11));

        System.out.println(getFactorial(5));
    }
}

数组的概念

概念：一组连续的存储空间，存储多个相同数据类型的值，长度是固定的。

数组的定义

先声明、再分配空间：
数据类型[] 数组名;
数组名 = new 数据类型[长度];

声明并分配空间：
数据类型[] 数组名 = new 数据类型[长度];

声明并赋值（繁）：
数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,…};

声明并赋值（简）：
数据类型[] 数组名 = {value1,value2,value3,…};

	public class TestArrayDefine {
    public static void main(String args []) {
        // 方式1 先声明 再开辟空间
        int [] arr1;
        arr1 = new int[3];

        // 方式2 声明并且开辟空间
        int [] arr2  = new int[5];

        // 方式3 声明并且赋值 (繁琐)
        int [] arr3 = new int[]{1,3,5,8,9,6,55,22};

        // 方式4 声明并且赋值 简单
        int [] arr4 = {89,55,666,999,120,352};
    }
}