Java方法

原创已于 2023-08-14 17:04:18 修改 · 143 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Java学习记录

于 2023-05-11 16:40:22 首次发布

Java方法

什么是方法

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

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

设计方法的原则：原子性——一个方法只完成一个功能，有利于后期的拓展。

如：System.out.print()中，System是一个类，out是System类中的一个对象，print是一个方法。

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

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

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

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

修饰符：是可选的，且可以有不止一个，告诉编译器如何调用该方法，定义了该方法的访问类型。如：public、static等。
返回值类型：方法可能会返回一个值，放回值类型是方法返回数据的类型，没有返回值则返回值类型关键字为void。
方法名：是方法的实际名称，命名规则遵守驼峰命名规则（首字母小写其余单词首字母均大写）。
参数类型：参数更像是一个占位符。当方法被调用时，传递值给参数，这个值被称为实参或变量。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
方法体：包含具体的语句，定义该方法的功能。

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

方法的调用

调用方法：

对象名.方法名(实参列表);

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

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

System.out.print("Hello, world");

public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 10);
        System.out.println(max);
    }

    // 比大小
    public static int max(int num1, int num2) {
        int result = 0;
        if (num1 > num2) {
            result = num1;
        } else if (num1 < num2) {
            result = num2;
        } else {
            System.out.println("num1==num2");
            // 终止方法
            return 0;
        }
        return result;
    }
}

运行结果：

num1==num2
0

值传递：是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

引用传递：是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将会影响到实际参数。

Java是值传递，对于对象参数，值的内容是对象的引用。

方法的重载

2023年8月14日补充

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

有相同的名字，不同的参数，便产生了重载~

方法重载的规则：

方法名称必须相同
参数列表必须不同（个数不同、或类型不同、或参数排列顺序不同等）
方法的返回值类型可以相同也可以不同

// add 方法
public static int add(int a, int b) {
    return a + b;
}

// 重载 add 方法
public static int add(int a, int b, int c) {
    return a + b + c;
}

以上重载为参数个数不同的情况。

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

方法的重写

重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。

方法名、参数列表必须相同，子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
构造方法无法被重写

重载和重写有什么区别

总结

综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。

区别点重载方法重写方法
发生范围同一个类子类
参数列表必须修改一定不能修改
返回类型可修改子类方法返回值类型应比父类方法返回值类型更小或相等
异常可修改子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
访问修饰符可修改一定不能做更严格的限制（可以降低限制）
发生阶段编译期运行期

方法的重写要遵循“两同两小一大”（以下内容摘录自《疯狂 Java 讲义》，issue#892open in new window ）：

“两同”即方法名相同、形参列表相同；
“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。

⭐️ 关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
public class Hero {
    public String name() {
        return "超级英雄";
    }
}
public class SuperMan extends Hero{
    @Override
    public String name() {
        return "超人";
    }
    public Hero hero() {
        return new Hero();
    }
}

public class SuperSuperMan extends SuperMan {
    public String name() {
        return "超级超级英雄";
    }

    @Override
    public SuperMan hero() {
        return new SuperMan();
    }
}
著作权归Guide所有原文链接：Java基础常见面试题总结(上) | JavaGuide(Java面试 + 学习指南)

区别点	重载方法	重写方法
发生范围	同一个类	子类
参数列表	必须修改	一定不能修改
返回类型	可修改	子类方法返回值类型应比父类方法返回值类型更小或相等
异常	可修改	子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
访问修饰符	可修改	一定不能做更严格的限制（可以降低限制）
发生阶段	编译期	运行期

也就是说，重载是同样的一个方法，根据输入数据（参数）的不同，做出不同的处理，返回不同的结果~

重写则是当子类继承父类的相同方法时，输入的数据是一样，但是要做出和父类方法不同的响应，不同的处理，在这一点上，子类重写方法相当于覆盖了父类的方法。我认为这是重写和重载最大的区别。

可变参数

又称为不定项参数
Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo03 {
    public static void main(String[] args) {
        // 调用可变参数方法
        printMax(1, 2, 3, 4, 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);
    }
}

递归

递归就是A方法调用A方法，自己调用自己。
利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分：
- 递归头：表示什么时候不调用自身方法。在递归函数中，递归头指的是一个条件语句，它用于检查是否需要停止递归并返回一个结果；如果递归头不满足，则递归继续，直到满足递归头为止；如果没有头，将陷入死循环。
- 递归体：表示什么时候需要调用自身方法。

public class Demo04 {
    // 递归思想
    public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static int f(int n) {
        // 递归的出口条件
        if (n == 1) {
            return 1;
        } else {
            return n * f(n - 1);
        }
    }
}

当我们调用 f(5) 时，它会递归地调用 f(4)，f(3)，f(2)，f(1)，并将结果返回给上一个调用。最后，f(5) 的计算结果为 5 * 4 * 3 * 2 * 1，即 120。

递归在计算阶乘等简单问题时非常有效，但是在处理大规模的问题时，递归可能会导致堆栈溢出。

堆栈溢出

堆栈溢出（Stack Overflow）是指当程序执行调用函数或方法时，系统将调用信息压入堆栈中，以便在函数或方法执行完毕后返回。
如果递归或连续调用函数或方法的次数太多，可能会导致堆栈空间不足，从而导致堆栈溢出错误。
堆栈溢出错误通常会导致程序崩溃或异常终止，因为操作系统无法为程序提供足够的堆栈空间。

补充

2023年8月14日补充：

此部分内容来自Java 面试指南 | JavaGuide(Java面试 + 学习指南)

Guide哥写的东西真的是通俗易懂，非常适合我这种自学的、基础不是很好的用来差缺补漏，易于理解的去复习，准备面试~

静态方法为什么不能调用非静态成员?

这个需要结合 JVM 的相关知识，主要原因如下：

静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
在类的非静态成员不存在的时候静态方法就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作。
public class Example {
    // 定义一个字符型常量
    public static final char LETTER_A = 'A';

    // 定义一个字符串常量
    public static final String GREETING_MESSAGE = "Hello, world!";

    public static void main(String[] args) {
        // 输出字符型常量的值
        System.out.println("字符型常量的值为：" + LETTER_A);

        // 输出字符串常量的值
        System.out.println("字符串常量的值为：" + GREETING_MESSAGE);
    }
}
著作权归Guide所有原文链接：Java基础常见面试题总结(上) | JavaGuide(Java面试 + 学习指南)

也就是说，重点在于静态方法和类一起出现，你那边非静态成员和对象（实例）一起出现，静态方法在的时候，非静态成员还不存在呢，怎么调用？调用不了一点~

静态方法和实例方法有何不同？

1、调用方式

在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。

不过，需要注意的是一般不建议使用 对象.方法名 的方式来调用静态方法。这种方式非常容易造成混淆，静态方法不属于类的某个对象而是属于这个类。

因此，一般建议使用 类名.方法名 的方式来调用静态方法。
public class Person {
    public void method() {
      //......
    }

    public static void staicMethod(){
      //......
    }
    public static void main(String[] args) {
        Person person = new Person();
        // 调用实例方法
        person.method();
        // 调用静态方法
        Person.staicMethod()
    }
}
2、访问类成员是否存在限制

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制。

著作权归Guide所有原文链接：Java基础常见面试题总结(上) | JavaGuide(Java面试 + 学习指南)