一.內(nèi)容

抽象類

當(dāng)編寫一個(gè)類時(shí)，常常會為該類定義一些方法，這些方法用于描述這個(gè)類的行為。但在某些情況下只需要定義出一些方法，而不需要具體的去實(shí)現(xiàn)這些行為。也就是說這些方法沒有方法體，只是一些簽名而已，這樣的方法被稱為抽象方法，包含抽象方法的類被稱為抽象類。

抽象方法與抽象類

抽象方法與抽象類必須使用abstract關(guān)鍵字進(jìn)行修飾，有抽象方法的類必須被定義成抽象類，抽象類里面可以沒有抽象方法。

抽象類與抽象方法的規(guī)則如下：

• 抽象類與抽象方法必須使用abstract關(guān)鍵字進(jìn)行修飾，抽象方法不能有方法體。
• 抽象類不能被實(shí)例化。即使抽象類不包含抽象方法，也不能被實(shí)例化
• 抽象類可以包含field、方法、構(gòu)造器、初始化塊、內(nèi)部類5種成分。
• 包含抽象方法的類，只能被定義成抽象類。

語法格式：抽象方法

【修飾符】 abstract 返回值類型 methodName（形參列表）;
//示例:
public abstract void runWay();//定義一個(gè)行進(jìn)的方法

注意：抽象方法是沒有方法體，僅僅是一個(gè)方法聲明而已。所有Java要求其子類必須將父類中定義的抽象方法進(jìn)行實(shí)現(xiàn)。這也就意味著子類需要先將該方法繼承過來，所以修飾符也就只能是public或者protected。

示例代碼：抽象類定義

public abstract class Piece{}//定義一個(gè)棋子類

注意：抽象類不能實(shí)例化，只能被繼承，抽象類中可以沒有抽象方法，即使抽象類中沒有抽象方法也不能被實(shí)例化。

抽象類的使用

抽象類不能創(chuàng)建實(shí)例，只能當(dāng)成父類來被繼承。抽象類可以看成是從多個(gè)具體類中抽象出來的父類，它具有更高層次的抽象。從多個(gè)具有相同特征的類中抽象出來的一個(gè)抽象類，以這個(gè)抽象類作為其子類的模板，從而避免子類設(shè)計(jì)的隨意性。

抽象類的體現(xiàn)就是一種模板模式的設(shè)計(jì)，抽象類作為多個(gè)子類的通用模板，子類在抽象類的基礎(chǔ)上進(jìn)行擴(kuò)展、改造，但子類總體上會保留抽象類的行為方式。

編寫一個(gè)抽象父類，父類提供了多個(gè)子類的通用方法，并把一個(gè)或多個(gè)方法留給其子類實(shí)現(xiàn)，這就是一種模板模式，模板模式也是十分常見的設(shè)計(jì)模式。

示例代碼：

//定義抽象父類Piece
public abstract class Piece{
    /**
    *定義棋子的行進(jìn)方法
    */
    public abstract void runWay();
    /**
    *定義棋子進(jìn)攻的方法
    */
    public void attack() { 
        System.out.println("吃掉下面的棋子");
    }
}
//Piece的子類Horse
public class Horse extends Piece{
    /**
    *實(shí)現(xiàn)父類中定義的抽象方法
    */
    public void runWay() {
        System.out.println("按照日字格行進(jìn)！");
    }
}
//Piece的子類Cannon
public class Cannon extends Piece{
    /**
    *實(shí)現(xiàn)父類中定義的抽象方法
    */
    public void runWay() { 
        System.out.println("按照直線方式行進(jìn)！");
    }
}

模板模式在面向?qū)ο蟮能浖泻艹Ｓ?，其原理簡單，?shí)現(xiàn)也很簡單。使用模板模式有如下規(guī)則：抽象父類可以只定義需要使用的方法，把不能實(shí)現(xiàn)的部分抽象成抽象方法留給子類去實(shí)現(xiàn)。

接口

抽象類是從多個(gè)類中抽象出來的模板，如果將這種抽象進(jìn)行得更徹底，則可以提煉出一種更加特殊的“抽象類”——接口（interface）。接口里不能包含普通方法，接口里的所有方法都是抽象方法。接口里面可以放:常量,抽象方法,默認(rèn)方法,靜態(tài)方法,私有化方法

接口的概念

Java中的接口是一系列方法的聲明，是一些方法特征的集合，一個(gè)接口只有方法的特征沒有方法的實(shí)現(xiàn)，因此這些方法可以在不同的地方被不同的類實(shí)現(xiàn)，而這些實(shí)現(xiàn)可以具有不同的行為（功能）。

接口的定義

接口和類定義不同，定義接口不在使用class關(guān)鍵字，而是使用interface關(guān)鍵字。

語法格式如下：

【public】interface 接口名 extends 父接口1,父接口2{
    //零到多個(gè)常量定義
    //零到多個(gè)抽象方法定義
}

語法分析：

• 修飾符可以是public或者protected，大多數(shù)是使用public，protected省略采用默認(rèn)包權(quán)限訪問控制符。
• 接口名應(yīng)與類名采用相同的命名規(guī)則。
• 一個(gè)接口可以有多個(gè)直接父接口，但接口只能繼承接口，不能繼承類。

接口中的成員變量

接口定義的是一種規(guī)范，因此接口里不能包含構(gòu)造器和初始化塊定義。接口里可以包含field、方法、內(nèi)部類定義。因?yàn)榻涌跊]有構(gòu)造器與初始化塊，因此系統(tǒng)不能為field進(jìn)行默認(rèn)的初始化操作，只能由程序編寫人員為field指定默認(rèn)的值，所以field只能是常量。又因?yàn)閒ield只能是常量，所以系統(tǒng)自動為這些field增加了static和final兩個(gè)修飾符。也就是說在接口中定義的Field不管是否使用了public static final修飾符，接口里的Field總是默認(rèn)使用public static final修飾符來進(jìn)行修飾,不可更改。

示例代碼

interface DBobjectType{
    //對于在接口中定義的成員變量，用或不用public static final，意義都是相同的
    public static final int ROOT=0;
    public static final int DATABASE=1; 
    int TABLE=2; 
    int COLUMN=3;
    int INDEX=4;
}

接口中的方法

接口里定義的方法都是抽象方法，因此系統(tǒng)會自動為方法增加public abstract修飾符。因此不管定義接口方法時(shí)是否使用了public abstract修飾符，系統(tǒng)都會默認(rèn)方法使用public abstract修飾符來進(jìn)行修飾。

示例代碼:

public interface DataConnection{
    /**
    *定義獲取數(shù)據(jù)庫連接的方法*/
    public abstract void getConnection();
    /**
    *定義關(guān)閉數(shù)據(jù)庫連接的方法，在接口中是否使用public abstract意義相同*/
    void close();
}

接口的繼承

接口的繼承與類的繼承不一樣，接口完全支持多繼承，即一個(gè)接口可以有多個(gè)直接父接口。和繼承相似，子接口擴(kuò)展父接口，將會獲得父接口里定義的所有抽象方法、field、內(nèi)部類和枚舉定義。

一個(gè)接口繼承多個(gè)父接口時(shí)，多個(gè)父接口排在extends關(guān)鍵字之后，多個(gè)父接口之間使用英文逗號（,）進(jìn)行分隔。

示例代碼:

public interface InterA{//定義接口A
    void a();
}
public interface InterB{//定義接口B
    void b();
}
public interface Inter extends InterA,InterB{//定義接口Inter繼承A、B
    voidc();
}

接口的實(shí)現(xiàn)/使用

接口不能用于創(chuàng)建實(shí)例，但接口可以用于聲明引用類型變量。當(dāng)使用接口來聲明引用類型變量時(shí)，這個(gè)引用類型變量必須引用到其實(shí)現(xiàn)類的對象。除此之外，接口的主要用途就是被實(shí)現(xiàn)類進(jìn)行實(shí)現(xiàn)。

一個(gè)類可以實(shí)現(xiàn)多個(gè)接口，繼承使用extends關(guān)鍵字，而實(shí)現(xiàn)則使用implements關(guān)鍵字。

單繼承多實(shí)現(xiàn)

示例代碼:

public interface InterA {
  void a();
}
public class InterAImpl implements InterA
{
    @Override
    public void a(){
        System.out.println("將接口InterA中定義的抽象方法進(jìn)行實(shí)現(xiàn)！");
    }
}

實(shí)現(xiàn)接口與繼承類相似，一樣可以獲得所實(shí)現(xiàn)接口里定義的常量field、抽象方法、內(nèi)部類和枚舉類定義。讓類實(shí)現(xiàn)接口需要在類定義后面增加implements部分，當(dāng)需要實(shí)現(xiàn)多個(gè)接口時(shí)，多個(gè)接口之間以英文逗號（,）隔開。一個(gè)類可以繼承一個(gè)父類并同時(shí)實(shí)現(xiàn)多個(gè)接口，implements部分必須放在extends部分之后。

示例代碼：

public interface DBobjectType {
    public static final int ROOT =0; 
    public static final int DATABASE =1;   
    int TABLE=2;
    int COLUMN=3;
    int INDEX=4;
}
public interface DataConnection{
    /**
    *定義獲取數(shù)據(jù)庫連接的方法
    */
    public abstract void getConnection();
    /**
    *定義關(guān)閉數(shù)據(jù)庫連接的方法，在接口中是否使用publicabstract意義相同
    */
    void close();
}
public class ConnectionImpl implements
    DBobjectType,DataConnection {
    @Override
    public void getConnection() {
        System.out.println("獲取一個(gè)連接對象！");
    }
    @Override
    public void close() {
        System.out.println("將連接進(jìn)行關(guān)閉！");
    }
    public static void main(String[]args){
        ConnectionImpl impl=new ConnectionImpl();
        //直接使用從DBobjectType繼承過來的成員變量定義
        System.out.println("數(shù)據(jù)對象類型："+ConnectionImpl.ROOT);
        impl.getConnection();
    }
}

一個(gè)類實(shí)現(xiàn)了一個(gè)或多個(gè)接口之后，這個(gè)類必須完全實(shí)現(xiàn)這些接口里所定義的全部抽象方法，否則該類將保留從父接口那里繼承到的抽象方法，該類也必須定義成抽象類。

接口與抽象類的差異

1、接口和抽象類都不能進(jìn)行實(shí)例化，它們都位于繼承樹的頂端，用于被其他類實(shí)現(xiàn)和繼承。

2、接口和抽象類都可以包含抽象方法，實(shí)現(xiàn)接口或繼承抽象類的普通子類都必須實(shí)現(xiàn)這些抽象方法。

接口作為系統(tǒng)與外界交互的窗口，接口體現(xiàn)的是一種規(guī)范。對于接口的實(shí)現(xiàn)者而言，接口規(guī)定了實(shí)現(xiàn)者必須向外提供哪些服務(wù)。對于接口的調(diào)用者而言，接口規(guī)定了調(diào)用者可以調(diào)用哪些服務(wù)。當(dāng)在一個(gè)程序中使用接口時(shí)，接口是多個(gè)模塊間的耦合標(biāo)準(zhǔn)，當(dāng)在多個(gè)應(yīng)用程序之間使用接口時(shí)，接口是多個(gè)程序之間的通信標(biāo)準(zhǔn)。

接口類似于系統(tǒng)的總綱，一旦接口發(fā)生變化，對于整個(gè)系統(tǒng)是輻射式的，所有實(shí)現(xiàn)這個(gè)接口的普通類都要進(jìn)行改寫。

分析：JDBC編程是后面需要給大家講到的數(shù)據(jù)庫編程，在此示例中不涉及到具體代碼，只看結(jié)構(gòu)圖。Java程序不可能為行業(yè)內(nèi)使用個(gè)各種數(shù)據(jù)庫都提供一套連接方式。它只會提供一套標(biāo)準(zhǔn)的接口，告訴數(shù)據(jù)庫生產(chǎn)廠商應(yīng)該提供哪些實(shí)現(xiàn)。所以不同的數(shù)據(jù)庫生產(chǎn)廠商需要將Java提出的接口進(jìn)行底層的實(shí)現(xiàn)，當(dāng)我們需要進(jìn)行JDBC編程時(shí)，只需要將不同數(shù)據(jù)庫生產(chǎn)廠商提供的JAR包導(dǎo)入進(jìn)來，按照接口的方式進(jìn)行編程即可

抽象類則不一樣，抽象類作為系統(tǒng)中多個(gè)子類的共同父類，它所體現(xiàn)的是一種模版式設(shè)計(jì)。抽象類作為多個(gè)子類的抽象父類，可以被當(dāng)成系統(tǒng)實(shí)現(xiàn)過程中的中間產(chǎn)品。這個(gè)中間產(chǎn)品已經(jīng)實(shí)現(xiàn)了系統(tǒng)的部分功能，但這個(gè)類不能稱為最終產(chǎn)品，必須有更進(jìn)一步的完善，這種完善可能有幾種不同的方式來實(shí)現(xiàn)。

接口與抽象類在用法上也存在如下差異：

• 接口里只能包含抽象方法，不包含已經(jīng)提供實(shí)現(xiàn)的方法，抽象類則完全可以包含普通方法。
• 接口和抽象類里都可以定義靜態(tài)方法。
• 接口里只能定義靜態(tài)常量Field，不能定義普通的Field，抽象類里則都可以。
• 接口里不包含構(gòu)造器，抽象類里可以包含構(gòu)造器，抽象類里的構(gòu)造器并不是用來創(chuàng)建對象，而是讓其子類調(diào)用這些構(gòu)造器完成屬于抽象類的初始化操作。
• 接口里不能包含初始化塊，但抽象類則完全可以包含初始化塊。
• 一個(gè)類最多只有一個(gè)父類，包括抽象類，但是一個(gè)類可以實(shí)現(xiàn)多個(gè)接口。

面向接口編程

接口體現(xiàn)的是一種規(guī)范和實(shí)現(xiàn)分離的設(shè)計(jì)模式，充分利用接口可以很好降低程序各模塊之間的耦合，從而提高系統(tǒng)的可擴(kuò)展性和可維護(hù)性。

基于這種原則，軟件架構(gòu)設(shè)計(jì)理論都倡導(dǎo)“面向接口”編程，而不是面向?qū)崿F(xiàn)類編程，希望通過面向接口編程來降低程序的耦合。下面使用數(shù)據(jù)庫編程這種場景來示范面向接口編程的優(yōu)勢。

//定義接口規(guī)范
public interface DataConnection{
    /**
    *定義獲取數(shù)據(jù)庫連接的方法*/
    public abstract void getConnection();
    /**
    *定義關(guān)閉數(shù)據(jù)庫連接的方法
    */
    public abstract void close();
}
//定義不同數(shù)據(jù)庫的實(shí)現(xiàn)類MySql
public class MySqlConnection implements DataConnection {
    @Override
    public void getConnection() {
        System.out.println("獲取MySql數(shù)據(jù)庫的連接。。。");
    }
    @Override
    public void close() {
        System.out.println("關(guān)閉MySql數(shù)據(jù)庫的連接。。。");
    }
}
//定義不同數(shù)據(jù)庫的實(shí)現(xiàn)類Oracle
public class OracleConnection implements DataConnection {
    @Override
    public void getConnection(){
        System.out.println("獲取Oracle數(shù)據(jù)庫的連接。。。");
    }
    @Override
    public void close() {
        System.out.println("關(guān)閉Oracle數(shù)據(jù)庫的連接。。。");
    }
}
//定義不同數(shù)據(jù)庫的實(shí)現(xiàn)類SqlServer
public class SqlServerConnection implements DataConnection {
    @Override
    public void getConnection() {
        System.out.println("獲取SqlServer數(shù)據(jù)庫的連接。。。");
    }
    @Override 
    public void close() {
        System.out.println("關(guān)閉SqlServer數(shù)據(jù)庫的連接。。。");
    }
}

內(nèi)部類

在定義類的時(shí)候，我們一般把類定義成一個(gè)獨(dú)立的程序單元。但是在某些情況下，我們會把一個(gè)類放在另一個(gè)類的內(nèi)部定義，這個(gè)定義在其他類內(nèi)部的類就被稱為內(nèi)部類，也可以稱為嵌套類。包含內(nèi)部類的類也被稱為外部類，也可以稱為宿主類。Java從JDK1.1開始引入內(nèi)部類，內(nèi)部類的主要作用如下：

• 內(nèi)部類提供了更好的封裝，可以把內(nèi)部類隱藏在外部類之內(nèi)，不允許同一個(gè)包中其他類訪問該類。
• 內(nèi)部類成員可以直接訪問外部類的私有數(shù)據(jù)，因?yàn)閮?nèi)部類被當(dāng)成外部類的成員，同一個(gè)類成員之間可以相互訪問。
• 匿名內(nèi)部類適合用于創(chuàng)建那些僅需要一次使用的類。

非靜態(tài)內(nèi)部類

定義內(nèi)部類非常簡單，只要把一個(gè)類放在另一個(gè)類內(nèi)部定義即可。此處的“內(nèi)部類”包括類中的任何位置，甚至在方法中也可以定義內(nèi)部類，在方法中定義的內(nèi)部類叫做局部內(nèi)部類。

通常情況下，內(nèi)部類都被作為成員內(nèi)部類定義，而不是作為局部內(nèi)部類。成員內(nèi)部類是一種與成員field、成員方法、構(gòu)造方法和初始化塊相同級別的類成員。

成員內(nèi)部類分為：靜態(tài)內(nèi)部類和非靜態(tài)內(nèi)部類兩種，使用static修飾的成員內(nèi)部類就是靜態(tài)內(nèi)部類，沒有使用static修飾的成員內(nèi)部類就是非靜態(tài)內(nèi)部類。

因?yàn)閮?nèi)部類作為其外部類的成員，所以可以使用任意訪問控制符：private、protected、public修飾的Field成員。

示例代碼:

public class DiningRoom {
    private String egg="雞蛋";
    class Cook { 
        public void makeFood() {
            //使用了外部類DiningRoom中定義的私有成員egg
            System.out.println("廚師使用"+egg+"，做了一份炒雞蛋！");
        }
    }
    /**
    *DiningRoom類對外提供的做炒雞蛋的功能*實(shí)際該功能是由內(nèi)部類Cook來執(zhí)行的
    */
    public void fireEgg(){
        new Cook().makeFood();
    }
}

代碼優(yōu)化

假設(shè)內(nèi)部類Cook提供了多個(gè)方法，而外部類中定義的多個(gè)方法又多次用到了Cook中提供的方法，那么類似上述示例中的調(diào)用方式，就會每次調(diào)用都會創(chuàng)建一個(gè)Cook的對象，用完即丟棄了，造成了程序上性能的降低。像這種情況我們就可以在父類DiningRoom中定義Cook的成員變量即可。

public class DiningRoom {
    private String egg="雞蛋";
    private Cook cook=new Cook();
    class Cook {
        public void makeFood() {
            //使用了外部類DiningRoom中定義的私有成員egg
            System.out.println("廚師使用"+egg+"，做了一份炒雞蛋！");
        }
    }
    /**
    *DiningRoom類對外提供的做炒雞蛋的功能*實(shí)際該功能是由內(nèi)部類Cook來執(zhí)行的
    */
    public void fireEgg(){ 
        this.cook.makeFood();
    }
}

分析：通過代碼的改寫，那么即使父類DiningRoom中的多個(gè)方法多次調(diào)用Cook類中定義的方法時(shí)，也只會創(chuàng)建Cook的一個(gè)對象，而不是多個(gè)對象。

靜態(tài)內(nèi)部類

使用static修飾符來修飾內(nèi)部類就稱為靜態(tài)內(nèi)部類，則這個(gè)內(nèi)部類就屬于外部類本身，而不屬于外部類的某個(gè)對象。因此使用static修飾的內(nèi)部類被稱為靜態(tài)內(nèi)部類

靜態(tài)內(nèi)部類可以包含靜態(tài)成員，也可以包含非靜態(tài)成員。根據(jù)靜態(tài)成員不能訪問非靜態(tài)成員的規(guī)則，靜態(tài)內(nèi)部類不能訪問外部類的實(shí)例成員，只能訪問外部類的類成員。即使是靜態(tài)內(nèi)部類的實(shí)例方法也不能訪問外部類的實(shí)例成員，只能訪問外部類的靜態(tài)成員。

示例代碼:

public class Factory {
    public static String noodle="面條";
    public static String dumplings="水餃";
    private String chicken="雞肉";
    public void madamFood(String food){
        System.out.println("廠長吃的是自己夫人做的飯！"+food);
    }
    public static void diningFood(String food){
        System.out.println("工人吃的是食堂做的飯！"+food);
    }
    static class DiningRoom {
        public static void eat(){
        	diningFood(Factory.noodle);
        }
        public void managerEat() {
            //編譯報(bào)錯(cuò)，在靜態(tài)內(nèi)部類中，即使是非靜態(tài)的成員
            //也不能訪問外部類的非靜態(tài)的成員
            madamFood("abc");
        }
    }
}

分析：在上述示例中，靜態(tài)內(nèi)部類DiningRoom在進(jìn)行編譯時(shí)報(bào)錯(cuò)，提示對象的實(shí)例上調(diào)用了不在范圍內(nèi)的數(shù)據(jù)信息。因?yàn)殪o態(tài)內(nèi)部類會跟隨外部類的靜態(tài)的信息同時(shí)存在，此時(shí)可以創(chuàng)建靜態(tài)內(nèi)部類的實(shí)例對象，但是并不一定會創(chuàng)建外部類的實(shí)例對象，那么去訪問外部類實(shí)例對象的成員就會出問題，因?yàn)閷ο蠖紱]有，怎么訪問對象上的成員呢？

局部內(nèi)部類

如果把一個(gè)內(nèi)部類定義在方法里面定義，則這個(gè)內(nèi)部類就是一個(gè)局部內(nèi)部類。

示例代碼：

public void run() {
    //定義一個(gè)局部內(nèi)部類，作用范圍更小，在方法外根本無法訪問
    class InnerTest {
        public int num2=5;
        public void run(){
            System.out.println(num2);
        }
    }
    InnerTest it=new InnerTest();
    it.run();
}

匿名內(nèi)部類

匿名內(nèi)部類的語法有些特別，創(chuàng)建匿名內(nèi)部類時(shí)會立即創(chuàng)建一個(gè)該類的實(shí)例，這個(gè)類定義立即消失，匿名內(nèi)部類不能重復(fù)使用。因此匿名內(nèi)部類適合創(chuàng)建那種只需要一次使用的類。

語法格式：

new 父類構(gòu)造器|實(shí)現(xiàn)接口 (){
    //匿名內(nèi)部類的類體部分
}

匿名內(nèi)部類必須繼承一個(gè)父類，或?qū)崿F(xiàn)一個(gè)接口，但最多只能繼承一個(gè)父類，實(shí)現(xiàn)一個(gè)接口。

• 匿名內(nèi)部類不能是抽象類，因?yàn)橄到y(tǒng)在創(chuàng)建匿名內(nèi)部類時(shí)，會立即創(chuàng)建匿名內(nèi)部類的對象。
• 匿名內(nèi)部類不能定義構(gòu)造器，因?yàn)槟涿麅?nèi)部類沒有類名，也就無法定義構(gòu)造器，但是匿名內(nèi)部類可以定義實(shí)例初始化塊，通過初始化塊來完成初始化操作。

在Java的類庫中，有很多非常有用的工具類提供了大量的底層操作，可以讓程序開發(fā)人員能夠快速的進(jìn)行軟件的業(yè)務(wù)邏輯開發(fā)，而不用去關(guān)注底層的實(shí)現(xiàn)。但是有些方法確實(shí)需要接收一些參數(shù)的，而這些參數(shù)都是接口類型，當(dāng)程序開發(fā)人員調(diào)用此方法時(shí)，就必須要提供該接口的一個(gè)實(shí)現(xiàn)類，再去創(chuàng)建該實(shí)現(xiàn)類的對象才能去調(diào)用那些方法。

如果僅僅是為了調(diào)用某個(gè)方法，就為此去創(chuàng)建一個(gè)新的類就有點(diǎn)得不償失了。因此Java提供了匿名內(nèi)部類的方式可以非常有效的解決此類問題。

示例代碼:

public class Test { 
    public static void main(String[]args) {
        Integer [] nums={1,3,10,21,14,5,27};
        //sort方法需要接收一個(gè)Comparator排序器對象，Comparator是接口類型
        Arrays.sort (nums,new Comparator <Integer>(){
            @Override 
            public int compare (Integer int1,Integer int2){ 
                if(int1>int2){
                    return-1;               
                }else {
                    return1;
                }
            }
        });
        System.out.println(Arrays.toString(nums));
    }
}

代碼分析：Comparator<T>是一個(gè)排序器接口，用于進(jìn)行兩個(gè)數(shù)據(jù)之間的比較，數(shù)據(jù)類型需要通過<>這種方式在其中定義出來，compare就是接口中定義的方法，如果大于返回1，小于返回1，等于返回0。就是普通的升序排序，而如果反過來就是降序排序。

總結(jié)

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！

最新評論