面向对象_静态的应用_工具类

Demo.java
/*
1、直接把代码写进main函数。
坏处：多个数组，需要把代码在main函数里面重新写一遍。
2、为了解决1的坏处，定义一个功能，把关键代码放进去。
好处：提高代码的复用。
坏处：不适合多个类(java文件)调用函数。
3、工具类：new Tool().getMax()
每个应用程序中都有共性的功能。工具类可以将这些功能进行抽取，独立封装到一个对象当中，以便复用。

多个应用程序，多个应用程序可以单独抽取出来，封装到一个类中，把功能封装到对象中，
找到了对象，就找到了功能。

坏处：虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。但是
	1、对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
	2、操作数组的每一个方法都没有用到ArrayTool对象的特有数据。
这里就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。
ArrayTool.java
//3、工具类。
class ArrayTool 
{
	//将构造函数私有化，外界只能通过调用函数，防止建立对象。
	private ArrayTool(){}

	
	public static int getMax(int[] arr)//static：主要为了调用方便，因为main函数是static的。
	{
		int max=0;
		for (int x=1;x<arr.length;x++ )
		{
			if(arr[x]>arr[max])
				max=x;
		}
		return arr[max];
	}

	public static int getMin(int[] arr)//static：主要为了调用方便，因为main函数是static的。
	{
		int min=0;
		for (int x=1;x<arr.length;x++ )
		{
			if(arr[x]<arr[min])
				min=x;
		}
		return arr[min];
	}

	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);
				}
			}
		}
	}

	public static void bubbleSort(int[] arr)
	{
		for (int x=0;x<arr.length-1 ;x++ )
		{
			for (int y=0;y<arr.length-x-1 ;y++ )
			{
				if(arr[y]>arr[y+1])
				{
					swap(arr,y,y+1);
				}
			}
		}
	
	}

	//public static void swap(int[] arr,int a,int b)//只提供给本类，不需要提交给外界，所以私有化
	private static void swap(int[] arr,int a,int b)
	{
		int temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}

	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]+"]");
		}
	}
}


4、用static修饰工具类的方法（函数），可以通过类名直接调用，不需要建立对象。将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更严谨，强制让该类不能建立对象。也防止别人建立对象。可以通过将构造函数私有化。*/class Demo {public static void main(String[] args) {int[] arr={3,4,1,-8};int[] a={5,4,2,0,9};//将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。但是建立了毫无意义。//ArrayTool
 tool=new ArrayTool();//需要将工具类的构造函数私有化，防止建立对象//4、用static修饰工具类的函数，可以直接通过类名调用工具类的函数int max=ArrayTool.getMax(arr);//不需System.out.println("max="+max);int min=ArrayTool.getMin(arr);System.out.println("min="+min);ArrayTool.printArray(arr);ArrayTool.selectSort(arr);ArrayTool.printArray(arr);ArrayTool.bubbleSort(arr);ArrayTool.printArray(arr);/*//3、调用工具类ArrayTool
 tool=new ArrayTool();//建立对象，调用工具类int max= tool.getMax(arr);//定义一个变量存储：使用对象的获取最大值的功能System.out.println("max="+max);//打印最大值int min= tool.getMin(arr);//定义一个变量存储：使用对象的获取最大值的功能System.out.println("min="+min);tool.printArray(arr);//打印排序后的数组tool.selectSort(arr);//使用对象的对数组进行选择排序功能tool.printArray(arr);//打印排序后的数组tool.bubbleSort(arr);//使用对象的对数组进行冒泡排序的功能tool.printArray(arr);//打印排序后的数组*//*3、新建一个数组，需要使用工具类的时候，也需要从新建立一个对象.*//*
 int[] arr1={};ArrayTool tool1=new ArrayTool();*//*2、调用getMax函数int max=getMax(arr);System.out.println("max="+max);//输出数组最大值*///1、（直接写在主函数里面）获取数组中最大的数/* int max=0;for (int x=1;x<arr.length;x++ ){if(arr[x]>arr[max])max=x;}System.out.println("max="+arr[max]);//输出数组最大值*/}//2、（定义一个函数）获取数组中最大的数./*
 public static int getMax(int[] arr)//static：主要调用方便，因为main函数是static的。{int max=0;for (int x=1;x<arr.length;x++ ){if(arr[x]>arr[max])max=x;}return arr[max];}*/}