java学习日志（九）-- 工具类、静态代码块、单例设计模式

1.static 关键字--用于修饰成员（成员变量和成员函数）

被修饰的成员具备以下特点：

*随着类的加载而加载，随着类的消失而消失，说明其生命周期最长

*优先于对象存在

*被所有对象所共享

*可以直接被类名调用

使用注意：

静态方法只能访问静态成员
静态方法不可以写this，super关键字
主函数是静态的

实力变量和类变量的区别：

1.存放位置

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

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

2.生命周期

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

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

静态的使用注意事项：

1.静态方法只能访问静态成员。非静态方法可以访问静态成员。

2.静态访问中不可以定义this，super关键字。因为静态优先于对象存在。

静态利弊：

利：

1.对对象的共享数据进行单独空间存储，节省空间。

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

弊：

1.生命周期过长。

2.访问出现局限性(只能访问静态)。

什么时候定义静态变量：
当对象中出现共享数据时，该数据被静态所修饰。

什么时候定义静态函数：
当功能内部没有访问到非静态数据，该功能可以定义为静态的。 

class Person{
	String name; //成员变量，实例变量
	static String country = "CN"; //静态成员变量，类变量
	public void show(){
		System.out.println(name + "::" + country);
	}
}

class StaticDemo{
	public static void main(String[] args){
		Person p = new Person();
		p.name = "Guang";
		p.show();
		System.out.println(Person.country);
	}
}

2.main函数--public static void main(String[] args){}

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

主函数的定义：

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

static：代表主函数随着类的加载就已经存在了。

void：主函数没有返回值。

main：不是关键字，但是是一个特殊的单词。可以被jvm识别。

（String[] args）：主函数的参数，参数类型是一个数组，该数组中是字符串。字符串类型数组。

主函数是固定格式的，jvm识别。只有args可改。args来至于arguments，参数。

jvm在调用主函数时，传入的时new String[0];

class MainDemo{
	public static void main(String[] args){
		String[] arr = {"这句话将成为主函数参数"};
		MainText.main(arr);
	}
}

class MainText{
	public static void main(String[] args){
		for(String x:args){
			System.out.println(x);
		}
	}
}

3.工具 类--静态的应用

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

将方法都静态后，可以方便使用，但是该类还是可以创建对象，为了更为严谨，通过将构造函数私有化，强制该类不能建立对象。

将ArrayTool.class文件发送给其他人，只要将该文件设置到classpath路径下（通过 set classpath=.;目录），就可以使用该工具类。

制作说明书：java的说明书通过文档注释来完成。

一个类中会有一个默认的无参构造函数，权限与所属类一致，随类变化而变化，即类被public修饰，其也被public修饰。

/**
这是一个可以对数组进行操作的工具类，该类提供了，获取最值，排序等功能。
@author GuangXS
@version v1.0 
*/
public class  ArrayTool{

	/**
	空参数构造函数。
	*/
	private ArrayTool(){}
	
	/**
	获取一个整型数组中的最大值。
	@param arr 接收一个int型数组
	@return 会返回数组中最大值
	*/
	public static int getMax(int[] arr){
		int max = 0; 
		for(int i = 0; i < arr.length; i++){
			if(arr[max] < arr[i])
				max = i;
		}
		return arr[max];
	}
	
	/**
	获取一个整型数组中的最大小值。
	@param arr 接收一个int型数组
	@return 会返回数组中最小值
	*/
	public static int getMin(int[] arr){
		int min = 0;
		for(int i = 0; i < arr.length; i++){
			if(arr[min] > arr[i])
				min = i;
		}
		return arr[min];
	}

	/**
	 给数组进行选择排序。
	 @param arr 接收一个int型数组
	*/
	public static void selecSort(int[] arr){
		for(int i = 0; i < arr.length - 1; i++){
			for(int j = i + 1; j < arr.length; j++){
				if(arr[i] < arr[j])
					swap(arr, i, j);
			}
		}
	}

	/**
	 给数组进行冒泡排序。
	 @param arr 接收一个int型数组
	*/
	public static void bubbleSort(int[] arr){
		for(int i = 0; i < arr.length -1; i++){
			for(int j = 0; j < arr.length - i -1; j++){
				if(arr[j] < arr[j+1])
					swap(arr, j, j+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,elelment3,......]
	@param arr 接收一个整型数组
	*/
	public static void printArr(int[] arr){
		System.out.print("[ ");
		for(int i : arr){
			System.out.print(i + " ");
		}
		System.out.println("]");
	}
}

4.静态代码块

格式：

static {
静态代码块中的执行语句
}

特点：随着类的加载而加载，只执行一次。优先于主函数执行。
用于给类进行初始化。

class StaticCode{
	
	StaticCode(){
		System.out.println("构造函数");
	}

	{
		System.out.println("构造代码块"); //初始化对象使用,可将多个构造函数中重复部分放在这里，先于构造函数
	} 

	static{
		System.out.println("静态代码块"); //初始化类使用
	}

	public static void show(){
		System.out.println("StaticCode show run");
	}
}

class StaticCodeDemo{
	static{
		System.out.println("StaticCodeDemo1");
	}

	public static void main(String[] args){
		new StaticCode(); 
//		new StaticCode();
//		StaticCode.show();
//		StaticCode s = null; //没有用到类中内容，类并没有加载
	}

	static{
		System.out.println("StaticCodeDemo2");
	}
}

/*
Person p = new Person();

这句话都做了什么事情？
1.因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
2.执行该类的static代码块，如果有的话，给Person类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性，并进行默认初始化。
5.对对象属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存地址赋给栈内存中的p变量。
*/

3.设计模式：解决某一问题的最行之有效的方法。java中有23中设计模式。

单例设计模式：解决一个类在内存中只存在一个对象。

想要保证对象唯一：
1.为了避免其他程序建立该类对象。先禁止其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

采取步骤：
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获得该对象。

class Single {

	private int num;

	private Single(){}
	
	private static Single s = new Single();

	public static Single getInstance(){
		return s;
	}

	public void setNum(int num){
		this.num = num;
	}

	public int getNum(){
		return num;
	}
}

class SingleDemo {
	public static void main(String[] args){
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		s1.setNum(20);
		System.out.println(s2.getNum());
	}
}

/*
饿汉式--先初始化对象。
Single类一进入内存，就已经创建好了对象。
class Single{
	private static s = new Single();  //建立私有静态类对象
	private Single(){}  //构造函数私有化
	public static Single getInstance(){ //提供获得对象的方法
		return s;
	}
}
*/

/*
懒汉式--对象是被调用时，才初始化，也叫做对象的演示加载。
Single类进内存时，对象还没有存在，只有调用了getInstance方法时，才建立对象。
*/
class Single {
	private static s = null;
	private Single(){}
	public static Single getInstance(){
		if (s == null) {
			s = new Single();
		}
		return s;
	}
}