Java方法

 

1、方法概念

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

• 方法是解决一类问题的所需步骤的有序集合

• 方法包含于类或对象中

• 方法在程序中被创建，在其他地方被引用

设计方法时，要尽量保证方法的原子性，就是一个方法只完成一个功能，有益于后续扩展

2、方法定义和调用

2.1、定义

//语法
修饰符 返回值类型 方法名（参数类型 参数名）{
    方法体
    return 返回值;
}
​
//示例1
public int add(int a,int b){
    int c = a + b;
    return c;
}
//示例2
public void test(){
    System.out.println("这个方法没有返回值");
}

• 修饰符：定义了该方法的访问类型，告诉编译器如何调用该方法，可选

• 返回值类型：方法可能存在返回值，像示例1，返回一个数据类型为int整形的数据，方法也可能不存在返回值，在这种情况下，返回值类型的关键字为void，如示例2所示

• 方法名：方法的实际名称，和参数列表共同构成方法签名

• 参数类型和参数名：两者共同构成参数列表，参数列表是指方法的参数类型，参数先后顺序，参数的个数

  • 参数相当于是一个占位符，可选，当方法被调用时，传递具体的值（实参，参数实际的值）给参数

  • 形参：当该方法被调用时用于接受外界输入的数据

    //这里的a和b就是方法的形参，提前定义好的当该方法被调用时，一个接受外界输入数据的盒子
    public int add(int a,int b)

  • 实参：调用方法时，实际传给该方法的数据

    //该方法被调用时，1传递给了a，2传递给了b
    add(1,2);

• 方法体：方法体包含具体的语句，定义该方法的功能

2.2、调用

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

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

  • 当方法返回一个值的时候，方法调用通常被当作一个值

    public class Test {
    ​
        public static void main(String[] args) {
            //add方法被调用方法调用，结果为一个整型数据
            int add = add(1, 2);
            System.out.println(add);
        }
    ​
        public static int add(int a,int b) {
            int c = a + b;
            return c;
        }
    }

  • 如果方法的返回值是void，方法调用的结果一定是一条语句

    public class Test {
    ​
        public static void main(String[] args) {
            //noReturn方法被调用，方法没有返回值，所有不用定义变量来接收返回值
            noReturn();
        }
    ​
        public static void noReturn() {
            System.out.println("这个方法没有返回值");
        }
    }

• 值传递和引用传递

  • 基本数据类型作为参数的方法调用

    public class Test02 {
        
        /*
        这里的change方法中，形参是a，实参是b
        实参给形参传递数据的方式为：实参b将值20复制一份给形参a
        实参和形参是两个方法中的相互独立的局部变量，所以修改形参a不会影响实参b的值
        */
    ​
        public static void change(int a){
            a = 10;
            System.out.println("a = " + a);//输出结果为：a = 10
        }
    ​
        public static void main(String[] args) {
            int b = 20;
            change(b);
            System.out.println("b = " + b);//输出结果为：b = 10
        }
    }

  • 引用类型作为参数的方法调用

    //定义一个Point类
    class Point{
        int x;
        int y;
    ​
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
    ​
        public void show(){
            System.out.println("(x = " + x + "，y = " + y + ")");
        }
    }
    ​
    public class TestReferencePassing {
    ​
        /*
        这里的change方法中，形参是point对象中的两个属性 x 和 y，实参是change方法中实际赋值给 x 和     y的值。实参给形参传递数据的方式为：实参将直接覆盖修改原先形参的值
         */
    ​
        public static void change(Point p1){
            p1.x = 5;
            p1.y = 5;
        }
    ​
        public static void main(String[] args) {
    ​
            Point point = new Point(1,1);
            //调用change方法前，show()方法的输出结果为(x = 1，y = 1)
            point.show();
            change(point);
            //调用change方法前，show()方法的输出结果为(x = 5，y = 5)
            //说明Point对象中x和y的值已经发生改变
            point.show();
        }
    ​
    }

    内存分配过程如下图所示：

• 基本数据类型的参数传递是值传递，引用类型的参数传递是引用地址，本质上也是值传递，所以Java参数传递的方式是值传递

3、方法重载

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

• 方法重载的规则

  • 方法名称必须相同

  • 参数列表不同

    • 参数类型不同

      public void add(int a) {}
      ​
      public void add(String a) {}

    • 参数的个数不同

      public void add(int a) {}
      ​
      public void add(int a,int b) {}

    • 有两个或者之上的不同参数类型的参数的先后顺序不同

      public void add(int a,String b) {}
      ​
      public void add(String b,int a) {}

  • 方法的返回类型可以相同也可以不相同

  • 仅仅返回类型不同不足以构成方法重载

• 实现理论

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

4、可变长参数

//语法
修饰符 返回值类型 方法名（参数类型... 参数名）{}
​
//示例
public void vlParams(int x,int... i){}

• 定义可变长参数后参数的数量不定，根据调用方法时传递的参数数量而定

• 一个方法中只能指定一个可变长参数，它必须是方法的最后一个参数

5、递归

• 方法调用自身

• 递归结构

  • 边界条件：判断什么时候不再调用自身的条件

  • 前阶段：调用自身

  • 返回阶段：得到最终的一个值，返回给程序

    public class testRecursion {
        public static void main(String[] args) {
            System.out.println(recursion(5));
        }
        //计算 n!（n的阶乘）
        public static int recursion(int n){
    ​
            //边界条件
            if (n == 1){
                return n;
            }else{
                //前阶段，调用自身n * recursion(n-1);
                //返回阶段：把值返回给程序
                return n * recursion(n-1);
            }
        }
    }

• 栈溢出

  递归没有边界条件就会引起栈溢出错误

  public class testRecursion {
      
      public static void main(String[] args) {    
          //栈溢出错误：Exception in thread "main" java.lang.StackOverflowError
          System.out.println(recursion(5));
      }
      public static int recursion(int n){
          return n * recursion(n-1);
      }
  }

笔记内容均为自己看大神【狂神说Java】的视频整理的，给狂神点赞

狂神视频链接