黑馬程序員——Java基礎---面向對象

-----------android培訓、java培訓、java學習型技術博客、期待與您交流！------------

2015-05-06

 1、理解面向對象

面向對象的特色：

        1. 是一種符合人們思考習慣的思想

        2. 能夠將複雜的事情簡單化

        3.將程序員從執行者轉換成了指揮者

 完成需求時：

                a)先要去找具備所需的功能的對象來用。

                b) 若是該對象不存在，那麼建立一個具備所需功能的對象。

                c) 這樣簡化開發並提升複用。

        在Java的開發過程，其實就是不斷的找對象，創建對象，維護對象。設計的過程，其實就是在管理和維護對象之間的關係。

面向對象的三個特徵：

        封裝（encapsulation）   繼承（inheritance）   多態（polymorphism）

面向對象的最高境界：萬物皆對象（面試時慎用）。

2、類與對象

一、類與對象的關係

類的定義：對現實生活中事物的描述

       使用計算機語言就是不斷的描述現實生活中的事物，而java中描述事物經過類的形式體現，類是具體事物的抽象，概念上的定義。

       生活當中描述事物無非就是描述事物的屬性和行爲。如：人的身高，體重等屬性；講話跑步等行爲。Java則是用類class來描述對象的屬性和行爲。定義類其實就是在定義類中的成員（成員變量和成員函數）。

       屬性：對應類中的成員變量。

       行爲：對應類中的成員函數。   

對象：便是該類事物實實在在存在的個體。具體對象就是對應的java在堆內存中用new創建實體。

eg：Car c=new Car();Car 是一個類，，c就是一個類類型變量，記住，類類型變量指向對象。

c.color="blue";//指揮java改變變量的值：對象.對象成員

c.run();//對象.對象方法

二、成員變量和局部變量

       以前咱們用到的基本都是局部變量，如今咱們將會使用成員變量。其實它兩都是變量，規範寫法上也沒啥區別，都是標識符，可是在做用範圍和內存中分配不一樣。

區別：

       成員變量：

                a)成員變量定義在類中，在整個類中均可以被訪問。

                b) 成員變量隨着對象的創建而創建，存在於對象所在的堆內存中。

                c) 成員變量有默認初始化值。

       局部變量：

                a) 局部變量只定義在局部範圍內，如：函數內，語句內等。

                b) 局部變量存在於棧內存中。

                c) 做用的範圍結束，變量空間會自動釋放。

                d) 局部變量沒有默認初始化值。

三、匿名對象

        匿名對象是對象的簡化形式。

       匿名對象兩種使用狀況

               一、當對對象方法僅進行一次調用的時。

                二、匿名對象能夠做爲實際參數進行傳遞。

例： new Car();匿名對象

eg:       Car c=new Car();

            c.num=5;--------->等價於new Car().num=5;

匿名對象使用方式之一：當對對象的方法只調用一次時，能夠用匿名對象來完成，這樣比較簡化。若是對一個對象進行多個成員調用，必須給這個對象起個名字。

匿名對象使用方式之二：能夠將匿名對象做爲實際參數進行傳遞。

eg：show(new Car());

3、對象的封裝

一、 概念

       是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

二、 好處

        a）將變化隔離。

        b）便於使用。

        c）提升重用性。

        d）調高安全性。

三、 封裝原則

        a)  將不須要對外提供的內容都隱藏起來。

        b)  把屬性都隱藏，提供公共方法對其訪問。

四、 封裝的表現形式之一——private（私有）

        private關鍵字：權限修飾符；用於修飾類中的成員（成員變量，成員函數）；私有隻在本類中有效。

       經常使用之一：

                將成員變量私有化，對外提供對應的set，get方法對其進行訪問。提升對數據訪問的安全性。

        如：我有一我的對象，而年齡這一屬性我不想被對象訪問，我就能夠將其設爲private。

 

4、對象知識——構造函數

一、 特色：

        a） 函數名與類名相同。

        b） 不用定義返回值類型。

        c） 不能夠寫return語句。

二、構造函數 做用：

        給對象進行初始化。

三、構造函數的小細節：

        當一個類中沒有定義構造函數時，那麼系統就會默認給該類加入一個空參數的構造函數。當在類中自定義了構造函數後，默認的構造函數就沒有了。

四、構造函數和通常函數在寫法上有不一樣。

在運行上也有不一樣：

        構造函數式在對象一創建就運行，給對象初始化。而通常方法是對象調用才執行，給是對象添加對象具有的功能。一個對象創建，構造函數只運行一次。而通常方法能夠被該對象調用屢次。

五、何時定義構造函數？

        當分析事物時，該事物存在具有一些特性或者行爲，那麼將這些內容定義在構造函數中。

六、構造代碼塊

      做用：給對象進行初始化。對象一創建就運行，並且優先於構造函數運行。

和構造函數的區別：

       構造代碼塊是給全部對象進行初始化。

       而構造函數是給對應的對象初始化。

構造代碼塊中定義的是不一樣對象共性的初始化內容。

5、對象知識點——this關鍵字

   private int age;  成員變量也是age 

    Person(int age)//局部變量時age，成員變量也是age 

    { 

        this.age = age;//this可以很好區分 

    } 

以上程序綜合了構造函數和this的用法。看上去，是用於區分局部變量與成員變量同名狀況。

       this：表明本類中的對象----------》表明它所在函數所屬對象的引用。

       簡單說：哪一個對象在調用this所在的函數，this就表明哪一個對象。

eg：Person p=new Person("hanxia");其中this就表明p

this的應用：

       當定義類中功能時，該函數內部要用到調用該函數的對象時，這時用this來表示這個對象。

       但凡本類功能內部使用到了本類對象，都用this表示。

this語句：

       用於構造函數之間進行互相調用。如：this(name);

       注意： thi語句只能定義在構造函數的第一行。由於初始化要先執行。

對this的歸納總結：

        this的兩種用法：一、用於區分同名變量的狀況，說的成員和局部同名的時候；二、用於構造函數間調用。

注：通常函數不能直接調用構造函數，由於this語句不能用在通常函數中，只能用在構造函數間。

 

6、對象知識點——static（靜態）關鍵字----------》共同數據《-------》共享數據

        用法：static是一個修飾符，用於修飾成員（成員變量和成員函數）。當成員被靜態修飾後，就不在堆內存中，就多了一個調用方式，除了能夠被對象調用外，還能夠直接被類名調用。

格式：類名.靜態成員。

static特色：

        一、隨着類的加載而加載。

             也就是說：靜態會隨着類的消失而消失，說明它的生命週期最長。

        二、優先於對象存在。明確一點：靜態是先存在。對象是後存在。

        三、被全部對象所共享。

        四、能夠直接被類名所調用。

       因爲靜態成員能夠直接被類名調用，所以靜態成員變量又稱爲類變量。而非靜態成員變量又被稱爲實例變量。

實例變量和類變量的區別：

        一、存放位置。

             類變量隨着類的加載而存在於方法區中。

             實例變量隨着對象的創建而存在於堆內存中。

        二、生命週期。

             類變量生命週期最長，隨着類的消失而消失。

            實例變量生命週期隨着對象的消失而消失。

靜態有利有弊：

       利處：a,對對象共享數據進行單獨空間的存儲，節省空間。沒有必要每個對象中都存儲一份。b:能夠直接被類名調用。

       弊端：生命週期過長。

                  訪問出現侷限性。（靜態雖好，只能訪問靜態）。

靜態須要清楚的幾個小問題：

何時使用靜態？

       從兩方面下手： 由於靜態修飾的內容有成員變量和成員函數。

一、何時定義靜態變量（類變量）呢？

       當對象中出現共享數據時，該數據被靜態所修飾。

       對象中的特有數據要定義成非靜態存在於堆內存中。

二、何時定義靜態函數呢？

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

靜態使用注意事項：

        一、靜態方法只能訪問靜態成員（變量和方法）。

             非靜態方法既能夠訪問靜態也能夠訪問非靜態。

        二、靜態方法中不能夠定義this，super關鍵字。

             由於靜態優先於對象存在。因此靜態方法中不能夠出現this。

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

主函數的定義：

public：  表明着主函數訪問權限是最大的

static：  表明主函數隨着類的加載就已經存在了

void：  主函數沒有具體的返回值

main： 不是關鍵字，是一個特殊的單詞，能夠被jvm識別

(String [] arr):  函數的參數，參數類型是一個數組，該數組中的元素是字符串。字符串類型的數組。主函數是固定格式的;jvm識別。

靜態代碼塊：

       格式：

              static

              {

                           靜態代碼塊中的語句。

              }

 

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

對象的初始化過程：Persom p=new Person();

       定義一個新對象都作了哪些事情？

        一、把類名.class文件加載到內存中。Persom.class

        二、執行該類中的static代碼塊，若是有得話，給該類進行初始化。

        三、在堆內存中開闢空間，分配內存地址。給對象

        四、在堆內存中創建對象的特有屬性。並進行默認初始化。

        五、對屬性進行顯示初始化。 

        六、對對象進行構造代碼塊初始化。

        七、對對象進行對應構造函數初始化。

        八、將內存地址賦給棧內存中的對象名變量。

靜態的應用——文檔說明書。

        每個應用程序中都有共性的功能，能夠將這些功能進行抽取，獨立封裝。以便複用。

下面咱們以一個數組工具類爲例。

 

package atheima;

public class ArrayTool {
    private ArrayTool(){}//私有化構造函數是爲了讓其不能建立對象
    /**
     * 
     * @param arr 接收一個int類型的數組
     * @return 返回接收的該數組的最大值
     */
    public static int getMax(int[]arr){
        int max=0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>arr[max]) {
                max=i;                
            }
        }
        return arr[max];
        
    }
/**
 * 
 * @param arr 接收一個int類型的數組
 * @return 返回接收的該數組的最小值
 */
    public static int getMin(int[]arr){
        int min=0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]<arr[min]) {
                min=i;                
            }
        }
        return arr[min];
        
    }
    /**
     *   對int類型數組進行選擇升序排列 
     * @param arr
     */
    public void selectSort(int[]arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]>arr[j]) {
                    swap(arr,i,j);
                }
            }
            
        }
    }
    /**
     *  對int類型數組進行冒泡升序排列
     * @param arr
     */
    public static void bubbleSort(int[]arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]) {
                    swap(arr,j,j+1);
                    
                }
            }
        }
    }
    private static void swap(int[] arr, int j, int i) {
        // TODO Auto-generated method stub
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    /**
     * 遍歷數組：打印數組中全部元素，形式爲：[elemet1,elemet2,...] 
     * @param arr
     */
    public static void printArray(int[]arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i!=arr.length-1) 
            {
                System.out.print(arr[i]+",");
            }
            else {
                System.out.println(arr[i]+"]");
            }
        }
        
    }
    public static void main(String[] args) {
        int []arr={1,34,43,2};
        ArrayTool.printArray(arr);
        ArrayTool.bubbleSort(arr);
        ArrayTool.printArray(arr);
        int max=ArrayTool.getMax(arr);
        System.out.println(max);
        int min=ArrayTool.getMin(arr);
        System.out.println(min);
    }
    }

 

7、單例設計模式

單例設計模式的做用：使一個類在內存中只存在一個對象。

用代碼實現單例設計模式須要作三部：

        一、將構造函數私有化。

             例：private Single(){}

        二、在類中建立一個本類對象。

              例：private static Single s= newSingle（）；

        三、提供一個訪問方法能夠獲取到該對象。

              例：public static Single getInstance（）

                     {

                            returns;

                      }

單例設計模式只是爲了保證內存中的對象惟一，其餘在類中該怎麼描述嗎，仍是怎麼描述。

單例設計模式有兩種寫法：

        一、餓漢式：也就是剛三部中的示例語句。它的特色是先初始化對象。如：Single類一進內存，就已經建立好了對象。在實際開發中，出於安全考慮，建議使用餓漢式。

完整代碼以下：

 

package atheima;
/**
 * 這個是先初始化對象
 * 稱爲：餓漢式
 * Single 類一進內存，就已經建立了對象
 * @author Administrator
 *
 */
public class Single {
    private Single(){}
    private static Single s1=new Single();
    public static Single getInstance(){
        return s1;        
    }
}
/**
 * 對象是方法被調用時，才被初始化，也叫作對象的延時加載
 * 懶漢式
 * Single類進內存，對象尚未存在，只有調用了getInstance方法時，才創建對象
 * @author Administrator
 *
 */
class Single2{
    private Single2(){}
    private static Single2 s2=null;
    public static Single2 getInstance(){
        if(s2==null)
            s2=new Single2();
        return s2;
        
    }
    
}