Python爬取抖音視訊（沒有水印的喲）

阿新 • • 發佈：2020-08-14

面向物件

面向物件程式設計（object-Oriented Programming ，OOP）

面向物件程式設計的本質是：以類的方式組織程式碼，以物件的組織（封裝）資料

抽象

三大特性

封裝
繼承
多型

物件是具體的事物，類是抽象的

構造器詳解

package com.oop.day2;

public class Person {
   //一個類即使什麼都不寫，它也會存在一個方法
   //顯示的定義構造器

   String name;
   int age;

   //1.使用new關鍵字，本質是在呼叫構造器
   //2.用來初始化值
   public Person() {
   }

   //一旦定義了有參構造，無參構造就必須顯示定義
 
   public Person(String name) {
     this.name = name;
   }

   //alt+insert
   public Person(String name, int age) {
     this.name = name;
     this.age = age;
   }
}
/*
 public static void main(String[] args) {
     //new 例項化了一個物件
   Person person = new Person();
     System.out.println(person.name);
   }
   構造器
   1.和類名相同
 
   2.沒有返回值
   作用：
   1.new 本質在呼叫構造方法
   2.初始化物件的值
   作用點：
   1.定義有參構造之後，如果想使用無參構造，顯示的定義一個無參的構造

   this.等於當前類
 */

建立物件記憶體分析

文字詳解

首先載入類，然後把類裡面的所有常量和靜態方法區裡面的static載入到方法區裡面，

然後載入main方法類在棧的最底層

之後建立物件，載入另一個類，這個類不是主類，把類裡面的name，age等屬性以及方法載入到方法區

建立一個類的引用名在棧裡，但這只是個名字

真正的物件在堆裡面，等於說我把一個類copy了一個模板作為物件

放在堆裡面的一個記憶體裡

然後賦予他的屬性的定義以及別的

之後如果我還要建立一個物件，現在複製另一個，然後放在堆裡面的另一個記憶體裡

這樣我就可以分別定義不同的物件，給他們的屬性的定義不同

但都是屬性都是一樣的

比如人，他是一個類

但是每個人都不一樣，我現在只需要把不一樣人的名字，年齡什麼的填寫一下就可以

所以說每一個人都是我定義的每一個不用的物件

public class Pet {
  String name;
  int age;
  public void shout(){
    System.out.println("giao");
   }
}
/*
 public static void main(String[] args) {
    Pet dog = new Pet();
    dog.name="旺財";
    dog.age=3;

    Pet cat = new Pet();
    cat.name="阿花";
    cat.age=1;
    cat.shout();

  }
 */

簡單小結類與物件

類與物件

類是一個模板：抽象

物件是一個具體的例項
方法

定義，呼叫
對應的引用

引用型別：基本型別（8大引用）

物件是通過引用來操作的：棧-->堆
屬性：欄位Field 成員變數

預設初始化：

數字：0 0.0

char：u000

boolean：false

引用：null

修飾符屬性型別屬性名= 屬性值！
物件的建立和使用

--- 必須使new關鍵字創造物件，構造器 Person tao = new Person();

---物件的屬性 tao.name;

---物件的方法 tao.do();

類：

靜態的屬性

動態的行為

封裝

該露的露，該藏得藏

我們程式設計要追求“高內聚，低耦合”。高內聚就是類的內部資料操作細節自己玩曾，不允許外部干涉，低耦合：僅暴露少量的方法給外部使用。

封裝（資料的隱藏）

通常，應禁止訪問一個物件中資料的實際表示，而應通過操作介面訪問，這稱為資訊隱藏。

屬性私有：get/set

優點

1.提高程式的安全性，保護資料

2.隱藏程式碼的實現細節

3.統一介面

4.系統可維護性增加了

例項

public class student {
  //姓名
  private String name;
  //學號
  private int id;
  //年齡
  private int age;


  //學習（）
  //吃飯（）


  //提供一些可以操作這個屬性的方法！
  //提供一些public 的 get set方法

  //get獲取這個資料

  public String getName() {
    return name;
   }

  public void setName(String name) {
    this.name = name;
   }

  public int getId() {
    return id;
   }

  public void setId(int id) {
    this.id = id;
   }

  public int getAge() {
    return age;
   }

  public void setAge(int age) {
    if(age>120||age<0) {
      this.age=3;
     }
    else
     {
      this.age=age;
     }
   }
}
/*
 public static void main(String[] args) {
    student s1 = new student();
    s1.setName("濤濤");

    System.out.println(s1.getName());
    s1.setAge(150);
    System.out.println(s1.getAge());
  }
 */

繼承

extends的意思是擴充套件，子類是父類的擴充套件

概念

繼承是java面向物件程式設計技術的一塊基石，因為它允許建立分等級層次的類。

繼承就是子類繼承父類的特徵和行為，使得子類物件（例項）具有父類的例項域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

繼承的意義

程式碼存在重複且臃腫，維護性不高，從根本上解決就需要繼承。

繼承型別

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 只能繼承一個類。

public class Animal { 
  private String name;  
  private int id; 
  public Animal(String myName, String myid) { 
    //初始化屬性值
   } 
  public void eat() { //吃東西方法的具體實現  } 
  public void sleep() { //睡覺方法的具體實現  } 
} 
 
public class Penguin extends Animal{ 
}

imolements關鍵字

使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用範圍為類繼承介面的情況，可以同時繼承多個介面（介面跟介面之間採用逗號分隔）。

public interface A {
  public void eat();
  public void sleep();
}
 
public interface B {
  public void show();
}
 
public class C implements A,B {
}

super與this關鍵字

super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前物件的父類。

this關鍵字：指向自己的引用。

class Animal {
 void eat() {
  System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
 void eat() {
  System.out.println("dog : eat");
  }
 void eatTest() {
  this.eat();  // this 呼叫自己的方法
  super.eat(); // super 呼叫父類方法
  }
}
 
public class Test {
 public static void main(String[] args) {
  Animal a = new Animal();
  a.eat();
  Dog d = new Dog();
  d.eatTest();
  }
}

輸出結果為：

animal : eat
dog : eat
animal : eat

final關鍵字

final 關鍵字宣告類可以把類定義為不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫：

宣告類：
```
final class 類名 {//類體}
```

宣告方法：

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

注:例項變數也可以被定義為 final，被定義為 final 的變數不能被修改。被宣告為 final 類的方法自動地宣告為 final，但是例項變數並不是 final

構造器

子類是不繼承父類的構造器（構造方法或者建構函式）的，它只是呼叫（隱式或顯式）。如果父類的構造器帶有引數，則必須在子類的構造器中顯式地通過 super 關鍵字呼叫父類的構造器並配以適當的引數列表。

如果父類構造器沒有引數，則在子類的構造器中不需要使用 super 關鍵字呼叫父類構造器，系統會自動呼叫父類的無參構造器。

例項

class SuperClass {
 private int n;
 SuperClass(){
  System.out.println("SuperClass()");
  }
 SuperClass(int n) {
  System.out.println("SuperClass(int n)");
  this.n = n;
  }
}
// SubClass 類繼承
class SubClass extends SuperClass{
 private int n;
 
 SubClass(){ // 自動呼叫父類的無引數構造器
  System.out.println("SubClass");
  } 
 
 public SubClass(int n){ 
  super(300); // 呼叫父類中帶有引數的構造器
  System.out.println("SubClass(int n):"+n);
  this.n = n;
  }
}
// SubClass2 類繼承
class SubClass2 extends SuperClass{
 private int n;
 
 SubClass2(){
  super(300); // 呼叫父類中帶有引數的構造器
  System.out.println("SubClass2");
  } 
 
 public SubClass2(int n){ // 自動呼叫父類的無引數構造器
  System.out.println("SubClass2(int n):"+n);
  this.n = n;
  }
}
public class TestSuperSub{
 public static void main (String args[]){
  System.out.println("------SubClass 類繼承------");
  SubClass sc1 = new SubClass();
  SubClass sc2 = new SubClass(100); 
  System.out.println("------SubClass2 類繼承------");
  SubClass2 sc3 = new SubClass2();
  SubClass2 sc4 = new SubClass2(200); 
  }
}

輸出結果為：

------SubClass 類繼承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 類繼承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

方法的重寫(Override)

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

重寫的好處在於子類可以根據需要，定義特定於自己的行為。也就是說子類能夠根據需要實現父類的方法。

重寫方法不能丟擲新的檢查異常或者比被重寫方法申明更加寬泛的異常。例如：父類的一個方法申明瞭一個檢查異常 IOException，但是在重寫這個方法的時候不能丟擲 Exception 異常，因為 Exception 是 IOException 的父類，只能丟擲 IOException 的子類異常。

在面向物件原則裡，重寫意味著可以重寫任何現有方法。例項如下：

class Animal{
  public void move(){
   System.out.println("動物可以移動");
  }
}
 
class Dog extends Animal{
  public void move(){
   System.out.println("狗可以跑和走");
  }
}
 
public class TestDog{
  public static void main(String args[]){
   Animal a = new Animal(); // Animal 物件
   Animal b = new Dog(); // Dog 物件
 
   a.move();// 執行 Animal 類的方法
 
   b.move();//執行 Dog 類的方法
  }
}

/*動物可以移動
狗可以跑和走*/

在上面的例子中可以看到，儘管 b 屬於 Animal 型別，但是它執行的是 Dog 類的 move方法。

這是由於在編譯階段，只是檢查引數的引用型別。

然而在執行時，Java 虛擬機器(JVM)指定物件的型別並且執行該物件的方法。

因此在上面的例子中，之所以能編譯成功，是因為 Animal 類中存在 move 方法，然而執行時，執行的是特定物件的方法。

方法的重寫規則

引數列表與被重寫方法的引數列表必須完全相同。
返回型別與被重寫方法的返回型別可以不相同，但是必須是父類返回值的派生類（java5 及更早版本返回型別要一樣，java7 及更高版本可以不同）。
訪問許可權不能比父類中被重寫的方法的訪問許可權更低。例如：如果父類的一個方法被宣告為 public，那麼在子類中重寫該方法就不能宣告為 protected。
父類的成員方法只能被它的子類重寫。
宣告為 final 的方法不能被重寫。
宣告為 static 的方法不能被重寫，但是能夠被再次宣告。
子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為 private 和 final 的方法。
子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為 public 和 protected 的非 final 方法。
重寫的方法能夠丟擲任何非強制異常，無論被重寫的方法是否丟擲異常。但是，重寫的方法不能丟擲新的強制性異常，或者比被重寫方法宣告的更廣泛的強制性異常，反之則可以。
構造方法不能被重寫。
如果不能繼承一個方法，則不能重寫這個方法。

Super 關鍵字的使用

當需要在子類中呼叫父類的被重寫方法時，要使用 super 關鍵字。

class Animal{
  public void move(){
   System.out.println("動物可以移動");
  }
}
 
class Dog extends Animal{
  public void move(){
   super.move(); // 應用super類的方法
   System.out.println("狗可以跑和走");
  }
}
 
public class TestDog{
  public static void main(String args[]){
 
   Animal b = new Dog(); // Dog 物件
   b.move(); //執行 Dog類的方法
 
  }
}

編譯結果

動物可以移動
狗可以跑和走

過載(Overload)

過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。返回型別可以相同也可以不同。

每個過載的方法（或者建構函式）都必須有一個獨一無二的引數型別列表。

最常用的地方就是構造器的過載。

過載規則:

被過載的方法必須改變引數列表(引數個數或型別不一樣)；
被過載的方法可以改變返回型別；
被過載的方法可以改變訪問修飾符；
被過載的方法可以宣告新的或更廣的檢查異常；
方法能夠在同一個類中或者在一個子類中被過載。
無法以返回值型別作為過載函式的區分標準。

public class Overloading {
  public int test(){
    System.out.println("test1");
    return 1;
   }
 
  public void test(int a){
    System.out.println("test2");
   }  
 
  //以下兩個引數型別順序不同
  public String test(int a,String s){
    System.out.println("test3");
    return "returntest3";
   }  
 
  public String test(String s,int a){
    System.out.println("test4");
    return "returntest4";
   }  
 
  public static void main(String[] args){
    Overloading o = new Overloading();
    System.out.println(o.test());
    o.test(1);
    System.out.println(o.test(1,"test3"));
    System.out.println(o.test("test4",1));
   }
}

重寫與過載之間的區別

區別點	過載方法	重寫方法
引數列表	必須修改	一定不能修改
返回型別	可以修改	一定不能修改
異常	可以修改	可以減少或刪除，一定不能丟擲新的或者更廣的異常
訪問	可以修改	一定不能做更嚴格的限制（可以降低限制）

總結

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

(1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
(3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

多型

多型是同一個行為具有多個不同表現形式或形態的能力。

多型性是物件多種表現形式的體現。

現實中，比如我們按下 F1 鍵這個動作：

如果當前在 Flash 介面下彈出的就是 AS 3 的幫助文件；

如果當前在 Word 下彈出的就是 Word 幫助；

在 Windows 下彈出的就是 Windows 幫助和支援。

同一個事件發生在不同的物件上會產生不同的結果。

多型的優點

1. 消除型別之間的耦合關係
1. 可替換性
1. 可擴充性
1. 介面性
1. 靈活性
1. 簡化性

多型存在的三個必要條件

繼承
重寫
父類引用指向子類物件

多型的實現方式

方式一：重寫：

這個內容已經在上一章節詳細講過，就不再闡述，詳細可訪問：Java 重寫(Override)與過載(Overload)。

方式二：介面

1. 生活中的介面最具代表性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，因為這個是每個國家都有各自規定的介面規則，有可能到國外就不行，那是因為國外自己定義的介面型別。
1. java中的介面類似於生活中的介面，就是一些方法特徵的集合，但沒有方法的實現。

強制轉換

package com.oop;
import com.oop.demo01.Person;
import com.oop.demo01.Students;


public class Application {

  public static void main(String[] args) {
    //型別之間的轉換： 父  子
    //高        低
    Person person = new Students();//向上轉換
    //向上轉換以後就不可以使用子類和父類不同的方法
    //person.eat();//報錯
    person.run();//如果重寫，使用的是子類已經重寫的方法


    //student將這個物件轉換為Student型別，我們就可以使用student方法了
     ((Students)person).eat();//向下轉換，這樣就可以使用子類的方法了




   }
}

/*
1.父類引用指向子類的物件
2.把子類轉換為父類，向上轉型：可能會丟失自己的一些方法
3.把父類轉換為子類，向下轉換：降低精度
4.方便方法的呼叫，減少重複的程式碼！簡介優點

抽象： 封裝，繼承，多型！  抽象類，介面
 */

instanceof

判斷一個例項是否屬於某種型別

同級別的不能相比較

例如

Person->student

Person->teacher

student和teacher是相同類別的，為false

Person和student，Person和teacher為true

static關鍵字詳解

1、被static修飾的變數屬於類變數，可以通過類名.變數名直接引用，而不需要new出一個類來

2、被static修飾的方法屬於類方法，可以通過類名.方法名直接引用，而不需要new出一個類來

package com.oop.demo02;

public class Student {
  private static int age;//靜態變數
  private double score;//非靜態變數

  public static void main(String[] args) {
    Student student = new Student();
    System.out.println(Student.age);//靜態屬性可以直接呼叫，所有例項共享  多執行緒
    System.out.println(student.score);
    System.out.println(student.age);

   }
}

程式碼塊

package com.oop.demo02;

public class Demo {
   {
    System.out.println("匿名程式碼塊");

   }
  static {
    //載入一些初始化資料  類載入直接執行，永久只執行一次
    System.out.println("靜態程式碼塊");
   }
  public Demo(){
    System.out.println("構造方法");
   }

  public static void main(String[] args) {
    Demo demo = new Demo();
   }
}

final

final修飾的類不能被繼承

抽象類

在面向物件的概念中，所有的物件都是通過類來描繪的，但是反過來，並不是所有的類都是用來描繪物件的，如果一個類中沒有包含足夠的資訊來描繪一個具體的物件，這樣的類就是抽象類。

抽象類除了不能例項化物件之外，類的其它功能依然存在，成員變數、成員方法和構造方法的訪問方式和普通類一樣。

由於抽象類不能例項化物件，所以抽象類必須被繼承，才能被使用。也是因為這個原因，通常在設計階段決定要不要設計抽象類。

父類包含了子類集合的常見的方法，但是由於父類本身是抽象的，所以不能使用這些方法。

在Java中抽象類表示的是一種繼承關係，一個類只能繼承一個抽象類，而一個類卻可以實現多個介面。

抽象類不能被例項化，但是該繼承子類可以例項化

抽象方法

如果你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類確定，那麼你可以在父類中宣告該方法為抽象方法。

Abstract 關鍵字同樣可以用來宣告抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名後面直接跟一個分號，而不是花括號。

package com.oop.demo03;
//抽象類本質：類 extends： 單繼承  （介面可以多繼承）
public abstract class Action {
  //約束，有人幫我們實現
  //抽象方法，只有方法名字，沒有方法的實現！
  public abstract void doSomething();

  /*1.不能new抽象類，只能子類去實現：約束！
  * 2.抽象類中可以寫普通的方法
  * 3.抽象方法必須在抽象類中
  * 抽象的抽象：約束*/
}
package com.oop.demo03;
//抽象類的所有方法，繼承了它的子類都必須要實現他的方法，除非子類也是抽象
public class A extends Action{
  @Override
  public void doSomething() {

   }
}

宣告抽象方法會造成以下兩個結果：

如果一個類包含抽象方法，那麼該類必須是抽象類。
任何子類必須重寫父類的抽象方法，或者宣告自身為抽象類。

總結

1. 抽象類不能被例項化(初學者很容易犯的錯)，如果被例項化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以建立物件。
1. 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。
1. 抽象類中的抽象方法只是宣告，不包含方法體，就是不給出方法的具體實現也就是方法的具體功能。
1. 構造方法，類方法（用 static 修飾的方法）不能宣告為抽象方法。
1. 抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。

介面

只有規範！自己無法寫方法->專業的約束！約束和實現分離：面向介面程式設計

介面就是規範，定義的是一組規則：如果你是->那麼你會

關鍵字：interface

package com.oop.demo04;
//抽象類 ：extends
//類 可以實現介面 impletents 介面
//實現了介面的類，就需要重寫介面重德方法

//介面可以多繼承
public class User implements UserSevice ,TimeSevice{

  @Override
  public void add() {

   }

  @Override
  public void delete() {

   }

  @Override
  public void update() {

   }

  @Override
  public void query() {

   }

  @Override
  public void Timer() {

   }
}


package com.oop.demo04;

public interface TimeSevice {
  void Timer();
}


package com.oop.demo04;

public interface UserSevice {

  //常量  public static final
  int age=18;
  //介面中所有的定義的方法其實都是抽象類 public abstract
  void add();
  void delete();
  void update();
  void query();
}

介面可以多繼承，一個類可以繼承多個介面，介面提供方法，類需要全部重寫接口裡的方法

作用

1. 約束

定義一些方法，讓不用的人實現，實現同一種方法，但是是不同的結構
public abstract
public static final 常量可以直接使用
介面不能被例項話，介面中沒有構造方法
implements可以實現多個介面
介面中的方法全部需要重寫

介面可以繼承

一個介面能繼承另一個介面，和類之間的繼承方式比較相似。介面的繼承使用extends關鍵字，子介面繼承父介面的方法。

下面的Sports介面被Hockey和Football介面繼承：

內部類

內部類就是在一個類的內部在定義一個類

Outer.Inner inner = outer.new Inner();

通過外部類例項化內部類

內部類可以獲得外部類的私有屬性

package com.oop.demo05;

public class Outer {
  private int id;
  public void out()
   {
    System.out.println("這是外部類的方法");
   }

  public class Inner{
    public void in()
     {
      System.out.println("這是內部類的方法");
     }
    //可以獲得外部類的私有屬性
    public void getId()
     {
      System.out.println(id);
     }
   }

}
public class Application {
  public static void main(String[] args) {
    Outer outer = new Outer();

    //通過外部類來例項化內部
    Outer.Inner inner = outer.new In    inner.in();

   }
}

Java 列舉(enum)

Java 列舉是一個特殊的類，一般表示一組常量，比如一年的 4 個季節，一個年的 12 個月份，一個星期的 7 天，方向有東南西北等。

Java 列舉類使用 enum 關鍵字來定義，各個常量使用逗號 , 來分割。

定義一個顏色的列舉

enum color
{
  Red,Blue,Yellow;
}

例項

enum Color 
{ 
  RED, GREEN, BLUE; 
} 
 
public class Test 
{ 
  // 執行輸出結果
  public static void main(String[] args) 
   { 
    Color c1 = Color.RED; 
    System.out.println(c1); 
   } 
}

內部類中使用列舉

public class Test 
{ 
  enum Color 
   { 
    RED, GREEN, BLUE; 
   } 
 
  // 執行輸出結果
  public static void main(String[] args) 
   { 
    Color c1 = Color.RED; 
    System.out.println(c1); 
   } 
}

每個列舉都是通過 Class 在內部實現的，且所有的列舉值都是 public static final 的。

以上的列舉類 Color 轉化在內部類實現：

class Color
{
   public static final Color RED = new Color();
   public static final Color BLUE = new Color();
   public static final Color GREEN = new Color();
}

迭代列舉元素

package com.oop.demo06;

public class Enum01 {
  public static void main(String[] args) {
    for(color myVar:color.values())
     {
      System.out.println(myVar);
     }
   }
}

在switch中使用列舉

enum Color 
{ 
  RED, GREEN, BLUE; 
} 
public class MyClass {
 public static void main(String[] args) {
  Color myVar = Color.BLUE;

  switch(myVar) {
   case RED:
    System.out.println("紅色");
    break;
   case GREEN:
     System.out.println("綠色");
    break;
   case BLUE:
    System.out.println("藍色");
    break;
   }
  }
}

values(), ordinal() 和 valueOf() 方法

enum 定義的列舉類預設繼承了 java.lang.Enum 類，並實現了 java.lang.Seriablizable 和 java.lang.Comparable 兩個介面。

values(), ordinal() 和 valueOf() 方法位於 java.lang.Enum 類中：

values() 返回列舉類中所有的值。
ordinal()方法可以找到每個列舉常量的索引，就像陣列索引一樣。
valueOf()方法返回指定字串值的列舉常量。

package com.oop.demo06;

public class Enum01 {
  public static void main(String[] args) {
    color arr[] = color.values();

    //迭代列舉
    for(color col : arr)
     {
      System.out.println(col+"在第"+col.ordinal()+"位");
     }
    // 使用 valueOf() 返回列舉常量，不存在的會報錯 IllegalArgumentException
    System.out.println(color.valueOf("RED"));
    // System.out.println(Color.valueOf("WHITE")); 
   }
}

列舉類成員

列舉跟普通類一樣可以用自己的變數、方法和建構函式，建構函式只能使用 private 訪問修飾符，所以外部無法呼叫。

列舉既可以包含具體方法，也可以包含抽象方法。如果列舉類具有抽象方法，則列舉類的每個例項都必須實現它。

enum Color 
{ 
  RED, GREEN, BLUE; 
 
  // 建構函式
  private Color() 
   { 
    System.out.println("Constructor called for : " + this.toString()); 
   } 
 
  public void colorInfo() 
   { 
    System.out.println("Universal Color"); 
   } 
} 
 
public class Test 
{   
  // 輸出
  public static void main(String[] args) 
   { 
    Color c1 = Color.RED; 
    System.out.println(c1); 
    c1.colorInfo(); 
   } 
}