java類的結構（屬性、方法、構造函數）

1、類的定義形式
類定義的通常形式以下

[類定義修飾符] class  <類名>   

{   //類體

  [成員變量聲明] [構造函數]

  [成員方法]

}

前面說過，在描述java語法時，方括號中的內容都是能夠省略掉的。實際上任何程序設計相關語法都是如此，這是國際通行的標準。那麼，要定義一個最簡單的類就是以下的寫法：
class Test
{

}
這個類由於類體沒有包含任何內容，因此什麼也不幹，同時若是直接調試該程序，能夠編譯，可是運行錯誤，提示錯誤信息以下：「錯誤: 在類 Test 中找不到主方法, 請將主方法定義爲:   public static void main(String[] args)」。
爲何會出現這個錯誤呢？由於講過前面，一個java程序或者說一個java項目，必須有一個主類（主類內容接下來會講），主類必須有一個主方法，主方法就是程序的入口，即程序首先是從主類的主方法中開始運行的，因此運行該程序天然會提出錯誤信息。
2、類的定義解釋  
一、類的定義：  類的定義經過關鍵字class來實現，所定義的類名應符合標識符的規定。類的名字必須由大寫字母開頭而單詞中的其餘字母均爲小寫；若是類名稱由多個單詞組成，則每一個單詞的首字母均應爲大寫例如TestPage；若是類名稱中包含單詞縮寫，則這個所寫詞的每一個字母均應大寫，如：XMLExample。還有一點命名技巧就是因爲類是設計用來表明對象的，因此在命名類時應儘可能選擇名詞。
二、類定義修飾符 修飾符:修飾符能夠省略，也能夠是public, protected, private, static, final，其中public、protected , private三個最多隻能出現其中之一，能夠與static, finaf組合起來修飾屬性。

三、成員變量聲明

成員變量是類的屬性，聲明的通常格式爲：
   [變量修飾符] <成員變量類型>   <成員變量名>

變量修飾符:public、protected、private、和默認（frieddlly）。四、構造函數通常咱們講的「函數」就是「方法」，構造函數是一個特殊的函數，雖然在類定義的過程當中用方括號括起來，即咱們能夠不寫構造函數，可是java系統會默認自動爲每一個類生成一個缺省的不帶任何參數的構造函數，在建立對象時系統會調用缺省的構造函數。若是程序中定義了構造函數，系統將再也不提供該缺省的構造函數。構造函數具備以下特色：（1）構造方法的方法名必須與類名相同，其它方法不能和類名相同。

 

　　（2）構造方法沒有返回類型，也不能定義爲void，在方法名前面不聲明方法類型。

 

　　（3）構造方法的主要做用是完成對象的初始化工做，它可以把定義對象時的參數傳給對象的域。

 

　　（4）構造方法不能由編程人員調用，而由系統調用。

 

　　（5）一個類能夠定義多個構造方法，若是在定義類時沒有定義構造方法，則編譯系統會自動插入一個無參數的默認構造器，這個構造器不執行任何代碼。

 

　　（6）構造方法能夠重載，以參數的個數，類型，或排列順序區分。
使用無參數構造函數的例子

class Test {
	String name;
	Test(){
		name="韋小寶";
	}
	public static void main(String[] args){
		Test t1=new Test();
		System.out.println(t1.name);
		t1.name="康熙";
		System.out.println(t1.name);
	}
}

 

執行程序，輸出結果以下：韋小寶康熙 在程序中並無對對象 t1的name變量進行賦值，而打印輸出 t1.name 輸出結果是「韋小寶」，此時Test類的構造函數中對name變量進行了初始化，輸出的就是初始化的值；而對t1對象的name屬性進行了賦值後，此時輸出結果就是從新賦值後的值，即「康熙」。使用有參數構造函數的例子

class Test {
	String name;
	Test(){
		name="韋小寶";
	}
	Test(String myName){
		this.name=myName;
	}
	public static void main(String[] args){
		Test t1=new Test();
		System.out.println(t1.name);
		Test t2=new Test("康熙");
		System.out.println(t2.name);
	}
}

執行程序，輸出結果以下：韋小寶康熙

五、成員方法成員方法定義的類的操做和行爲，通常形式爲：
 [方法修飾符] <方法返回值類型> <方法名>（[<參數列表>]）
  {
    方法體
}
成員方法修飾符主要有public、private、protected、final、static、abstract和synchronized七種，前三種的訪問權限、說明形式和含義與成員變量一致。
與成員變量相似，成員方法也分爲實例方法和類方法。若是方法定義中使用了static ,則該方法爲類方法。public static void main(String [] args)就是一個典型的類方法




3、類的修飾符及其訪問範圍
前面說了修飾符，可是沒有提及含義，這裏講解一下 常見的類訪問修飾符：

可見度	public	protected	private	缺省
同一類中可見	是	是	是	是
同一包中對子類可見	是	是	否	是
同一包中對非子類可見	是	是	否	是
不一樣包中對子類可見	是	是	否	否
不一樣包中對非子類可見	是	否	否	否

關於包、子類概念以後講解。

Java程序在定義類時，除了使用class關鍵字標識以外，還能夠在class以前增長若干類的修飾符來修飾限定所定義的類的特性。類的修飾符分爲訪問控制符和非訪問控制符兩大類。修飾符之間的前後排列次序對類的性質沒有任何影響。

 

一）非訪問修飾符。

 1，  抽象類：
    凡是用abstract修飾符修飾的類被稱爲抽象類。抽象類就是沒有具體對象的概念類。
    抽象類是一種通過優化的概念組織方式：把共同特色抽象出來；其後在描述和處理某一種具體對象時，就只需描述不一樣的特殊之處。這種組織方式使得全部的概念井井有條，簡潔洗練，很是符合人們平常的思惟習慣。
    因爲抽象類是它的全部子類的公共屬性的集合，因此使用抽象類的一個優勢就是能夠充分利用這些公共屬性來提升開發和維護程序的效率。
    值得一提的是，面向對象技術是要用更接近於人類思惟方式的方法來處理實際問題，抽象類的設立就是這種思想的具體體現之一，它是模仿人類的思惟模式的產物。

 2，最終類：
    若是一個類被final修飾符所修飾和限定，說明這個類不可能有子類。
    被定義爲final的類一般是一些有固定做用、用來完成某種標準功能的類。如Java系統定義好的用來實現網絡功能的InterAddress、Socket等類都是final類。
       abstract和final修飾符不能同時修飾一個類，由於abstract類自身沒有具體對象，須要派生出子類後在建立子類的對象；而final類不可能有子類。這樣放在一塊兒修飾就沒有意義了。

 3，有些類的修飾符也能夠用來修飾類中的域或方法：

 (1)    域：是類和對象的靜態屬性，定義域的操做就是說明變量或建立對象的操做。

 <1> 靜態域：
    用static修飾符修飾的域是僅屬於類的靜態域。靜態域是類中每一個對象共享的域。他們是類的域，不屬於任何一個類的具體對象。是一個公共的存儲單元，任何一個類的對象訪問它時，取到的都是相同的數值。

 <2> 靜態初始化器：
    靜態初始化器是由關鍵字static引導的一對大括號括起的語句組。做用是：在加載時，初始化類的靜態域。
    與構造函數相同，他們都是用來完成初始化的工做，可是靜態初始化器與構造函數有三點不一樣：
        ①構造函數是對每一個新建立的對象初始化，而靜態初始化器是對類自身進行初始化。
     ②構造函數是在用new運算符產生新對象時由系統自動執行，而靜態初始化器則是在它所屬的類加載到內存時由系統調用執行。
     ③不一樣於構造函數，靜態初始化器不是方法，沒有方法名、返回值和參數列表。

 <3> 最終域：
    用final修飾的域，實際上就是Java中的常量。
    用final修飾符說明常量時，須要注意如下幾點：
    ①須要說明常量的數據類型。
    ②須要同時指出常量的具體取值。
    ③由於全部類對象的常量成員，其數值都固定一致，爲了節省空間，常量一般聲明爲static。

 <4> 易失域：
    若是一個域被volatile修飾符所修飾，說明這個域可能同時被幾個線程所控制和修改，即這個域不只僅被當前程序所掌握，在運行過程當中可能在其餘未知的程序操做影響和改變該域的取值。在使用當中應該特別注意。
    一般，volatile用來修飾接受外部輸入的域。如表示當前時間的變量將系統的後臺線程隨時修改，以保證程序中取到的老是最新的當前系統時間，因此能夠把它定義爲易失域。

 (2)方法：是類的動態屬性，標誌了類所具備的功能和操做。小括號是方法的標誌。

 <1> 抽象方法：
    修飾符abstract修飾的抽象方法是一種僅有方法頭，而沒有具體的方法體和操做實現的方法。使用抽象方法的目的是使全部的子類，對外都呈現一個相同名字的方法，是一個統一的接口。全部的抽象方法，都必須存在於抽象類之中。

 <2> 靜態方法：
    用static修飾符修飾的方法，是屬於整個類的類方法，不用的是對象或實例的方法。調用這種方法時，應該使用類名做前綴；這種方法在內存中的代碼段將隨着類的定義而分配和裝載，不被任何一個對象專有；只能處理屬於整個類的成員變量。

 <3> 最終方法：
    用final修飾符修飾的類方法。功能和內部語句不能再更改的方法，不能再被繼承。
    注意：全部已被private修飾符限定爲私有的方法，以及全部包含在final類中的方法，都被缺省地認爲是final的。

 <4> 本地方法：
    用native修飾符聲明其餘語言書寫方法體並具體實現方法功能的特殊的方法。這裏的其餘語言包括C/C++/FROTRAN/彙編等。因爲native的方法的方法體使用其餘語言在程序外部寫成，因此全部的native方法都沒有方法體，而用一個分號代替。

 <5> 同步方法：
      若是synchronized修飾的方法是一個類的方法（即static的方法），那麼在被調用執行前，將把系統類Class中對應當前類的對象加鎖。若是synchronized修飾的是一個對象的方法（未用static修飾的方法），則這個方法在被調用執行前，將把當前對象加鎖。Synchronized修飾符主要用於多線程共存的程序中的協調和同步。

   
 二）訪問控制符。
    訪問控制符是一組限定類、域或方法是否能夠被程序裏的其餘部分訪問和調用的修飾符。類的訪問控制符只有一個public，域和方法的訪問控制符有四個，分別是public、private、protected、private protected，另外還有一種沒有定義專門的訪問控制符的缺省狀況。

 1，  公有訪問控制符public：
      Java的類是經過包的概念來組織的，包氏類的一個鬆散的集合。處於同一個包中的類能夠不須要任何說明而方便的互相訪問和引用，而對於不一樣包中的類，則不行。但當一個類被聲明爲public時，他就具備了被其餘包中的類訪問的可能性，只要這些其餘包中的類在程序中使用import語句引入public類，就能夠訪問和引用這個類。
    類中被設定爲public的方法是這個類對外的接口部分，避免了程序的其餘部分直接去操做類內的數據，這實際就是數據封裝思想的體現。
    每一個Java程序的主類都必須是public類，也是基於相同的緣由。
    用public修飾的類的域稱爲公共域。若是公共域屬於公共類，則它能被全部的其餘類所引用。public修飾符會形成安全性的數據封裝性降低，因此通常應減小public域的使用。

 2， 缺省訪問控制符：
    缺省訪問控制權規定，該類只能被同一個包中的類訪問和引用，而不能夠被其餘包中的類使用，這種訪問特性又稱爲包訪問性。
    一樣道理，類內的域或方法若是美育訪問控制符來限定，也就具備包訪問性。
    簡單說，定義在同一個程序中的全部類屬於一個包。

 3，私有訪問控制符private :
    用private修飾得域或方法只能被該類自身所訪問和修改，並且不能被任何其餘類（包括該類的子類）來獲取和引用。private修飾符用來聲明那些類的私有成員，它提供了最高的保護級別。

 4，保護訪問控制符protected :
    用protected修飾的成員變量能夠被三種類所引用：該類自身、與它在同一個包中的其它類、在其餘包中的該類的子類。使用protected修飾符的主要做用是容許其餘包中該類的子類來訪問父類的特定屬性。

 5，私有保護訪問控制符 private protected :
    用private protected修飾的成員變量能夠被兩種類訪問和引用，一種是該類自己，一種是該類的全部子類。把同一個包內的非子類排除在可訪問的範圍以外，使得成員變量更專於具備明確繼承關係的類，而不是鬆散地組合在一塊兒的包。

class   Animal {   
  String   name;   
  int   age;   
  Animal(){
    name="Dog";
    age=3;
  }
  Animal(String name,int age){
     this.name=name;
     this.age=age;
    }
}
public class AnimalDemo{
  public static void main(String args[]){
    Animal  a=new Animal();
    Animal  b=new Animal("cat",5);
    System.out.println(a.name+" is "+a.age+" years  old");
    System.out.println(b.name+" is "+b.age+" years  old");
  }
}

4、類的加載機制：

 

一、在虛擬機的生命週期中一個類只被加裁一次 
二、加載的原則是：延遲加載 
三、類加載的時機 
1）當第一次建立對象時要加載 
2）調用static方法時要加裁，訪問static屬性時要加裁，調用static代碼塊時要加載 
3）當加載子類時會先加裁父類 
4）建立對象引用時不加裁類 
5）子類調用父類的static方法時會加裁 
在這裏要注意的是：當子類沒有重寫父類的static方法時，只加裁父類不加裁子類。當子類重寫了父類的靜態方法時既加裁父類又加裁子類。 
6）訪問static常量時，若是編譯器在以計算出常量的值能夠不加裁類，不然會加裁。 
7）用Class.forName(類名)來顯示的加載一個類 

5、java編程多個類的程序運行。

在一個*.java的文件中，只能有一個public class的聲明，可是容許有多個class的聲明，即一個源文件（*.java）中只能有一個公共類，能夠有若干默認類。舉例：

class   Animal {   
  String   name;   
  int   age;   
  Animal(){
    name="Dog";
    age=3;
  }
  Animal(String name,int age){
    	this.name=name;
    	this.age=age;
    }
}
public class AnimalDemo{
  public static void main(String args[]){
    Animal  a=new Animal();
    Animal  b=new Animal("cat",5);
    System.out.println(a.name+" is "+a.age+" years  old");
    System.out.println(b.name+" is "+b.age+" years  old");
  }
}

 

 

程序執行結果：Dog is 3 years  old
cat is 5 years  old

本例中AnimalDemo.java源文件中有兩個類：Animal類 和 AnimalDemo類，AnimalDemo類做爲公共類，也就是主類，該類中有主方法；默認類（Default類）Animal類定義了兩個構造方法，沒有主方法，程序編譯時生成兩個
 字節碼文件，分別是Animal.class 和 AnimalDemo.class。在AnimalDemo類中調用了
 Animal類實例化對象，並進行相應的數據處理。注意當一個源文件中有多個類的時候，使用主類做爲 文件名。
一樣，咱們能夠將一個源文件中的多個類分解成多個源文件，即一個類爲一個源文件。好比上面的例子。源文件：Animal.java

class   Animal {   
  String   name;   
  int   age;   
  Animal(){
    name="Dog";
    age=3;
  }
  Animal(String name,int age){
    	this.name=name;
    	this.age=age;
    }
}

源文件：AnimalDemo.java

public class AnimalDemo{
  public static void main(String args[]){
    Animal  a=new Animal();
    Animal  b=new Animal("cat",5);
    System.out.println(a.name+" is "+a.age+" years  old");
    System.out.println(b.name+" is "+b.age+" years  old");
  }
}

在命令提示符下，執行下面三個步驟：一、編譯Animal.java文件（javacAnimal.java）二、編譯AnimalDemo.java文件（javacAnimalDemo.java）三、執行AnimalDemo.javae文件 （javaAnimalDemo）。 也能夠直接編譯運行AnimalDemo文件，即直接從上面第二個步驟執行，當程序編譯AnimalDemo源文件時，遇到 Animal  a=new Animal()語句時，會自動編譯Animal源文件。java程序中，就是由這樣的類組成個應用程序，在編寫過程當中，通常採用 一個類一個源文件的方式進行編程，一遍對類進行維護和修改。