15-类的结果之二：方法

Posted 2020-12-17 shici

类的设计中，两个重要结构之二：方法

方法：描述类应该具的功能。
 比如：Math类：sqrt() andom() ...
 Scanner类：nextXxx() ...
 Arrays类：sort() binarySearch() toString() equals() ...

1.举例： 

1 public void eat(){}
2 public void sleep(int hour){}
3 public String getName(){}
4 public String getNation(String nation){}

 

2. 方法的声明：

权限修饰符 返回值类型 方法名(形参列表){
    方法体
 }    

 

3. 说明：
　　3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
　　　Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说

　　3.2 返回值类型： 返回值 vs 没返回值
　   　　3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
　　　　　　return关键字来返回指定类型的变量或常量：“return 数据”。
　　　　　　如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
　　　　　　使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

　　　　3.2.2 我们定义方法该不该返回值？
　　　　　　① 题目要求
  　　　　　  ② 凭经验：具体问题具体分析

　　3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
　　3.4 形参列表： 方法可以声明0个，1个，或多个形参。
　　　　3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
　　　　3.4.2 我们定义方法时，该不该定义形参？
　　　　　　① 题目要求
　　　　　　② 凭经验：具体问题具体分析
　　3.5 方法体：方法功能的体现。

4. 方法的使用中，可以调用当前类的属性或方法
　　特殊的：方法A中又调用了方法A:递归方法。
　　方法中，不可以定义方法。

//========================================================
return关键字：
　　1.使用范围：使用在方法体中
　　2.作用：① 结束方法
　　　　　　② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
　　3.注意点：return关键字后面不可以声明执行语句。

//========================================================
方法的重载：
1.方法的重载的概念
　定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结："两同一不同":同一个类、相同方法名
　　　参数列表不同：参数个数不同，参数类型不同

2.构成重载的举例：
举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
举例二：

 1 //如下的4个方法构成了重载
 2 public void getSum(int i,int j){
 3      System.out.println("1");
 4 }
 5 
 6 public void getSum(double d1,double d2){
 7      System.out.println("2");
 8 }
 9 
10 public void getSum(String s ,int i){
11      System.out.println("3");
12 }
13 
14 public void getSum(int i,String s){
15      System.out.println("4");
16 }

 

不构成重载的举例：

 1 //如下的3个方法不能与上述4个方法构成重载
 2 //    public int getSum(int i,int j){
 3 //        return 0;
 4 //    }
 5 
 6 //    public void getSum(int m,int n){
 7 //    
 8 //    }
 9 
10 //    private void getSum(int i,int j){
11 //    
12 //    }

 

3. 如何判断是否构成方法的重载？
严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

4.如何确定类中某一个方法的调用：
方法名 ---> 参数列表

//========================================================

可变个数形参的方法：
1.使用说明：
* 1.jdk 5.0新增的内容

*2.具体使用：
* 2.1 可变个数形参的格式：数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
* 2.5 可变个数形参在方法的形参中，必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

举例说明：

 1 public void show(int i){
 2 
 3 }
 4 
 5 public void show(String s){
 6     System.out.println("show(String)");
 7 }
 8 
 9 public void show(String ... strs){
10     System.out.println("show(String ... strs)");
11 
12     for(int i = 0;i < strs.length;i++){
13         System.out.println(strs[i]);
14     }
15 }
16 
17 //不能与上一个方法同时存在
18 //    public void show(String[] strs){
19 //    
20 //    }
21 //调用时：
22 test.show("hello");
23 test.show("hello","world");
24 test.show();
25 
26 test.show(new String[]{"AA","BB","CC"});    

//========================================================

java的值传递机制：
1.针对于方法内变量的赋值举例：

System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;

System.out.println("m = " + m + ", n = " + n);

n = 20;

System.out.println("m = " + m + ", n = " + n);

System.out.println("***********引用数据类型：****************");

Order o1 = new Order();
o1.orderId = 1001;

Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

o2.orderId = 1002;

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

规则：

　　如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
　　如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

2.针对于方法的参数概念
　　形参：方法定义时，声明的小括号内的参数
　　实参：方法调用时，实际传递给形参的数据

3.java中参数传递机制：值传递
　　规则：
　　　　* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
　　　　* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

　　推广：
　　　　如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
　　　　如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

4.典型例题与内存解析：
【例题1】

【例题2】

 

 

//========================================================

递归方法：
1.定义：
　　递归方法：一个方法体内调用它自身。
2.如何理解递归方法？
　　> 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
　　> 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
3.举例：

1 // 例1：计算1-n之间所自然数的和
2 public int getSum(int n) {// 3
3         if (n == 1) {
4             return 1;
5         } else {
6         return n + getSum(n - 1);
7         }
8 }                        

1 // 例2：计算1-n之间所自然数的乘积:n!
2 public int getSum1(int n) {
3         if (n == 1) {
4             return 1;
5         } else {
6             return n * getSum1(n - 1);
7         }
8 }    

 1 //例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
 2 //其中n是大于0的整数，求f(10)的值。
 3 public int f(int n){
 4         if(n == 0){
 5             return 1;
 6         }else if(n == 1){
 7             return 4;
 8         }else{
 9 //    return f(n + 2) - 2 * f(n + 1);
10             return 2*f(n - 1) + f(n - 2);
11         }
12 }