構造方法constructor構造器

構造方法的定義

[修飾符] 類名（形式參數清單）{

//語句

}

構造器用于構造該類的執行個體。作用：用來初始化對象！一般由系統在建立對象（即類的執行個體化）時自動調用

分析事物時，該事物存在具備一些特性或者行為，那麼将這些内容定義在構造函數中。

(1)通過new關鍵字調用！！

(2)構造器雖然有傳回值，但是不能定義傳回類型（傳回值的類型肯定是本類），不能在構造器裡調用 return。

(3)如果我們沒有定義構造器，則系統會自動定義一個無參數的構造函數，如果已經定義則編譯器不會添加，覆寫了系統預設的構造方法。

(4)構造器的方法名必須和類名一緻。

(5) 構造該類的對象，經常用來初始化對象的屬性。

1.構造方法名必須與類名保持一緻，

2.無傳回值類型的聲明，也不能用“void”修飾

3.構造方法不能用static和final來修飾。

4.方法中不能使用return語句傳回一個值

5.通過new來調用

6.無參構造函數問題：

a)如果我們沒有定義構造器，則系統會自動定義一個無參數的構造函數

b)如果已經定義則編譯器不會添加

7.構造方法的第一句總是super，即調用直接父類的構造方法

a)有繼承關系的構造方法調用的順序

對象一建立就會調用與之對應的構造函數，new幾次就會調用幾次。

構造函數和一般方法在運作上的不同：

構造函數是在對象一建立就運作，給對象初始化。而一般方法是對象調用才執行，是給對象添加對象具備的功能

一個對象建立，構造函數隻運作一次，而一般方法可以被該對象調用多次。

構造函數與set、get方法應同時存在，構造函數是給對象初始化，set、get方法是對外提供的公共方法。

構造代碼塊

{

語句

}

作用：給對象進行初始化，對象一建立就運作，而且優先于構造函數執行。

差別：構造代碼塊是給所有對象進行統一初始化，定義的是不同對象共性的初始化内容。構造函數是給對應的對象初始化。

構造方法的重載

在一個類中可以定義多個構造方法，隻要每個構造方法的參數類型或參數個數不同即可。

在建立對象時，可以通過調用不同的構造方法為不同的屬性指派

this關鍵字

隐式參數，用于區分成員和局部變量的同名情況。

在普通方法中，this總是指向調用該方法的對象。

在構造方法中，this總是指向正要初始化的對象。

this不能用于static方法中。可以用來調用其他的構造方法。

this代表它所在函數所屬對象的引用，哪個對象在調用this所在的函數，this就代表哪個對象。

在定義類中功能時，該函數内部要用到調用該函數的對象時，這時用this表示這個對象，但凡本類功能内部使用到了本類對象，都用this表示。

this關鍵字在構造函數間調用：隻能在構造方法中使用this調用其它的構造方法

this();用于構造函數間的調用。通過this調用構造方法，必須位于第一句，且隻能出現一次。

不能在一個類的兩個構造方法中使用this互相調用

用法

1、通過this關鍵字可以明确地去通路一個類的成員變量，解決與局部變量名稱沖突的問題---使用“this.age”則是通路成員變量

2、通過this關鍵字調用成員方法

使用“this.openMouth()”則是調用該成員方法

3、構造方法是在執行個體化對象時被Java虛拟機自動調用的，在程式中不能像調用其它方法一樣去調用構造方法，但可以在一個構造方法中使用“this([參數1,參數2…])”的形式來調用其它的構造方法。

static關鍵字

是一個修飾符，隻能用于修飾成員（成員變量和成員函數）

靜态變量

在類中，用static聲明的成員變量為靜态成員變量，或者叫做類屬性、類變量。

-- 它為該類的公用變量，屬于類，被該類的所有執行個體共享，在類被載入時，被顯示初始化。

-- 對于該類的所有對象來說，static成員變量隻有一份，被該類的所有對象共享！！

-- 可以使用“對象.類屬性”來調用，不過一般都是用，類名.靜态成員

-- static變量位于方法區中

static關鍵字隻能用于修飾成員變量，不能用于修飾局部變量，否則編譯會報錯

靜态方法

用static修飾的方法為靜态方法

可以使用“類名.方法名”的方式來通路，也可以通過類的執行個體對象來通路"對象名.方法名"。

使用注意事項

1.靜态方法隻能通路靜态成員，原因在于沒有被static修飾的成員需要先建立對象才能通路，而靜态方法在被調用時可以不建立任何對象。

非靜态方法即可以通路靜态也可以通路非靜态

2.靜态方法中不可以定義 this super關鍵字，因為靜态優先于對象存在，是以靜态方法中不可以出現this，靜态方法建立時，還沒有對象。

靜态代碼塊

static {

靜态代碼塊中的執行語句

}

特點：随着類的加載而執行，隻執行一次并優先于主函數，用于給類的成員變量進行初始化。

執行優先級

靜态代碼塊初始化----預設初始化------顯示初始化------構造代碼塊初始化----構造函數初始化

靜态的特點

1.随着類的加載而加載，随着類的消失而消失，生命周期最長

2.優先于對象存在

3.被所有對象所共享

4.可以直接被類名調用

靜态的利與弊

利：對對象的共享資料進行單獨空間的存儲，節省空間，沒有必要每一個對象中都存儲一份

可以被類名調用

弊：生命周期過長

通路出現局限性（靜态隻能通路靜态）

什麼時候使用靜态

什麼時候定義靜态變量（類變量）

當對象中的出現共享資料時，該資料被靜态所修飾，對象中的特有資料要定義成非靜态尋在于堆記憶體中。

什麼時候定義靜态函數

當功能内部沒有通路到非靜态資料（對象的特有資料），那麼該功能就能定義成靜态的，也就是說，該功能方法是否需要通路非靜态的成員變量（共有的靜态變量），如果不需要，就定義成靜态的。

靜态的應用

工具類，裡面的方法都是靜态方法。并且私有化構造函數。

每一個程式都有共性的功能，可以将這些功能進行抽取，獨立封裝，以便複用。

class ArrayTool {
	//私有化構造函數
	private  ArrayTool() {		
	}
	//定義一個功能擷取數組中的最大值
	public static int  getmax(int[] arr) {
		int max=0;
		for(int x=0; x<arr.length;x++) {
			if(arr[max]<arr[x]){
				max=x;
			}
		}
		return max;
	}
	//查詢某個值在數組中是否存在
	public static int  select(int[] arr,int key) {			
		for(int x=0; x<arr.length;x++) {
			if(arr[x]==key){
				return x;
			}
		}
		return -1;
	}
	//選擇排序
	public static void  xuanze(int[] arr) {
		for(int x=0; x<arr.length-1;x++) {
			for(int y=x;y<arr.length;y++) {
				if(arr[x]>arr[y]){
					int temp=arr[y];
					arr[y]=arr[x];
					arr[x]=temp;
				}
			}
		}
	}
	//冒泡排序
	public static void  maopao(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]) {
					int temp=arr[y+1];
					arr[y+1]=arr[y];
					arr[y]=temp;					
				}				
			}
		}
	}
	//數組列印
	public static void pring(int[] arr) {
		  for(int x=0;x<arr.length;x++) {
		        if(x!=arr.length-1)
		           System.out.print( arr[x]+",");
		        else
		           System.out.println( arr[x]);
		  }
	}
}

單例設計模式

設計模式就是針對這些問題和需求，在大量的實踐中總結和理論化之後優選的代碼結構、程式設計風格、以及解決問題的思考方式

解決一個類在記憶體中隻有一個執行個體對象

多個程式使用統一配置資訊對象時，需要保證該對對象的唯一性。

保證對象唯一性的實作步驟

1.将構造函數私有化：為了避免其他程式過多建立該對象，禁止其他程式調用該對象。

2.在類中建立一個本類對象：為了讓其他程式可以通路該類對象

3.提供一個方法可以擷取到該對象的方法：友善其他程式通路自定義的本類對象。

餓漢式：一進記憶體就建立了對象

class single {
    private single(){}  1.将構造函數私有化
    private static single s=new single();  2.在類中建立一個本類對象
    public static single getInstance() {  3.提供一個方法可以擷取到該對象的方法
         return s;
    }
}
public class SingleDemo {
    public static void main(String[] args) {	
        single ss=single.getInstance();
    }
}

懶漢式：什麼時候調用什麼時候建立對象,對象的延時加載

class single {
    private single() {}
    private static single s=null;
    public static single getInstance() {
         if(s==null) {
              synchronized(Single.class) {  //同步鎖
                   if （s==null）{
                       s=single.getInstance();
                   }
              }
         }
         return s;
    }
}
public class SingleDemo {
    public static void main(String[] args) {	
         single ss=single.getInstance()
    }
}

内部類inner class

将一個類定義在另一個類的裡面，對裡面那個類就叫做内部類，或者嵌套類(nested class)。相當于外部類中的一個屬性

建立嵌套類的原因是因為被嵌套的類僅僅被它的上一級類所調用

class Outer {
    class Inner {
        public void function() {
            System.out.println("Run...");
        }
    }
}

特點

内部類可以直接通路外部類中的成員，包括私有成員。是因為内部類中持有了一個外部類的引用。格式：外部類名.this

而外部類要通路内部類中的成員必須要建立内部類對象。

内部類作為外部類的成員可以被私有化

使用環境

當描述事物時，發現事物的内部還有事物，該事物用内部類來描述。

因為内部事務在使用外部事物中的内容。

Java精選筆記_面向對象(構造方法、this關鍵字、static關鍵字、内部類)構造方法constructor構造器this關鍵字static關鍵字内部類inner class