Java学习笔记2024/2/3

Angus1648

已于 2024-02-04 02:11:43 修改

阅读量432

点赞数 8

文章标签： java 学习笔记

于 2024-02-04 02:10:59 首次发布

本文链接：https://blog.csdn.net/2201_75933645/article/details/136018901

版权

1. 方法

1.1 什么是方法

package com.angus.method.whatIsTheMethod_1;

public class note {
    public static void main(String[] args) {
        //什么是方法
        //方法是程序当中最小的执行单元

        //调用方法和使用数组很类似
        //方法->方法名
        //数组->数组名->地址值

        //什么时候用到方法
        //重复的代码,具有独立功能的代码可以抽取到方法当中

        //方法有什么好处
        //可以提高代码的复用性
        //可以提高代码的可维护性

        System.out.println("^^");
    }
}

1.2 方法的格式

package com.angus.method.theFormatOfTheMethod_2;

public class note {
    public static void main(String[] args) {
        //关于方法的格式只要学习两点
        //如何打包
        //打包好后如何调用

        //方法定义
        //把一些代码打包在一起,该过程称为方法定义

        //方法调用
        //方法定义后并不是直接运行的,需要手动调用才能执行,
        //该过程称为方法调用

        //方法的定义格式
        //分为三种解析
        //最后一种可操作性最高,也是方法最完整的定义格式

        //第一种
        //最简单的方法定义和调用

        //方法定义

        //格式:
        //public static Void 方法名(){
        //    方法体(就是打包起来的代码);
        //}

        //范例:
        //public static Void playGame(){
        //    七个打印语句;
        //}

        //方法调用

        //格式:
        //方法名();

        //范例:
        //playGame();

        //注意:方法必须先定义后调用,否则程序将报错

        //看代码
        //看到方法进入方法
        //执行完毕后回到调用处

        //第二种
        //带参数的方法定义和调用
        //一个参数的定义和调用

        //public static void 方法名(参数){...}
        //public static void method(int number){...}

        //方法名(参数);
        //method();
        //method(变量);

        //多个参数
        //public static void 方法名(参数1,参数2,...){...}
        //public static void method(int number1,int number2,...){...}

        //方法名(参数1,参数2,...);
        //getSun(10,20);
        //getSun(变量1,变量2);

        //注意:方法调用时,参数的数量与类型必须与方法定义中
        //小括号里面的变量一一对应,否则程序将报错

        //形参和实参
        //形参:
        //全称为形式参数,是指方法定义中的参数
        //实参:
        //全称为实际参数,是指方法调用中的参数
        //注意:方法调用时,形参和实参必须一一对应,否则程序将报错

        //方法定义的小技巧
        //1.我要干啥? ->方法体
        //2.我干这件事情需要啥才能完成? ->形参

        //第三种
        //带返回值方法的定义和调用

        //方法的返回值其实就是方法运行的最终结果

        //如果在调用处要根据方法的结果,去编写另外一段代码逻辑
        //为了在调用处拿到方法产生的结果,就需要定义带有返回值的方法

        //定义

        //格式:
        //public static 返回值类型 方法名(参数){
        //方法体;
        //return 返回值;
        // }

        //范例:
        //public static int getSum(int a, int b){
        // int c = a + b;
        // return c;
        // }

        //调用

        //直接调用: ->一般用于没有返回值类型的
        //方法名(实参);

        //赋值调用: ->最常用
        //整数类型 变量名 = 方法名(实参);

        //输出调用:
        //System.out.println(方法名(实参));

        System.out.println("^^");
    }
}

package com.angus.method.theFormatOfTheMethod_2;

public class demo1 {
    public static void main(String[] args) {
        //最简单的方法定义和调用格式

        playGame();

        System.out.println("^^");
    }
    public static void playGame(){
        System.out.println("afa");
        System.out.println("acaca");
        System.out.println("阿拉敖灿哦");
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class demo2 {
    public static void main(String[] args) {
        GFinfo();

        System.out.println("^^");
    }
    public static void GFinfo(){
        System.out.println("小美");
        System.out.println("1.63");
        System.out.println("萌妹子");
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class demo3 {
    public static void main(String[] args) {
        qiuHe();

        System.out.println("^^");
    }
    public static void qiuHe() {
        int a = 10;
        int b = 10;
        int sum = a + b;
        System.out.println(sum);
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class demo4 {
    public static void main(String[] args) {
        getSum(10,20);

        System.out.println("^^");
    }
    public static void getSum(int a, int b) {
        int sum = a + b;
        System.out.println(sum);
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class demo5 {
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义和调用格式

        //直接调用 ->一般不用于返回值的调用
        getSum(1,1,1);

        //赋值调用
        int sum =getSum(1,1,1);
        System.out.println(sum);

        //输出调用
        System.out.println(getSum(1,1,1));

        System.out.println("^^");
    }
    public static int getSum(int num1,int num2,int num3){
        int re = num1 + num2 + num3;
        return re;
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class demo6 {
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义和调用格式

        //计算全年的总营业额
        int sum1 = getSum(1,1,1);
        int sum2 = getSum(2,2,2);
        int sum3 = getSum(3,3,3);
        int sum4 = getSum(4,4,4);
        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum);

        System.out.println("^^");
    }
    public static int getSum(int num1,int num2,int num3){
        int re = num1 + num2 + num3;
        return re;
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class test1 {
    public static void main(String[] args) {
        //需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。
        c(1,1);

        System.out.println("^^");
    }

    //我要干甚么? 求长方形的周长
    //需要啥完成它? 长和宽

    public static void c(int a, int b) {
        int C = (a + b) * 2;

        System.out.println(C);
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class test2 {
    public static void main(String[] args) {
        //需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
        //目标：根据不同的需求，选择定义无参的方法，还是带参数的方法 -> 带参
        getS(3);

        System.out.println("^^");
    }

    public static void getS(double r) {
        double S = r * r * 3.14;
        System.out.println(S);
    }

}

package com.angus.method.theFormatOfTheMethod_2;

public class test3 {
    public static void main(String[] args) {
        //目标：要能区分出什么时候使用带返回值的方法 ->要在调用处用到返回值的时候
        //需求：定义方法，比较两个长方形的面积

        double S1 = getArea(1,1);
        double S2 = getArea(2,2);

        if (S1 > S2){
            System.out.println("第一个面积大");;
        } else {
            System.out.println("第二个面积大");;
        }

        System.out.println("^^");
    }

    public static double getArea(double length,double width) {
        double area = length * width ;
        return area;
    }

}

1.3 方法的重载

package com.angus.method.overloadingOfMethod_3;

public class note {
    public static void main(String[] args) {
        // 方法的重载
        //
        // 在同一个类中,定义了多个同名的方法,这些同名的方法具有同种的功能
        // 每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系
        //
        // 简单记:
        // 就是看是不是在同一个类中,方法名是不是相同,形参是不是不同,不看返回值
        // 形参不同有哪些不同:个数,类型,顺序(不建议用)
        
        System.out.println("^^");
    }
}

package com.angus.method.overloadingOfMethod_3;

public class test1 {
    public static void main(String[] args) {
        long num1 = getNum(1);
        int num2 = getNum(2);

        if (num2 == num1) {
            System.out.println("相等");
        } else {
            System.out.println("不相等");
        }

        System.out.println("^^");
    }

    public static long getNum(long num) {

        return num;
    }
    public static int getNum(int num) {

        return num;
    }
    public static short getNum(short num) {

        return num;
    }
    public static byte getNum(byte num) {

        return num;
    }

}

package com.angus.method.overloadingOfMethod_3;

public class test2 {
    public static void main(String[] args) {
        com((byte)1,(byte)2);
        com((short)2,(short)3);
        com(3,4);
        com(56464646464464166L,6841864164164164189L);

        byte a = 1;
        byte b = 1;
        com(a,b);

        byte b1 = 5;
        byte b2 = 5;
        com(b1,b2);

        int c = 2;
        int d = 2;
        com(c,d);

        System.out.println("^^");
    }

    //方法重载的好处
    //1.一个单词就可以干很多事情
    //2.调用方法变得非常容易

    public static void com(byte b1,byte b2) {
        System.out.println("byte");
        System.out.println(b1 == b2);
    }

    public static void com(short s1,short s2) {
        System.out.println("short");
        System.out.println(s1 == s2);
    }

    public static void com(int i1,int i2) {
        System.out.println("int");
        System.out.println(i1 == i2);
    }

    public static void com(long n1,long n2) {
        System.out.println("long");
        System.out.println(n1 == n2);
    }

}

package com.angus.method.overloadingOfMethod_3;

public class test3 {
    public static void main(String[] args) {
        //需求:设计一个方法用于数组遍历,要求遍历的结果是在一行上的,例如:[1,2,3,4,5]

        int arr[] = {1,2,3,4,5};

        getArr(arr); //把数组名放进去,要记住方法名+数组名才可以调用

        System.out.println(); //只做换行处理,换行了下面的才不会接着
        System.out.println("^^");
    }
    public static void getArr(int arr[]){ // (int类型 数组名[]) ,要记住数据类型+变量名/数组名[],调用时变量直接写数值,数组写数组名,不绝对哈,这只是目前的领悟

        System.out.print("["); //->不换行,下面的才会接着
        for (int i = 0; i < arr.length; i++) {

            if ( i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.print("]"); //->上一个不换行,自己才能接着

    }

}

package com.angus.method.overloadingOfMethod_3;

public class test4 {
    public static void main(String[] args) {
        //设计一个方法求数组的最大值,并将最大值值返回
        int arr[] = {1,5,6,7,2,4,6,9};

        int max = getMax(arr);
        System.out.println(max);

        System.out.println("^^");
    }

    public static int getMax(int[] arr) {
        int max = arr[0];

        for (int i = 1; i < arr.length; i++) {

            if (arr[i] > max) {
                max = arr[i];
            }

        }
        return  max;

    }

}

package com.angus.method.overloadingOfMethod_3;

public class test5 {
    public static void main(String[] args) {
        //定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处
        int arr[] = {1,2,3,4,5,6,7,8,9};
        boolean pan = pan(arr,9);
        System.out.println(pan);

        System.out.println("^^");
    }

    //1.干啥 -> 定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处
    //2.怎么干,需要啥 -> 数组,某一个数
    //3.返否 -> 返,因为判断

    public static boolean pan(int arr[], int num) {


        for (int i = 0; i < arr.length; i++) {

            if (arr[i] == num) {
                return true;
            }

        }
        return false;
    }





}
//return结束方法并返回结果
//break结束循环或者switch

package com.angus.method.overloadingOfMethod_3;

public class test6 {
    public static void main(String[] args) {
        //复制数组
        //需求: 定义一个方法copyOfRange(int[] arr,int from,int to)
        //功能: 将索引arr中从索引from(包含from)开始,
        //到索引to结束(不包含to)的元素复制到新数组中,
        //将新数组返回

        //老数组
        int arr[] = {1,2,3,4,5,6,7,8,9};

        //返回,又得定义一个新数组
        int newArr2[] = copyOfRange(arr,3,7);
        //遍历
        for (int i = 0; i < newArr2.length; i++) {
            System.out.print(newArr2[i] + " "); //下次注意,打印的是元素newArr2[i],不是索引i
        }

        System.out.println();
        System.out.println("^^");
    }

    public static int[] copyOfRange(int[] arr,int from,int to) {
        //index自增,伪造索引思想
        int index = 0;
        //新数组
        int newArr1[] = new int[to - from];
        for (int i = from; i < to; i++) { //遍历的话,不是谁固定遍历,而是只要有循环都可以遍历,所以数组赋值给数组的操作才能进行 -> test6_6演示
            //老数组复制给新数组
            newArr1[index] = arr[i];
            index++;
        }
        //返回
        return newArr1;

    }

}

package com.angus.method.overloadingOfMethod_3;

public class test6_6 {
    public static void main(String[] args) {
        int arr[] = {1,2,3};
        int brr[] = {4,5,6};
        for (int i = 0; i < arr.length; i++) {

            System.out.println(arr[i]);
            System.out.println(brr[i]);

        }

        System.out.println("^^");
    }
}

未完待续...