Java基础：方法和类详解

示例代码：

向方法传递对象：

1. class Block{                            //类Block
2.     int a,b,c;                               //int类型变量
3.     int volume;
4.     Block(int x,int y,int z){          //带三个参数的构造         
5.         a = x;                                //给变量赋值
6.         b = y;
7.         c = z;
8.         
9.         volume = a*b*c;
10.         }
11.     boolean sameBlock(Block ob){            //向方法传递对象
12.         if(ob.a==a&ob.b==b&ob.c==c){
13.             return true;
14.             }else{
15.                 return false;
16.                 }
17.         }
18.     boolean sameVolume(Block ob){        //向方法传递对象
19.         if(ob.volume==volume){
20.             return true;
21.             }else{
22.                 return false;
23.                 }
24.         };    
25. }

------------------------------------------------------------------------------------------------------

方法返回对象：

1. class ErrorMsg{
2.     String[] msgs={"1 error","2 error","3 error","4 error"};
3.     
4.     String getErrorMsg(int i){                 //返回String类型的对象
5.         if(i>=0&i<msgs.length){
6.             return msgs[i];
7.         }else{
8.             return "Invalid Error Code";
9.         }
10.     }
11. }

--------------------------------------------------------------------------------------------------------

方法重载：方法名相同，参数返回类型，参数个数不相同

1. class Overload{
2.     void Oload(){
3.         System.out.println("没有参数");
4.     }
5.     void Oload(int a){
6.         System.out.println("一个参数："+a);
7.     }
8.     int Oload(int a,int b){
9.         System.out.println("两个参数："+a+"   "+b);
10.         return a+b;
11.     }
12.     double Oload(double a,double b){
13.         System.out.println("两个double参数："+a+"   "+b);
14.         return a+b;
15.     }
16. }

--------------------------------------------------------------------------------------

重载构造函数：

1. class Queue{
2.     private char[] q;
3.     private int putd,getd;
4.     
5.     Queue(int size){                   //Queue(int size)
6.         q = new char[size];
7.         putd=getd=0;
8.         }
9.     Queue(Queue ob){            //Queue(Queue ob)
10.         putd = ob.putd;
11.         getd = ob.getd;
12.         q = new char[ob.q.length];
13.         for(int i=getd;i < putd;i++){
14.             q[i] = ob.q[i];
15.             }               
16.         }
17.     Queue(char[] a){               //Queue(char[] a)          
18.         putd = 0;
19.         getd = 0;
20.         q = new char[a.length];
21.         for(int i=0;i < a.length;i++){
22.             put(a[i]);
23.             }        
24.         }    
25. }

 

-----------------------------------------------------------------------------------------------------

递归方法：

1. class Factorial{
2.     int factR(int n){                //递归方法求阶乘
3.         int resualt;
4.         if(n==1) return 1;
5.         resualt = factR(n - 1)*n;
6.         return resualt;
7.         }
8.     
9.     int factI(int n){             //非递归方法求阶乘
10.         int t,resualt;
11.         resualt = 1;
12.         for(t=1;t <= n;t++){
13.             resualt *=t;
14.             }
15.             return resualt;
16.         }    
17. }

--------------------------------------------------------------------------------------------------------------------

内部类：嵌套在类的内部，可以访问外层类的所有变量和方法

1. class Outter{                  //外层类
2.     int[] nums;                  //数组变量
3.     Outter(int[] n){            //构造方法
4.         nums = n;
5.         }
6.     void     analyze(){           //普通方法，创建内部类对象，调用内部类方法
7.         Inner in = new Inner();
8.         
9.         System.out.println(in.min());
10.         System.out.println(in.max());
11.         System.out.println(in.ave());
12.         
13.         }
14.         class Inner{                         //内部类，封装了三个方法min(), max(), ave()
15.             int min(){
16.                 int m = nums[0];            //调用外部类的变量
17.                 for(int i=0;i < nums.length;i++){
18.                     if(nums[i] < m) m = nums[i];
19.                     }
20.                     return m;
21.                 }
22.             int max(){
23.                 int m = nums[0];
24.                 for(int i=0;i < nums.length;i++){
25.                     if(nums[i] > m) m = nums[i];
26.                     }
27.                         return m;
28.                 }
29.             int ave(){
30.                 int a = 0;
31.                 for(int i=0;i < nums.length;i++){
32.                      a += nums[i];
33.                     }
34.                     return a/(nums.length);
35.                 }        
36.         }        
37. }
38.  
39. class NestedClassDemo{
40.     public static void main(String args[]){
41.         int[] x = {3,2,1,5,6,9,7,8,};
42.         Outter ob = new Outter(x);
43.         ob.analyze();
44.     }
45. }