Przerwa kawowa #133. Jak uzyskać tylko część tablicy w Javie. Interfejsy i klasy abstrakcyjne w Javie

Jak uzyskać tylko część tablicy w Javie

Źródło: Asyncq Kopiowanie części tablicy jest bardzo powszechną operacją, z którą spotyka się każdy programista. W tym artykule przyjrzymy się tradycyjnemu stylowi imperatywnemu i nowoczesnemu kodowi w stylu deklaratywnym z wyrażeniem lambda i API przesyłania strumieniowego.

Podejście imperatywne

Imperatywny styl programowania jest od dawna powszechny w Javie. Dlatego naturalnym jest, że programiści Java piszą poniższy kod w celu skopiowania określonej części oryginalnej tablicy. Aby to zrobić, po prostu wykonaj iterację po elementach, odfiltrowując tylko te, które są potrzebne, i zapisz je w końcowej tablicy.

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;
   }

Wielu z nas często zapomina, że ​​biblioteka Java Arrays posiada wygodną metodę copyOfRange . Tej metody można użyć do skopiowania części tablicy poprzez przekazanie do i z indeksu.

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;
}

Podejście deklaratywne

Od wersji Java 8 możemy używać interfejsu Streams API do kopiowania części tablicy. W poniższym kodzie możemy przekazać int[] i odfiltrować tylko wartości większe niż 3 i na koniec skopiować je do tablicy.

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));
    }

Powyższy kod jest opartą na wartościach kopią części tablicy, ale możemy również skopiować na podstawie indeksu. Poniżej kodu nadajemy Instream od i=0; i=len(tablica) . Zazwyczaj w kodzie imperatywnym piszemy pętlę for od indeksu początkowego do indeksu końcowego i iterujemy po każdym elemencie. To samo możemy zrobić za pomocą Intstream i uzyskać dostęp do elementu indeksu .

// 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));

Chociaż powyższa metoda działa, mamy inny sposób wykorzystania AtomicInteger do skopiowania części tablicy. Posiada metodę getAndInkrement , która zasadniczo dostarcza indeks i zwiększa go o 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));

Wniosek

W tym artykule omówiliśmy, jak skopiować część tablicy Java, używając stylów imperatywnych i deklaratywnych. Wolałbym pracować w stylu deklaratywnym, ponieważ dzięki temu mój kod jest bardziej czytelny i mniej gadatliwy.

Interfejsy i klasy abstrakcyjne w Javie

Źródło: Devgenius Ucząc się języka Java z pewnością natrafiamy na koncepcję zwaną Interfejsami. Interfejsy to jedna z kluczowych cech języka Java, dlatego każdy programista powinien wiedzieć, jak z nich korzystać. Należy pamiętać, że interfejsy mają zarówno zalety, jak i wady. Zagłębmy się w zrozumienie interfejsów. Implementując interfejsy spotykamy się z klasami abstrakcyjnymi. Czym są klasy abstrakcyjne? Do czego są potrzebne? Co to jest interfejs? Jak się je wykorzystuje? Dlaczego interfejsy używają klas abstrakcyjnych? Odpowiedzi na wszystkie te pytania znajdziesz w tym artykule.

Co to jest interfejs?

Interfejs to specjalny mechanizm w Javie, który opisuje zachowanie i pomaga osiągnąć abstrakcję. Pod wieloma względami jest podobna do klasy, ponieważ ma stałe statyczne i metody abstrakcyjne. Interfejsy mogą mieć tylko metody abstrakcyjne (metody bez treści). Krótka różnica między interfejsem a klasą abstrakcyjną:

• W interfejsie nie zaimplementowano żadnych metod, wszystkie są publiczne i nie ma zmiennych klasowych.
• Klasa abstrakcyjna to klasa, która nie ma zaimplementowanej jednej lub więcej metod.

Od wersji Java 9 w interfejsach możemy także używać metod private , default i static . Przejdźmy teraz do prostej logiki interfejsu, która służy do osiągnięcia abstrakcji.

Czym jest abstrakcja?

Weźmy przykład z życia wzięty. Wszyscy korzystamy z aplikacji na telefonach komórkowych. Ilekroć chcemy skorzystać z dowolnej aplikacji, musimy założyć w niej konto. Kiedy rejestrujemy się poprzez nasz numer telefonu, na nasz telefon komórkowy zostaje przesłane hasło jednorazowe. Wiemy, że hasło otrzymujemy po kliknięciu przycisku „Pobierz hasło” w aplikacji, ale nie wiemy, jak ten system działa w backendzie i co właściwie dzieje się po kliknięciu przycisku. Obecnie proces pomyślnego wykonywania zadań bez pokazywania użytkownikowi, co faktycznie dzieje się w backendie, nazywany jest abstrakcją. W Javie abstrakcję możemy osiągnąć za pomocą interfejsów i klas abstrakcyjnych.

Po co korzystać z interfejsu?

Istnieją trzy powody, dla których warto korzystać z interfejsu:

• Aby osiągnąć abstrakcję.
• Aby obsługiwać funkcję wielokrotnego dziedziczenia.
• Aby uzyskać luźne połączenie.

Jak korzystać z interfejsu?

Interfejs deklaruje się za pomocą słowa kluczowego interfejs . Zapewnia abstrakcję, czyli deklaruje strukturę klasy. Wszystkie metody w interfejsie są abstrakcyjne i domyślnie ustawione są na public, static i final ( public , static , final ). Jakakolwiek klasa implementuje interfejs, musi implementować wszystkie metody zadeklarowane w interfejsie.

interface <interface_name>{

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

Podobnie jak abstrakcja interfejsu, abstrakcję można również osiągnąć za pomocą klas abstrakcyjnych.

Czym są klasy abstrakcyjne?

Klasy abstrakcyjne to klasy, które mają przed sobą słowo kluczowe „abstrakt” . Zawierają zarówno metody abstrakcyjne, jak i konkretne (z treścią). Nie można tworzyć instancji klas abstrakcyjnych, należy je rozszerzać, a ich metody muszą być implementowane. Klasa abstrakcyjna opisuje jakiś abstrakcyjny obiekt (samochód, osobę itp.), a nie tylko zachowanie. Pamiętać:

• Klasę abstrakcyjną należy zadeklarować za pomocą słowa kluczowego streszczenie .
• Istnieją metody abstrakcyjne i nieabstrakcyjne.
• Nie można utworzyć instancji klasy abstrakcyjnej.
• Może mieć konstruktory i metody statyczne.
• Może mieć metody końcowe, które zmuszą podklasę do niezmieniania treści metody.

Przykład klasy abstrakcyjnej z metodą abstrakcyjną: W tym przykładzie Bike jest klasą abstrakcyjną zawierającą tylko jedno uruchomienie metody abstrakcyjnej. Jego realizację zapewnia klasa Honda .

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();
}
}

Klasa abstrakcyjna posiadająca konstruktor, element danych i metody: Klasa abstrakcyjna może mieć element danych, metodę abstrakcyjną, treść metody (metoda nieabstrakcyjna), konstruktor, a nawet metodę 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();
}
}

Teraz pojawia się główne pytanie. Jeśli interfejsy i klasy abstrakcyjne pomagają w abstrakcji, którego lepiej użyć? Odpowiedź jest taka, że ​​Java nie obsługuje wielokrotnego dziedziczenia, tak jak C++. Oznacza to, że jeśli chcemy osiągnąć wielokrotne dziedziczenie, powinniśmy użyć interfejsów. Innymi słowy, klasy abstrakcyjne pomagają w 1 do 100% przypadków, a interfejsy pomagają w 100% przypadków. Jeśli potrzebujemy zachowania, musimy użyć interfejsu. Jeśli mówimy o obiekcie pojęciowym, musimy użyć klasy abstrakcyjnej.

Przykład interfejsu Java

W tym przykładzie interfejs Drawable ma tylko jedną metodę. Jego implementację zapewniają klasy Rectangle i Circle . W rzeczywistym scenariuszu interfejs jest definiowany przez kogoś innego, a jego implementację zapewniają różni dostawcy wdrożeń. Co więcej, jest on używany przez kogoś innego. Część implementacji jest ukryta przez użytkownika za pomocą interfejsu.

//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();
}}

Dziedziczenie wielokrotne w Javie przy użyciu interfejsu

Jeśli klasa implementuje wiele interfejsów lub interfejs rozszerza wiele interfejsów, nazywa się to dziedziczeniem wielokrotnym.

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();
 }
}

Pytanie: Dziedziczenie wielokrotne nie jest obsługiwane przez klasę w Javie, ale jest możliwe poprzez interfejs. Dlaczego? Jak już wyjaśniono w sekcji dotyczącej dziedziczenia, w przykładzie klasy nie jest obsługiwane dziedziczenie wielokrotne ze względu na niejednoznaczność. Jest to jednak poparte przykładem interfejsu, ponieważ nie ma w nim dwuznaczności. Powodem jest to, że jego implementacja jest zapewniana przez klasę implementacji.