Java面向对象-（匿名对象，工具类，重载，可变个数形参，值传递，递归方法）

Java面向对象-（匿名对象，工具类，重载，可变个数形参，值传递，递归方法）

匿名对象

1. 创建的一个对象没有显示的赋给一个变量名，即为匿名对象
2. 匿名对象只能调用一次

工具类

package day08;

//自定义数组的工具类
public class niming {
//求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

//	求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

//	求数组的总和
	public int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

//	求数组的平均值
	public int getAvg(int[] arr) {

		return getSum(arr) / arr.length;
	}

//	反转数组
	public void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}

//	复制数组
	public int[] copy(int[] arr) {
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return arr1;
	}

//	数组排序
	public void sort(int[] arr) {
//	冒泡排序
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

//	遍历数组
	public void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i] + "\t");
		}
	}

//	查找指定元素
	public int getIndex(int[] arr, int dest) {
//		线性查找
		for (int i = 0; i < arr.length; i++) {
			if (dest == arr[i]) {
				return i;
			}
		}
		return -1;// 返回一个负数，表示没有找到
	}

}

方法重载

定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数分数或者类型不同即可。

两同一不同：同一个类，相同方法名，参数列表不同，参数个数不同，参数类型不同

可变个数形参

1. 格式：可变个数形参的格式：数据类型 … 变量名
2. 当调用可变个数形参的方法时，传入的参数是可变的。
3. 可变个数形参，传入的参数必须是同一个类型。
4. 可变个数形参，在方法的声明必须声明在末尾

方法参数的值传递机制

值传递机制：

• 如果参数是基本数据类型，此时实参赋给形参的是实参正是存储的数据值
• 如果参数是引用数据类型，此时实参赋给新参的是实参存储数据的地址值

问题：定义一个int型的数组：int[] arr = new int[]{12,34,45,122,56,75};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
    
 package day08;

public class chongzai {
	public static void main(String[] args) {
		int[] arr = new int[] {12,3,3,4,56,77,345};
//		方法一
		for(int i = arr.length - 1;i>=0;i--)
		{
			arr[i] = arr[i] / arr[0];
			System.out.print(arr[i]+"  ");

		}
//		方法二
		int temp = arr[0];
		for(int i = 0;i<arr.length;i++) {
			arr[i] = arr[i]/temp;
			System.out.print(arr[i]+"  ");
		}
	}

}

练习题一：

	//定义一个类PassObject，在类中定义一个方法printAreas()，
	//该方法的定义 如下：public void printAreas(Circle c, int time) 
	//在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。 
	//例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积
	public static void main(String[] args) {
		chongzai test = new chongzai();
		Circle c = new Circle();
		test.printAreas(c, 5);
	}
	public void printAreas(Circle c,int time) {
		System.out.println("Radis\t\tArea");
		for(int i = 1;i<= time;i++) {
//			设置元的半径
			c.radius = i;
			double area = c.gindArea();
			System.out.println(c.radius + "\t\t"+area);
		}
	}

练习2

//定义一个Circle类，包含一个double型的radius属性代表圆的半径
//一个findArea()方法的返回圆的面积
public class chongzai {
	double radius;//半径
	
//	求圆的面积
	public double findArea() {
		return Math.PI*radius*radius;
    }
}

递归方法

• 递归方法，哦一个方法体内调用它自身

  package day08;
  public class chongzai{
  //	例一》计算1-100之间所有自然数的和
  	public static void main(String[] args) {
  //		方法一
  		int sum = 0;
  		for(int i = 1; i <= 100; i++) {
  			sum += i;
  		}
  //		方法一的计算结果
  		System.out.println(sum);
  //		方法二的计算结果
  		chongzai test = new chongzai();
  		int sum1 = test.getSum(100);
  		System.out.println(sum1);
  	}
  	
  //	方法二,使用递归方法
  	public int getSum(int n) {
  		if(n == 1) {
  			return 1;
  		}else {
  			return n + getSum(n-1);
  		}
  	}
  }