黑马程序员------面向对象（No.3）(static、静态代码块、封装、说明文档制作、main函数)

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 

 static

用于修饰成员（成员变量和成员函数）

特点

1.随着类的加载而加载（例，Person一加载内存，静态成员country就已经存在），静态会随着类的消失而消失，说明它的生命周期最长。

2.优于对象存在 静态先存在，对象是后存在。

3.被所有对象共享

4.可以直接被类名调用

 

区别

1.存放位置

类变量随着类的加载而存在与方法区中。

实例变量随着对象的建立而存在与堆内存中。

2.生命周期

类变量生命周期最长，随着类的消失而消失

实例变量生命周期随着对象的消失而消失

 

注意

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

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

主函数是静态的

 

静态有利有弊

好处：

1.对对象的共享数据进行单独空间的存储，节省内存。没有必要每个对象中都存储一份。

2.可以直接被类名调用。

弊端：

生命周期过长，访问出现局限性（静态方法不能访问非静态）。

class Person{
	//成员变量（实例变量）。创建对象之后，内存中才出现
	String name;
	//静态成员变量（类变量）。Person类加载进内存，就存在。
	static String country = "CN";
	//非静态方法
	public void show(){
		System.out.println(name+":"+country);
	}
	//静态方法
	public static void show_1(){
		System.out.println(country);
		//System.out.println(this.name); //this,super不能在静态方法中使用
		//System.out.println(name); //name在实例创建前没有。。。
	}
}
class StaticDemo{
	public static void main(String[] args){
		Person p = new Person();
		p.name = "zhanggsan";
		p.show();
		System.out.println(Person.country);//输出CN
		Person.show_1();
		}
}

 

什么时候使用静态？

要从两个方面下手：因为静态修饰的内容有成员变量和函数。

 

什么时候使用静态变量？

当对象中出现共享数据时，该数据被静态所修饰。

注：对象中特有的数据要定义成非静态存在与堆内存中。

 

什么时候使用静态函数？

当功能内部没有访问到非静态数据（对象特有的数据）；那么该功能可以定义成静态的。

 

静态方法的应用

 

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便使用

虽然可以用ArrayTool的对象使用这些工具方法，对数组进行操作，但是发现了问题：

1.对象是用于封装数据的，可是ArrayTool对象并未封装特有的数据；

2.操作数组的每一个方法都没有用到ArrayTool对象中特有的数据；

 

静态代码块

 

1.格式：static{

         静态代码块中的执行语句;

       }

2.特点：随着类的加载而执行，只执行一次，用于类的初始化。

class StaticCode{
	int num = 9;
	StaticCode(){
		System.out.println("b");
	}
	static{
		//这里不能访问num；
		//System.out.println("a"+num); 这里编译出错
		System.out.println("a");
	}
	{
		//这里可以访问num
		//System.out.println("c"+num); 这里编译出错
		System.out.println("c");
	}
	StaticCode(int x){
		System.out.println("d");
	}
	public static void show(){
		System.out.println("show run");
	}
}
class StaticCodeDemo{
	public static void main(String[] args){
		new StaticCode(4);//输出 a c d
	}
}

 

封装原理

这时就考虑，让程序更加严谨、健壮，是不需要对象的。可以将ArrayTool中的方法定义成static的，直接通过类名调用即可。

将方法都静态后，可以方便于使用，但是该类还是可以被其他程序创建对象的，为了更加严谨，强制让该类不能建立对象；可以通过将构造函数私有化完成。

/*封装array操作工具类*/
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 selecteSort(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){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	//打印数组
	public static void priArray(int[] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i!=arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.println(arr[i]+"]");
		}
	}
}
class Demo{
	public static void main(String[] args){
		int[] arr = {3,6,1,95,45,22,66,42};
		System.out.println(ArrayTool.getMax(arr));
		System.out.println(ArrayTool.getMin(arr));
		ArrayTool.priArray(arr);
		ArrayTool.selecteSort(arr);
		ArrayTool.priArray(arr);
		ArrayTool.bubbleSort(arr);
		ArrayTool.priArray(arr);
	}
}

 

制作程序的说明书，java的说明书是由文档注释来完成

一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。
如果这个类被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰。
默认的构造函数的权限是随着类的变化而变化的。

制作时要输入的指令：

要制作的类文件：

/**
这是一个可以对数组操作的工具类，该类中提供了获取最值，排序等功能。
@version v1.0
@author Xiaobi Lee
*/
public 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];
	}
	/**
	给整型数组从小到大选择排序。
	@param arr 接收一个int类型的数组。
	*/
	public static void selecteSort(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);
				}
			}
		}
	}
	/**
	给整型数组从小到大冒泡排序。
	@param arr 接收一个int类型的数组。
	*/
	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);
				}
			}
		}
	}
	/**
	给数组中的元素位置置换。
	@param arr 接收一个int类型的数组。
	@param a 要置换的位置。
	@param b 要置换的位置。
	*/
	public static void swap(int[] arr,int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	/**
	用于打印数组中的元素，形式[element1,element2,...]。
	@param arr 接收一个int类型的数组。
	*/
	public static void priArray(int[] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i!=arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.println(arr[i]+"]");
		}
	}
}

帮助文档如图所示：

图1

图2

 

 

主函数

public static void main(String[] args)

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。

 

主函数的定义：

public：代表该函数的访问权限是最大的。

static: 代表主函数随着类的加载就已经存在。
void： 主函数没有具体的返回值。
main：不是关键字，但是一个特殊的单词，可以被jvm识别。
(String[] args): 函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串的类型是数组。

  

主函数是固定格式的：jvm识别。

 

jvm在调用主函数时，传入的是new String(0);

 

class MainDemo{
	//jvm需要要的主函数，只有args（变量名）可以改变。args是arguments的简写。
	public static void main(String[] args){
		System.out.println(args);//输出[Ljava.lang.String;@42ff87dc
		System.out.println(args.length);//输出0
	}
}

 

 ---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

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