JAVA笔记整理-JAVA方法

一、方法

方法的概念

​ 将一个功能抽取出来，放在类中的大括号中， 形成一个独立的功能 ， 当需要使用该功能时，则调用它， 这样可以增强代码的复用性（重复利用） ，并解决代码的冗余现象。

方法的语法：

​ [访问修饰符] 返回值类型 方法名( [参数类型 参数名1 , 参数类型 参数名2 ...] ){

​ 方法体

​ }

​ 详解：

​ 访问修饰符： 用于修饰这个方法的调用范文 目前默认 public static

​ 返回值类型： 无返回值就写void 或者 方法执行后返回的结果的数据类型 ，方法执行完之后会将结果返回

​ 方法名 ： 给方法取名， 准寻标识符的规则

​ 参数类型 、参数名： 它们是同时定义 ，方法在执行时未知的数据，需要在调用方法时进行传递值。 参数类型表示 这个参数的数据类型 ，参数名就是一个参数名称 这个参数名可以在方法体中使用。

​ 方法体： 这个方法具有的功能（代码块）

    定义一个方法
    public static int add（int num1 ， int num2）{
    	  
    	  return num1+num2;
    
    } 

​ 根据方法的参数 不同，返回值不同，可以将方法分为四类：

1、无参无返回值方法

语法：

   public  static  void 方法名(){
       方法体 
   }

2、无参有返回值方法

​ 语法：

 public static 返回值类型  方法名 (){
     方法体
 }

结果在n中

3、有参无返回值方法

​ 语法：

public  static void 方法名(参数列表 ){
    方法体
}

情况一、 当参数中是基本数据类型 ，将实参的值赋值给 形参

public  static void add(int num){
    num++;	
    System.out.println("方法中 num 的值："+num);

}

调用方法： num的改变不会改变n 的值 ，因为是两个独立的内存

int n =10;
System.out.println(n);
add(n);
System.out.println("方法外面 实参的值："+n);

结果输出：

​ 方法中 num 的值： 11

​ 方法外面 实参的值：10

情况二： 当参数的数据类型是引用数据类型

例如 数组 、类

​

 // 方法的比对   参数是数组
    public static  void add(int [] arr){
        arr[0]++;
        System.out.println("方法中 arr[0]="+arr[0]);
    }

调用：

       int [] array ={10,20};
        add(array);// 会调用 参数是数组的add方法
        System.out.println("方法外面的 arr[0]="+ array[0]);

结果：

​ 方法中 arr[0]=11
​ 方法外面的 arr[0]=11

类的调用：

  public static void addAge(Student student){
        // 将学生的年龄 获取 自加
       int age =  student.age;
       age++;
       //  在重新赋值
       student.age=age;

    }
    

调用

 Student student = new Student(); // age默认为 18
        System.out.println("方法调用之前： "+student.age); // 18
         addAge(student); // 传的地址
        System.out.println("方法外面 学生的年龄："+student.age);

结果输出： 方法调用之前： 18

​ 方法外面 学生的年龄：19

  /**
         *   以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
         *       也就是说  参数再传递时，将引用类型的地址赋值给 方法的形参
         *                      对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
         *                      不会影响实参的值
         *       原因： 引用数据类型在参数传递时 是地址  （JVM对于堆内存的大小不可控）
         *             基本数据类型在参数传递时 是值
         *
         */

情况三、 当参数是String类型时 ，String是引用数据类型 ，但是在参数传递时，是与基本类型一样

 public static void main(String[] args) {
    // 参数是字符串
        String uname ="李四";
        sayHello(uname);
        System.out.println("我最后对"+uname+"sayHello");
    }
    public static void sayHello(String name){
        name="张三";
        System.out.println("我对"+name+"sayHello");
    }

结果：

我对张三sayHello
我最后对李四sayHello

4、有参有返回值方法

语法：

  public  static 返回值类型 方法名(参数列表){
      方法体
  }

​

例如 ：

    public static String sayHello(String name){
        name="张三";
        System.out.println("我对"+name+"sayHello");
        return name ;
    }

调用

 public static void main(String[] args) {		
		// 参数是字符串
        String uname ="李四";
        // 将返回值接收  ，这是 uname 才被改变 ，如果不接受，则不改变
        uname = sayHello(uname);
        System.out.println("我最后对"+uname+"sayHello");
 }

结果：

我对张三sayHello
我最后对张三sayHello

二、方法的调用以及方法参数传递

​ 1、方法的定义：

​ 访问修饰符 返回值类型 方法名 （[参数列表]）{

​ 方法体

​ }

​ 如果方法体中需要一些未知的数据作为执行条件，那么这些数据可以作为参数。

​ 如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型

​ 方法调用两种方式：

​ 1、 对象名.方法名(参数)

​ 2、直接写方法名调用 ，但必须是static修饰的

​

 // 获取这个字符串的第一个字符 
 public static char method1(String str){
         return str.charAt(0); //获取字符串的第一个字符
  }

//方式一： 调用方法
对象名.method1()
//方式二：  调用静态方法 （static修饰的）
String s ="abc";
char c = method1（s）//  s将赋值给 方法的形参 str   ，那么方法执行时str有值
// c 就是方法调用后的返回值
   

1、方法的参数是基本数据类型 ，它传递的是 值

  // 计算一个数的平方  
  public static int  pow(int a){
      a=a+2;  // 6
      return a*a;  // 6*6 = 36
      
  }

  main:
     int num=4;
    int sum =   pow(num); //num实参    num赋值给a 
    System.out.println(num);  // 4
    System.out.println(sum); // 36

2、方法的参数是引用数据类型，它传递的是地址 （String类型除外）

    //参数 是数组类型
    public static int pow(int [] arr){
        arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
        return arr[0]*arr[0];  // 4*4
    }

调用

 // 调用另一个pow
        int [] array = {2,3};
       int sum2 =  pow(array) ; //  array中存放数组的地址  ，将地址赋值给  arr形参
        System.out.println(array[0]);// 4
        System.out.println(sum2 ); // 16

方法的重载：

​ 在一个类中，存在相同方法名的两个及以上的方法，且他们的参数列表不同（参数类型不同 ，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型

​ 一个类中不能存在完全相同的方法，他们是重复的方法 JVM编译不通过

例如：

  public  int  add(int a ,int b){
      return  a+b;
  }
  public int add(long a,long b){
      return  (int)(a+b);
  }
  //与前两个 不重载
  public void add(int c,int d){
      
  }
  // 能与 方法1 ，2 构成重载
  public void  add(int a){
      
  }
   // 能与 方法1 ，2 构成重载
  public void  add(int a ,long b){
      
  }
   // 能与 方法1 ，2 构成重载
  public void add(long a ,int b){
      
  }

把握： 方法名是否相同，同时 参数列表是否不同 （参数个数不同 或者参数类型不同或者参数顺序不同）

在一个方法可以调用其他的方法， 它们的执行流程

  /**
     * 程序入口
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("这里是main方法的开始");
         method1();
        System.out.println("这是main方法的结束");
    }
    // 在一个方法中可以调用另一个方法， 它们的执行顺序是这样的
    public static   void method1(){
        System.out.println("这是method1 的开始语句块 ");
        // 调用method2
        method2();
        System.out.println("这是method1的 结束语句块");
    }
    public static void method2(){
        System.out.println("这是method2 的开始语句块 ");
        //  调用method3
        method3();
        System.out.println("这是method2 的结束语句块");

    }

    public static  void  method3(){
        System.out.println("这是method3的执行语句块");
    }

三、方法的递归调用

1、定义

​ 在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用， 为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。

方法递归调用执行流程

 public static void m3(int i){
        if(i==5){
            return ;
        }
        System.out.println("这是m3方法开始i :"+ i);
        i++;
        m3(i);
        System.out.println("m3方法的结束 i:"+ i );
  }
   public static void main(String[] args) {
      

        m3(0); //
    }

​ 练习1 ： 使用递归计算一个数的阶乘

​ n =5 = 5! = 5*4的阶乘

​ f(n) = n* f(n-1) =

​ (n-1)*f(n-1-1)

public static int f(int n ){
    if(n==1){
        return 1;
    }
    int s = n*f(n-1);
    System.out.println("结束 --"+s);
    return s;
}
// n =5             n=4                 n=3          n=2           n=1 return 1
 // s = 5*f(4)      s=4* f（3）        s= 3* f(2)    s=2*f(1)
 //  s=5*24          s=4* 6             s=3* 2= 6     s=2
 // s = 120

练习2 ： 一组序列 1 ，1, 2，3, 5 , 8... n， 第12个数 为多少？

public static void main(String[] args) {
       int s= f(12);
        System.out.println("第12个数为：s="+s);
}

public static int f(int n){
    if(n<=2){
        return 1;    //当a=1时返回值为1
    }
     int sum=f(n-1)+f(n-2);//求f(n)的值
     return sum;  //将值sum返回给f(n)

}

练习3： 1， 3， 5， 7， 9， 11 . 问前10个数的和

public static void main(String[] args) {
     int sum=0;
     int su=g(10);
     while (su>=1){      //求前十个数的和
           sum+=su;
           su=su-2;
     }
     System.out.println("前10个数的和为：sum="+sum);
}
 public static int g(int a){
        int sum=0;
        if(a==1){
            return 1;    //当a=1时返回值为1
        }
        int su=g(a-1)+2;                 //求g(a)的值
     //   System.out.println("这里su="+su);
        return su;
    }

练习4 ： 前5个阶乘之和 例如 5!+4!+3!+...1!

public static void main(String[] args) {
long sv=0;
        int i=5;      //定义要求的第几个阶乘
        long d=h(i);
        System.out.println("h="+d);
        for(long j=i;j>=1;j--){       //求阶乘的和
            sv=sv+h(j);
        }
        System.out.println("前5个阶乘之和为："+sv);
  }
  
 public static long h(long i){
        if(i==1){
            return 1;    //当a=1时返回值为1
        }
        long sum=i*h(i-1);//求h(i)的阶乘
        return sum;
    }

练习5：定义一个函数，函数有一个整型参数n，
如果参数n为偶数时，调用函数求1/2+1/4+...+1/n,
如果参数n为奇数时，调用函数1/1+1/3+...+1/n

 public static void main(String[] args) {
     Scanner sc=new Scanner(System.in);
     int p=sc.nextInt();
     double m= j(p);
     System.out.println("m="+m);
}

public static double  j(double n){
    double su=0;
    if(n%2==0){
        if(n==2) {
            return 0.5;
        }
         su=j(n-2)+1/n;
        System.out.println("su="+su);
        return su;

    }else {
        if(n==1) {
            return 1;
        }
         su=j(n-2)+1/n;
        //返回值当n=4时，su(4)=j(2)+j(4) 也就是  su(4)=1/2+1/4
        //1.0/n:表示它本身；如，当n=4时它本身的值为1/n
        //j(n-2):表是它前一个数的值；求和，相加，如n=4时，j(4)=1/2+1/4
        //如n=6时，su(6)=sum(4)+1/6
        return su;
    }
}

练习6、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和。

public static void main(String[] args) {
double sum=0;
        int z=8;
        for(int i=z;i>0;i--){
            int a=l(i);   //分子
            int b=sm(i);   //分母
        sum=sum+a*1.0/b;     //double 型，所以返回值要为为：double型，所以：1.0/1
        }
        System.out.println("sum="+sum);
  }
  
public static int l(int n){
    if(n<=2){
        return 1;
    }
    int h=l(n-1)+l(n-2);   //求单个分子
    return h;
}
public static int sm(int m){
    if(m==1){
        return 1;
    }
    if (m == 2) {
        return 2;
    }
    int k=sm(m-1)+sm(m-2);  //求单个分母
    return k;
}