方法及其参数

1，      Confirm确定， step over :跨过，单步执行，terminate结束的，使终止 resume 重新开始 process 加工处理

3,return的用法：

主要使用在方法中，表示可以有返回值。

6，方法：

•     定义：方法就是完成特定功能的代码块语句块

–    在很多语言里面都有函数的定义

–    函数function在Java中被称为方法method

•     格式：

–    修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {

                 函数体;

                 return 返回值;

}

修饰符：可以有很多种，访问修饰符（public,private,protected)

 *        静态修饰符 static 

 *        最终的修饰符 final

 *   返回值类型：可以有很多种，int,byte,8中基本数据类型，3中引用数据类型；

 *         有一种特殊的返回值类型 void，表示没有返回值类型。

 *         如果返回值类型是void，可以省略return，

 *         否则其他情况下不能省略return语句

 *  

 *   方法名: 标识符， 第一个单词所有的小写，第二单词的首字母大写，其他字母小写，以此类推

 *       例如： myMethod(),subWay() halfSearch() 驼峰式的命名方式

 *      

 *   参数列表：parameter list

 *     parameter:参数

 *     list：列表

 *     可以没有参数，参数列表为空。也可以有一个参数，也可以有多个参数。

方法的示意图：

  

*

 * 方法的练习：

 *

 * 两个明确：

 *   1：要明确定义的方法的返回值类型应该是什么？

 *       8+3+1

    3+1：String类型，数组类型，集合，类类型，

 *   2：要明确方法的参数列表需要不需要为空，参数到底有几个？

 *  

 *  

 *  

 *   举例说明：

 *      求两个数据之和的案例

 *     

 *      如果数不说什么类型，默认使用int即可

 *     

 *     

 *   程序分析：

 *      要有返回值类型，int类型

 *      参数列表，需要两个int类型参数

 * @author jerry

 *

 */

public class MethodDemo2 {

 

      //程序的入口，不准修改任何字

      public staticvoid main(String[] args) {

           System.out.println("helloworld");

 

           // 方法不调用不执行

          

           //定义两个变量,a,b的作用域 main 方法内

           int a =3;

           int b =4;

          

           //调用方法,并且 接受方法的返回值，同时赋值给sum变量

           int sum =add(a,b);// a,b 我们实际参数

          

          

           System.out.println(a+"+ " +b +" = "+ sum);

          

          

           /**

            * 总结：

            *  1：方法不调用不执行

            *  2：如果方法没有返回值，我们可以不用本地变量来接收

            *  3：如果方法有返回值，建议大家使用本地变量来接收方法的返回值；

            */

          

           /**

            * java的术数：

            *

            *  实际参数：在调用方法的时候，传递给方法的参数列表的参数，我们叫做实际参数

            *  形式参数：方法定义中，参数列表中的参数名，我们叫做形式参数

            * 

            * 

            *  当实际参数的值，传递给形式参数的时候，发生了值的copy

            * 

            *  生活中的例子：

            *     快递员：

            */

          

//        System.out.println(num1);//不行，因为num1 超出了作用域

//        System.out.println(sum);//不行，因为sum 超出了作用域

      }

     

     

      /**

       * 输入两个整数求两个数的和

       * @param num1 第一整数

       * @param num2 第二个整数

       * @return

       */

      public staticint add(int num1,int num2){// num 1,num2 叫做形式参数，形参

//        int num1 =a;

//        int num2 =b;

           //Thismethod must return a result of type int

          

           // num1,num2 这个两个本地变量（local variable)作用域 在 add 方法内;

           // 变量离开了作用域，就消失了（jvm,就回收了内存）

           // 求两个数字的和

 

           int sum =0;

          

          

            //sum 这个本地变量，的作用域 也在add方法内。

          

           sum =num1 + num2;

          

           System.out.println("直接输出" +sum);

           return sum;

      }

 

}

练习一：

* 练习：

 * 打印数字金字塔，如下所示：

 

              1

            1 2 1

          1 2 3 2 1

        1 2 3 4 3 21

      1 2 3 4 5 4 32 1

 

 * @author jerry

 *

 */

public class Exercise1 {

 

      public staticvoid main(String[] args) {

 

           // 外循环 控制 行数

           for(inti=1;i<=5;i++){

                

                 //内循环 控制列数

                

                 // 控制 空白

                 for(intm = 1;m<=5-i;m++){ // 第一行 需要 4空白；第二行，需要3空白

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

                 }

                

                 // 控制 前半部分的数字

                 for(intj=1;j<=i ;j++){

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

                 }

                

                 // 控制 后半部分的数字

                 for(intn=i-1;n>0;n--){ // i=1 ,判断条件不成立 不执行，i=2 执行，输出 1；i=3 执行 ，输出2 1

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

                 }

                

                 // 控制 换行

                 System.out.println();//打印一个空格，并且换行；

           }

      }

 

}

3，方法的调用演示

 * （1）用明确返回值的方法调用

 * A形式：直接调用

 * B形式：直接输出到控制台

 * C：使用一个本地变量，接收方法的返回值

 * 4,对于无返回值的方法调用

 * 直接调用

 * 5, 方法的注意事项：

 *   

 *   方法不调用不执行

 *   方法与方法是平级关系，不能嵌套定义

 *   方法定义的时候参数之间用逗号隔开

 *   方法调用的时候不用在传递数据类型

 *   如果方法有明确的返回值，一定要有return带回一个值

 * 6,明确：

 * （1）是否需要返回值，参数类型

 * （2）参数列表

 * 7，自定义的方法中，尽量不出现scanner,它出现在main()方法（程序的入口）中

 * 8，写方法名的时候，建议附加上一个小括号。

 * 9,方法的重载演示

 * （1）定义：在同一个类中，允许存在多个同名的方法，只要参数个数和参数类型不一样

 * （2）特点;

 * 方法的返回值，不能作为方法是否为重载方法的判断依据

举例说明：

举例说明：

 *   

 *   比较两个数据是否相等。

 *   参数类型分别为：

 *   两个byte类型，

 *   两个short类型，

 *   两个int类型，

 *   两个long类型，

 *   并在main方法中进行测试

 * @author jerry

 *

 */

public class OverloadDemo1 {

      public static void main(String[] args) {

            //int类型的方法调用

            isEqual(10, 20);

            //byte类型的方法调用

            byte b1 = 10;

            byte b2 = 20;

//          isEqualByte(b1, b2);

            //这种情况下，需要多记一个方法名，增加了调用者的负担。

            //使用方法的重载来改造

            isEqual(b1, b2);

      }

      //方法签名 isEqual(int,int)

      public static boolean isEqual(int num1,int num2){

            boolean result =false;

            if(num1==num2){

                  result = true;

            }

            return result;

      }

//    public static boolean isEqualByte(byte num1,byte num2){

      // 方法的签名 isEqual(byte,byte)

    public static boolean isEqual(byte num1,byte num2){

            boolean result =false;

            if(num1==num2){

                  result = true;

            }

            return result;

      }

 

 * 10，方法签名：方法名+参数列表，作为方法的唯一表示。

public static void isEqual(byte num1,byte num2,int a){

            boolean result =false;

            if(num1==num2){

                  result = true;

            }

//          return result;

      }

 

 * 11，返回类型不能作为方法重载的依据

12,典型例题：

通过键盘录入两个数，输出两个数中的最大值。

分析思路：如图

publicstaticvoid main(String[] args) {

    

     Scanner sc=new Scanner(System.in);

     System.out.println("请输入一个整数值");

     intx=sc.nextInt();

     System.out.println("请输入另一个整数值");

     inty=sc.nextInt();

     intz=isCompare(x,y);

     if(z==0){

        System.out.println("这两个数相等");

     }

     else{

        System.out.println("这两个数中较大的为"+z);

     }

publicstaticint isCompare(intnum1 ,intnum2){

   intsum=0;

   if(num1>num2){

     returnsum=num1;

   }

   elseif(num1<num2){

     returnsum=num2;

   }

   else{

     returnsum;

   }

  

   }

java 中基本数据类型和引用数据类型作为参数传递给方法时的不同

结论：

 * 基本数据类型作为形式参数传递时，在方法内，对形式参数的改变，不会影响实际参数的值。

 * 引用数据类型作为形式参数传递时，在方法内，对形式参数的改变，会影响实际参数的值。

 *   (引用数据类型：两个变量指向了同一块内存空间)

 *

 * 如何debug?

 * 1: 在所有的方法中在有效的代码行位置，添加断点

 * 2：以debug模式启动程序

 * 3：debug模式下，使用单步执行来查看程序的执行

 * @author jerry

 *

 */

public class ParamterDemo {

 

   public static void main(String[] args) {

     //定义两个本地变量 a和b，并且a和b分别初始化为 10和20

     int a = 10; //本地变量a，作用域在 main()里面

       int b = 20;//本地变量b，作用域在 main()里面

      

      System.out.println("原值：a:"+a+",b:"+b);

       //方法的调用，a , b 是实际参数

       change(a,b);

      System.out.println("改变后a:"+a+",b:"+b); // a =? b=?

       // 20,40    or 10 ,20

 

       //本地变量，引用类型，堆内存

       int[] arr = {1,2,3,4,5};

      System.out.println(arr);//数组的地址值（堆内存上）

       //方法的调用

       change(arr);//实际参数 arr= 0xfff01

      System.out.println("数组元素："+arr[1]); // 输出什么？2 or 4

 

   }

  

   /**

    * 

    * @param a int类型的参数，作为方法的参数，形式参数

    * @param b int类型的参数，作为方法的参数，形式参数

    */

   public static void change(int a,int b)  // 形式参数

   {

     /**

      * int a = ? 从调用者来，从实际参数来 10 作用域在change()方法内 

      * int b  =? 从调用者来，从实际参数来 20 作用域  在change()方法内

      * 本地的基本数据类型的变量，在栈空间中存放

      */

      System.out.println("change()方法内原值：a:"+a+",b:"+b);

       // 只是改变形式参数的值

       a = b; // a = 20

       b = a + b; // b= 40;

      System.out.println("change()方法内改变后a:"+a+",b:"+b);

   }

  

   /**

    *

    * @param arr 数组类型，引用类型

    */

   public static void change(int[] arr1) //形式参数

   {

     /**

      * arr1 = 0xfff01; 相等于两个变量指向了同一块内存空间

      * 相对于在方法内部，有一个本地变量

      * int[] arr = ？从调用者来，谁调用，谁提供；实际参数来

      */

       for(int x=0;x<arr1.length; x++)

       {

         //对于数组元素的值为偶数的元素，进行乘以2操作。

           if(arr1[x]%2==0)

           {

           // 通过数组的地址值，找到堆内存，对具体的元素的值进行乘以2操作

               arr1[x]*=2;

           }

       }

   }

 

 

}