JAVA基础（七）

匿名对象

我们创建的对象。没有显式的赋给一个变量名，即为匿名变量。

特征：匿名对象只能调用一次

使用：

package com.xxx.java;

public class PhoneTest {
	public static void main(String[] args) {
//		匿名对象
		new Phone().sendEmail();
		new Phone().playgame();
		
		new Phone().price = 1999;
		new Phone().showPrice();
		
		//匿名对象的应用场景
		new PhoneMall().show(new Phone());
		
	}
}

//匿名对象的应用场景
class PhoneMall{
	public void show(Phone phone) {
		phone.sendEmail();	
		phone.playgame();
	}
}

class Phone {
	double price;

	public void sendEmail() {
		System.out.println("发送邮件");
	}

	public void playgame() {
		System.out.println("玩游戏");
	}
	
	public void showPrice() {
		System.out.println("手机的价格为" + price);
	}
}

工具类的封装

package com.xxx.java;

//自定义数组工具类

public class ArrayUtil {
	// 求数组的最大值
	public int getMax(int[] arr) {
		int max = arr[0];
		for (int i = 0; i < arr.length; i++) {		
			 if(max < arr[i]) {
				 max = arr[i];
			 }
		}
		return max;
	}

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

	// 求数组的总和
	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, j =  arr.length-1; i  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.print(arr[i] + " ");
		}
	}
	
	//查找指定元素
	public int getIndex(int[] arr,int dest) {

		for (int i = 0; i < arr.length; i++) {
			if (dest == arr[i]) {
				return i;
			}
		}
		return -1;
		
	}
}

使用

package com.xxx.java;

public class ArrayUtilTest {
	public static void main(String[] args) {
		ArrayUtil util = new ArrayUtil();
		int[] arr = {32,34,32,5,3,54,654,-98,0,-53,5};
		
		int max = util.getMax(arr);
		System.out.println("最大值为：" + max);
		
//		System.out.println("排序前");
//		util.print(arr);
//		
//		util.sort(arr);
//		System.out.println();
//		System.out.println("排序后");
//		util.print(arr);
		
		System.out.print("查找：");
		int index = util.getIndex(arr, -5);
		if (index >= 0) {
			System.out.println(index);
		} else {
			System.out.println("没找到");
		}
	}
}

方法的重载

重载的概念

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

重载的特点：

        与方法的返回值类型、权限修饰符、形参变量名、方法体都无关，只看参数列表，且参数              列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

package com.xxx.java1;

public class OverLoadTest {
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1, 2);//若int型方法注释掉，则结果为2
	}
    //如下的四个方法构造重载
	public void getSum(int i,int j) {
		System.out.println("1");
	}
	
	public void getSum(double i,double j) {
		System.out.println("2");
	}
	
	public void getSum(String s,int i) {
		System.out.println("3");
	}
	
	public void getSum(int i,String s) {
		System.out.println("4");
	}
	
	//不构成重载
	//public int getSum(int i,int j) {
	//	System.out.println(i + j);
	//}
	
//	public void getSum(int m,int n) {
//		System.out.println(m + n);
//	}
	
//	private void getSum(int i,int j) {
//		System.out.println(i + j);
//	}
}

        

package com.xxx.exer;

public class OverLoadExer {
	public static void main(String[] args) {
		OverLoadExer test = new OverLoadExer();
		
		//例一
		test.mOL(2);
		test.mOL(2,3);
		test.mOL("Test");
		System.out.println();
		
		//例二
		System.out.println(test.max(3, 4));
		System.out.println(test.max(3.5, 4.6));
		System.out.println(test.max(23.5, 4.7,53.8));
		
		
	}
//	例1
	public void mOL(int i) {
		System.out.println(i * i);
	}

	public void mOL(int i, int j) {
		System.out.println(i * j);
	}

	public void mOL(String s) {
		System.out.println(s);
	}
	
//	例2
	public int max(int i,int j) {
		return (i > j) ? i : j;
	}
	
	public double max(double i,double j) {
		return (i > j) ? i : j;
	}
	
	public double max(double i,double j,double k) {
		return (i > j) ? ((i > k) ? i : k) : ((j > k) ? j : k);
	}
	
}

可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而可以用一种更简单的方式来传递个数可变的实参。

JDK 5.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. 在一个方法的形参位置，最多只能声明一个可变个数形参

方法参数的值传递机制

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

        形参：方法声明时的参数

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

package com.xxx.java1;

public class SwapTest {
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		
		SwapTest test = new SwapTest();
		
		test.swap(m, n);
		System.out.println(m + " " + n);	//10 20
		//交换失败，是因为swap内的形参m，n执行了交换，并在方法
		//结束后销毁，而实参m和n，指数将值复制给了形参m和n，而没有参加
		//实际的交换
		
	}
	public void swap(int m,int n) {
		int temp = m;
		m = n;
		n = temp;
		System.out.println(m + " " + n);	//20 10

	}
}

 

package com.xxx.java1;

public class SwapTest1 {
	public static void main(String[] args) {
		Date date = new Date();

		date.m = 10;
		date.n = 30;
		
		System.out.println(date.m + " " + date.n);
		
		new SwapTest1().swap(date);
		System.out.println(date.m + " " + date.n);
	}
	public void swap(Date date) {
		int temp = date.m;
		date.m = date.n;
		date.n = temp;
	} 
}

class Date {
	int m;
	int n;
}

如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

练习

（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个 findArea()方法返回            圆的面积

（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义 如下：                           public void printAreas(Circle c, int time) 在printAreas方法中打印输出1到time之间的每个整             数半径值，以及对应的面积。 例如，times为5，则输出半径1，2，3，4，5，以及对应的               圆面积。

（3）在main方法中调用printAreas()方法，调 用完毕后输出当前半径值。程序运行结果如图                   所示。

package com.xxx.exer;

public class PassObject {
	public static void main(String[] args) {
		PassObject test = new PassObject();
		
		Circle c = new Circle();
		
		test.printAreas(c, 5);
	}
	public void printAreas(Circle c, int time) {
		System.out.println("Radius\t\tArea");
		for (int i = 1; i <= time; i++) {
			c.radius = i;
			System.out.println(i + "\t\t" + c.findArea());
		}
	}
}

递归

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

        方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

        递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

package com.xxx.java1;

public class RecursionTest {
	public static void main(String[] args) {
		RecursionTest test = new RecursionTest();

		System.out.println(test.getSum(100));
		
		System.out.println(test.f(10));
		
		System.out.println(test.Fibonacci(8));
	}

	// 例1：计算1-n所有自然数的和
	public int getSum(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}
	}

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

	// 例三已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0
	// 的整数，求f(10)的值。
	public int f(int n) {
		if (n == 0) {
			return 1;
		} else if (n == 1) {
			return 4;
		} else {
			return 2 * f(n - 1) + f(n - 2);
		}
	}
	
	//例四：输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
	//1 1 2 3 5 8 13 21 34 55
	//规律：一个数等于前两个数之和
	//要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
	public int Fibonacci(int n) {
		if(n == 0) {
			return 0;
		}else if (n == 1) {
			return 1;
		}else {
			return Fibonacci(n-2) + Fibonacci(n-1);
		}
	}
}