面向對象

                                                 面向對象

3.1面向對象概念

•1、面向對象時相對面向過程而言
2、面向對象和麪向過程都是一種思想
3、面向過程 強調的是功能行爲
4、面向對象 將功能封裝進對象，強調具備了功能的對象
5、面向對象時基於面向過程的
6、面向對象特徵：封裝、繼承、多態

3.2類與對象的關係

1、類就是對現實生活中事物的描述
2、對象就是這類事物，實實在在的個體

3、成員變量：作用於整個類中，成員變量在對內存中，因爲對象的存在，纔在內存中存在
局部變量：作用於函數或者語句中，局部變量在棧內存中
4、匿名對象：匿名對象是對象的簡化形式，有兩種使用情況
    1、當對對象方法僅進行一次調用時，只有調用方法纔有意義
    2、匿名對象可以作爲實際參數進行傳遞
    3、如果對一個對象的多個成員進行調用，必須給對象起名
           new Car();就是一個匿名對象

3.3封裝

1、封裝：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式
2、好處：將變化隔離、便於使用、提高重用性、提高安全性
3、封裝原則：將不需要對外提供的內容都隱藏起來，把屬性都隱藏，提供公共方法對其訪問
4、privare：私有，權限修飾符：用於修飾類中的成員（成員變量和成員函數），私有隻在本類中有效
      注：私有僅僅是封裝的一種表現形式
5、一個成員變量通常都會對應兩個訪問方式 get set。
6、之所以對外提供訪問方式，就是因爲可以在訪問方式中加入邏輯判斷語句，對訪問的數據進行操作，提高代碼健壯性

3.4構造函數

1、特點：函數名與類名相同
      不用定義返回值類型
      可以不寫return語句
2、作用：給對象進行初始化， 對象已建立就會調用與之對應的構造函數

3、默認構造函數的特點：當一個類中沒有定義構造函數時，那麼系統會默認給該類加入一個空參數的構造函數 Person(){}。當在類        中自定義了構造函數，默認構造函數就沒有了
4、多個構造函數是以重載的形式存在的
5、構造函數與一般方法的不同之處：構造函數是在對象已建立就運行，給對象初始化，而一幫方法是對象調用才執行，是給對象添       加對象具備的功能。一個對象建立，構造函數只運行一次，而一般方法可以被該對象調用多次。
6、構造代碼塊：在類中定義一個空名的函數 例如直接寫個打印語句：。。。。。{ System.out.print（“初始化”）}。而且每一個構造         函數一建立的時候都先優先打印這個語句。
  1） 特點：對象一建立就運行，而且優先於構造函數執行
  2） 和構造函數的區別：構造代碼塊是給所有對象進行統一初始化，構造函數是給對應的對象進行初始化

3.5 this關鍵字

1、用於區分成員變量和局部變量同名的問題 例如：this.name(成員變量的name) = name(局部變量傳進來的name)
2、this 代表本類的對象。This代表它所在函數所屬對象的引用，簡單說哪個對象在調用this所在的函數，this就代表哪個對象
3、this應用：當定義類中函數功能時，該函數內部要調用到該函數的對象時，這時用this來表示這個對象。但凡本類功能內部使用了       被對象，都用this表示。
4、this語句 this();：用於構造函數間互相調用，只能放在構造函數的第一行，因爲初始化要先執行

3.6 static關鍵字

1、用於修飾成員（成員變量和成員函數

2、被修飾後的成員具備以下特點
      隨着類的加載而加載，存儲在方法區。也會隨着類的消失而消失
      優先於對象存在
      被所有對象所共享
      可以直接被類名調用 格式：類名.靜態成員

3、靜態（類）變量與實例（非靜態）變量的區別
1）存放位置：類變量隨着類的加載而存在於方法區，實例變量隨着對象的建立而存在於堆內存區
2）生命週期：類變量生命週期最長，隨着類的消失而消失，實例變量生命週期隨着對象的消失而消失。

4、使用注意
      靜態方法只能訪問靜態成員；非靜態方法既可以訪問靜態也可以訪問非靜態
      靜態方法中不可以寫this、super關鍵字，因爲靜態優先於對象存在
     主函數是靜態的

5、靜態有利有弊
     利：對對象的共享數據進行單獨空間存儲，節省空間。沒有必要每一個對象都存儲一份，可以直接被類名調用
     弊：生命週期過程，訪問有侷限性。（靜態雖好，只能訪問靜態）

6、主函數：是一個特殊的函數，作爲程序入口，可以被jvm（java虛擬機）調用
      定義：public 代表着該函數訪問權限是最大的
     static 代表主函數隨着類的加載而加載
     void 主函數沒有返回值
     mian 不是關鍵字，但是是一個特殊的單詞，可以被jvm識別
  （String[] arr）函數的參數，參數，參數類型是一個數組，該數組中的元素時字符串，字符串類型數組。
     主函數是固定格式：jvm識別
      Jvm在調用主函數時，傳入的new String[0]
7、什麼時候使用靜態？ 從兩方面下手，因爲靜態修飾的內容有成員變量和函數
     1）什麼時候定義靜態變量

           當對象中出現共享數據時，該數據被靜態所修飾。對象中的特有數據要定義成非靜態存在於堆內存中
     2）什麼時候定義靜態函數
           當功能內部沒有訪問到非靜態數據（對象的特有數據），那麼該功能可以定義成靜態的

靜態實例應用：數組工具的封裝

/*
靜態的應用：
每個應用程序中都有共性的功能，
以便將這些功能進行抽取，獨立封裝，以便複用，如下面的class ArrayTool

雖然可以通過建立ArrayTool的對象使用這些工具方法，對數組進行操作。
發現了問題：
1：對象適用於封裝數據的，可是ArrayTool對象並未封裝特有數據。
2:操作數組的每一個方法都沒有用到ArrayTool對象中的特有數據。

這時就考慮，讓程序更嚴謹，是不需要對象的。
可以講ArrayTool中的方法定義成static的。直接通過類名. 方法名稱即可。

將方法都靜態後，可方便於使用，但是該類還是可以被其它程序建立對象的。
爲了更爲嚴謹，強制讓該類不能建立對象。
可以通過將構造函數私有化完成。

接下來，將ArrayTool。class文件發送給其他人，其他人只要將該文件設置到classpath路徑下，就可以使用該類工具。

但是很遺憾，該類中到底有多少個方法，對方卻不清楚，因爲該類並沒有使用說明。

開始製作程序的說明書。java的說明書通過文檔註釋來完成。
*/
/**
這是一個可以對數組進行操作的工具，該類提供了，獲取最值、排序等功能。
@author 關軍波
@version v1.1

*/
public class ArrayTool
{
    /**
    空參數構造函數。
    */
    private ArrayTool(){}//構造函數私有化

    /**
    獲取一個整形數組中的最大值。
    @param arr 接收一個int類型的數組。
    @return 會返回一個該數組中最大值。
    */
    public static int getMax(int[] arr)//取數組最大值
    {
        int max=0;
        for (int x=1;x<arr.length ;x++ )
        {
            if(arr[max]<=arr[x])
            {
                int temp=arr[max];
                arr[max]=arr[x];
                arr[x]=temp;
            }

        }
        return arr[max];
    }

    /**
    獲取一個整形數組中的最小值。
    @param arr 接收一個int類型的數組。
    @return 會返回一個該數組中最小值。
    */
    public static int getMin(int[] arr)//取數組最小值
    {
        int min=0;
        for (int x=1;x<arr.length ;x++ )
        {
            if(arr[min]>=arr[x])
            {
                int temp=arr[min];
                arr[min]=arr[x];
                arr[x]=temp;
            }
        }
        return arr[min];
    }

    /**
    給int數組進行選擇排序
    @param arr 接收一個int類型的數組。

    */
    public static void selectSort(int[] arr)//數組選擇排序
    {
        for (int x=0;x<arr.length-1 ;x++ )
        {
            for (int y=x+1;y<arr.length ;y++ )
            {
                /*if(arr[x]>=arr[y])
                {
                    int temp=arr[x];
                    arr[x]=arr[y];
                    arr[y]=temp;
                }*/
                swap(arr,x,y);
            }

        }
        printArray(arr);
        /*
          System.out.print("[ ");
          for (int x=0;x<arr.length ;x++ )
          { if(x!=arr.length-1)
                System.out.print(arr[x]+" ");
            else
                System.out.println(arr[x]+" ]");
          }
        */

    }

    /**
    給int數組進行冒泡排序
    @param arr 接收一個int類型的數組。

    */
    public static void bubbleSort(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];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }*/
                swap(arr,y,y+1);
            }
        }
        printArray(arr);
        /*
          System.out.print("[ ");
          for (int x=0;x<arr.length ;x++ )
          { if(x!=arr.length-1)
                System.out.print(arr[x]+" ");
            else
                System.out.println(arr[x]+" ]");
          }
        */
      }

     /**
      用於打印數組中的元素。打印形式是：[element1 element2 ...]
     */
     public static void printArray(int[] arr )
    {
        System.out.print("[ ");
        for (int x=0;x<arr.length ;x++ )
        {   if(x!=arr.length-1)
                System.out.print(arr[x]+" ");
            else
                System.out.println(arr[x]+" ]");
        }
    }
    /**
    給數組中的元素進行位置的置換。
    @param arr 接收一個int類型的數組。
    @param a 要置換的位置
    @param b 要置換的位置
    */
    private static  void swap(int[] arr,int a,int b)//內部調用可以私有化
    {
        if(arr[a]>arr[b])
            {
                int temp=arr[a];
                arr[a]=arr[b];
                arr[b]=temp;
            }
    }

}

封裝功能，製作java程序說明書

要求：獲取數組中的最大值、最小值並用選擇排序和冒泡排序對數組進行排序        

{2,1,4,7,8,3,1}

思路：上面已將數組的這些功能進行了封裝，我們只需調用即可

class ArrayToolDemo
{
    public static void main(String[] args)
    {
        int[] arr=new int[]{2,1,4,7,8,3,1};

        int max=ArrayTool.getMax(arr);
        System.out.println("max="+max);
        int min=ArrayTool.getMin(arr);
        System.out.println("min="+min);
        ArrayTool.selectSort(arr);
        System.out.println();
        ArrayTool.bubbleSort(arr);
    }
}

打印結果：

8、靜態代碼塊

格式：static {靜態代碼塊執行語句；}
特點：隨着類的加載而執行，只執行一次，用於給類進行初始化的，優先於主函數
靜態代碼塊-->執行完->-構造代碼塊->--執行完->-構造函數 執行順序

9、對象的初始化過程 Person p = new Person(“zhangsan”,20)，這句話都做了什麼

1）因爲new用到了Person.class，所以會先找到Person.class文件並加載到內存中
2）執行該類中的static代碼塊，如果有的話，給Person.class類進行初始化
3）在對內存中開闢空間，分配內存地址
4）在對內存中建立對象的特有屬性，並進行默認初始化
5）對屬性進行顯示初始化
6）對對象進行構造代碼塊初始化
7）對對象進行對應的構造函數初始化
8）將內存地址給棧內存中的p變量

3.7 單例設計模式

設計模式：解決某一類問題最行之有效的方法，java有23中設計模式
單例設計模式：解決一個類在內存中只存在一個對象
想要保證對象唯一性：

1：先禁止其它程序建立該類對象，避免其它程序過多建立該類象（私有構造函數）
2：爲了讓其它程序可以訪問到該類對象，只好在本類中自定義對象
3：爲了方便其它程序對自定義對象的訪問，可以對外提供一些訪問方式

這三部怎麼用代碼體現呢？

1：將構造函數私有化
2：在類中創建一個本類對象
3：提供一個方法可以獲取到該對象

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

<span style="font-size:14px;">class Single
{
    private int age;

    private Single(){}//將構造函數封裝，禁止其它類創建Single類對象
    private static Single s=new Single();//創建本類對象
    public static Single getInstance()//對外提供訪問接口
    {
        return s;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    public int getAge()
    {
        return age;
    }

}

class SingleDemo
{
    public static void main(String[] args)
    {
        Single s1=Single.getInstance();
        Single s2=Single.getInstance();
        s1.setAge(20);
        System.out.println("age="+s2.getAge());//結果 20


    }
}
</span>

單例內存分佈圖

單例設計的兩種模式：

<span style="font-size:14px;">/*
這個是先初始化對象。
稱爲：餓漢式。

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  SingleDemo1
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
    }
}</span>