java方法

java方法

1. 何谓方法

1. System.out.println()（ 类.对象.方法() ）
2. 方法是语句的集合，它们执行一个功能
   1. 方法解决一类问题的步骤的有序结合
   2. 方法包含于类或对象中
   3. 方法在程序中被创建，在其他地方调用
3. 设计方法原则
   1. 一个方法只完成一个功能，有利于后期扩展

2.方法的定义和调用

1. 方法的定义

   1. 方法包含一个方法头和一个方法体

      1. 修饰符（可选）：定义方法访问类型
      2. 返回值类型（return）
      3. 方法名：方法的实际名称
      4. 参数类型：
         1. 形式参数：方法调用用于接收外界输入数据
         2. 实参：调用方法时传给方法的数据
      5. 方法体：定义方法的功能

      修饰符 返回值类型 方法名（参数类型 参数名）{
          ...
          方法体
          ...
          return 返回值;
      }
      修饰符	//修饰符不区分先后循序 修饰符（final static/public static）
      

      package com.jam.method;
      
      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;
          }
      }
      

   2. 方法调用

      1. 调用方法：对象名.方法名（实参列表）
      2. java支持两种调用模式
         1. 有返回值：方法调用被当成一个值
         2. 无返回值：方法调用为一个语句

   3. 值传递和引用传递

      1. 值传递（java大多数为值传递）

         1. 把实参的值传给形参（形实独立），形参改变但不返回（return）时实参不改变

         public class Demo1 {
                 public static void main(String[] args) {
                         int b =20;
                     	// 实参  实际上的参数
                         change(b);		//值传递（数值）
                         System.out.println(b);
                 }
             	//形参  形式上的参数
                 public static void change(int a){
                         a=100;
                 }
         }
         

      2. 引用传递

         1. 实参和形参统一指向一个地址（形实关联），形参改变实参也会改变

         public class Demo1 {
                 public static void main(String[] args) {
                         int [] a={1,2,3};
                         System.out.println(a[0]);
                         change(a);		//引用传递（数组）
                         System.out.println(a[0]);
                 }
                 public static void change(int[] a ){
                         a[0]=100;
                 }
         }
         //结果为 1 100
         

3.方法重载

1. 在一个类中，有相同的方法名，但形参不同的函数
2. 重载规则
   1. 方法名相同
   2. 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
   3. 方法返回类型可相同也可不相同
   4. 仅仅返回类型不同不足以成为方法重载
3. 注
   1. 方法名相同时，编译器会调用方法的参数个数、参数类型等去逐个匹配；如匹配失败，则编译器报错
4. 重载和重写的区别
   1. 重写
      1. 发生在父类和子类之间
      2. 方法名，参数，返回类型必须相同
      3. 重写访问修饰符的限制一定大于被重写访问修饰符（public > protected > default > private）
   2. 重载

4.命令行传参

1. 通过编写代码在命令行中运行实现传参

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

   

5.可变参数

1. 可变参数 == 不定项参数

2. 声明：在指定参数类型后加一个省略号...

3. 一个方法只能指定一个参数，它必须在参数列表的最后，其他普通参数必须在它之前声明。

   package com.jam.method;
   
   public class Demo04 {
       public static void main(String[] args) {
   
           printMax(new double[]{1, 2, 3});
   
       }
       public static void printMax(double... numbers){
           if(numbers.length == 0 ){
               System.out.println("null");
               return ;
           }
   
           double result = numbers[0];
   
           for (int i = 1 ; i < numbers.length ; i++){
               if (numbers[i]>result){
                   result = numbers[i];
               }
           }
           System.out.println("max value is " + result );
       }
   }
   

6.递归

1. A调用A的方法（即自己调用自己）

2. 通过递归可把复杂问题变简单，递归的能力在用有限语句来定义对象的无限集合

3. 递归结构分成两部分：

   1. 递归头：什么时候不调用自己的方法
   2. 递归体：什么时候调用自身方法

4. 注：

   1. java用栈存储内存
   2. 能不用递归就不用递归，占用内存大，容易宕机

   package com.jam.method;
   
   public class Demo05 {
       //求阶乘
       public static void main(String[] args) {
           Demo05 test = new Demo05();
           int result = test.f(5);
           System.out.println(result);
       }
       public static int f (int n){
           if (n == 1){
               return 1;
           }
           else {
               return n * f (n-1);		//递归
           }
       }
   }