黑马程序员——面向对象8：静态的应用—工具类

------- android培训、java培训、期待与您交流！ ----------

我们以下述代码为例，说一说静态的应用。

代码1：

class ArrayTools
{
	//为了防止创建该类的对象，提供代码的严谨性，将构造函数私有化
	private ArrayTools(){}
	//最大值
	public static int getMax(int[] arr)
	{
		int max = arr[0];
		for(int x=1; x<arr.length; x++)
		{
			if(max< arr[x])
				arr[x]= max;
		}
		return max;
	}
	//最小值
	public static int getMin(int[] arr)
	{
		int min = arr[0];
		for(int x=1; x<arr.length; x++)
		{
			if(min > arr[x])
				min = arr[x];
		}
		return max;
	}
	//选择排序
	public static void selectSort(int[] arr)
	{
		for(int x=0; x<arr.length-1; x++)
		{
			for(int y=x+1; y<arr.length; y++)
			{
				if(arr[x]> arr[y])
					swap(arr, x, y);
			}
		}
	}
	//交换两元素的位置
	private static void swap(int[] arr, int x, int y)
	{
		arr[x] = arr[x] ^ arr[y];
		arr[y] = arr[x] ^ arr[y];
		arr[x] = arr[x] ^ arr[y];
	}
	//打印数组
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x != arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
}
class Demo
{
	public static void main(String[] args)
	{
		int[] arr = {565, 12, 78, 22, 91, 10};
             
		//排序
		ArrayTools.selectSort(arr);
		ArrayTools.printArray(arr);
             
		//求最大值
		int max = ArrayTools.getMax(arr);
		System.out.println("max= "+max);
             
		//求最小值
		int min = ArrayTools.getMin(arr);
		System.out.println("min= "+min);
	}
}

上述代码的运行结果为：

[10, 12, 22, 78, 91, 565]

max = 565

min = 10

我们来解释一下上述代码。getMax、getMin方法是在一个整型数组中寻找最大值和最小值的方法，selectSort是对整型数组进行选择排序，私有方法swap是交换一个整型数组中两元素的位置（之所以私有是因为，该方法仅在该类内部调用，不需要对外提供），printArray是按照某种格式打印数组，首先为了提高代码的复用性，我们对这些方法进行了封装，定义了上述的几个方法名，而不是直接写进主函数中。其次，为了可以在别的类中也可以使用这些方法，将它们又封装进了ArrayTools类中。但是，如果把这些方法定义为非静态方法，那么每次要使用到这些方法时候就需要创建ArrayTools对象，而一方面这些方法中并没有该类的特有数据，另一方面这个类也并没有封装其特有数据，因此应该将这些方法定义为静态。

最后，我们需要注意的是，即使将所有方法都定义为静态，但我们还是可以闯将ArrayTools的对象，这样代码就不够严谨，因此，最好将该类的构造方法私有化，防止创建改了的对象。

 

小知识点1：

       如果两个类分别定义在了两个“.java”文件中，并且通过其中一个类（A，下同）调用另一个类（B类，下同）的时候，可以直接编译A类所在的“.java”文件，这样编译器会同时编译A、B两个“.java”文，省去了手动编译两次的麻烦。具体过程是这样的，当编译器在A类中发现需要调用B类的时候会自动在当前目录（或指定目录）下寻找有没有B类的“.class”文件，如果没有，就会再次寻找有没有B类的“.java”文件，如果有就先将B类编译，然后再编译A类；当然，如果没有，编译就会报错。