第二章：面向对象：方法重载、可变个数形参；变量的赋值、值传递机制及其描述、递归思想

package com.atguigu.java1;

/*
 * 关于变量的赋值:
 * 		如果变量是基本数据类型，此时赋值的是变量所保存的数据。
 * 		如果变量是引用数据类型，此时赋值的是变量所保存的地址值。
 */
public class ValueTransferTest {
	public static void main(String[] args) {
		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 = 123;
		Order o2 = o1;
		System.out.println("o1地址值：" + o1.orderId + "\t" + "o2地址值：" + o2.orderId);
		o2.orderId = 234;
		System.out.println("o1地址值：" + o1.orderId + "\t" + "o2地址值：" + o2.orderId);
	}
}

class Order {
	int orderId;
}

package com.atguigu.java1;

/*
 * 方法的形参的传递机制：值传递
 * 1.形参：方法定义时，声明在小括号里面的参数。
 *   实参：方法调用时，实际传递给形参的数据。
 * 2.值传递机制的描述：
 * 如果参数是基本的数据类型，此时实参赋给形参的是：实参真实储存的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是：实参储存数据的地址值。
 */
//public class ValueTranferTest1 {
//	public static void main(String[] args) {
//		int m = 10;
//		int n = 20;
//		System.out.println("m = " + m + "\t" + "n = " + n);
//		// 交换两个变量的值
//		// int temp = m;
//		// m = n;
//		// n = temp;
//		ValueTranferTest1 test = new ValueTranferTest1();
//		test.swap(m, n);
//		System.out.println("m = " + m + "\t" + "n = " + n);
//	}
//	public void swap(int m, int n) {
//		int temp = m;
//		m = n;
//		n = temp;
//	}
//}
public class ValueTranferTest1 {
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		System.out.println("m = " + m + "\t" + "n = " + n);
		ValueTranferTest1 test = new ValueTranferTest1();
		test.swap(m, n);
		System.out.println("m = " + m + "\t" + "n = " + n);
	}

	public void swap(int m, int n) {
		int temp = m;
		m = n;
		n = temp;
		System.out.println("m = " + m + "\t" + "n = " + n);
	}
}

package com.atguigu.java1;

/*
 * 
 */
public class ValueTransferTest2 {
	public static void main(String[] args) {
		Data data = new Data();
		data.m = 10;
		data.n = 20;

		System.out.println("m =" + data.m + "n = " + data.n);
		// 交换m和n的值：这样一定是可以的，但是我们想用个方法。
		// int temp = data.m;
		// data.m = data.n;
		// data.n = temp;
		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);
		System.out.println("m =" + data.m + "n = " + data.n);
	}

	public void swap(Data data) {
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}

class Data {
	int m;
	int n;
}

package com.atguigu.java2;

/*
 * 递归方法的使用：
 * 1.递归方法：一个方法体内调用它自身。
 * 2.方法递归包含了一种隐式的循环，他会重复执行某段代码，但是不用循环控制。
 * 递归一定要向已知方向递归，否则就成了无穷递归，类似于死循环。
 */
public class RecursionTest {
	public static void main(String[] args) {
		RecursionTest test = new RecursionTest();
		int sum = test.fb(6);// 测试斐波那契数列
		System.out.println(sum);
	}

	// 例1：计算1-100的和
	public int getSum(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}
	}

	// 计算所有1-100自然数的乘积
	public int getSum1(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n * getSum(n - 1);
		}
	}

	public int f(int i) {
		if (i == 0) {
			return 1;
		} else if (i == 1) {
			return 4;
		} else {
			return 2 * f(i - 1) + f(i - 2);
		}

	}

	// 斐波那契数列
	public int fb(int i) {

		if (i == 1) {
			return 1;
		} else if (i == 2) {
			return 1;
		} else {

			return fb(i - 1) + fb(i - 2);
		}

	}
}