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 返回的值，赋给 变量 returnRes
		int 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 返回值;
}

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

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

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

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

2.返回的数据类型

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

3.方法名

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

4.形参列表

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

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); //调用swap
		System.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 年龄=12
        System.out.println("p2的hashCode：" + p2.hashCode() + 
                            " 姓名=" + p2.name + " 年龄=" + p2.age);
        // p2的hashCode：1956725890 姓名=alice 年龄=12
        System.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.使用递归的重要规则

执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响，比如n变量
如果方法中使用的是引用类型变量(比如数组、对象)，就会共享该引用类型的数据
递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError
当一个方法执行完毕，或者遇到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 == 1
        if (num == 1) {
            // 把a移动到c即可
            System.out.println(a + "->" + c);
        } else {
            //如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
            //(1)先移动上面所有的盘到 b, 借助 c
            tower(num - 1, a, c, b);
            //(2)把最下面的这个盘，移动到 c
            System.out.println(a + "->" + c);
            //(3)再把b塔的所有盘，移动到c ,借助a
            tower(num - 1, b, a, c);
        }
    }
}

以3个圆盘为例，结果：

(八)方法的重载(OverLoad)

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

注意事项和使用细节：

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

方法重载示例：

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;
	}
}

(九)可变参数

注意事项和使用细节

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

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;
    }
}

二、作用域

(一)基本使用

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

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

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

(三)跨类访问对象属性的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);
    }
}