黑马程序员-static关键字和单例模式

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

静态：是一个修饰符，用于修饰成员。
当成员被静态修饰时，可以直接被类名调用。
static特点：

• 随着类的加载而加载，随着类的消失而消失。
• 优先于对象存在，被所有对象所共享。
• 可以直接被类名调用。

实例变量和类变量的区别：
1.实例变量存在堆内存中，随着对象的建立而存在；
类变量存在于方法区中，随着类的加载而加载。
2.实例变量生命周期随着对象的消失而消失；
类变量的生命周期最长，随着类的消失而消失。


当对象中出现共享数据时，该数据可以被静态修饰，定义成静态变量。
当功能内部没有访问到对象中的特有数据(非静态数据)，那么可以定义成静态方法。


默认构造函数的权限是和类的权限相同的。


静态使用注意事项：

• 静态方法只能访问静态成员。非静态方法既可以访问非静态方法，也可以访问静态方法。
• 静态中不可以存在this，super关键字，因为静态是优先于对象存在的。
• 主函数是静态的。因为程序是从main开始执行的，需要在对象之前就加载到内存中。

静态的优缺点：
优点：静态可以对对象的共享数据进行单独空间的存储，节省空间。可以被类名直接调用。
缺点：生命周期过长，不能被非静态方法访问，访问有局限性。


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

• public：该函数访问权限最大
• static：代表随着类的加载就加载了。
• void：主函数没有返回值
• main：是一个特殊的单词，不是关键字，但可以被jvm识别。
• String[] args:函数的参数。是一个字符串数组。默认传入的是new String[0].

静态代码块：
static{执行语句};
随着类的加载而执行，只执行一次。用于给类进行初始化。优先于主函数。
StaticCode s = null;如果对象没有指向，类不会加载，只有建立对象或者调用类时，才会加载。


对象的初始化过程：
Person p = new Person("zhangsan",20);

• 加载Person.class文件到内存中
• 执行该类中的static代码块，给类进行初始化
• 在堆内存总开辟空间，分配内存地址
• 在堆内存中分配特有属性，并进行默认初始化
• 对特有属性进行显示初始化
• 执行构造代码块对对象初始化
• 执行构造函数对对象进行初始化
• 把内存地址分配给栈内存中的p变量

方法调用过程：

• 非静态方法：

在栈内存开辟该方法空间，空间中存储this和方法中的局部变量，this指向调用该方法的对象
执行方法代码，把改变后的局部变量赋给对象中的特有属性
释放方法的栈内存空间

• 静态方法：

在方法区中开辟空间，存储静态变量和静态方法
执行静态方法代码，调用的静态方法和静态变量前省略所属的类名加点号
执行后直到类消失，静态变量和方法也随之消失。

ArrayTool类：

class ArrayTool
{
	private ArrayTool(){}
	public static int getMax(int[] arr)
	{
		int max=0;
		for(int x=1;x<arr.length;x++)
		{
			if(arr[max]<arr[x])
				max=x;
		}
		return arr[max];
	}
	public static int getMin(int[] arr)
	{
		int min=0;
		for(int x=1;x<arr.length;x++)
		{
			if(arr[min]>arr[x])
				min=x;
		}
		return arr[min];
	}
	public static int binarySearch(int[] arr,int key)
	{
		int max=arr.length-1,min=0,mid;
		while(min<=max)
		{
			mid=(max+min)>>1;
			if(key>arr[mid])
				min = mid +1;
			else if(key<arr[mid])
				max = mid -1;
			else
				return mid;
		}
		return -1;
	}
	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 printArray(int[] arr)
	{
		for(int x=0;x<arr.length;x++)
		{
			System.out.print("[");
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	private static void swap(int[] arr,int x,int y)
	{
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

设计模式：解决某一类问题最行之有效的方法，java中有23中设计模式。
单例设计模式：解决一个类中只存在一个对象的相关问题。
想要保证对象的唯一性，需要控制通过该类建立对象，可以把构造方法私有化。然后再类中自定义一个对象，
并私有化，提供一些对外的静态公共方法，可以让外界通过类名调用该方法，获得自定义对象。
对于事物该怎么描述就怎么描述。当需要将该事物的对象保证唯一性，就需要加上单例设计的三步代码即可。
如果只有这三步代码，该类没有任何用处。
private Single(){}
private static Single s = new Single();
private static Single getInstance()
{
return s;
}


单例模式的两种方式：
1.饿汉式

Class Single
{
	private Single(){}
	private static Single s = new Single();
	private static Single getInstance()
	{
		return s;
	}
}

开发中建议使用饿汉式
2.懒汉式,也成为对象的延时加载

Class Single 
{
	private Single(){}
	private static Single s =null;
	private static synchronized Single getInstance()
	{
		if(s==null)//双重判断
		{
			synchronized(Single.class) //使用synchronized机制防止线程运行过程中的cpu切换问题导致的产生多个对象问题
			{
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}