集合存放數據的容器，存放的數據可以是基本類型也可以是引用類型，數據類型必須一致，存放數據的空間是連續的即地址連續，長度固定
聲明數組變量
首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法：

dataType[] arrayRefVar; // 首選的方法 dataType arrayRefVar[]; // 效果相同，但不是首選方法

注意: 建議使用 dataType[] arrayRefVar 的聲明風格聲明數組變量。
dataType arrayRefVar[] 風格是來自 C/C++ 語言 ，在Java中采用是為了讓 C/C++ 程序員能夠快速理解java語言。
創建數組
Java語言使用new操作符來創建數組，語法如下：
arrayRefVar = new dataType[arraySize];
上面的語法語句做了兩件事：
一、使用 dataType[arraySize] 創建了一個數組。
二、把新創建的數組的引用賦值給變量 arrayRefVar。
數組變量的聲明，和創建數組可以用一條語句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，你還可以使用如下的方式創建數組。
dataType[] arrayRefVar = {value0, value1, …, valuek};
數組的元素是通過索引訪問的。數組索引從 0 開始，所以索引值從 0 到 arrayRefVar.length-1。

例一：

public class ArrayDf{public static void main(String[] args){String[] stringArray; //主方法棧幀中創建一個String[]類型變量，存放一個String[]類型的變量，里面包含若干元素，引用類型//String[]是一種類型，不能有下標//數組變量存儲的位置看定義的位置，比如static——靜態數據區stringArray = new String[10]; //創建對象在堆區，開辟10個String[]類型的空間相當于創建了10個連續的變量，初值一樣stringArray[1]="two"; //把two賦給stringArray[]所指數組對象的第二個元素 //數組名對應數組元素空間地址，數組對象每一個元素的空間 //元素名和變量名類似，尋址方式不同，導致叫法不同 //變量——直接尋址 //元素——間接尋址 //元素名：元素空間首地址+下標 //有確切的初值null //一個new String一次創建兩個對象，分別儲存在堆中和方法區的常量池 //元素個數已經定義，是final不可分割，不可改變的System.out.println("元素默認初始化值是："+stringArray[2]); //輸出String[]類型System.out.println("元素默認初始化值是："+stringArray);} }

例二：

public class StaticInitArray{public static void main(String[] args){int[]a = {1,3,5,7,9,11};//這種初始化只能在聲明時使用 主方法棧幀中開辟空間，創建變量a，int[]類型，不會默認初始化 在類中定義的實例變量（堆）和靜態全局變量（方法區靜態數據區）會默認初始化，在棧楨中不會默認初始化//int[] a;//a= {1,3,5,7,9,11}; 錯誤這屬于賦值不是初始化//初始化有默認初始化，顯式初始化 //顯示初始化是在定義變量的時候//賦值可以多次，初始化只能有一次int[]k=new int[0];//System.out.println(k[0]);//int[]m=new int[-10];int[]num;num=new int[]{1, 2, 3, 4, 5};既可以初始化，也可以賦值，比較靈活int[]b = new int[3]; //指定元素個數3，默認為0b=num;b原來所指的數組對象地址丟失，游離，內存泄露 //b,num都是首元素地址a,b,num類型相同，可以相互賦值b[2]=100;for (int i = 0;i<b.length;i++){System.out.println(num[i]);} System.out.println("--------------------");for (int i:b){ //拿出數組元素賦給iSystem.out.println(i);}集合可以存放不同類型對象的地址，數組也可以，但必須是object[]類型} }

多維數組
多維數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組，例如：

String str[][] = new String[3][4];

多維數組的動態初始化（以二維數組為例）
1. 直接為每一維分配空間，格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

type 可以為基本數據類型和復合數據類型，arraylength1 和 arraylength2 必須為正整數，arraylength1 為行數，arraylength2 為列數。
例如：

int a[][] = new int[2][3];

解析：
二維數組 a 可以看成一個兩行三列的數組。
2. 從最高維開始，分別為每一維分配空間，例如：

String s[][] = new String[2][]; s[0] = new String[2]; s[1] = new String[3]; s[0][0] = new String("Good"); s[0][1] = new String("Luck"); s[1][0] = new String("to"); s[1][1] = new String("you"); s[1][2] = new String("!");

解析：
s[0]=new String[2] 和 s[1]=new String[3] 是為最高維分配引用空間，也就是為最高維限制其能保存數據的最長的長度，然后再為其每個數組元素單獨分配空間 s0=new String(“Good”) 等操作。
多維數組的引用（以二維數組為例）
對二維數組中的每個元素，引用方式為 arrayName[index1][index2]，例如：

num[1][0];

Arrays 類
java.util.Arrays 類能方便地操作數組，它提供的所有方法都是靜態的。
具有以下功能：
? 給數組賦值：通過 fill 方法。
? 對數組排序：通過 sort 方法,按升序。
? 比較數組：通過 equals 方法比較數組中元素值是否相等。
? 查找數組元素：通過 binarySearch 方法能對排序好的數組進行二分查找法操作。
具體說明請查看下表：
序號 方法和說明

1 public static int binarySearch(Object[] a, Object key)

用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。如果查找值包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。

2 public static boolean equals(long[] a, long[] a2)

如果兩個指定的 long 型數組彼此相等，則返回 true。如果兩個數組包含相同數量的元素，并且兩個數組中的所有相應元素對都是相等的，則認為這兩個數組是相等的。換句話說，如果兩個數組以相同順序包含相同的元素，則兩個數組是相等的。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

3 public static void fill(int[] a, int val)

將指定的 int 值分配給指定 int 型數組指定范圍中的每個元素。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

4 public static void sort(Object[] a)

對指定對象數組根據其元素的自然順序進行升序排列。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

length屬性，length()方法和size()的方法的區別
1.length屬性是針對Java中的數組來說的，要求數組的長度可以用其length屬性；
2.length()方法是針對字符串來說的，要求一個字符串的長度就要用到它的length()方法；
3.java中的size()方法是針對泛型集合說的,如果想看這個泛型有多少個元素,就調用此方法來查看!

public static void main(String[] args) {String []list={"ma","cao","yuan"};String a="macaoyuan";System.out.println(list.length);System.out.println(a.length());List array=new ArrayList();array.add(a);System.out.println(array.size()); }

冒泡法排序的基本思想：
從前向后（或從后向前）依次比較相鄰兩個元素的大小,如果逆序（與題意要求的順序相反）就進行交換,使最小（最大）的元素上浮（下沉）到本次排序的最前面（最后面），從而完成一趟(pass)排序。下一趟排序時，已經有序的元素不再參與。這樣的話，n個元素需要進行n-1趟排序
冒泡排序的關鍵點：
（1）采用雙層循環：時間復雜度為O（n的平方）
外層循環表示的是排序的趟數，n個數字需要n-1趟，因此，外層循環的次數是n-1次；
內層循環表示的是每一趟排序的數字。根據冒泡排序的思想，第i趟排序后，就會有i個數屬于有序的元素，它們不參與第i+1趟的排序。因此，用一個循環來控制，只是不同的方式的寫法不一樣，望學者理解掌握。
（2）相鄰兩個數只要屬于逆序，就實行交換。正序就不交換，因此，是穩定排序；也就是說，即使序列中出現相同的兩個數字，它們不會實施交換，相同數字的相對順序不會發生變化！

選擇排序的基本思想：
找到當前數字序列中最大（最小）的數，記錄其所在位置，將其和最前面（最后面）的數進行交換，使最小（最大）的元素上浮（下沉）到本次排序的最前面（最后面），從而完成一趟(pass)排序。下一趟排序時，已經有序的元素不再參與。這樣的話，n個元素需要進行n-1趟排序
選擇排序的關鍵點：
（1）采用雙層循環：時間復雜度也是O（n的平方）
外層循環表示的是排序的趟數，n個數字需要n-1趟，因此，外層循環的次數是n-1次；同時也代表數的位置。
內層循環表示的是每一趟排序的數字。根據選擇排序的思想，第i趟排序時，最前面的位置就是i，用一個循環來不斷更新。
（2）找到最值數的位置，將該位置的數和當前序列最前面（最后面）位置的數進行交換；。（穩定排序）

插入排序的基本思想是：
將數組的第一個數認為是有序數組，從后往前（從前往后）掃描該有序數組，把數組中其余n-1個數，根據數值的大小，插入到有序數組中，直至數組中的所有數有序排列為止。這樣的話，n個元素需要進行n-1趟排序
插入排序的關鍵點：
? 采用雙層循環：時間復雜度也是O（n的平方）
（1）外層循環表示的是排序的趟數，n個數字需要n-1趟，因此，外層循環 的次數是n-1次；同時也代表數的位置。
（2）內層循環表示的是每一趟排序的數字。根據插入排序的思想，第i趟排 序時，有序數組中的數字就有i個，就需要進行i次比較，因此循環i次。注 意采用的是從后往前進行比較。
? 從后往前掃描的時候，如果必須插入的數大于有序數組中當前位置的數，則有序數組中的數和它之后的數均往后移一個位置，否則，把插入的數插入到有序數組中。（穩定排序）

繼承類型
需要注意的是 Java 不支持多繼承，但支持多重繼承。

繼承的特性

子類擁有父類非 private 的屬性、方法。

子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展。

子類可以用自己的方式實現父類的方法。

Java 的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如A類繼承B類，B類繼承C類，所以按照關系就是C類是B類的父類，B類是A類的父類，這是Java繼承區別于C++繼承的一個特性。提高了類之間的耦合性（繼承的缺點，耦合度高就會造成代碼之間的聯系越緊密，代碼獨立性越差）。

繼承關鍵字
繼承可以使用extends和implements這兩個關鍵字來實現繼承，而且所有的類都是繼承于java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，所以不需要 import）祖先類。
extends關鍵字
在Java中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以extends只能繼承一個類。
implements關鍵字
使用implements關鍵字可以變相的使java具有多繼承的特性，使用范圍為類繼承接口的情況，可以同時繼承多個接口（接口跟接口之間采用逗號分隔）。
super 與 this 關鍵字
**super關鍵字：**我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。
**this關鍵字：**指向自己的引用。
final關鍵字 final 關鍵字聲明類可以把類定義為不能繼承的，即最終類；或者用于修飾方法，該方法不能被子類重寫：

聲明類：
final class 類名 {//類體}
聲明方法：

修飾符(public/private/default/protected) final 返回值類型 方法名(){//方法體}

**注:**實例變量也可以被定義為 final，被定義為 final 的變量不能被修改。被聲明為 final 類的方法自動地聲明為 final，但是實例變量并不是 final

構造器
子類是不繼承父類的構造器（構造方法或者構造函數）的，它只是調用（隱式或顯式）。如果父類的構造器帶有參數，則必須在子類的構造器中顯式地通過 super 關鍵字調用父類的構造器并配以適當的參數列表。
如果父類構造器沒有參數，則在子類的構造器中不需要使用 super 關鍵字調用父類構造器，系統會自動調用父類的無參構造器。

代碼分析
只創建了一個子類對象，父類對象沒有創建
不會創建父類對象，但是會為父類的私有屬性在堆中開辟空間，四個字節，會默認初始化為0
但這個空間不屬于父類對象，也不屬于子類對象，而是和定義這個屬性的父類做動態綁定

class Animal{ private int weight; Boolean sex; //可以被繼承//父類構造方法public Animal(){System.out.println("Animal(): "+this);this.weight=20; //根據this.weight，拿到this地址優先在子類中找weight屬性，沒有就會到構造方法動態綁定的Animal類動態綁定的屬性weight，進行初始化設值。this.sex=true; //調用父類構造方法（也和父類進行的動態綁定），父類的私有屬性只能用父類的構造方法初始化，this.sex傳過去的對象地址是子類對象Dog的地址 //先回在子類中尋找sex屬性，找到了設置為true//this.age=10; //父類的方法里看不到子類新增的屬性和方法 //只能看的子類繼承的或者繼承和重寫的屬性和方法} public int getWeight(){ //可被子類繼承return this.weight;} public void setWeight(int w){ //可被子類繼承this.weight=w;this.sex=false;//this.age=10;//父類看不到子類新增的屬性，不能給子類屬性進行初始化 } } class Dog extends Animal{ int age; //子類新增屬性，父類看不到public Dog(){ //子類構造方法與子類綁定System.out.println("Dog(): "+this);this.age=10; //調用子類的構造方法為子類對象的屬性初始化this.sex=false;//上轉型 //雖然是父類屬性，但是被子類繼承，且傳入的是子類對象的地址，優先在子類中尋找，這里可以為sex進行初始化false//this.weight=20; //子類構造方法不能給父類私有屬性初始化 //1、weight是父類的私有屬性，子類沒有繼承 //2、在子類對象尋找weight，子類的構造方法和子類綁定，子類沒有綁定weight}

構造方法執行結束后，對象也就創建結束了

/**子類新增方法*/public void Bark(){ //方法空間//this.weight=20;this.sex=false;System.out.println("Wang~~Wang~~~"); } }

//測試類

public class MyDog{ //加載到方法區的類代碼區private static Animal myAnimal; //靜態綁定，加載Animal字節碼文件//方法區的靜態數據區創建Animal類的靜態變量,默認初始化nullpublic static void main(String args[]){ myAnimal=new Dog(); //對象的上轉型 //Dog對象父類Animal類的變量，父類不知道子類有新增的屬性和方法 //有在方法區的靜態數據區myAnimal.setWeight(50); ///調用myAnimal所指對象的setWeight方法，現在子類中尋址沒有，再到綁定的Animal類中綁定的setWeight方法System.out.println("My Dog's Weight is"+myAnimal.getWeight());//myAnimal.weight=100;// myAnimal.Bark();//Dog dog=new Dog();//dog.Bark();} }

總結：
創建子類對象時
1、先為父類中被子類繼承的sex屬性開辟空間，默認初始化false
2、再為子類新增的屬性age開辟空間，4個字節,初始化為0
3、為父類定義的被子類繼承的方法getWeight()，setWeight(int)開辟空間
4、為子類新增的方法Bark()開辟空間
此使就有了一個dog類型的this指針
? 只要屬性和方法在父類中定義，即使能被子類繼承或者不被繼承，都要和父類做動態綁定，方法getWeight()，setWeight(int)，屬性sex，weight都和父類做了動態綁定

總結

以上是生活随笔為你收集整理的Java基础三个排序详解_继承粗解语法关键字分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。