Java中方法的学习_java 的共通方法怎么学习写-CSDN博客

本文链接：https://blog.csdn.net/sinat_40775402/article/details/117021002

方法学习不知死过多少次，还让我学是吧！！！你没完了哈！！！！

来~来~来~，咱们一起来分析！！！

老师

前面的关键字我讲过吧~~
数据类型还用说嘛~~~
方法的定义格式我说过吧~~
上面都会的话直接定义一个方法这个很难吗？

···························

学生

你学了多久了？
讲这些内容你一共才花了多长时间啊？
我们是否真正理解会用了，还是只是知道有这么回事儿啊？
你前面的东西学了不忘啊？

说什么学习学习在学习，努力努力在努力。你不通俗的说，我永远都不是那块料！！！

通俗说方法

方法是抽象的，是一件事儿从开始到完成的一个实现过程。包含实现这件事儿用到的数据元素、实现规则、实现逻辑、结果反馈等。

Java中的方法定义：

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

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

设计方法的原则

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法时，最好保持方法的原子性，即一个方法完成一个功能，利于后期拓展

方法的命名规则

小驼峰命名法(见名知意)
修饰符返回值类型方法名（参数类型参数名）{

方法体；

return 返回值；

}

代码实现

需求：写一个比大小的方法

/*
权限修饰符暂且认识public这一种，后期文章会跟大家分享。
static修饰符在没学面向对象时,先用类直接调用的方式测试方法的使用
比大小至少要两个数，故方法中至少放入两个参数
比较完我们要返回一个最大的结果，故返回值根据最大结果的数据类型来定义
*/
public static int getMax(int a,intb){
    int max=0;//避免比较赋值时出现损失精度或者数据类型强转，设置接收参数类型一致

    if(a==b){
        System.out.println("a==b");
        return 0;//终止方法
    }
    if(a>b){
        max=a;
    }else{
        max=b;
    }
    return max;//max为int类型
}

方法调用

有static关键字（静态方法）

调用方法：类名.方法名（实参列表）

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

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

int larger=max（20，30）；

当方法返回值为void，方法调用一定是一条语句

System.out.println("这是一个调用println方法的语句")；

无static修饰的方法（非静态方法）

调用方法：先使用new关键字创建对象，通过对象名调用方法

public class StudentDemo{

    public static void main(String[] args){

        Student st=new Student();

        //静态方法调用示例
        Student.sayHello1();//Hello,我是静态方法

        //非静态方法调用示例
        st.sayHello2();//Hello,我是非静态方法

    }


}

class Student{

    public static void sayHello1(){

        System.out.println("Hello,我是静态方法");

    }


    public void sayHello2(){

        System.out.println("Hello,我是非静态方法");

    }

}

public class Demo{
    public static void main(String[] args){




    }

    public void a(){

        b();
    }

    //非静态方法是类实例化以后才存在
    public void b(){

    }

    //含static关键字的方法是随着类的加载而加载
    public static void c(){

        b();//报错：原因b方法需实例化以后才能调用，时间上有错误
    }

}

值传递和引用传递

/**
值传递演示:
    只是将实参带入，方法中并未有返回值，因此a的值并未发生变化

*/

public class Demo{
    public static void main(String[] args){
        int a = 1;
        System.out.println(a);//a=1

        Demo.change(a);
        System.out.println(a); //a=1
    }

    public static void change(int a){
        a = 10;

    }

}

/**
引用传递：
    对象，本质还是值传递
*/
public class Demo{
    public static void main(String[] args){
        Person person = new Person();//实例化Person
        System.out.println(person.name);// null

        Demo.change(person);
        System.out.println(person.name);// 段海涛

    }

    public static void change(Person person){
        //person是一个对象：指向实例化后的人，可以改变属性
        person.name = "段海涛";
    }
}

class Person{

    String name;
}

方法的重载

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

重载的规则：

方法名称必须相同
参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）；
方法的返回值类型可以相同，也可以不同；
仅仅返回值类型不同不足以成为方法的重载；

public class MethodDemo{
    public static void main(String[] args) {
        int max=getMax(3,7,4);
        System.out.println(max);
    }
    public static int getMax(int a,int b){
        int max=0;
        if(a==b){
            max=0;
            return max;
        }
        if(a>b){
            max=a;
        }else{
            max=b;
        }
        return max;
    }
    public static double getMax(double a,int b){
        double max=0;
        if(a==b){
            max=0;
            return max;
        }
        if(a>b){
            max=a;
        }else{
            max=b;
        }
        return max;
    }
    public static double getMax(int a,double b){
        double max=0;
        if(a==b){
            max=0;
            return max;
        }
        if(a>b){
            max=a;
        }else{
            max=b;
        }
        return max;
    }
    public static int getMax(int a,int b,int c){
        int max=0;
        if(a==b&&b==c){
            max=0;
            return max;
        }
       if(a>b){
           if(a>c){
               max=a;
           }else{
               max=c;
           }
       }else{
           if(b>c){
               max=b;
           }else{
               max=c;
           }
       }
        return max;
    }
}

实现理论：

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

命令行传参（拓展）

可变参数

jdk 1.5开始，java支持传递同类型的可变参数给一个方法；
在方法生命中，在指定参数类型后加一个省略号（···）。
一个方法中只能指定一个可变参数，它必须hi方法的最后一个参数，任何普通的参数必须在它之前声明

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方法调用B方法
递归就是A方法调用A方法，即自己调用自己。（报错会导致栈溢出）
利用递归可以用简单的程序来解决一些复杂的问题。通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归的结构包括两个部分

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。（栈溢出）

递归体：什么时候需要调用自身方法。

需求：求5的阶乘

/**
5的阶乘：5*4*3*2*1
*/

public static void f(int i){
   
    if(i==1){
       return 1;
    }else{
        return i*f(i-1)

    }
}

你掌握了吗？学习更多请点我要学更多。