Java面向對象 Main函數 靜態的應用 單例設計模式



Java面向對象 Main函數 靜態的應用與單例設計模式

知識概要

            （1）Main函數的細解

             （2）靜態的應用，靜態變量，靜態代碼塊，靜態函數

             （3）單例設計模式

1.Main函數的細解

           
                public static void main(String[] args)

     主函數：是一個特殊的函數。做爲程序的入口，能夠被jvm調用。

     主函數的定義：
     public：表明着該函數訪問權限是最大的。
     static：表明主函數隨着類的加載就已經存在了。
     void：主函數沒有具體的返回值。
     main：不是關鍵字，可是是一個特殊的單詞，能夠被jvm識別。
    （String[] args）:函數的參數，參數類型是一個String數組，該數組中的元素是字符串。字符串類型的數組。

    主函數是固定格式的：jvm識別。

     jvm在調用主函數時，傳入的是new String[0];

將main函數中傳入的字符串依次打印出來。

class MainDemo 
{
	public static void main(String[] args)//new String[]
	{
		String[] arr = {"hah","hhe","heihei","xixi","hiahia"};

		MainTest.main(arr);
	}
}

//String[] args = new String[3];
//String[] args = null;


class MainTest
{
	public static void main(String[] args)
	{
		for(int x=0; x<args.length; x++)
			System.out.println(args[x]);
	}
}

2.什麼使用靜態？

靜態：static。
   

用法：是一個修飾符，用於修飾成員(成員變量，成員函數).
當成員被靜態修飾後，就多了一個調用方式，除了能夠被對象調用外，
還能夠直接被類名調用。類名.靜態成員。

static特色：
1，隨着類的加載而加載。
   也就說：靜態會隨着類的消失而消失。說明它的生命週期最長。

2，優先於的對象存在
明確一點：靜態是先存在。對象是後存在的。

3，被全部對象所共享
4，能夠直接被類名所調用。

實例變量和類變量的區別：
1，存放位置。
 類變量隨着類的加載而存在於方法區中。
 實例變量隨着對象的創建而存在於堆內存中。
2，生命週期：
 類變量生命週期最長，隨着類的消失而消失。
 實例變量生命週期隨着對象的消失而消失。

靜態使用注意事項：
1，靜態方法只能訪問靜態成員。
 非靜態方法既能夠訪問靜態也能夠訪問非靜態。
2，靜態方法中不能夠定義this，super關鍵字。
 由於靜態優先於對象存在。因此靜態方法中不能夠出現this。
3，主函數是靜態的。
 

靜態有利有弊
利處：對對象的共享數據進行單獨空間的存儲，節省空間。沒有必要每個對象中都存儲一份。
 能夠直接被類名調用。
弊端：生命週期過長。訪問出現侷限性。(靜態雖好，只能訪問靜態。)

  由於靜態修飾的內容有成員變量和函數。
  何時定義靜態變量(類變量)呢？
  當對象中出現共享數據時，該數據被靜態所修飾。
  對象中的特有數據要定義成非靜態存在於堆內存中。

  何時定義靜態函數呢？

  當功能內部沒有訪問到肺靜態數據(對象的特有數據)，
  那麼該功能能夠定義成靜態的。

static特色：
  1，隨着類的加載而加載。
  也就說：靜態會隨着類的消失而消失。說明它的生命週期最長。

  2，優先於的對象存在
  明確一點：靜態是先存在。對象是後存在的。

  3，被全部對象所共享
  4，能夠直接被類名所調用。

class Person
{
	String name;
	static String country = "cn";
	public  static void show()
	{
		System.out.println(contry+"haha");	
	}

}


class  
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.show();
		//Person .show();
	}

}

靜態代碼塊------示例

/*
靜態代碼塊。
格式：
static
{
	靜態代碼塊中的執行語句。
}

特色：隨着類的加載而執行，只執行一次,並優先於主函數。
用於給類進行初始化的。

*/

class StaticCode
{	int num = 9;
	StaticCode()
	{
		System.out.println("b");
	}

	static
	{
		System.out.println("a");
	}
	{
		System.out.println("c"+this.num);
	}

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

class StaticCodeDemo 
{
	static
	{
		System.out.println("b");
	}
	public static void main(String[] args) 
	{
		new StaticCode(4);
	}
	static
	{
		System.out.println("c");
	}
}

 單例設計模式: 懶漢式  餓漢式

設計模式：解決某一類問題最行之有效的方法。
java中23種設計模式：
單例設計模式：解決一個類在內存只存在一個對象。

想要保證對象惟一。
1，爲了不其餘程序過多創建該類對象。先禁止其餘程序創建該類對象
2，還爲了讓其餘程序能夠訪問到該類對象，只好在本類中，自定義一個對象。
3，爲了方便其餘程序對自定義對象的訪問，能夠對外提供一些訪問方式。

這三部怎麼用代碼體現呢？
1，將構造函數私有化。
2，在類中建立一個本類對象。
3，提供一個方法能夠獲取到該對象。

對於事物該怎麼描述，還怎麼描述。
當須要將該事物的對象保證在內存中惟一時，就將以上的三步加上便可。

<strong>/*
這個是先初始化對象。
稱爲：餓漢式。

Single類一進內存，就已經建立好了對象。
class Single
{
	private static Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}
*/

//對象是方法被調用時，才初始化，也叫作對象的延時加載。成爲：懶漢式。
//Single類進內存，對象尚未存在，只有調用了getInstance方法時，才創建對象。
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

//記錄原則：定義單例，建議使用餓漢式。

class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}
</strong>