Java面向对象（二）

Java面向对象（二）


目录

• Java面向对象（二）
  
  
  
  • 
    
    
    
    • 五、方法
      
      
      
      • 5.1 方法的重载（overload）
        
      • 5.2 可变参数的形参
        
      • 5.3 方法参数的值传递机制
        
      • 5.4 递归方法
        
      
      
    
    
  
  

五、方法

5.1 方法的重载（overload）

• 定义：在同一个类中，允许定义多个相同名字的方法，只要参数列表（参数类型或者参数个数）是不同的。
  
• 判断是否为方法重载：
  （1）同一个类，同样的方法名，不同的参数列表！
  （2）与方法修饰符、方法返回值、形参名、方法体无关！
  1. public class OverloadTest{
  2.        
  3.     public void getSum(int a,int b){}
  4.    
  5.     public void getSum(int a,int b,int c){}
  7.     public void getSum(double a,double b){}
  8.    
  9.     public void getSum(int a,double b){}
  10.    
  11.     public void getSum(double a,int b){}
  12.    
  13. /*  不属于方法重载：与方法返回值类型无关  
  14.         public int getSum(int a,int b){      
  15.         return 0;
  16.     }
  17. */
  19. /*  不属于方法重载：与形参名称无关
  20.         public void getSum(int m,int n){}
  21. */
  22.    
  23. /*  不属于方法重载：与方法修饰符无关   
  24.         private void getSum(int a,int b){}
  25. */
  26.    
  27. }

  复制代码
• 方法重载中一些特殊情况：
  

情况一：

1. public class OverloadTest {
2.     public static void main(String[] args){
3.         OverloadTest o = new OverloadTest();
4.         
5.         System.out.println(o.getSum(1,2));                // 输出3
6.         System.out.println(o.getSum(1.0,2.0));        // 输出3.0
7.         System.out.println(o.getSum(1.0,2));        // 输出3.0
9.     }
10.     public int getSum(int a,int b){
11.         return a + b;
12.     }
13.     public double getSum(double a,double b){
14.         return a + b;
15.     }
17. }
19. /*         可以看到，我们并没有定义 getSum(double,int)类型的方法，但是 getSum(1.0,2)还是正常输出，没有报错。
20.         这里getSum(1.0,2)是调用了getSum(double a,double b)的方法，原因是实参2被自动转换为double类型并传递给这个方法。
21.        
22.         那为什么getSum(1,2)调用时不会使用getSum(double a,double b)方法？
23.         原因：
24.         其实 getSum(int a,int b) 和 getSum(double a,double b) 都是 getSum(1.0,2) 可能的匹配。调用方法时，Java编译器会查找最精确匹配的方法，因为方法 getSum(int a,int b) 比 getSum(double a,double b) 更精确，所以调用 getSum(1,2) 时使用的是getSum(int a,int b)。
25.        
26. */

复制代码

情况二：

1. public class OverloadTest {
2.     public static void main(String[] args){
3.         OverloadTest o = new OverloadTest();
5.         System.out.println(o.getSum(1,2));
7.     }
8.     public double getSum(int a,double b){
9.         return 1.0;
10.     }
11.     public double getSum(double a,double b){
12.         return 2.0;
13.     }
15. }
17. /*         输出 1.0
18.         根据调用方法时，Java编译器会查找最精确匹配的方法。
19.         所以 getSum(1,2)调用时使用的是 public double getSum(int a,double b)方法
20. */

复制代码

情况三：
有时调用一个方法时会有两个或多个可能的匹配，但编译器无法判断哪个是最精确的匹配。这就称为“歧义调用”（ambiguous invocation），会产生编译错误。

1. public class OverloadTest {
2.     public static void main(String[] args){
3.         OverloadTest o = new OverloadTest();
5.         System.out.println(o.getSum(1,2));
7.     }
8.     public double getSum(int a,double b){
9.         return 1.0;
10.     }
11.     public double getSum(double a,int b){
12.         return 2.0;
13.     }
15. }
17. /*        编译报错：
18.         Error:(9, 29) java: 对getSum的引用不明确
19.         javase.OverloadTest 中的方法 getSum(int,double) 和 javase.OverloadTest 中的方法 getSum(double,int) 都匹配       
20. */

复制代码

5.2 可变参数的形参

• JavaSE 5.0 中提供了 Varargs (variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
  

1. //JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
2. public class Test {
3.     public static void main(String[] args){
4.         Test o = new Test();
5.         o.test(new String[]{"aa","bb","cc"});        //调用时必须new String[]数组
7.     }
9.     public static void test(String[] books){
10.     for (int i = 0; i < books.length; i++) {
11.             System.out.println(books[i]);
12.         }
13.     }
14. }
16. //JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
17. public class Test {
18.     public static void main(String[] args){
19.         Test o = new Test();
20.         o.test(new String[]{"aa","bb","cc"});        //同样可以用
21.         o.test("aa","bb","cc");                                        //更加简单
22.     }
24.     public static void test(String ... books){
25.         for (int i = 0; i < books.length; i++) {
26.             System.out.println(books[i]);
27.         }
28.     }
29. }
31. /*        输出:
32.         aa
33.         bb
34.         cc
35. */

复制代码

• 说明：
  
  
  
  • 声明格式：方法名(参数的类型名 ... 参数名) 。
    
  • 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个。
    
  • 可变个数形参的方法与同名的方法之间，彼此构成重载。
    
  • 可变参数方法的使用与方法参数部分使用数组是一致的，故两个不能构成方法重载！
    
  • 方法的参数部分有可变形参，需要放在形参声明的最后。
    1. public static void test(int a ,String ... books);
    3. /*        报错，Java编译器不知道可变参数什么时候结束
    4.         public static void test(String ... books,int a);
    5. */

    复制代码
  • 在一个方法的形参位置，最多只能声明一个可变个数形参。
    
  
  

5.3 方法参数的值传递机制

• Java 里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
  
  
  
  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
    
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
    
  
  
• 例子：
  

1. //        针对基本数据类型：
2. public class Test {
3.     public static void main(String[] args) {
4.         int num1 = 1;
5.         int num2 = 2;
6.         System.out.println("在调用 swap 方法前，变量 num1 的值为：" + num1 + "，变量 num2 的值为：" + num2);
8.         swap(num1, num2);
9.         System.out.println("在调用 swap 方法后，变量 num1 的值为：" + num1 + "，变量 num2 的值为：" + num2);
10.     }
12.     public static void swap(int n1, int n2) {
13.         System.out.println("在进行交换前，变量 n1 的值为：" + n1 + "，变量 n2 的值为：" + n2);
14.         int temp = n1;
15.         n1 = n2;
16.         n2 = temp;
17.         System.out.println("在进行交换后，变量 n1 的值为：" + n1 + "，变量 n2 的值为：" + n2);
18.     }
19.    
20. }
22. /*        输出结果：
23.         在调用 swap 方法前，变量 num1 的值为：1，变量 num2 的值为：2
24.         在进行交换前，变量 n1 的值为：1，变量 n2 的值为：2
25.         在进行交换后，变量 n1 的值为：2，变量 n2 的值为：1
26.         在调用 swap 方法后，变量 num1 的值为：1，变量 num2 的值为：2
28.         可以看到，num1 和 num2 的值并没有因为调用 swap 方法而进行交换。
29. */

复制代码

Java 内存分析：

1. //        针对引用数据类型：
2. public class Test {
3.     public static void main(String[] args) {
5.         Data data = new Data();
7.         data.m = 10;
8.         data.n = 20;
10.         System.out.println("m = " + data.m + ", n = " + data.n);
12.         Test test = new Test();
13.         test.swap(data);
16.         System.out.println("m = " + data.m + ", n = " + data.n);
18.     }
20.     public void swap(Data d){
21.         int temp = d.m;
22.         d.m = d.n;
23.         d.n = temp;
24.     }
26. }
28. class Data{
29.     int m;
30.     int n;
31. }

复制代码

Java内存分析：

所以，在写交换数组元素位置方法时：

1. //错误的：交换数组中指定两个位置元素的值
2. //        public void swap(int i,int j){
3. //                int temp = i;
4. //                i = j;
5. //                j = temp;
6. //        }
7.         //正确的：交换数组中指定两个位置元素的值
8.         public void swap(int[] arr,int i,int j){
9.                 int temp = arr[i];
10.                 arr[i] = arr[j];
11.                 arr[j] = temp;
12.         }

复制代码

• 特殊的，String类型
  

1. public class Test {
2.         public static void main(String[] args) {
3.                
4.                 String s1 = "hello";
5.                
6.                 Test test = new Test();
7.                 test.change(s1);
8.                
9.                 System.out.println(s1);       
10.                
11.         }
12.        
13.         public void change(String s){
14.                 s = "hi";
15.         }
16. }
18. //        输出：hello

复制代码

Java内存分析：

结论：String 属于引用类型变量，形参仍然接收的是实参变量的地址值，只是字符串在常量池是一个 char[] 型的一个字符数组，新赋值 hi 时会在常量池新创建一个字符数组，再将 hi 字符串的地址赋值给 s 变量。
5.4 递归方法

• 递归方法：一个方法体内调用它自身。
  
  
  
  • 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
    
  • 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
    
  
  
• 典型使用场景：
  
  
  
  • 求 n 的阶乘
    1. //        求 n！方法
    2. public int f(int n) {
    4.         if (n == 1) {
    5.                 return 1;
    6.         } else {
    7.                 return n * f(n - 1);
    8.         }
    9. }

    复制代码
  • 斐波那契数列
    1. public int f(int n) {
    3.         if (n == 1 || n == 2) {
    4.                 return 1;
    5.         }
    6.     if (n > 2) {
    7.         return f(n-1) + f(n-2);
    8.     }
    9.     return -1;
    10. }

    复制代码
  • 快速排序
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！