05. 【方法】

最新推荐文章于 2022-09-28 21:44:35 发布

LiuszZZ

最新推荐文章于 2022-09-28 21:44:35 发布

阅读量185

点赞数

分类专栏： # Dark horse 文章标签： java

原文链接：http://www.itheima.com/

版权

Dark horse 专栏收录该内容

89 篇文章 0 订阅

订阅专栏

概念

基本格式

方法名称命名规则：和变量一样，使用小驼峰。

方法体：也就是大括号当中可以包含任意条语句。

public static void 方法名称() {
	方法体
}

注意事项

方法定义的先后顺序无所谓。
方法的定义不能产生嵌套包含关系。
方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用。

调用方法格式

方法名称();

代码：

运行的不是HelloWorld.java 是HelloWorld.class

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello,World!!");
    }
}

完整格式

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

参数

修饰符：现阶段固定写法：public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型（参数其实就是个变量）
参数名称：进入方法的数据对应的变量名称
参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事情，若干行代码
return:两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果

方法的三种调用

单独调用：方法名称(参数);
打印调用
赋值调用

在这里插入图片描述

注意事项

return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应

/*
    方法的定义格式

    方法其实就是若干语句的功能集合

    方法好比是一个工厂
    蒙牛工厂    原料：奶牛、饲料、水
           产出物：奶制品
    钢铁工厂    原料：铁矿石、煤炭
           产出物：钢铁建材

    参数 (原料)：就是进入方法的数据。
    返回值(产出物): 就是从方法中出来的数据。

    定义一个两个int数字相加的方法。三要素：
        返回值类型：int
        方法名称：sum
        参数列表：int a, int b
 */

public class Demo02MethodDefine {

    public static void main(String[] args) {

        // 单独调用
        sum(10,20);

        // 打印调用
         // 输出语句先去调用方法，把方法最终的返回值打印输出
        System.out.println("两数和为：" + sum(50,40));

        // 赋值调用
        int num = sum(2,5);
        num += 100;
        System.out.println("两数和为：" + num);
    }

    public static int sum(int a, int b) {
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }
}

结果：

方法执行啦！
方法执行啦！
两数和为：90
方法执行啦！
两数和为：107

对比有参数和无参数

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。

例如：两个数字相加，必须知道两个数字各是多少，才能相加。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数.

例如：定义一个方法，打印固定10次HelloWorld。

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

    // 无参数
    public static void method2 () {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello,World!" + (i+1));
        }
    }
}

对比有返回值和无返回值

对于有返回值的方法，可以使用单独调用、打印调用和赋值调用。
无返回值的方法，只能使用单独调用。

在这里插入图片描述

package cn.luis.demo2;

/*
    对比有返回值和无返回值

    题目要求：定义一个方法，用来【求出】两个数字之和 （你帮我算，算完之后把结果告诉我）
    题目变形：定义一个方法，用来【打印】两个数字之和 （你帮我算，算完之后自己显示结果，不用告诉我）
    
 */
public class Demo04MethodReturn {

    public static void main(String[] args) {

        // 有返回值
        int num = getSum(10,20);
        System.out.println("返回值是：" + num);

        System.out.println(getSum(10,20)); // 正确写法
        getSum(10,20); // 正确写法，但返回值没有用到

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

        // 无返回值 （对于void没有返回值的方法，只能单独调用，不能打印或复制）

        // 单独
        printSum(10,20); // 正确写法   左面不能有变量来接收 因为没有返回值

/*        // 打印
        System.out.println(printSum(10,20)); // 错误写法！ 返回值类型为void（什么也没有）
        System.out.println(void);*/

/*        // 赋值
        int num2 = printSum(10,20);
        int num3 = void;
        void num4 = void;*/

    }

    // 我是一个方法，我负责两个数字相加。
    // 我有返回值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);
    }
}

案例：判断两个数字是否相同

题目：定义一个方法，用来判断两个数字是否相同。

/*
    方法练习一：
    题目：定义一个方法，用来判断两个数字是否相同。  ---->  是否：boolean！！！

    思路：三要素
    返回值类型： boolean
    方法名称： isSame
    参数列表： int a, int b
 */
public class Demo01MethodSame {

    public static void main(String[] args) {
      boolean same = isSame(3,5);
        System.out.println("两个数字是否相同:" + same);
    }

    public static boolean isSame (int a, int b) {
        /*if (a == b) {
            return true;
        } else {
            return false;
        }*/ //这样写不太好

        // 第二种
        boolean same;
          if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;

        /*// 第三种
        same = a == b ? true : false; // 可以写成boolean same = a == b;
        return same;

        // 第四种
        return a == b;*/

    }
}

案例：求出1~100之间所有数字的和

/*
    题目：定义一个方法，求出1~100之间所有数字的和。

    思路：三要素
    1. 返回值：有返回值，计算结果是一个int数字
    2. 方法名称：getSum
    3. 参数列表：数据范围已经确定，是固定的，所以不需要告诉我任何条件 不需要参数
 */
public class Demo02MethodSum {

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

    public static int getSum () {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

案例：打印指定次数的HelloWorld

/*
    题目：定义一个方法，用来打印指定次数的HelloWorld。

    思路：三要素
    返回值类型：只是打印操作，没有计算，也没有结果要告诉调用处
    方法名称：printCount
    参数列表：到底要打印多少次？？ 次数：int
 */
public class Demo03MethodPrint {

    public static void main(String[] args) {
        // 单独调用
        printCount(10);
        System.out.println("===================");

        // 打印调用
        System.out.println(printCount(10L));
        System.out.println("===================");

        // 赋值调用
        long num = printCount(10L);
        System.out.println("返回值是：" + num);
    }

    public static void printCount (int num) {
        for (int i = 1; i <= num; i++) {
            System.out.println("Hello,World!!" + i);
        }
    }
    public static int printCount(long num) {
        int count = 0;
        for (int i = 1; i <= num; i++) {
            count += i;
            System.out.println("Bitch ！" + i);
        }
        return count;
    }
}

注意事项

对于一个void没有返回值的方法，不能return后面的返回值，只能写：return;
对于void方法当中的最后一行return可以省略不写。
一个方法当中可以有多个return语句，但是必须保证同时只会有一个被执行到。两个return不能连写

public class Demo04MethodNotice {

    //  5
    public static int method1() {
        return 10;
    }

    //  6
    public static void method2() {
//        return 10;  // error!!
        return;  // 没有返回值，只是结束方法的执行而已。
    }

    // 7
    public static void method3() {
        System.out.println("AAA");
        System.out.println("AAA");
        System.out.println("AAA");

        return; //void方法 最后一行的return可以不写
    }

    // 8
    public static int getMax(int a, int b) {
       /* int max;
        if(a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;*/
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

方法的重载

方法的重载（Overload）:多个方法的名称一样，但是参数列表不一样。

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能

与下列因素相关

参数个数不同
参数类型不同
参数的多类型顺序不同

与下列因素无关

与参数名称无关
与方法的返回值类型无关

public class Demo01MethodOverload {

    public static void main(String[] args) {
        /*System.out.println(sumTwo(10,20)); // 30
        System.out.println(sumThree(10,20,30)); // 60
        System.out.println(sumFour(10,20,30,40)); // 100*/

        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行啦！");
        return a + b;
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行啦！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4个参数的方法执行啦！");
        return a + b + c + d;
    }

    //2. 参数类型不同
    public static int sum(double a, double b) {
        return (int) (a + b);  // 必须强转
    }

    // 3. 参数的多类型顺序不同
    public static int sum(int a, double b) {
        return (int) (a + b);  // 必须强转
    }

    public static int sum(double a, int b) {
        return (int) (a + b);  // 必须强转
    }

/*    // 错误写法！与参数名称无关
    public static int sum(int x, int y) {
        System.out.println("有2个参数的方法执行啦！");
        return x + y;
    }*/

/*    // 错误写法！与返回值类型无关
    public static double sum(int a, int b) {
        System.out.println("有2个参数的方法执行啦！");
        return a + b + 0.0;
    }*/

}

案例：比较两个数据是否相等

/*
    题目：比较两个数据是否相等。
    参数类型分别为两个byte类型，两个short、两个int、和两个long类型
    并在main方法中进行测试。
 */
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,12L));
    }


    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参数的方法执行啦！");
        boolean same;
        return a == b;
    }

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

案例：判新哪些方法是重载关系

package cn.luis.demo4;

/*
判新哪些方法是重载关系。
 */
public class Demo03OverloadJudge {

    public static void open() {}  // 正确重载

    public static void open(int a) {}  // 正确重载

    static void open(int a，int b) {}  // 代码错误：和第8行冲突

    public static void open(double a，int b){}  // 正确重载

    public static void open(int a，double b) {}  // 代码错误：和第6行冲突

    public void open(int i，double d) {}  // 代码错误：和第5行冲突

    public static void OPEN() {} // 代码正确不会报错，但是并不是有效重|

    public static void open(int i，int j) {}  // 代码错误：和第3行冲突

}

实现重载的`println`方法

在调用输出语句的时候，println方法其实就是进行了多种类型的重载形式。

否则就得叫printShortln、printIntln等等很麻烦

package cn.luis.demo4;

public class Demo04OverloadPrint {

    public static void main(String[] args) {
        myPrint(100);
        myPrint("我");
    }

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

}

LiuszZZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
05. 【方法】

概念基本格式方法名称命名规则：和变量一样，使用小驼峰。方法体：也就是大括号当中可以包含任意条语句。public static void 方法名称() { 方法体}注意事项方法定义的先后顺序无所谓。方法的定义不能产生嵌套包含关系。方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用。调用方法格式方法名称();代码：/*HelloWorld...
复制链接

扫一扫