Java入門——（2）面對對象（上）

關鍵詞：面對對象、類、、構造方法、this、static、內部類一、面對對象的概念：把解決的問題安裝一定規則劃分為多個獨立的對象，然後通過調用對象的方法來解決問題。其特點可概括為封裝性、繼承性、多態性。 1、封裝性：面對對象的核心，將對象的屬性和行為封裝起來，不需要讓外界知道具體實現細節，這就是封 ...

關鍵詞：面對對象、類、、構造方法、this、static、內部類一、面對對象的概念：把解決的問題安裝一定規則劃分為多個獨立的對象，然後通過調用對象的方法來解決問題。其特點可概括為封裝性、繼承性、多態性。 1、封裝性：面對對象的核心，將對象的屬性和行為封裝起來，不需要讓外界知道具體實現細節，這就是封裝思想。 2、繼承性：主要描述的是類與類之間的關係，通過繼承，可以在無需重新編寫原有類的情況下，對原有類的功能進行擴展。 3、多態性：是在程式中允許出現重名現象，它指在一個類中定義的屬性和方法被其他類繼承後，他們可以具有不同的數據類型或表現出不同的行為，這使得同一個屬性和方法在不同的類中具有不同的語義。二、類與對象 1、類是對象的抽象，它用於描述一組對象的共同特征和行為。類中可以定義成員變數和成員方法，其中成員變數用於描述對象的特征，也稱作屬性，成員方法用於描述對象的行為，可簡稱方法。如何創建類：

1 class Person{
2      //定義int 類型的變數
3       int age;
4      //定義speak（）方法
5       void speak （）{
6             System.out.println(“***”)
7       }
8 } //Person 類名，age 是成員變數，speak（）成員方法

2、對象的創建與使用：創建：類名對象名= new 類名（）；//實例對象使用：對象引用.對象成員；實例化對象時，Java虛擬機會自動為成員變數進行初始化，針對不同類型的成員變數，賦予不同的初始值。

表：成員變數的初始值
成員變數類	初始值	成員變數類	初始值
byte	0	double	0.0D
short	0	char	空字元，‘\u0000'
int	0	boolean	false
long	0L	引用數據類型	null
float	0.0F

在Java中，null是一種特殊的常量，當一個變數的值為null時，則表示該變數不指向任何一個對象，變成垃圾被回收。 3、所謂的類的封裝是指定義一個類時，將類中的屬性私有化，即利用private 關鍵字來修飾，私有屬性只能在它所在類中被訪問。為了能讓外界訪問私有屬性，需要提供一些使用public 修飾的公用方法，其中包括用於獲得屬性值得getXXX（）方法和設置屬性值得setXXX（）方法。

 1 class Student{
 2     private String name;    //將name屬性私有化
 3     private int age;        //將age屬性私有化
 4     //下麵是公有的getXXX（）和setXXX（）方法
 5     public String getName (){
 6         return name;
 7     }
 8     public void setName(String stuName){
 9         name = stuName ;
10     }
11     public int getAge (){
12         return age ;
13     }
14     public void setAge(int stuAge){
15         //下麵是對傳入的參數進行檢查
16         if(stuAge<=0){
17             System.out.println("年齡不合法");
18         }else {
19             age = stuAge ;        //對屬性賦值
20         }
21     }
22     public void introduce(){
23         System.out.println("大家好，我叫"+name+",我今年"+age+"歲!");
24     }
25 }
26 public class Example01{
27     public static void main(String[] args){
28         Student stu  = new Student();
29         stu.setAge(-30);
30         stu.setName("李芳");
31         stu.introduce();
32     }
33 }

三、構造方法 1、構造方法：構造方法是類中一個特殊成員，它會在實例化對象時被自動調用。 2、構造方法的特點： ①方法名與類名相同；

②在方法名前面沒有返回值類型的聲明；

③在方法中不能使用return語句返回一個值；

 1 class Person{
 2       //構造方法
 3      public Person(){
 4           //無參構造方法
 5       }
 6      public Person(int age){
 7           age = a;   //有參構造方法
 8      }
 9      public void speak(){
10           System.out.println(“I am” +age+”years old !");
11      }
12 }
13 public  class Example{
14      public  static void main (String [] args){
15          Person p = new Person(20);  //實例化Person對象
16          p.speak();
17      }
18 }

3、構造方法的重載：與普通方法一樣，方法名相同，只需要參數類型或參數個數不同即可。一般情況下，構造方法通常會使用public來修飾。四、this 關鍵字 1、this關鍵字三種常用方法：

①通過this關鍵字可以明確地訪問一個類的成員變數，解決與局部變數名稱衝突問題。

 1 class Person{
 2      int age ;
 3      public Person(int age){
 4           this.age = age ;   //訪問成員變數
 5      }
 6      public int getAge(){
 7          return this .age;
 8     }
 9  }

②通過this關鍵字調用成員方法。

③構造方法是在實例化對象時被Java虛擬機自動調用的，在程式中不能像調用其他方法一樣去調用構造方法，但可以在一個構造方法中使用“this（【參數1，參數2……】）”的形式來調用其他的構造方法。

註意點：

①只能在構造方法中使用this 調用其他的構造方法，不能在成員方法中使用。

②在構造方法中，使用this 調用構造方法的語句必須位於第一行，且只能出現一次。

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

五、static關鍵字 1、使用static關鍵字來修飾成員變數，該變數被作靜態變數。靜態變數被所有實例共用，可以使用“類名.變數”的形式來訪問。註意：static關鍵字只能用於修飾成員變數，不能用於修飾局部變數。 2、靜態方法：在類中定義的方法前加上static關鍵字，可在不創建對象的情況下調用某方法。可使用“類名.方法名”的形式訪問。註意：在一個靜態方法中只能訪問static修飾的成員，靜態方法在被調用時可以創建任何對象。 3、靜態代碼塊：用static關鍵字修飾的代碼塊稱為靜態代碼塊，當類被載入時，靜態代碼塊會被執行，由於類只載入異常，因此靜態代碼塊只能執行一次。 4、單例模式：

 1 class Single{
 2      private static Single INSTANCE = new Single();
 3      private Single(){}
 4      public static Single getInstance(){  
 5          return INSTANCE ; 
 6        }
 7 }
 8 //上面單例又可寫成以下形式
 9 class Single{
10      private Single(){}
11      public static final Single INSTANCE = new Single()；
       /*變數名INSTANCE的前面有三個修飾符，其中，public的作用是允許外部直接訪問該變數，static 的作用是 讓外部可以使用
         “類名.變數名“的方式來訪問變數，final的作用是禁止外部對該變數進行修改。*/
12 }
13 
14 class Example {
15     public static void main(String[] args){
16          Single s = Single.getInstance();    //   getInstance()方法是獲得Single類實例對象的唯一途徑，Single 類是一個單例的類    
17      }
18 }

被關鍵字final修飾的變數為常量,其值不可變。六、內部類：根據內部類的位置、修飾符和定義的方式可分為成員內部類、靜態內部類、方法內部類。 1、創建內部類對象的具體語法格式：外部類名.內部類名變數名 = new 外部類名（）.new 內部類（）；

 1 class Outer{
 2     private int num = 4;              //定義類的成員變數
 3     //下麵的代碼定義了一個成員方法，方法中訪問內部類
 4     public void test(){
 5         Inner inner = new Inner();
 6         inner.show();
 7     }
 8     //下麵的代碼定義了一個成員內部類
 9     class Inner{
10         void show(){
11             //在成員內部類的方法中訪問外部類的成員變數
12             System.out.println("num = "+num);
13         }
14     }
15 }
16 public class Example16 {
17     public static void main(String[] args){
18         Outer outer = new Outer();               //創建外部類對象
19         outer.test();                                 //調用test（）方法
20     }
21 }
22 //直接創建內部類對象示例
23 public class Example16 {
24     public static void main(String[] args){
25         Outer.Inner inner = new Outer().Inner() ;               //創建內部類對象
26         inner.show();                                 //調用show（）方法
27     }
28 }
29 //當內部類被聲明為私有，外界將無法訪問。

2、創建靜態內部類對象的具體語法格式：外部類名.內部類名變數名 = new 外部類名.內部類名（）；

 1 class Outer{
 2     private static int num = 6;              //定義類的成員變數
 3     //下麵的代碼定義了一個靜態內部類
 4     static class Inner{
 5         void show(){
 6             System.out.println("num = "+num);
 7         }
 8     }
 9 }
10 public class Example16 {
11     public static void main(String[] args){
12         Out.Inner inner = new Out.Inner();             //創建內部類對象
13             inner.show();                                 //調用內部類的方法
14     }
15 }

註意：①在靜態內部類中只能訪問外部類的靜態成員。

②在靜態內部類中可以定義靜態成員，而在非靜態的內部類中不允許定義靜態的成員。 3、方法內部類：是指在成員方法中定義的類，它只能在當前方法中被使用。方法內部類可以訪問外部類的成員變數。