Day_09 【java基础】面向对象之可变参数、值传递、重载和递归【附源码】

一.面向对象

面向对象的三条主线：
类以及类的成员：属性、方法、构造器、代码块、内部类
面向对象三大特征：封装、继承、多态
其他关键字：this、super、interface、abstract、package、import、final等
怎么理解类和对象？

类：对某一类具体事物的抽象。
对象：实实在在存在的一个实体，由类创建而来。

类和对象的使用三步骤：
①定义类（包括属性和方法）
②创建类的实体
③调用对象的结构（对象.属性，对象.方法）
方法的内部可以调用属性和别的方法和方法本身（递归调用），不能定义方法。

二.理解“万事万物皆对象”

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

Scanner , String等
文件:File
网络资源:URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象
3.匿名对象的使用
（1）理解:我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
如 ：new Person().show(); //创建匿名对象并调用show()方法
（2）特征:匿名对象只能调用一次。

三.可变参数

JavaSE 5.0中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参，来传递个数可变的实参。

//JDK5.0以前:采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0:采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

关于可变参数的说明:
1.声明格式：方法名(参数的类型名…参数名)
2.可变参数:方法参数部分指定类型的参数个数是可变多个：0个，1个或多个3.可变个数形参的方法与同名的方法之间，彼此构成重载
4.可变参数方法的使用与方法参数部分使用数组是一致的
5.方法的参数部分有可变形参，需要放在形参声明的最后
6.在一个方法的形参位置，最多只能声明一个可变个数形参

/**
 * 
 * @Description 可变参数的使用
 * @author wds Email:393742942@qq.com
 * @version
 * @date 2021年11月5日 下午12:55:30
 *
 */
public class VariableParameter {
	public static void main(String[] args) {
		VariableParameter vp = new VariableParameter();
		vp.sum(1,2,3,4,5,6,7,8,9);
		vp.show(10,1,2,5,6,8,9,5,45);
		int[] arr = new int[] {1,2,3,4,5,6,7,8,9};
		vp.sum1(arr);
	}
	//可变参数方法一：计算可变参数的总和
	public void sum(int...arr) {
		int sum=0;
		for(int i = 0;i<arr.length;i++) {
			sum+=arr[i];
		}
		System.out.println("sum="+sum);
	}
	//此方法和public void sum(int...arr){}功能一样，只是传入的是一个数组（javase 5之前的方法）
	public void sum1(int[] arr) {
		int sum=0;
		for(int i = 0;i<arr.length;i++) {
			sum+=arr[i];
		}
		System.out.println("sum="+sum);
	}
	
	//可变参数方法二：根据传入的可变参数arr的大小输出arr.length遍的m
	public void show(int m,int...arr) {
		for(int i =0;i<arr.length;i++) {
			System.out.println("第"+(i+1)+"遍打印m,m="+m);
		}
	}

}

四.值传递机制

1.方法：
必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数
实参：方法调用时实际传递给形参的参数值

2.Java的实参的值传递机制
Java里方法的参数传递只有一种：值传递。即将实际参数的副本传入方法内，而参数本身不受影响

（1）形参是基本数据类型，将实参基本数据类型变量的“数据值”传递给形参；
（2）形参是引用数据类型，将实参引用数据类型变量的“地址值（含变量的数据类型）”传递给形参。

2.1基本数据类型内存解析

/*
 * 基本数据类型值传递：形参是基本数据类型，
 * 将实参基本数据类型变量的“数据值”传递给形参； 
 */
public class SwapTest {
	
	public void swap(int x,int y) {
		int temp =x;
		x = y;
		y = temp;
		System.out.println("x="+x+",y="+y);		//此时输出的是交换之后结果
	}
	public static void main(String[] args) {
		SwapTest st = new SwapTest();
		int m=10;
		int n=20;
		st.swap(m,n);
		System.out.println("m="+m+",n="+n);		//此时输出的是原本的值
	}

}

2.2引用数据类型

/*
 * 引用类型的值传递：形参是引用数据类型，
 * 将实参引用数据类型变量的“地址值”传递给形参。
 */
public class ValueTest01 {
	public static void main(String[] args) {
		Circle circle = new Circle();
		ValueTest01 vt = new ValueTest01();
		vt.getArea(circle, 6);
	}
	public void getArea(Circle c,int times) {
		System.out.println("redius"+"\t\t"+"area");
		for(int i=1;i<times;i++) {
			c.redius = i;
			System.out.println(c.redius+"\t\t"+c.area());
		}	
	}
}
class Circle{
	int redius;
	public double area() {
		return Math.PI*redius*redius;
	}
}

五.方法的参数传递解析

输出的结果是：15 0 20

六.方法的重载（overload）

1.在一个类中，允许定义多个同名的方法，它们的参数个数或参数类型不同即可。

说明：
前提是听一个类中相同的方法名，参数类型不同或者参数个数不同，与返回值类型，权限修饰符、形参变量名、方法体都没有关系。

2.调用方法时，如何确定调用的是哪个方法：

先看方法名，后看参数的个数和参数类型

/**
 * 
 * @Description	方法的重载和可变参数的使用
 * @author wds Email:393742942@qq.com
 * @version
 * @date 2021年11月5日 下午12:35:50
 *
 */
public class OverloadTest {
	public static void main(String[] args) {
		//调用非static方法时必须初始化一个对象
		OverloadTest ot = new OverloadTest();
		//根据传入的方法名和参数自动匹配对应的方法
		ot.sum(12, 5);
		ot.sum(12, 5, 10);
		ot.sum(1.2, 3.4);
	}
	//计算一个整数和一个小数的和
	public double sum(double x,int y) {
		return x+y;
	}
	//计算两个整数的和
	public void sum(int x,int y) {
		System.out.println("x+y="+(x+y));	
	}
	//计算三个整数的和
	public void sum(int x,int y,int z) {
		System.out.println("x+y+z="+(x+y+z));
	}
	//计算两个double类型的和
	public void sum(double x,double y) {
		System.out.println("x+y="+(x+y));
	}
	//可变参数，当一个方法存在多个参数时，只允许将可变参数写在最后
	public void sum(int m,int...arr) {
		
			System.out.println(m);
		
	}
	//方法1：
	public void print(int...arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
	}
	/*方法2和方法1冲突：主要是可变参数int...arr 和 int[] arr在java内部认为是一样的
	编译时认为是一个方法，不是方法的重载*/
	//编译报错：Duplicate method sum(int[]) in type OverloadTest
	/*
	 public void print(int[] arr) {
	 
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
	}
	*/

}

七.递归（recursion)方法

递归方法：一个方法体内调用它自身。

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

/*
 * 方法递归的使用
 */
public class RecursionTest {
	public static void main(String[] args) {
		RecursionTest rt = new RecursionTest();
		int sum = rt.getSum(100);
		System.out.println("rt.getSum(100) = "+sum);
		int result = rt.factorial(10);
		System.out.println("result = "+result);
		int result1 = rt.Fibonacci(10);
		System.out.println("result1 = "+result1);
	}
	//例1：递归求前n项和
	public int getSum(int n) {
		int sum=0;
		if(n==1) {
			return 1;
		}else {
			return getSum(n-1)+n;
		}
	}
	//例2：递归求斐波那契数列
	/*
	 * 斐波那契数列：{1, 1, 2, 3, 5, 8, 13, 21…}
			当 n == 1时， fib(n) = 1
			当 n == 2时， fib(n) = 1
			当 n > 2 时， fib(n) = fib(n - 1) + fib(n - 2)
	 */
	public int Fibonacci(int n) {
		if(n==1) {
			return 1;
		}else if(n==2) {
			return 2;
		}else {
			return Fibonacci(n-1)+Fibonacci(n-2);
		}
	}
	//3.例3：递归求前n项的阶乘
	public int factorial(int n) {
		int result=1;
		if(n==0) {
			return 1;
		}else if(n==1) {
			return 1;
		}else {
			return (n-1)*n;
		}	
	}
}