08：方法

Java方法

什么是方法

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

方法的优点

使程序变得更简短而清晰。
有利于程序维护。
可以提高程序开发的效率。
提高了代码的重用性。

一、方法的定义

Java方法是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

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

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。(形参：用来定义作用；实参：实际调用传递给他的参数)
方法体：方法体包含具体的语句，定义该方法的功能。

实例如下：

//比较两个数的大小
    public static int max(int num1, int num2){
        int result;

        if (num1 > num2) {
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }

二、方法的调用

JAVA中方法的调用主要有以下几种：
1、非静态方法
非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对象来调用的，语法如下：

对象名.方法();

实例如下：

public class Demo01 {
    public static void main(String[] args) {
        //非静态调用
        Demo01 demo01 = new Demo01();
        demo01.add(20,30);
    }

    public int add(int a, int b){   //没有static
        int sum;
        sum = a + b;
        return sum;
    }
}

2、调用静态方法
静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的，语法如下：

类名.方法();

实例如下：

public class Demo02 {
    public static void main(String[] args) {
        //静态调用
        Demo02.add(20,30);
    }

    public static int add(int a, int b){   //没有static
        int sum;
        sum = a + b;
        return sum;
    }
}

3、方法与方法之间的调用

方法与方法之间的调用，主要是在一个方法内部如何调用其他方法。

静态方法内部调用其他方法

在本类当中，静态方法可以直接调用静态方法。
在本类当中是非静态方法，就必须通过对象来调用。

实例如下：

public class Demo01 {
    
    //非静态方法
    public  void say1(){
        System.out.println("非静态方法");
    }
    //静态方法
    public static void say2(){
        System.out.println("静态方法");
    }

    //静态方法内部调用其他方法
    public static void dy1(){
        
        //静态方法调用静态方法
        say2();
        
        //静态方法调用非静态方法需通过对象来调用
        Demo01 s = new Demo01();  //创建对象
        s.say1();
    }
}

在不同类当中，静态方法调用其他类的静态方法，需要通过
```
类名.静态方法名();
```
在不同类当中，静态方法调用其他类的非静态方法，需要导入该类中的包，以及通过创建对象调用。

非静态方法内部调用

在本类中，非静态方法可以直接调用静态方法与非静态方法。
在不同类中，非静态方法调用其他类的静态方法，需要通过导入该类中的包，并且需要通过类名来调用
在不用类中，非静态方法调用其他类的非静态方法时，需要导入该类中的包，还需要通过创建对象来调用。

三、方法的重载

方法的重载就是在一个类中，有相同的函数名称，但形参不同的函数。

说明：

参数列表不同包括：个数不同、顺序不同、类型不同。
仅仅参数变量名称不同是不可以的。
跟成员方法一样，构造方法也可以重载。
声明为final的方法不能被重载。
声明为static的方法不能被重载，但是能够被在此声明。

实例如下：

public class Demo03 {

        //一个普通得方法，不带参数，无返回值
        public void add(){
            //method body
        }

        //重载上面的方法，并且带了一个整形参数，无返回值
        public void add(int a){
            //method body
        }

        //重载上面的方法，并且带了两个整型参数，返回值为int型
        public int add(int a,int b){
            //method body
            return 0;
        }
}

方法的重载的规则：

方法名称必须相同。
参数列表必须不同。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以称为方法的重载。

方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。

四、可变参数

jdk 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示：

数据类型... 参数名

在方法声明中，在指定参数类型后加一个省略号(...) 。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

实例如下：

public class Demo04 {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

五、递归

递归算法是一种直接或间接地调用自身的算法。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

实例：

不使用递归实现99乘法表。实现如下：

public class Demo05 {

    public static void main(String[] args) {

        for(int i=1; i<=9;i++){
            for(int j=1; j<=i; j++){
                System.out.print(j+" * "+i+ " = "+(i*j) +" ");
            }
            System.out.println();
        }
    }

}

使用递归实现99乘法表。实现如下：

public class Demo05 {
    public static void main(String args[]) {
        m(9);
    }

    /**
     * 打印出九九乘法表
     */
    public static void m(int i) {
        if (i == 1) {
            System.out.println("1*1=1 ");
        } else {
            m(i - 1);
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + j * i + " ");
            }
            System.out.println();
        }
    }
}

说明：

递归很耗费栈内存，递归算法能不用尽量不用。有些情况必须靠递归实现。例如：目录拷贝
无法结束的递归在程序运行时发生错误【不是异常，是错误Error】
递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误
递归即使有了结束条件，即使条件是正确的，也可能会发生栈内存溢出错误，因为递归的太深了

六、return的用法

return：必须放在方法中
return的主要作用有两点：

返回方法指定类型值
用于方法结束的标志,return 后面的语句不会被执行

例：

package com.itlb.method;

public class Demo06 {
    public static void main(String[] args) {
        int i;
        System.out.println("return语句之前"+getInfo());
        for (i = 0; i < 5; i++) {
            if(i==3){
                return;//无返回类型，用于方法的结束
            }
            System.out.println(String.format("i=%d",i));
        }
        //return 之后的语句将不会被执行
        System.out.println("return语句之后"+getInfo());
    }
    public static int getInfo(){
        return 1;//有返回类型，返回方法指定类型的返回值

    }
}

posted @ 2021-07-31 00:04 Happy*^_^* 阅读(148) 评论(0) 收藏举报

刷新页面返回顶部

Happy^_^

08：方法

Java方法

一、方法的定义

二、方法的调用

三、方法的重载

四、可变参数

五、递归

六、return的用法

公告