JavaSE入门：方法

雙馬程序猿

已于 2023-02-10 10:14:21 修改

阅读量250

点赞数

分类专栏： Java 文章标签： java

于 2022-07-30 14:08:06 首次发布

本文链接：https://blog.csdn.net/m0_64095482/article/details/126071524

版权

Java 专栏收录该内容

46 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中的方法，包括方法的定义、调用、参数类型、返回值、重载等核心概念。通过示例代码解释了方法如何封装代码功能，如何传递参数，以及如何实现方法重载。还探讨了命令行参数、可变参数和递归的概念及其应用。

摘要由CSDN通过智能技术生成

1.什么是方法

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用。

Java方法是语句的集合，它们在一起执行一个功能。
   方法是解决一类问题的步骤的有序组合
   方法必须包含于类或对象中
   方法在程序中被创建，在其他地方被引用
设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的
时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

例：
    public static void main(String[] args) {
//        int sum = add(1,2);
//        System.out.println(sum);
        text();			//调用
    }
    public static  int add(int a,int b){
        return  a+b;			//返回a+b
    }
    public static void text(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容:");
        String s = scanner.nextLine();
        //equals:判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }

2.方法的定义和调用

方法的编写顺序无所谓，但方法必须写在类中，不能独立存在。
方法与方法之间是平级关系，方法内部不能再声明方法，即不能嵌套定义。
方法调用一次就会执行一次，方法不调用就不执行，调用时必须严格匹配方法的参数情况。
方法如果没有返回值,方法体内可以没有return;如果写了return,那么表示方法结束。
方法声明的返回值类型必须和实际返回的数据类型一致。

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:
修饰符返回值类型方法名（参数类型参数名）{
   ...
   方法体
   ...
   return 返回值；
}

修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。public（公有：所有类都可以使用）、private（私有：只有自己可以使用）、protected（受保护的：自己和自己包下的类还有子类可以使用）、default（默认：自己和自己包下的可以使用）
返回值类型:指的就是函数计算结果的数据类型如果函数没有返回值，则为void
返回值:指的就是这一具有独立功能的代码块的计算结果，需要传递给外界配合return。取值范围：常用基本类型与引用类型
方法名:是方法的实际名称。方法名和参数表共同构成方法签名。英文小写，驼峰模式
参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数:声明方法时指定的参数，用来说明这个方法可以接受哪些参数。在方法被调用时用于接收外界输入的数据。
实际参数:调用方法时实际传给方法的数据。
方法体:方法体包含具体的语句，定义该方法的功能。

return:仅仅表示函数结束！如果函数有返回值，则return跟返回值，如果没有返回值，则return可以不写，但是return是存在的（没有参数的时候隐藏在最后一行）。return语句下面不能编写代码，因为永远执行不到，属于无效代码

return返回值：指的就是这一具有独立功能的代码块的计算结果，需要传递给外界，用来配合

1.修饰符

Java中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

2.形参、实参

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

3.静态对象

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。

静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问

使用 static 可以修饰变量、方法和代码块。

例：
    public static void main(String[] args) {
        int max = max(11,10);                               //11 10
        System.out.println(max);    //num1==num2 return 0   11
    }
    //比大小
    public static int max(int num1,int num2){
        int  result = 0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;		//终止方法 如果max赋值相等 return0将终止方法
        }
        //不相等则继续运行
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;		//返回结果  返回到result = 0 需要赋初始值所以要加=0
    }

4.返回值

返回值的作用：接收出结果，使得它可以用于其他的操作！

方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。

5.值传递、引用传递

值传递(pass by value)：在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数；java只存在值传递

引用传递(pass by reference):在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数；

3.方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载的规则:
   方法名称必须相同。
   参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
   方法的返回类型可以相同也可以不相同。
   仅返回类型不同不足以成为方法的重载。
实现理论：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法.如果匹配失败，则编译器报错.

例：
    public static void main(String[] args) {
        int max = max(11,10);                               //11 10
        System.out.println(max);    //num1==num2 return 0   11
    }
    //比大小
    public static int max(int num1,int num2){
        int  result = 0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法 如果max赋值相等 return0将终止方法
        }
        //不相等则继续运行
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
    public static double max(double num1,double num2){
        double  result = 0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法 如果max赋值相等 return0将终止方法
        }
        //不相等则继续运行
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
    public static int max(double num3,double num4,double num5){
        int  result = 0;
        if (num3==num4){
            System.out.println("num1==num2");
            return 0;//终止方法 如果max赋值相等 return0将终止方法
        }
        //不相等则继续运行
        if (num3>num4){
            result = (int)num3;
        }else {
            result = (int)num4;
        }
        return result;
    }

重载练习题

package java_se.java_jichu.zuoye8_5;

public class TestMax {
    public static void main(String[] args) {
        /*
        (4)编写一个Java程序，创建一个TestMax类，定义两个getMax()方法，分别用来求两个数和三个数的最大值，并测试结果。
         */
        Max max = new Max();
        System.out.println(max.getMax(1,2));
        System.out.println(max.getMax(1,2,3));
    }
}
/*
求两个数和三个数的最大值
package java_se.java_jichu.zuoye8_5;

public class Max {
    public Max() {
    }
    public int getMax(int n1,int n2,int n3){
        int max = 0;
        if (n1>n2){
            if (n1>n3){//321
                max=n1;
                System.out.println("");
            }else {//323 213
                max=n3;
            }
        }else {
            if (n2>n3){//121
                max=n2;
            }else {//123 122
                max=n3;
            }
        }
        return max;
    }
    public  int getMax(int number1, int number2){
        if (number1 >= number2) {//11 21
            return number1;
        }
        else {//12
            return number2;
        }
    }
}

 */

4.命令行传参

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main(）函数实现。
javac 类名.java
从cmd
cd..
java 类的路径 this is kuangshen

传入了数组
args[0]:this
args[1]:is
args[2]:kuangshen

5.可变参数

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

例：
    public static void main(String[] args) {
        //如果需要引用的方法不是静态方法，则需要用new实例化一个类对象，然后调用类中的方法
        Demo05 demo05 = new Demo05();
        //如果需要引用的方法是静态方法，则直接调用，就不需要重新new一个static（静态）类用啦调用
        demo05.text(1,2,3,35,5,55,6,6,6,6);
    }
    public void text(int x,int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }

6.递归

能不用递归就不用递归

A方法调用B方法,我们很容易理解!
递归就是: A方法调用A方法!就是自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：
递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体:什么时候需要调用自身方法。

public static void main(String[] args) {
        //阶乘
        /*
        * 2！ 2*1
        * 3！ 3*2*1
        * 7！ 7*6*5*4*3*2*1
        * */
        System.out.println(f(5));
    }
    public static int f(int n){
        if(n==1){                //等于1就返回1
            return 1;
        }else {
            return n*f(n-1);    //不等于1就调用自己上一个方法体减一，第二次就是调用f（1）
        }
    }

阶段：
边界条件：边界（当程序执行到最后一个数的时候，所有的程序都会有值，然后一步一步返回）
前阶段：（当值不等于1的时候就会一直运算，直到等于1就返回结果）
返回阶段：n*（n-1）

优缺点：
优点：容易理解程序变成，小数值运算，
缺点：数值大的时候计算机运算速度慢或崩溃