喝咖啡休息#133。如何在 Java 中僅取得數組的一部分。Java 中的介面與抽象類

Java中如何只取得數組的一部分

來源：Asyncq 複製陣列的一部分是每個開發人員都會遇到的非常常見的操作。在本文中，我們將看到傳統的命令式風格和帶有 lambda 表達式和流 API 的現代聲明式風格程式碼。

命令式方法

命令式程式設計風格在 Java 中早已很常見。因此，Java 開發人員自然會編寫以下程式碼來複製原始陣列的特定部分。為此，只需迭代元素，僅過濾掉需要的元素，並將它們寫入最終的陣列中。

private static int[] copyArray(){
       int[] numbers = {1,2,3,4,5,6,7};
       int[] subArray = new int[numbers.length-3];
       int j =3;
       for (int i=0;i<subArray.length;i++){
           subArray[i] = numbers[j+i];
       }
       System.out.println(Arrays.toString(subArray));
       return subArray;
   }

我們中的許多人經常忘記 Java Arrays庫有一個方便的copyOfRange方法。此方法可用於透過傳入和傳出索引來複製陣列的一部分。

private static int[] copyArray1(){
  int[] numbers = {1,2,3,4,5,6,7};
  int[] subArray = Arrays.copyOfRange(numbers,3,numbers.length);
  System.out.println(Arrays.toString(subArray));
  return subArray;
}

聲明式方法

從 Java 8 開始，我們可以使用 Streams API 來複製陣列的一部分。在下面的程式碼中，我們可以傳遞int[]並過濾掉大於3的值，最後將它們複製到陣列中。

private static void copyArray2(){
        int[] numbers = {1,2,3,4,5,6,7};
        // copy with values
        int[] subArray = Arrays.stream(numbers).filter(a-> a>3).toArray();
        System.out.println(Arrays.toString(subArray));
    }

上面的程式碼是對陣列的一部分進行基於值的複製，但我們也可以基於索引進行複製。在程式碼下面，我們從 i=0 廣播 Intstream；i=len(數組)。通常，在命令式程式碼中，我們會寫一個從開始索引到結束索引的for循環，並迭代每個元素。我們可以使用 Intstream 執行相同的操作並存取索引元素。

// copy with index
int[] subArray1 = IntStream
                .range(0, numbers.length)
                .filter(i -> i > 3)
                .map(a->numbers[a]).toArray();

System.out.println(Arrays.toString(subArray1));

雖然上述方法有效，但我們還有另一種方法可以使用AtomicInteger複製部分陣列。它有一個getAndIncrement方法，該方法本質上提供一個索引並將其遞增 1。

// copy with index
AtomicInteger atomicInteger = new AtomicInteger();
int[] subArray2 = Arrays.stream(numbers).filter(i -> atomicInteger.getAndIncrement() > 3).toArray();
System.out.println(Arrays.toString(subArray2));

結論

在本文中，我們討論如何使用命令式和宣告式樣式複製 Java 陣列的一部分。我更喜歡以聲明式的方式工作，因為它使我的程式碼更具可讀性且不那麼冗長。

Java 中的介面與抽象類

來源：Devgenius 在學習 Java 語言時，我們肯定會遇到一個稱為介面的概念。介面是 Java 的關鍵特性之一，因此每個開發人員都應該知道如何使用它們。重要的是要記住，介面既有優點也有缺點。讓我們更深入地了解介面。在實作介面時，我們會遇到抽象類別。什麼是抽象類別？需要它們做什麼？什麼是介面？它們是如何使用的？為什麼介面使用抽象類別？您將在本文中得到所有這些問題的答案。

什麼是介面？

介面是Java中的一種特殊機制，用來描述行為並幫助實作抽象。它在許多方面與類別相似，因為它具有靜態常數和抽象方法。介面只能有抽象方法（沒有主體的方法）。 介面和抽象類別的簡要區別：

• 該介面沒有實作任何方法；它們都是公共的，並且沒有類別變數。
• 抽象類別是沒有實作一個或多個方法的類別。

從 Java 9 開始，我們也可以在介面中使用私有、預設和靜態方法。現在讓我們繼續討論用於實作抽象的簡單介面邏輯。

什麼是抽象？

讓我們舉一個現實生活中的例子。我們都在手機上使用應用程式。每當我們想要使用任何應用程式時，我們都必須在其中建立一個帳戶。當我們透過電話號碼註冊時，一次性密碼會發送到我們的手機上。我們知道在應用程式中單擊“獲取密碼”按鈕後會收到密碼，但我們不知道該系統在後端如何工作以及單擊該按鈕後實際發生了什麼。現在，成功完成任務而不向使用者顯示後端實際發生的情況的過程稱為抽象。在Java中，我們可以使用介面和抽象類別來實作抽象。

為什麼要使用介面？

使用該介面的三個原因：

• 達到抽象的目的。
• 支援多重繼承功能。
• 實現松耦合。

介面如何使用？

介面是使用interface關鍵字聲明的。它提供了抽象，即它聲明了類別的結構。介面中的所有方法都是抽象的，並且預設為 public、static 和 Final（public、static、final）。無論什麼類別實作接口，都必須實作接口中聲明的所有方法。

interface <interface_name>{

     // declare constant fields
     // declare methods that abstract
     // by default.
 }

與介面抽象類似，抽像也可以使用抽象類別來實作。

什麼是抽象類別？

抽象類別是前面有abstract關鍵字的類別。它們包含抽象方法和具體方法（帶有主體）。抽象類別不能被實例化，它們必須被擴展並且它們的方法必須被實作。抽象類別描述一些抽象物件（汽車、人等），而不僅僅是行為。記住：

• 抽象類別必須用abstract關鍵字聲明。
• 可以有抽象方法和非抽象方法。
• 無法建立抽象類別的實例。
• 它可以有建構子和靜態方法。
• 它可以有最終方法來強制子類別不更改方法體。

具有抽象方法的抽象類別的範例： 在此範例中， Bike是一個抽象類別，僅包含一個抽象方法 run。它的實作是由Hon​​da類別提供的。

abstract class Bike{
  abstract void run();
}
class Honda4 extends Bike{
void run(){System.out.println("running safely");}
public static void main(String args[]){
 Bike obj = new Honda4();
 obj.run();
}
}

具有建構函式、資料成員和方法的抽象類別： 抽象類別可以具有資料成員、抽象方法、方法體（非抽象方法）、建構函式甚至 main ()方法。

//Example of an abstract class that has abstract and non-abstract methods
 abstract class Bike{
   Bike(){System.out.println("bike is created");}
   abstract void run();
   void changeGear(){System.out.println("gear changed");}
 }
//Creating a Child class which inherits Abstract class
 class Honda extends Bike{
 void run(){System.out.println("running safely..");}
 }
//Creating a Test class which calls abstract and non-abstract methods
 class TestAbstraction2{
 public static void main(String args[]){
  Bike obj = new Honda();
  obj.run();
  obj.changeGear();
}
}

現在主要問題出現了。如果介面和抽象類別有助於抽象，那麼使用哪一個更好？答案是Java不像C++那樣支援多重繼承。也就是說，如果我們需要實作多重繼承，那麼我們就應該使用介面。換句話說，抽象類別可以幫助 1% 到 100% 的情況，而介面可以幫助 100% 的情況。如果我們需要行為，我們需要使用介面。如果我們談論概念對象，則必須使用抽象類別。

Java 介面範例

在此範例中，Drawable介面只有一個方法。它的實作由Rectangle和Circle類別提供。在實際場景中，介面是由其他人定義的，其實作由不同的實作提供者提供。而且，它正在被別人使用。部分實作被使用介面的使用者隱藏。

//Interface declaration: by first user
interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
}
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable()
d.draw();
}}

Java中使用介面的多重繼承

如果一個類別實作了多個介面或一個介面擴展了多個接口，則稱為多重繼承。

interface Printable{
void print();
}
interface Showable{
void show();
}
class A7 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){
A7 obj = new A7();
obj.print();
obj.show();
 }
}

問題：Java 中的類別不支援多重繼承，但透過介面可以，為什麼？ 正如繼承部分中已經解釋的那樣，由於不明確，在類別範例中不支援多重繼承。然而，它得到了介面範例的支持，因為它沒有歧義。原因是它的實作是由實作類別提供的。