修飾符：

訪問修飾符：

public 所有類均可訪問
protected 當前類、同包的類、不同包的子類
default 當前類、同包類
private 當前類
final：最終的，可以修飾類、方法、成員變數、區域性變數
final修飾的類不能被繼承
final修飾的方法不能被重寫
final修飾的變數，值不能被修改，常量

abstract：

修飾類、修飾方法
注意:abstract不可以和哪些關鍵字一起使用？
A final
B static
C private

static：

靜態的
用法：是一個修飾符，用於修飾成員(成員變數，成員函式).
當成員被靜態修飾後，就多了一個呼叫方式，除了可以被物件呼叫外，還可以直接被類名呼叫。類名.靜態成員。

靜態成員變數的特點：
1 static的變數值所有物件共享
2 static 隨著類的載入而進入方法區中
3 static修飾的成員，多了一種呼叫方法，通過類名
4 唯一的弊端是生命週期過長
5 只能在靜態方法中呼叫靜態成員
什麼時候使用？
1 當變數需要被所有的物件共享時
2 通常在工具類中使用

static特點：
1，隨著類的載入而載入。
也就說：靜態會隨著類的消失而消失。說明它的生命週期最長。

2，優先於的物件存在
明確一點：靜態是先存在。物件是後存在的。

3，被所有物件所共享
4，可以直接被類名所呼叫。

例項變數和類變數的區別：
1，存放位置。
類變數隨著類的載入而存在於方法區中。
例項變數隨著物件的建立而存在於堆記憶體中。
2，生命週期：
類變數生命週期最長，隨著類的消失而消失。
例項變數生命週期隨著物件的消失而消失。

靜態使用注意事項：
1，靜態方法只能訪問靜態成員。
非靜態方法既可以訪問靜態也可以訪問非靜態。
2，靜態方法中不可以定義this，super關鍵字。
因為靜態優先於物件存在。所以靜態方法中不可以出現this。
3，主函式是靜態的。

靜態有利有弊
利處：

靜態的應用。

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

雖然可以通過建立ArrayTool的物件使用這些工具方法，對陣列進行操作。
發現了問題：
1，物件是用於封裝資料的，可是ArrayTool物件並未封裝特有資料。
2，運算元組的每一個方法都沒有用到ArrayTool物件中的特有資料。

這時就考慮，讓程式更嚴謹，是不需要物件的。
可以將ArrayTool中的方法都定義成static的。直接通過類名呼叫即可。

將方法都靜態後，可以方便於使用，但是該類還是可以被其他程式建立物件的。
為了更為嚴謹，強制讓該類不能建立物件。
可以通過將建構函式私有化完成。

接下來，將ArrayTool.class檔案傳送給其他人，其他人只要將該檔案設定到classpath路徑下，就可以使用該工具類。

但是，很遺憾，該類中到底定義了多少個方法，對方去不清楚。因為該類並沒有使用說明書。

開始製作程式的說明書。java的說明書通過文件註釋來完成。

/**
這是一個可以對陣列進行操作的工具類，該類中提供了，獲取最值，排序等功能。
@author 張三
@version V1.1
*/

//javadoc -d myhelp -author -version ArrayTool.java

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[x]>arr[max])
                max = x;
        }
        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[x]<arr[min])
                min = x;
        }
        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])
                {
                    swap(arr,x,y);
                }
            }
        }
    }
    /**
    給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])
                {
                    swap(arr,y,y+1);
                }
            }
        }
    }
    /**
    給陣列中元素進行位置的置換。
    @param arr  接收一個int型別的陣列。
    @param a 要置換的位置 
    @param b 要置換的位置 
    */
    private  static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    /**
    用於列印陣列中的元素。列印形式是：[elemet1, 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]+"]");
        }
    }
}

/*
一個類中預設會有一個空引數的建構函式，
這個預設的建構函式的許可權和所屬類一致。
如果類被public修飾，那麼預設的建構函式也帶public修飾符。
如果類沒有被public修飾，那麼預設的建構函式，也沒有public修飾。
預設構造建構函式的許可權是隨著的類的變化而變化的。
*/

class Demo
{
    public static void main(String[] args)
    {
        int[] arr = {3,4,1,8};
        int max = getMax(arr);
        System.out.println("max="+max);
    }
    public static int getMax(int[] arr)
    {
        int max = 0;
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
}

class Test
{
    public static int getMax(int[] arr)
    {
        int max = 0;
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
}