概述：

  1. 定义方法 请见method1注释，调用：类.方法(...)、对象.方法(...)。
  2. static 如果方法被static修饰那么这个方法属于类可以被类或对象调用，如果没有那么它只能被对象调用。
  3. 参数传递的机制：基本类型传值和引用类型传引用(String 是一个情况特殊的例子，以后写专门文章介绍)。
  4. 方法的重载：方法名相同(method3)，但是参数不同(注意返回类型不同不能作为重载的标准)，多态的体现之一。
  5. 动态参数：当不确定到底有多少个参数的时候可以采用动态定义。(类似一个数组，但是使用起来比数组方便)。
  6. 递归调用：方法调用自身(注意结束递归的条件!!),经典例子：遍历文件夹(请关注后续相关文章)。

 

程序演示： 放大

  1. package com.cxyapi.oo;  
  2.   
  3. /** Java方法 
  4.  * @author cxy @ www.cxyapi.com 
  5.  */  
  6. public class MethodTest  
  7. {  
  8.     public static void main(String[] args)  
  9.     {  
  10.         String aa="cxyapi";  
  11.         //method1没有被static修饰，所以需要创建一个对象来调用  
  12.         new MethodTest().method1(aa);   
  13.         //method2被tatic修饰，可以直接使用类调用，通常将工具类方法这样定义  
  14.         MethodTest.method2(aa);  
  15.         System.out.println("---------------------");  
  16.           
  17.         //传值演示  
  18.         int i=0;  
  19.         MethodTest.method3(i);  
  20.         System.out.println("main方法里的变量i："+i);  
  21.         //可以看到i传入方法的是一个值，方法内改变传入参数并不会修改原来的i变量。  
  22.           
  23.         //传引用演示  
  24.         Point p=new Point();  
  25.         System.out.print("p的初始值：");  
  26.         p.show();  
  27.         MethodTest.method3(p); //传引用类型，实际是在传递p的引用(指针)，方法对其的改变会改变原来的它  
  28.         System.out.print("method3执行后p的值：");  
  29.         p.show();  
  30.         System.out.println("---------------------");  
  31.         //我们看到method3定义3个方法，名称相同，但是参数不同(可以是类型不同，也可以是个数不同)  
  32.           
  33.         //动态参数演示  
  34.         MethodTest.method4(aa,"www.cxyapi.com");  
  35.         System.out.println("~~~~~~~~~~~~~~~~~~~~~~");  
  36.         MethodTest.method4(aa,"www.cxyapi.com","http://www.cxyapi.com");  
  37.         System.out.println("---------------------");  
  38.     }  
  39.   
  40.     /** 定义一个方法 
  41.      *  修饰符 返回值类型 方法名称(参数类型 参数名) 
  42.      */  
  43.     public void method1(String aa)  
  44.     {  
  45.         System.out.println("非静态方法："+aa);  
  46.     }  
  47.       
  48.     /** 一个静态类 可以直接使用 类.方法 的方式调用 
  49.      */  
  50.     public static void method2(String aa)  
  51.     {  
  52.         System.out.println("静态方法："+aa);  
  53.     }  
  54.       
  55.     //传值  
  56.     public static void method3(int i)  
  57.     {  
  58.         i=2;  
  59.         System.out.println("method3方法内的变量i："+i);  
  60.     }  
  61.       
  62.     //传引用  
  63.     public static void method3(Point p)  
  64.     {  
  65.         p.x=1;  p.y=1;  
  66.         System.out.print("method4中：");  
  67.         p.show();  
  68.     }  
  69.       
  70.     //方法重载演示：3个method3(...)名字相同，但是类型和个数各有不同  
  71.     public static void method3(int i,Point p)  
  72.     {  
  73.         System.out.println("方法重载演示~");  
  74.     }  
  75.       
  76.     /* 采用...来定义一个动态的参数，效果类似参数数组。 
  77.      * 动态参数只能有一个且必须在参数列表的最后 
  78.      * */  
  79.     public static void method4(String ... str)  
  80.     {  
  81.         for(String one:str)  
  82.         {  
  83.             System.out.println(one);  
  84.         }  
  85.     }  
  86. }  
  87.   
  88. /** 定义一个Point类 来演示参数传递引用 
  89.  * @author cxy @ www.cxyapi.com 
  90.  */  
  91. class Point  
  92. {  
  93.     //为了演示方便 我将其定义成为piblic  
  94.     public int x=0;  
  95.     public int y=0;  
  96.       
  97.     public void show()  
  98.     {  
  99.         System.out.println("x="+x+",y="+y);  
  100.     }  
  101. }