Kaffeepause Nr. 133. So erhalten Sie nur einen Teil eines Arrays in Java. Schnittstellen und abstrakte Klassen in Java

So erhalten Sie nur einen Teil eines Arrays in Java

Quelle: Asyncq Das Kopieren eines Teils eines Arrays ist ein sehr häufiger Vorgang, mit dem jeder Entwickler konfrontiert wird. In diesem Artikel werden wir den traditionellen imperativen Stil und den modernen deklarativen Stilcode mit Lambda-Ausdruck und Streaming-API sehen.

Imperativer Ansatz

Der imperative Programmierstil ist in Java seit langem üblich. Daher ist es für Java-Entwickler selbstverständlich, den folgenden Code zu schreiben, um einen bestimmten Teil des ursprünglichen Arrays zu kopieren. Dazu durchlaufen Sie einfach die Elemente, filtern nur die benötigten heraus und schreiben sie in das endgültige Array.

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

Viele von uns vergessen oft, dass die Java- Arrays- Bibliothek über eine praktische copyOfRange- Methode verfügt . Diese Methode kann verwendet werden, um einen Teil eines Arrays durch Übergabe an und von dem Index zu kopieren.

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

Deklarativer Ansatz

Seit Java 8 können wir die Streams-API verwenden, um einen Teil eines Arrays zu kopieren. Im folgenden Code können wir int[] übergeben und nur Werte größer als 3 herausfiltern und sie schließlich in ein Array kopieren.

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

Der obige Code ist eine wertbasierte Kopie eines Teils des Arrays, wir können ihn aber auch basierend auf einem Index kopieren. Unterhalb des Codes senden wir Intstream von i=0; i=len(array) . Typischerweise schreiben wir im imperativen Code eine for- Schleife vom Startindex zum Endindex und durchlaufen jedes Element. Das Gleiche können wir mit Intstream tun und auf das Indexelement zugreifen .

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

Während die obige Methode funktioniert, haben wir eine andere Möglichkeit, mit AtomicInteger einen Teil des Arrays zu kopieren. Es verfügt über eine getAndIncrement- Methode , die im Wesentlichen einen Index bereitstellt und diesen um 1 erhöht.

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

Abschluss

In diesem Artikel haben wir besprochen, wie Sie einen Teil eines Java-Arrays mithilfe imperativer und deklarativer Stile kopieren können. Ich würde es vorziehen, in einem deklarativen Stil zu arbeiten, da mein Code dadurch besser lesbar und weniger ausführlich ist.

Schnittstellen und abstrakte Klassen in Java

Quelle: Devgenius Beim Erlernen der Java-Sprache stoßen wir sicherlich auf ein Konzept namens Interfaces. Schnittstellen sind eine der Hauptfunktionen von Java, daher sollte jeder Entwickler wissen, wie man sie verwendet. Es ist wichtig zu bedenken, dass Schnittstellen sowohl Vor- als auch Nachteile haben. Lassen Sie uns tiefer in das Verständnis von Schnittstellen eintauchen. Bei der Implementierung von Schnittstellen stoßen wir auf abstrakte Klassen. Was sind abstrakte Klassen? Wofür werden sie benötigt? Was ist eine Schnittstelle? Wie werden sie verwendet? Warum verwenden Schnittstellen abstrakte Klassen? Auf all diese Fragen erhalten Sie in diesem Artikel Antworten.

Was ist eine Schnittstelle?

Eine Schnittstelle ist ein spezieller Mechanismus in Java, der das Verhalten beschreibt und zur Abstraktion beiträgt. Sie ähnelt in vielerlei Hinsicht einer Klasse, da sie über statische Konstanten und abstrakte Methoden verfügt. Schnittstellen können nur abstrakte Methoden (Methoden ohne Körper) haben. Kurzer Unterschied zwischen Schnittstelle und abstrakter Klasse:

• In der Schnittstelle sind keine Methoden implementiert; sie sind alle öffentlich und es gibt keine Klassenvariablen.
• Eine abstrakte Klasse ist eine Klasse, in der keine oder mehrere Methoden implementiert sind.

Seit Java 9 können wir in Schnittstellen auch private , default und statische Methoden verwenden . Kommen wir nun zur einfachen Schnittstellenlogik, die zum Erreichen der Abstraktion verwendet wird.

Was ist Abstraktion?

Nehmen wir ein Beispiel aus dem wirklichen Leben. Wir alle nutzen Apps auf unseren Mobiltelefonen. Wann immer wir eine Anwendung nutzen möchten, müssen wir darin ein Konto erstellen. Wenn wir uns über unsere Telefonnummer registrieren, wird ein Einmalpasswort an unser Mobiltelefon gesendet. Wir wissen, dass das Passwort nach dem Klicken auf die Schaltfläche „Passwort abrufen“ in der Anwendung empfangen wird, wissen jedoch nicht, wie dieses System im Backend funktioniert und was nach dem Klicken auf die Schaltfläche tatsächlich passiert. Nun wird der Prozess des erfolgreichen Abschließens von Aufgaben, ohne dem Benutzer zu zeigen, was tatsächlich im Backend passiert, als Abstraktion bezeichnet. In Java können wir Abstraktion mithilfe von Schnittstellen und abstrakten Klassen erreichen.

Warum die Schnittstelle nutzen?

Es gibt drei Gründe, die Schnittstelle zu verwenden:

• Abstraktion erreichen.
• Zur Unterstützung der Mehrfachvererbungsfunktionalität.
• Um eine lose Kopplung zu erreichen.

Wie verwende ich die Schnittstelle?

Eine Schnittstelle wird mit dem Schlüsselwort interface deklariert . Es bietet Abstraktion, das heißt, es deklariert die Struktur der Klasse. Alle Methoden in einer Schnittstelle sind abstrakt und standardmäßig auf public, static und final eingestellt ( public , static , final ). Welche Klasse auch immer eine Schnittstelle implementiert, sie muss alle in der Schnittstelle deklarierten Methoden implementieren.

interface <interface_name>{

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

Ähnlich wie bei der Schnittstellenabstraktion kann die Abstraktion auch mithilfe abstrakter Klassen erreicht werden.

Was sind abstrakte Klassen?

Abstrakte Klassen sind Klassen, denen das Schlüsselwort abstract vorangestellt ist. Sie enthalten sowohl abstrakte als auch konkrete Methoden (mit Körper). Abstrakte Klassen können nicht instanziiert werden, sie müssen erweitert und ihre Methoden implementiert werden. Eine abstrakte Klasse beschreibt ein abstraktes Objekt (Auto, Person usw.), nicht nur Verhalten. Erinnern:

• Eine abstrakte Klasse muss mit dem Schlüsselwort abstract deklariert werden .
• Es kann abstrakte und nicht abstrakte Methoden geben.
• Eine Instanz einer abstrakten Klasse kann nicht erstellt werden.
• Es kann Konstruktoren und statische Methoden haben.
• Sie kann finale Methoden haben, die die Unterklasse zwingen, den Methodenkörper nicht zu ändern.

Beispiel einer abstrakten Klasse mit einer abstrakten Methode: In diesem Beispiel ist Bike eine abstrakte Klasse, die nur einen abstrakten Methodenlauf enthält. Die Implementierung erfolgt durch die Honda- Klasse .

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

Abstrakte Klasse mit einem Konstruktor, einem Datenelement und Methoden: Eine abstrakte Klasse kann ein Datenelement, eine abstrakte Methode, einen Methodenkörper (nicht abstrakte Methode), einen Konstruktor und sogar eine main()- Methode haben .

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

Nun stellt sich die Hauptfrage. Wenn Schnittstellen und abstrakte Klassen bei der Abstraktion helfen, welche ist besser zu verwenden? Die Antwort ist, dass Java keine Mehrfachvererbung unterstützt, wie dies in C++ der Fall ist. Das heißt, wenn wir eine Mehrfachvererbung erreichen müssen, sollten wir Schnittstellen verwenden. Mit anderen Worten: Abstrakte Klassen helfen in 1 bis 100 % der Fälle und Schnittstellen helfen in 100 % der Fälle. Wenn wir Verhalten benötigen, müssen wir eine Schnittstelle verwenden. Wenn wir über ein konzeptionelles Objekt sprechen, müssen wir eine abstrakte Klasse verwenden.

Beispiel für eine Java-Schnittstelle

In diesem Beispiel verfügt die Drawable- Schnittstelle nur über eine Methode. Die Implementierung wird durch die Klassen „Rechteck“ und „Kreis“ bereitgestellt . In einem realen Szenario wird die Schnittstelle von jemand anderem definiert und ihre Implementierung wird von verschiedenen Implementierungsanbietern bereitgestellt. Darüber hinaus wird es von jemand anderem verwendet. Ein Teil der Implementierung wird vom Benutzer, der die Schnittstelle nutzt, ausgeblendet.

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

Mehrfachvererbung in Java mithilfe der Schnittstelle

Wenn eine Klasse mehrere Schnittstellen implementiert oder eine Schnittstelle mehrere Schnittstellen erweitert, spricht man von Mehrfachvererbung.

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

Frage: Mehrfachvererbung wird in Java nicht über eine Klasse unterstützt, ist aber über eine Schnittstelle möglich. Warum? Wie bereits im Abschnitt zur Vererbung erläutert, wird die Mehrfachvererbung im Klassenbeispiel aus Unklarheiten nicht unterstützt. Es wird jedoch vom Schnittstellenbeispiel unterstützt, da darin keine Mehrdeutigkeit besteht. Der Grund dafür ist, dass seine Implementierung von der Implementierungsklasse bereitgestellt wird.