黑马程序员——static和final关键字

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

一丶Static关键字

1、static是一个修饰符，用于修饰成员（成员变量，成员函数）；

2、成员被static修饰后，可以被对象调用，也可以直接被类名调用：类名.静态成员

3、栈内存，方法区（共享区），堆内存

4、特点：
         ①随着类的加载而加载，随着类的消失而消失，说明它的生命周期最长

         ②优先于对象存在。

         ③被所有对象共享
         static String country="CN";//静态成员变量（类变量），随着类的加载存在于方法区
                   String name；//成员变量（实例变量），随着对象的建立存在于堆内存中，随着对象的消失而消失

5、静态方法只能访问静态成员；非静态方法既可以访问静态成员也可以访问非静态成员

            静态方法中不可以出现this,super关键字，以为静态优先于对象存在

6、什么时候使用静态。因为静态修饰的内容有成员变量和成员函数，所以从这两个方面考虑：
               ①什么时候定义静态变量（类变量）：
                          当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态存在于堆内存中。
               ②什么时候定义静态函数：
                          当功能内部没有访问到非静态数据（对象的特有数据，那么该功能可以定义成静态的

7、静态的应用示例代码：

/*
		每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用
		*/
		class Dmeo
		{
			public static void main(String[] args)
			{
				int[] arr={3,4,1,8};
				
				/*
				int max=0;
				for(int x=1;x<arr.length;x++)
				{
					if(arr[x]>arr[max])
						max=x;
				}
				*/
				int max=getMax[arr];
				System.out.println("max="+max);
			}
			
			public static int getMax(int[] arr)
			{
				int max=0;
				for(int x=1;x<arr.length;x++)
				{
					if(arr[x]>arr[max])
						max=x;
				}
				return arr[max];
			}
		}
	  
	  
		class Test
		{
			public static int getMax(int[] arr)
			{
				int max=0;
				for(int x=1;x<arr.length;x++)
				{
					if(arr[x]>arr[max])
						max=x;
				}
				return arr[max];
			}
		}
		
		//数组工具类
		/*
		我们发现ArrayTool对象并未封装特有的数据，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据
		所以可以讲ArrayTool中方法都定义成static的，直接通过类名调用即可
		为了更为严谨，可以强制该类不能创建对象，则将构造函数私有化即可
		*/
		class ArrayTool
		{
			//获取最大值
			private ArrayTool(){};//私有化默认的构造函数
			public static int getMax(int[] arr)
			{
				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)
			{
				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 bubleSort(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);
						}
					}
				}
			}
			//交换位置，此功能没有必要提供，所以可以私有化
			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.print(arr[x]+"]");
				}
			}
		}
		
		//测试功能
		class ArrayToolDmeo
		{
			public static void main(String[] args)
			{
				int[] arr={3,1,87,32,8};
				ArrayToll tool=new ArrayToll();
				int max=tool.getMax(arr);
				System.out.println("max="+max);
			}
		}

9、静态代码块：

/*
	随着类的加载而执行，只执行一次，优先于主函数执行
	*/
	static
	{
		System.out.println("a");
	}  

二、final关键字

1、修饰符，可以修饰类，函数，变量。

2、被final修饰的类不可以被继承。可以避免被子类继承复写功能。

3、被final修饰的方法不可以被复写。

4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
       当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。而这些值不需要改变，所以          加上final修饰。
       常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过"_"连接。

5、内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

三、帮助文档的制作示例代码

/**
		这是一个可以对数组进行操作的工具类，该类中提供了：获取最值，排序等功能。
		@author 张三
		@version V1.1
		*/
		class ArrayTool
		{
			
			private ArrayTool(){};//私有化默认的构造函数
			/**
			获取一个整型数组中的最大值。
			@param arr 接收一个int类型的数组。
			@return 返回该数组中的最大值。
			*/
			public static int getMax(int[] arr)
			{
				int max=0;
				for(int x=1;x<arr.length;x++)
				{
					if(arr[x]>arr[max])
						max=x;
				}
				return arr[max];
			}
			/**
			获取一个整型数组中的最小值。
			@param arr 接收一个int类型的数组。
			@return 返回该数组中的最小值。
			*/
			public static int getMin(int[] arr)
			{
				int min=0;
				for(int x=1;x<arr.length;x++)
				{
					if(arr[x]<arr[min])
						min=x;
				}
				return arr[min];
			}
			/**
			给int数组进行选择排序。
			@param arr 接收一个int类型的数组。
			*/
			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);
						}
					}
				}
			}
			/**
			给int数组进行冒泡排序。
			@param arr 接收一个int类型的数组。
			*/
			public static void bubleSort(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);
						}
					}
				}
			}
			//交换位置，此功能没有必要提供，所以可以私有化
			/**
			给数组中元素进行位置的置换。
			@param arr 接收一个int类型的数组。
			@param a 要置换的位置。
			@param b 要置换的位置。
			*/
			private static void swap(int[] arr,int a,int b)
			{
				int temp=arr[a];
				arr[a]=arr[b];
				arr[b]=temp;
			}
			/**
			用于打印数组中元素，打印形式是：[element1,element2......]
			*/
			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.print(arr[x]+"]");
				}
			}
		}

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

                                                                                    详细请查看：http://edu.csdn.net/heima