JavaSE方法

.ଲ

已于 2022-12-28 15:21:26 修改

阅读量86

点赞数

文章标签： java

于 2022-12-28 13:35:24 首次发布

本文链接：https://blog.csdn.net/weixin_73430122/article/details/128467387

版权

方法

什么是方法？

内涵

方法是语句的集合，它们在一起执行一个功能
是解决一类问题的步骤和有序组合
被包含在类或对象中
在程序中可以被创建，在其他地方可以被引用

设计方法的原则

方法的原子性，通俗讲，一个方法只完成一个功能，利于后期拓展

方法的命名规则: 驼峰原则

如下所示：

package method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        int sum = add(1,2);  //实际参数
        System.out.println(sum);
    }

    //加法
    public static int add(int a,int b){  //形式参数
        return a+b;

    }
}

方法的定义

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

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

方法包含一个方法头和一个方法体，解释如下：
- **修饰符：**可选，定义方法的访问类型（public，static，final等）
- **返回值类型：**方法执行的操作需要返回值时，返回值的类型是所使用的数据类型，方法执行所需的操作不需要返回值时, 返回值类型是关键字void(void: 表示空)
- **方法名：**是方法的实际名称，方法名和参数表共同构成方法签名add();
- **参数类型：**相当占位符，可以给参数传递数值。add(a, b);这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数个数。方法可以不包含任何参数
  - 形式参数：用来定义作用的
    
    public static int add(int a,int b){}int a, int b 是参数类型+参数名
  - 实际参数：实际调用传递给它的参数
    
    int sum = add(a:1,b:2);**a:,b:**是被调用的参数，1, 2是赋给参数的值
    
    如下所示：
```
package Second.one;

public class Demo03 {
    public static void main(String[] args) {
        //实参：给形参实际调用的值
        int add = Demo03.add(2,5);
        System.out.println(add);
    }
    //形参：定义作用
    public static int add(int a,int b){
        return a+b;
    }
}
```
- **方法体：**方法体包含具体的语句，定义该方法的功能

如下所示：

package method;

public class Demo02 {
    public static void main(String[] args) {
        int max = max(30,30);  //方法调用
        System.out.println(max);
    }

    //比大小
    public static int max(int a,int b){

        int result = 0;

        if (a>b){
            result = a;
        }else if (a<b){
            result = b;
        }else if(a == b){
            System.out.println("a == b");
        }
        return result;  //终止方法
    }
}

方法重载

在一个类中有相同的函数名，但形参不同的函数

如下所示：

package method;

public class Demo02 {
    public static void main(String[] args) {
        //使用double类型使用第一个语句块，输出小数
        //使用int类型使用第二个语句块，输出整数
        int max = max(50.50, 30.0);  //方法调用
        System.out.println(max);
    }

    //比大小
    public static int max(double a, double b) {

        double result = 0;

        if (a > b) {
            result = a;
        } else if (a < b) {
            result = b;
        } else if (a == b) {
            System.out.println("a == b");
        }
        return (int) result;  //(int): 强行转换参数类型为int
    }

    //比大小
    public static int max(int a, int b) {

        int result = 0;

        if (a > b) {
            result = a;
        } else if (a < b) {
            result = b;
        } else if (a == b) {
            System.out.println("a == b");
        }
        return result;  //终止方法
    }
}

规则：
- 方法名称必须相同
- 参数列表必须不同(参数个数不同，数据类型不同，参数排列顺序不同等)
- 方法的返回类型可以相同也可以不同（不同的话，即，强制转换返回值数据类型）
- 仅仅返回类型不同不足以成为方法的重载
实现理论：

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个匹配，以选择对应的方法，如果匹配失败则编译器报错

命令行传参

作用：运行一个程序时，再传递给其消息

如下所示：

package method;

public class Demo03 {
    public static void main(String[] args) {
        //args.length: 数组长度
        for (int i = 0; i< args.length; i++){
            System.out.println("args["+ i +"]:"+ args[i]);
        }
    }
}

在cmd运行：

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法
方法声明中，指定参数类型后加一个省略号(…)；

即，public static void printMax(double... numbers){}(在这里double是指定参数类型)

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

如下所示：

package method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(3,2,3,5); //值必须是相同类型
    }
    public static void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }
}

方法调用

调用方法：对象名. 方法名(实参列表)
Java支持两种调用方法的方式，根据方法是否需要返回值来选择
当方法返回一个值的时候，方法调用通常被当做一个值，如：

int larger = max(30, 40);
如果方法返回值是void，方法调用一定是一条语句

System.out.println("haha");
值传递(Java) 和引用传递
this关键字：this.name表示在当前的类里调用属性

递归

A方法调用A方法（即，自身调用）
通常把一个大型复杂的问题层层转化为与原问题相似的规模较小的问题来求解，大大减少程序的代码量。即，用有限的语句来定义对象的无限集合
递归结构：
- 递归头：没有头将陷入死循环
- 递归体：根据条件调用自身方法

如下所示：

package method;
//计算阶乘  5!
public class Demo05 {
    public static void main(String[] args) {
        //java使用栈机制(累加内存)，大数额不建议使用递归
        System.out.println(f(5));  
    }

    //边界条件：程序执行到底时返回所有值(此题中执行到f(1)时，所有值计算完成准备返回)
    //前阶段(当参数不为1时，不停调用自身，直到为1时才结束)
    //返回阶段：从最大的数开始(本题中通过n*(n-1)返回值)
    public static int f(int n){
        if(n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

静态方法

调用类时，不需要实例化

如图所示：

package Second.one;

public class Demo02 {
    public static void main(String[] args) {
        hhh.haha();  //两个类一样时，直接调用
    }
    public static void haha(){
        System.out.println("hahaha");
    }
}

非静态方法

调用类时，需要实例化（用new定义一个新的类）

package Second.one;

public class Demo02 {
    public static void main(String[] args) {
        //两个类不一样时，需要new
        //对象类型 对象名 = 对象值;
        hhh hhh = new hhh();
        hhh.haha();
    }
    public void haha(){
        System.out.println("hahaha");
    }
}

值传递

如下所示：

package Second.one;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);  //输出1
        Demo04.transmit(a);
        System.out.println(a);  //输出1
    }

    //返回值为空
    public static void transmit(int a){  
        //主方法中传递a = 1，则a = 10自动转换为a = 1
        a = 10;
    }
}

引用传递

如下所示：

package Second.one;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);  // 输出null
        Demo05.change(person);  //传递给change方法
        System.out.println(person.name);  //输出Amy

    }

    public static void change(Person person){
        //person是一个对象，指向的是 Person person = new Person(); //这是一个具体的人，可以改变属性
        person.name = "Amy";  //给String name传递值
    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;  //不赋值的情况下，String默认值为null
}