java方法学习笔记

一、方法
1.方法的定义格式
修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2…) {
方法体;
return 返回值;
}

    修饰符： public static 
    返回值类型：用于确定方法执行后最终的结果是什么数据类型的
    方法名：自己起，建议见名知意
    参数列表：可有可无(根据实际需求)。
    方法体：方法中要执行的代码
    return: 将结果返回、并且结束方法
    返回值：方法运行后最终的一个结果

2.定义方法技巧
    A：明确返回值类型
    B：明确参数列表

    需求：定义一个获取两个int类型的整数和的方法
    public static int getSum(int num1,int num2) {
        int result = num1 + num2;
        return result;
    }

3.调用
    有返回值类型：

public class Demo01 {
                public static void main(String[] args) {
                    //直接调用   没有意义。因为方法会返回一个结果。但是没有接收
                    //getSum(10,20);

                    //输出调用   可以使用。但是不推荐
                    //System.out.println(getSum(10,20));

                    //赋值调用   推荐的使用方式。接收到了结果，既可以做打印。还可以做其他的操作
                    int sum = getSum(10,20);
                    System.out.println(sum);

                    //其他操作：
                    sum += 20;
                    System.out.println(sum);
                }

                /*
                    需求：定义一个求两个int类型的数字之和方法
                    两个明确：
                        明确返回值类型：int
                        明确参数列表：int num1,int num2
                 */
                public static int getSum(int num1,int num2) {
                    //求和
                    int result = num1 + num2;
                    //将结果返回
                    return result;
                }
            }

    没有返回值类型：

public class Demo02 {
                public static void main(String[] args) {
                    //直接调用     可以使用的方式
                    //print();

                    //输出调用     不支持
                    //System.out.println(print());

                    //赋值调用    不支持
                    //void d = print();
                }

                /*
                    需求：定义一个方法，打印一句话：我爱学习
                    两个明确：
                        明确返回值类型：void
                        明确参数列表：无
                 */
                public static void print() {
                    System.out.println("我爱学习");
                }
            }

4.有返回值类型和没有返回值类型的方法如何区分使用？
    就看方法执行后的结果你还要不要

public class Demo04MethodReturn {
            public static void main(String[] args) {
                // 我是main方法，我来调用你。
                // 我调用你，你来帮我计算一下，算完了之后，把结果告诉我的num变量
                int num = getSum(10, 20);
                System.out.println("返回值是：" + num);
                System.out.println("==============");

                printSum(100, 200);
                System.out.println("==============");
            }

            // 我是一个方法，我负责两个数字相加。
            // 我有返回值int，谁调用我，我就把计算结果告诉谁
            public static int getSum(int a, int b) {
                int result = a + b;
                return result;
            }

            // 我是一个方法，我负责两个数字相加。
            // 我没有返回值，不会把结果告诉任何人，而是我自己进行打印输出。
            public static void printSum(int a, int b) {
                int result = a + b;
                System.out.println("结果是：" + result);
            }
        }

5.对比有参数列表的方法和没有参数列表的方法

public class Demo03MethodParam {
            public static void main(String[] args) {
                method1(10, 20);
                System.out.println("==============");
                method2();
            }

            // 两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
            // 有参数
            public static void method1(int a, int b) {
                int result = a * b;
                System.out.println("结果是：" + result);
            }

            // 例如打印输出固定10次文本字符串
            public static void method2() {
                for (int i = 1; i <= 10; i++) {
                    System.out.println("Hello, World!" + i);
                }
            }
        }

6.如果方法的参数是基本数据类型的情况
    注意：如果方法的参数是基本数据类型,方法中操作的改变。不会影响调用者的参数实际的值

public class Demo04 {
            public static void main(String[] args) {
                /*int num1 = 10;
                int num2 = 20;
                System.out.println("num1:" + num1);   // num1:10
                System.out.println("num2:" + num2);   // num2:20

                change(num1,num2);

                System.out.println("num1:" + num1);   // num1:10
                System.out.println("num2:" + num2);   // num2:20*/

                // String虽然是一个引用数据类型，但是作为方法参数传递的时候。其现象和基本数据类型是一样的
                String s = "abc";
                System.out.println(s);  // abc

                change2(s);

                System.out.println(s);  // abc
            }

            public static void change2(String s) {
                s = s + "123";
                System.out.println(s);  // abc123
            }

            public static void change(int num1,int num2) {
                num1 += 10;
                num2 += 10;

                System.out.println("num1:" + num1); // num1:20
                System.out.println("num2:" + num2); // num2:30
            }
        }

7.方法的练习-比较两个数据是否相同

public class Day04_AM {
            public static void main(String[] args) {
                boolean result = compare(10,10);
                System.out.println(result);
            }

            /*
                需求：定义一个方法，用于比较两个整数是否相同
                两个明确：
                    明确返回值类型：boolean
                    明确参数列表：int,int
             */
            public static boolean compare(int num1,int num2) {
                boolean flag = num1 == num2;
                return flag;
            }
        }

8.方法的练习-求出1--100之间的数字和

public class Demo02MethodSum {

            public static void main(String[] args) {
                System.out.println("结果是：" + getSum());
            }

            /*
            三要素
            返回值：有返回值，计算结果是一个int数字
            方法名称：getSum
            参数列表：数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数
             */
            public static int getSum() {
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }

        }

9.方法的练习-打印指定次数的HelloWorld

public class Demo03MethodPrint {

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

            /*
            三要素
            返回值类型：只是进行一大堆打印操作而已，没有计算，也没有结果要告诉调用处
            方法名称：printCount
            参数列表：到底要打印多少次？必须告诉我，否则我不知道多少次，没法打印。次数：int
             */
            public static void printCount(int num) {
                for (int i = 0; i < num; i++) {
                    System.out.println("Hello, World!" + (i + 1));
                }
            }

        }

10.打印所有的水仙花数和统计水仙花数量

public class Test01 {
            public static void main(String[] args) {
                printFlower();
            }

            /*
                两个明确：
                    明确返回值类型：void
                    明确参数列表：无
             */
            public static void printFlower(){
                //定义一个统计变量
                int count = 0;

                //1.三位数的循环范围
                for(int i = 100; i <= 999; i++) {
                    //2.对数字进行判断
                    int ge = i % 10;
                    int shi = i / 10 % 10;
                    int bai = i / 100 % 10;
                    if((ge*ge*ge + shi*shi*shi + bai*bai*bai) == i) {
                        System.out.println(i);
                        count++;
                    }
                }

                System.out.println("水仙花数一共有：" + count + "个");
            }
        }

10.方法的注意事项和方法的好处
    注意事项：
        1. 方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
        2. 方法定义的前后顺序无所谓。
        3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
        4. 如果方法有返回值类型，那么必须写上“return 返回值;”，不能没有。
        5. return后面的返回值数据类型，必须和方法的返回值类型，对应起来。
        6. 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
        7. 对于void方法当中最后一行的return可以省略不写。
        8. 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
    好处：
        1.提高了代码的复用性
        2.提高了代码的阅读性
        3.由于引入了方法重载的机制，可以让我们少记很多个方法的名称

二、方法的重载
1.什么是方法的重载
方法名相同
参数列表不同：
参数的个数不同
参数的类型不同
参数的顺序不同
与返回值类型无关
与方法参数的名称无关
2.方法重载的练习-判断四种类型的数据是否相同

    public class Demo02MethodOverloadSame {
            public static void main(String[] args) {
                byte a = 10;
                byte b = 20;
                System.out.println(isSame(a, b));

                System.out.println(isSame((short) 20, (short) 20));

                System.out.println(isSame(11, 12));

                System.out.println(isSame(10L, 10L));
            }

            public static boolean isSame(byte a, byte b) {
                System.out.println("两个byte参数的方法执行！");
                boolean same;
                if (a == b) {
                    same = true;
                } else {
                    same = false;
                }
                return same;
            }

            public static boolean isSame(short a, short b) {
                System.out.println("两个short参数的方法执行！");
                boolean same = a == b ? true : false;
                return same;
            }

            public static boolean isSame(int a, int b) {
                System.out.println("两个int参数的方法执行！");
                return a == b;
            }

            public static boolean isSame(long a, long b) {
                System.out.println("两个long参数的方法执行！");
                if (a == b) {
                    return true;
                } else {
                    return false;
                }
            }

        }

3.方法重载的练习-实现打印不同数据类型的方法

public class Demo04OverloadPrint {
            public static void main(String[] args) 
            {
                myPrint(100); // int
                myPrint("Hello"); // String
            }

            public static void myPrint(byte num) 
            {
                System.out.println(num);
            }

            public static void myPrint(short num) 
            {
                System.out.println(num);
            }

            public static void myPrint(int num) {
                System.out.println(num);
            }

            public static void myPrint(long num) {
                System.out.println(num);
            }

            public static void myPrint(float num) {
                System.out.println(num);
            }

            public static void myPrint(double num) {
                System.out.println(num);
            }

            public static void myPrint(char zifu) {
                System.out.println(zifu);
            }

            public static void myPrint(boolean is) {
                System.out.println(is);
            }

            public static void myPrint(String str) {
                System.out.println(str);
            }

        }