JavaSE——面向对象2：方法的调用机制、传参机制、方法递归、方法重载、可变参数、作用域

目录

一、成员方法

(一)方法的快速入门

(二)方法的调用机制(重要)

(三)方法的定义

(四)注意事项和使用细节

1.访问修饰符(作用是控制方法的使用范围)

2.返回的数据类型

3.方法名

4.形参列表

5.方法体

6.方法调用细节说明

(五)传参机制

1.基本数据类型的传参机制

2.引用数据类型的传参机制

2.1方法传参传入数组

2.2方法传参传入对象

2.3传参后对象=null 

2.4传参后创建新的对象

(六)对象的克隆

(七)方法的递归调用

1.方法的递归执行机制

2.使用递归的重要规则

3.方法递归经典题目

3.1计算n的阶乘

3.2斐波那契数列

3.3猴子吃桃问题

3.4汉诺塔

(八)方法的重载(OverLoad)

(九)可变参数

二、作用域

(一)基本使用

(二)注意事项和细节使用

(三)跨类访问对象属性的2种方式

---

一、成员方法

(一)方法的快速入门

        在某些情况下，我们需要定义成员方法(简称方法)。比如人类：除了有一些属性外(年龄、姓名...)，还有一些行为，比如：说话、跑步、唱歌...这些都要用成员方法才能完成。

方法代码示例：

public class Method01 { public static void main(String[] args) {//方法使用//1. 方法写好后，如果不去调用(使用)，不会输出//2. 先创建对象 ,然后调用方法即可Person p1 = new Person();//调用getSum方法，同时num1=10, num2=20//把 方法 getSum 返回的值，赋给 变量 returnResint returnRes = p1.getSum(10, 20); System.out.println("getSum方法返回的值=" + returnRes);}
}class Person {String name;int age;//方法(成员方法)//添加getSum成员方法,可以计算两个数的和//1. public 表示方法是公开的//2. int :表示方法执行后，返回一个 int 值//3. getSum 方法名//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数//5. return res; 表示把 res 的值， 返回public int getSum(int num1, int num2) {int res = num1 + num2;return res;}
}

(二)方法的调用机制​​​​​​​(重要)

下图是JVM内存中，方法的调用机制分析图：

成员方法的好处：提高代码的复用性；可以将实现的细节封装起来，然后供其他用户来调用即可。

(三)方法的定义

访问修饰符 返回数据类型 方法名(形参列表){语句;return 返回值;
}

1. 形参列表：表示成员方法输出，例如上面的getSum(int num1,int num2)
2. 返回数据类型：表示成员方法输出，void表示没有返回值
3. 方法体：表示为了实现某一功能代码块
4. return语句不是必须的：当有返回数据类型时，必须要有return语句

(四)注意事项和使用细节

1.访问修饰符(作用是控制方法的使用范围)

如果不写默认访问，有4种：public、protected、默认、private

2.返回的数据类型

1. 一个方法最多有一个返回值，要想返回多个值，就可以返回一个数组；
2. 返回类型可以为任意类型，包含基本数据类型或引用数据类型(数组，对象)；
3. 如果方法要求有返回数据类型，则方法体中，最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容；
4. 如果方法返回值类型是void，则方法体中可以没有return语句，或者只写return；

3.方法名

        遵循驼峰命名法，最好见名知义，表达出该功能的意思即可，比如得到两个数的和getSum这种，开发中按照规范来命名。

4.形参列表

1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1,int n2)
2. 参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(int[][] map)
3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！
4. 方法定义时的参数类型为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参；形参和实参的类型要一致或兼容、个数、顺序必须一致！

5.方法体

        方法体中写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是方法体里面不能再定义方法！即：方法不能嵌套定义。 

6.方法调用细节说明

1)同一个类中的方法调用：直接调用即可

public class MethodDetail {public static void main(String[] args) {A a = new A();a.sayOK();// print()方法被调用 n=10// 继续执行sayOK()~~~}
}class A {public void print(int n) {System.out.println("print()方法被调用 n=" + n);}public void sayOK(){ // sayOK可以直接调用同类中其他成员方法print(10);System.out.println("继续执行sayOK()~~~");}
}

2)跨类中的方法A类调用B类方法：需要通过对象名调用。比如 对象名.方法名(参数); 

public class MethodDetail {public static void main(String[] args) {A a = new A();a.m1();}
}class B {public void hi() {System.out.println("B类中的hi()方法被执行");}
}class A {// 在A类中访问B类的方法public void m1() {System.out.println("m1()方法被调用");// 先创建B对象B b = new B();// 然后再调用方法b.hi();System.out.println("m1()方法继续执行");}
}

3)特别说明：跨类的方法调用和方法的访问修饰符相关。

(五)传参机制

1.基本数据类型的传参机制

基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参！

因为多个方法的调用会在栈中开辟各自独立的空间，基本数据类型不是引用，不同的方法中的变化不会互相影响。

public class MethodParameter01 {public static void main(String[] args) {AB ab = new AB();int a = 10;int b = 20;ab.swap(a, b); //调用swapSystem.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20}
}class AB {public void swap(int a,int b){System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20//完成了 a 和 b的交换int tmp = a;a = b;b = tmp;System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10}
}

上述代码内存图： 

2.引用数据类型的传参机制

引用数据类型传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参!

2.1方法传参传入数组

public class TestDemo1 {public static void main(String[] args) {AAB aab = new AAB();int[] arr = {1, 2, 3};aab.test100(arr);System.out.println("main的arr输出：" + Arrays.toString(arr));// test100的arr输出：[200, 2, 3]// main的arr输出：[200, 2, 3]}
}class AAB {// test100方法，接收一个数组，在方法中修改数组public void test100(int[] arr) {arr[0] = 200;System.out.println("test100的arr输出：" + Arrays.toString(arr));}
}

2.2方法传参传入对象

public class TestDemo1 {public static void main(String[] args) {AAB aab = new AAB();Person p = new Person();p.name = "jack";p.age = 10;aab.test200(p);System.out.println("main 的p.age=" + p.age); // 10000}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {p.age = 10000;// 修改对象属性}
}

2.3传参后对象=null 

public class TestDemo1 {public static void main(String[] args) {AAB aab = new AAB();Person p = new Person();p.name = "jack";p.age = 10;aab.test200(p);System.out.println("main 的p.age=" + p.age); // 10}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {
//        p.age = 10000;// 修改对象属性p = null;}
}

2.4传参后创建新的对象

public class TestDemo1 {public static void main(String[] args) {AAB aab = new AAB();Person p = new Person();p.name = "jack";p.age = 10;aab.test200(p);System.out.println("main 的p.age=" + p.age); // 10}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {
//        p.age = 10000;// 修改对象属性
//        p = null;p = new Person();p.name = "tom";p.age = 99;}
}

(六)对象的克隆

对象的克隆：编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象
注意：要求得到新对象和原来的对象，是两个独立的对象，只是他们的属性相同

编写方法的思路：
1.方法的返回值类型：Person
2.方法的名字：copyPerson
3.方法的形参：(Person p)
4.方法体，创建一个新对象，并复制属性，返回即可

代码如下：

public class TestDemo1 {public static void main(String[] args) {AAB aab = new AAB();Person p = new Person();p.name = "alice";p.age = 12;Person p2 = aab.copyPerson(p);System.out.println("p的hashCode：" + p.hashCode() + " 姓名=" + p.name + " 年龄=" + p.age);// p的hashCode：1163157884 姓名=alice 年龄=12System.out.println("p2的hashCode：" + p2.hashCode() + " 姓名=" + p2.name + " 年龄=" + p2.age);// p2的hashCode：1956725890 姓名=alice 年龄=12System.out.println(p == p2); // false}
}class Person {String name;int age;
}class AAB {public Person copyPerson(Person p) {Person p2 = new Person();p2.name = p.name;p2.age = p.age;return p2;}
}

(七)方法的递归调用

1.方法的递归执行机制

        递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于解决复杂问题，同时可以让代码变得简洁。方法的递归就是，栈不断地开辟后，直到遇到返回条件，才会一个个关闭。

给出一段代码，画出内存图：

public class Recursion01 {public static void main(String[] args) {T t1 = new T();t1.test(4);}
}class T {public void test(int n) {if (n > 2) {test(n - 1);}System.out.println("n=" + n);}
}

上面的结果输出：

当添加else分支后，只会输出2，因为其他的方法没有打印部分，只有当n=2的时候才会打印： 

public void test(int n) {if (n > 2) {test(n - 1);} else {System.out.println("n=" + n);}}

2.使用递归的重要规则

1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2. 方法的局部变量是独立的，不会相互影响，比如n变量
3. 如果方法中使用的是引用类型变量(比如数组、对象)，就会共享该引用类型的数据
4. 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError
5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

3.方法递归经典题目

3.1计算n的阶乘

public class Recursion01 {public static void main(String[] args) {T t1 = new T();int result = t1.factorial(5);System.out.println(result);}
}class T {public int factorial(int n) {if (n == 1) {return 1;} else {return factorial(n - 1) * n;}}
}

计算n的阶乘内存图：

3.2斐波那契数列

请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n，求出它的值是多
思路分析
1. 当n = 1 斐波那契数 是1
2. 当n = 2 斐波那契数 是1
3. 当n >= 3  斐波那契数 是前两个数的和
4. 这里就是一个递归的思路

public class TestDemo1 {public static void main(String[] args) {T t = new T();System.out.println(t.fibonacci(7)); // 13}
}class T {public int fibonacci(int n) {if (n >= 1) {if (n == 1 || n == 2) {return 1;} else {return fibonacci(n - 1) + fibonacci(n - 2);}}else {System.out.println("您的输入有误!");return -1;}}
}

3.3猴子吃桃问题

        猴子吃桃问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天，想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？

思路分析——逆推
1. day = 10 时 有 1个桃子
2. day = 9 时  有 (day10 + 1) * 2 = 4
3. day = 8 时  有 (day9 + 1) * 2 = 10
4. 规律就是  前一天的桃子 = (后一天的桃子 + 1) *2   ==> 后一天的桃子 = day + 1
5. 递归

public class TestDemo1 {public static void main(String[] args) {
//        demo1();T t = new T();System.out.println(t.peach(1)); // 1534}private static void demo1() {// 已知第10天剩下1个桃子int peachesOnTenthDay = 1;// 逆向推算到第一天for (int i = 9; i >= 1; i--) {// 每一天的桃子数量是前一天的桃子数量加1的两倍peachesOnTenthDay = (peachesOnTenthDay + 1) * 2;}// 输出第一天摘的桃子数量System.out.println("第一天猴子共摘了 " + peachesOnTenthDay + " 个桃子。");}
}class T {public int peach(int day) {if (day == 10) {return 1;} else if (day >= 1 && day <= 9) {return (peach(day + 1) + 1) * 2;} else {System.out.println("day在1-10");return -1;}}
}

3.4汉诺塔

        汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子， 在一根柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一 根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

public class TestDemo1 {public static void main(String[] args) {T t = new T();t.tower(3, 'A', 'B', 'C');}
}class T {//num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔public void tower(int num, char a, char b, char c) {// 如果只有一个盘num == 1if (num == 1) {// 把a移动到c即可System.out.println(a + "->" + c);} else {//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)//(1)先移动上面所有的盘到 b, 借助 ctower(num - 1, a, c, b);//(2)把最下面的这个盘，移动到 cSystem.out.println(a + "->" + c);//(3)再把b塔的所有盘，移动到c ,借助atower(num - 1, b, a, c);}}
}

以3个圆盘为例，结果：

(八)方法的重载(OverLoad)

        Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。重载减轻了起名和记名的麻烦。

注意事项和使用细节：

1. 方法名：必须相同
2. 形参列表：必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求
3. 返回类型：无要求

方法重载示例：

public class OverLoad01 { public static void main(String[] args) {// System.out.println(100);// System.out.println("hello,world");// System.out.println('h');// System.out.println(1.1);// System.out.println(true);// MyCalculator mc = new MyCalculator();System.out.println(mc.calculate(1, 2));System.out.println(mc.calculate(1.1, 2));System.out.println(mc.calculate(1, 2.1));}
}class MyCalculator  {//下面的四个 calculate方法构成了重载//两个整数的和public int calculate(int n1, int n2)  {System.out.println("calculate(int n1, int n2) 被调用");return n1 + n2;}//没有构成方法重载, 仍然是错误的，因为是方法的重复定义// public void calculate(int n1, int n2)  {// 	System.out.println("calculate(int n1, int n2) 被调用");// 	int res =  n1 + n2;// } // 没有构成方法重载，也是方法的重复定义// public int calculate(int a1, int a2)  {// 	System.out.println("calculate(int n1, int n2) 被调用");// 	return a1 + a2;// } //一个整数，一个double的和public double calculate(int n1, double n2) {return n1 + n2;}//一个double ,一个int的和 public double calculate(double n1, int n2) {System.out.println("calculate(double n1, int n2) 被调用..");return n1 + n2;}//三个int的和public int calculate(int n1, int n2,int n3) {return n1 + n2 + n2;}
}

(九)可变参数

注意事项和使用细节

1. 可变参数的实参可以为0个或任意多个。
2. 可变参数的实参可以为数组
3. 可变参数的本质就是数组
4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5. 一个形参列表中只能出现一个可变参数

public class TestDemo1 {public static void main(String[] args) {T t = new T();int[] arr = {1, 2, 3};t.sum(arr); // 传入数组t.sum(1, 5, 9); // 传入多个参数}
}class T {// 参数列表可变public void sum(int... nums) {int n = 0;for (int i = 0; i < nums.length; i++) {n += nums[i];}System.out.println("接收的参数个数=" + nums.length);System.out.println("和为：" + n);}
}

public class TestDemo1 {public static void main(String[] args) {T t = new T();String res = t.showScore("张三", 85.6, 90.5, 60);System.out.println(res);// 张三的3门课程总分为：236.1}
}class T {// 参数列表可变public String showScore(String name, double... num) {double sum = 0;for (double score : num) {sum += score;}return name + "的" + num.length + "门课程总分为：" + sum;}
}

二、作用域

(一)基本使用

1. 在Java编程中，主要的变量就是属性(成员变量)和局部变量。
2. 局部变量一般是指在成员方法中定义的变量。
3. 全局变量：属性，作用域为整个类体；局部变量：除了属性之外的其他变量，作用域为定义它的代码块中。
4. 全局变量(属性)可以不赋值，直接使用，因为有默认值；局部变量必须赋值后，才能使用，因为没有默认值。
5. 细节: 属性可以加修饰符(public protected private..)；局部变量不能加修饰符。

(二)注意事项和细节使用

1. 属性和局部变量可以重名，访问时遵循就近原则。
2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁；局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
4. 全局变量/属性：可以被本类使用，或其他类使用(通过对象调用)；局部变量：只能在本类中对应的方法中使用。
5. 全部变量/属性可以加修饰符；局部变量不可以加修饰符。

(三)跨类访问对象属性的2种方式

public class TestDemo1 {public static void main(String[] args) {T t = new T();t.test(); // 第1种跨类访问对象属性的方式Person p = new Person();t.test2(p);// 第2种跨类访问对象属性的方式}
}class T {// 参数列表可变public void test() {Person p1 = new Person();System.out.println(p1.name);}public void test2(Person p) {System.out.println(p.name);}
}class Person {String name = "jack";public void say() {String name = "king"; // 属性和局部变量可以重名，访问时遵循就近原则System.out.println("say() name=" + name);}
}