Java总结第三章

本章目的：
1.方法的声明与调用
2.一维数组的声明、初始化与遍历
3.方法中传递一维数组
4.方法的可变参数
难点：方法的递归调用

一.方法的声明与调用

1、方法的定义及语法结构：

 [修饰符列表] 返回值类型 方法名(形式参数列表){

     方法体；

   }

 2、对以上的语法结构进行解释说明：

   2.1、关于修饰符列表

    *是可选项，不是必须的，目前统一写成：public static。

    *方法的修饰符列表当中有static关键字的话，用“类名.方法名(实际参数列表);“调用这个方法。

   2.2、关于返回值类型

    * 一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的，  执行结果可能是一个具体存在的数据。这个具体存在的数据就是返回值。

    * 返回值是一个具体存在的数据，数据都是有类型的，需要指定的是返回值的具体类型。

    * 当一个方法执行结束之后不返回任何数据类型的话，返回值位置必须编写：void关键字。

    * 返回值类型可以是： byte,short,int,long,float,double,boolean,char,String,void....

    * 返回值类型若不是void，则表示这个方法执行结束之后必须返回一个具体的数值，当方法执行结束的时候没有返回任何数据的话，编译会报错。

      返回值的代码编写："return 值;",并且要求值的类型必须和“方法返回值类型”一致。否则也会编译会报错。

    * 只要return语句执行结束，则return所在的方法结束 

   2.3、方法名：

    * 只要是合法的标识符就可以

    * 方法名最好见名知意

    * 方法名命名遵守驼峰命名方式（方法名首字母小写，后边每个单词首字母大写）

   2.4、形式参数列表【形参】：

    * 形参是局部变量：int a; double b;float c; String s;....

    * 形参的个数可以是可以有很多个

    * 形参中起决定作用的是形参的数据类型，形参的名字就是局部变量的名字

    * 方法在调用的时候，实际给这个方法传递的真实数据被称为：实际参数，简称为实参

    * 实参列表和形参列表必须满足：数量相同，类型对应相同

    例如：

    方法定义

     public static int sum(int 变量名,int 合法的标识符就行) {   // (int a,int b)是形参列表

     }

     方法调用

     sum("abc","def");//则会编译报错

     sum(10,20);//(10,20)是实参列表
  
  3、方法的调用

   方法只定义不去调用时不会执行。只有在调用的时候才会执行。

   语法规则：方法的修饰符中有static

    类名.方法名(实参列表);       //表示调用某个方法，传递这样的实参

个人理解：

public class Method{  

 //类体：类体中不能直接编写语句，除声明变量外。方法出现在类体中

 //主方法就是需要这样固定编写，这是程序入口。

    public static void main(String[] args){

   //这里的程序是一定会执行的，从这里作为起点开始执行程序，调用Method的sum方法，传递两个实参

  Method.sum(10,20);    //(10,20)实参列表，实际上执行到这里main方法暂停了，进入sum方法执行，sum方法执行结束，代表这一句语句执行结束，才会进入下一句接

着执行

  //一个方法可以被重复使用，重复调用

  int a=100;

  Method.sum(a,500);       //(a,500)实参列表

  //再次调用方法
  int k=90;
  int f=10;
  Method.sum(k,f);     //(k,f)实参列表
 }
 注意：自定义方法，不是程序入口

 public static void sum(int x,int y){     //方法体

        System.out.println(x+"+"+y+"="+(x+y)); 

  }
}

***关于方法的递归调用

1、 什么是递归？

方法自身调用自身。

即

a(){

  a()

     }

递归算法的两个条件:

递归出口(结束条件)

逐层递推向出口逼近

2、 递归很耗费栈内存，递归算法可以不用的时候尽量不用

3、递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误。

4、递归即使有了结束条件，即使结束条件是正确的，也可能会发生栈内存溢出错误。

注意：有些情况下功能的实现必须依靠递归方式。例如：目录拷贝。

递归算法举例：

package recursive;

public class SumRecursive {

public static void main(String[] args) {

        int result=getSum(100);

        System.out.println(result);

}

/*此方法的作用是获取从1到number的和 */

public static int getSum(int number){

if(number==1){      //结束条件

return 1;

}else{

int temp=getSum(number-1);   // 从1开始到number-1的和

return temp+number;

}

}

}

练习：编写一个计算器，实现加减乘除

package org.day3;

import java.util.Scanner;

public class Calculator {
 

   public static void main(String[] args) {

         Scanner scan=new Scanner(System.in);

         System.out.print("请输入第一个数字:");

         int num1=scan.nextInt();

         System.out.print("请输入符号:");

         String operator=scan.next();

         System.out.print("请输入第二个数字:");

         int num2=scan.nextInt();

         counter(num1,operator,num2);

        System.out.println("计算结果是:"+num1+operator+num2+"="+counter(num1,operator,num2));

   }

   public static int counter(int num1,String operator,int num2){

         int result=0;

        switch(operator){

        case "+":

        result=num1+num2;

        break;

        case "-":

        result=num1-num2;

        break;

        case "*":

        result=num1*num2;

        break;

        case "/":

        result=num1/num2;

        break;

        }

     return result;

   }

}

二.一维数组的声明，初始化与遍历

1.数组的定义：数组是一个变量，存储相同数据类型的一组数据。

2.一维数组的声明

声明一个变量就是在内存空间划出一块合适的空间，声明一个数组就是在内存空间划出一串连续的空间。

下面将举例一一说明一维数组的初始化：

int[] a;    //声明未初始化

a = new int [10];     // 定义占用空间大小（10个int）

int[] a = new int [10];       //声明并定义大小（即分配了指定大小的空间）

int[] a = {1,2,3};       // 声明并初始化，占用空间大小是3个int。

3.遍历数组的两种方式

方法一：.通过for循环获取数组下标从而遍历对应元素。

方法二：foreach输出

for(数据类型 变量名称：数组类型）{

.....

}

两种方法包含在下列代码中：

package array;

public class ArrayDemo {

 public static void main(String[] args) {

  int[] a=new int[5];

  a[2]=23;

  a[4]=19;

  System.out.println("遍历第一个数组：");

  for(int i=0;i<a.length;i++){   // i充当了下标

   System.out.print(a[i]+"  ");

  }

  System.out.println();

  int[] b={11,22,33,44,55,66};   // 直接给数组赋值

  System.out.println("遍历第二个数组：");

  for(int i=0;i<b.length;i++){   // i充当了下标

   System.out.print(b[i]+"  ");

  }

  System.out.println();

  System.out.println("使用foreach方式遍历数组：");

  for(int x:b){

   System.out.print(x+"  ");

  }

  System.out.println();

 }

}

三。方法中传递一维数组

由下列代码陈述：

package array;

public class MethodArray {

 public static void main(String[] args) {

  int[] a={23,12,999,88,78};

        changeArray(a);

        for (int i = 0; i < a.length; i++) {

       System.out.print(a[i]+"  ");

       }

 }

 public static void changeArray(int[] a){

  a[2]=666;

 }

}

四.方法的可变参数

概念：方法中可接收的参数不再是固定的，而是可以根据需要传递数量不等的参数个数。

格式：返回值类型  方法名（类型...  参数名）{

              ...

}

例：package array;

public class ChangeableParam {

   public static void main(String[] args) {

        show();

        show(1,3,5,7,9);

        show(2,4,6,8,0,12);

   }

   public static void show(int... a){

    System.out.println("当前传递的参数个数是："+a.length);

     for (int i = 0; i < a.length; i++) {

      System.out.print(a[i]+"  ");

      }

   System.out.println();

   System.out.println("***************************");

   }

}

注意：向方法传递可变参数后，参数在方法内部是以数组的形式保存下来的。