Java方法-CSDN博客

本文链接：https://blog.csdn.net/weixin_45467181/article/details/123194782

Java方法

tips:基础理解为主，基础经常会用到。

System.out.println();  //是什么？
//System调用系统的类 out输出对象 （）方法

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

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

设计方法的原则：

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

方法的命名规则：首字母小写，驼峰命名

创建包package，命名：方法method
创建类

package com.feng.method; 
public class Demo{
    //main方法
    public static void main(String[] args){
        int sum =add(a:1,b:2);
        System.out.println(sum);
    
   }


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

package com.feng.method; 
public class Demo{
    //main方法
    public static void main(String[] args){  
        //main方法时刻保持简洁，公共模块放到外面，通过方法调用
        //int sum =add(a:1,b:2);
        int sum add(1,2);
        System.out.println(sum);
        test();//调用下面的方法
        
   }
   
    public static void test(){   //static对象
       for （int i =0 ;i <=1000;i++){
          if (i%5==0){
             System.out.println(i+"\t");
          }
          if (i%(5*3)==0){ //每行
             System.out.println();
             //System.out.println("\n");
          }
          
       }
}

方法的定义及调用

方法的定义：

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段

一般情况下，定义一个方法包含以下语法：

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

返回值类型：方法可能会返回值。retrunValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。这种情况下，retrunValueType是关键字void（空）。

方法名：方法的实际名称，方法名和参数表共同构成方法签名（命名规范）。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

形式参数：在方法被调用时用于接收外界输入的数据（用来定义作用的）

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

实参：调用方法时实际传给方法的数据（实际调用传递给它的参数）

int sum = add(a:1,b:2);

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

修饰符 返回值类型 方法名（参数类型 参数名）{
    ...
    方法体
    ...
    return 返回值；
}

package com.feng.method;
public class Demo{
    public static void main(String[] args){
        
        int max = max(10,20);
        System.out.println(max);
    }






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

方法的调用

调用方法：对象名.方法名（实例列表）

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

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

示例：

int larger = max (30,50);

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

System.out.println("Hello,feng");

值传递（Java都是值传递）

引用传递

方法的重载

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

规则：

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

理论：

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

命令行传递参数

有时候（不经常）你希望运行一个程序的时候再传递给它消息，这要靠命令行参数给main()函数实现。

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

tips:找到到的路径

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法。

在方法声明中，在指定参数类型后加一个省略号（…）。

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

package com.feng.method;
public class Demo{
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.test();
    }
/*
public void method(){}
public void method(int i){}
public void method(int i,int  i2){}
public void method(int i,doublei2){}
参数越多代码就开始繁琐
*/

//public void test(intx,int...i){  必须是方法的最后一个参数
//不定项
public void test(int...i){
    System.out.println(i);
}
}

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


//调用可变参数的方法
package com.feng.method;
public class Demo{
    public static void main(String[] args){
        printMax(...numbers:34,3,3,2,56.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);
}

package com.feng.method;
public class Demo{
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.test(...i:1,2,3,4,5);
    }
    
    
    public void test(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]);
        System.out.println(i[5]);
        
    } //可变参数与数组的联系
}

递归思想

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

递归头：什么时候不调用自身方法。如果没有头，就陷入死循环

package com.feng.method;

public class Demo03{
    public static void main(String[] args){
       Demo03 test = new Demo03 (); 
        //类型，变量名，变量值
    }
    public void test(){
        test();  //报错，Exception in thread"main" java.lang.StackOverflowError 栈溢出异常，电脑内存不够。
    }
}

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

package com.feng.method;
   //阶乘
   //1! 1
   //2！ 2*1
   //3！ 3*2*1
   //5！ 5*4*3*2*1
public class Demo04{
   //递归思想
   public static void main(String[] args){
       System.out.println(f(n:3));  //n为所求阶乘，如果调用阶乘太多了反而会影响机器性能（n=1000或更大,机器可能会崩）
   }
       
       
      public static int f(int n) {
          if (n==1){
              return 1;
 
          }else{
              return n*f(n:n-1);
          }
      }
}