Pause café #133. Comment obtenir seulement une partie d'un tableau en Java. Interfaces et classes abstraites en Java

Comment obtenir seulement une partie d'un tableau en Java

Source : Asyncq Copier une partie d'un tableau est une opération très courante que rencontre tout développeur. Dans cet article, nous verrons le style impératif traditionnel et le code de style déclaratif moderne avec expression lambda et API de streaming.

Approche impérative

Le style de programmation impératif est depuis longtemps courant en Java. Par conséquent, il est naturel que les développeurs Java écrivent le code ci-dessous pour copier une partie spécifique du tableau d'origine. Pour ce faire, parcourez simplement les éléments, en filtrant uniquement ceux qui sont nécessaires, et écrivez-les dans le tableau final.

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

Beaucoup d'entre nous oublient souvent que la bibliothèque Java Arrays dispose d'une méthode copyOfRange pratique . Cette méthode peut être utilisée pour copier une partie d'un tableau en passant vers et depuis l'index.

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

Approche déclarative

Depuis Java 8, nous pouvons utiliser l'API Streams pour copier une partie d'un tableau. Dans le code ci-dessous, nous pouvons passer int[] et filtrer uniquement les valeurs supérieures à 3 et enfin les copier dans un tableau.

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

Le code ci-dessus est une copie basée sur la valeur d'une partie du tableau, mais nous pouvons également copier en fonction d'un index. Sous le code, nous diffusons Intstream à partir de i=0 ; je=len(tableau) . Généralement, dans le code impératif, nous écrivons une boucle for de l'index de début à l'index de fin et parcourons chaque élément. Nous pouvons faire la même chose en utilisant Intstream et accéder à l' élément index .

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

Bien que la méthode ci-dessus fonctionne, nous disposons d’un autre moyen d’utiliser AtomicInteger pour copier une partie du tableau. Il possède une méthode getAndIncrement qui fournit essentiellement un index et l'incrémente de 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));

Conclusion

Dans cet article, nous avons expliqué comment copier une partie d'un tableau Java à l'aide de styles impératifs et déclaratifs. Je préférerais travailler dans un style déclaratif car cela rend mon code plus lisible et moins verbeux.

Interfaces et classes abstraites en Java

Source : Devgenius En apprenant le langage Java, on tombe certainement sur un concept appelé Interfaces. Les interfaces sont l'une des fonctionnalités clés de Java, chaque développeur doit donc savoir comment les utiliser. Il est important de se rappeler que les interfaces présentent à la fois des avantages et des inconvénients. Approfondissons la compréhension des interfaces. Lors de l'implémentation d'interfaces, nous rencontrons des classes abstraites. Que sont les classes abstraites ? A quoi servent-ils ? Qu'est-ce qu'une interface ? Comment sont-ils utilisés ? Pourquoi les interfaces utilisent-elles des classes abstraites ? Vous obtiendrez des réponses à toutes ces questions dans cet article.

Qu'est-ce qu'une interface ?

Une interface est un mécanisme spécial en Java qui décrit le comportement et permet de réaliser l'abstraction. Elle ressemble à une classe à bien des égards car elle possède des constantes statiques et des méthodes abstraites. Les interfaces ne peuvent avoir que des méthodes abstraites (méthodes sans corps). Brève différence entre interface et classe abstraite :

• L'interface n'a aucune méthode implémentée ; elles sont toutes publiques et il n'y a pas de variables de classe.
• Une classe abstraite est une classe dans laquelle aucune méthode n’est implémentée.

Depuis Java 9, nous pouvons également utiliser des méthodes private , default et static dans les interfaces . Passons maintenant à la logique d'interface simple utilisée pour réaliser l'abstraction.

Qu’est-ce que l’abstraction ?

Prenons un exemple concret. Nous utilisons tous des applications sur nos téléphones mobiles. Chaque fois que nous voulons utiliser une application, nous devons y créer un compte. Lorsque nous nous inscrivons via notre numéro de téléphone, un mot de passe à usage unique est envoyé sur notre téléphone mobile. Nous savons que le mot de passe est reçu après avoir cliqué sur le bouton « Obtenir le mot de passe » dans l'application, mais nous ne savons pas comment ce système fonctionne dans le backend et ce qui se passe réellement après avoir cliqué sur le bouton. Désormais, le processus permettant de terminer avec succès des tâches sans montrer à l'utilisateur ce qui se passe réellement dans le backend est appelé abstraction. En Java, nous pouvons réaliser l'abstraction en utilisant des interfaces et des classes abstraites.

Pourquoi utiliser l'interface ?

Il y a trois raisons d'utiliser l'interface :

• Pour parvenir à l’abstraction.
• Pour prendre en charge plusieurs fonctionnalités d’héritage.
• Pour obtenir un couplage lâche.

Comment utiliser l'interface ?

Une interface est déclarée à l'aide du mot-clé interface . Il fournit une abstraction, c'est-à-dire qu'il déclare la structure de la classe. Toutes les méthodes d'une interface sont abstraites et sont définies par défaut sur public, static et final ( public , static , final ). Quelle que soit la classe implémentant une interface, elle doit implémenter toutes les méthodes déclarées dans l'interface.

interface <interface_name>{

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

Semblable à l’abstraction d’interface, l’abstraction peut également être réalisée à l’aide de classes abstraites.

Que sont les classes abstraites ?

Les classes abstraites sont des classes avec le mot-clé abstract devant elles. Ils contiennent à la fois des méthodes abstraites et concrètes (avec un corps). Les classes abstraites ne peuvent pas être instanciées, elles doivent être étendues et leurs méthodes doivent être implémentées. Une classe abstraite décrit un objet abstrait (voiture, personne, etc.), pas seulement un comportement. Souviens-toi:

• Une classe abstraite doit être déclarée avec le mot clé abstract .
• Il peut y avoir des méthodes abstraites et non abstraites.
• Une instance d'une classe abstraite ne peut pas être créée.
• Il peut avoir des constructeurs et des méthodes statiques.
• Il peut avoir des méthodes finales qui obligeront la sous-classe à ne pas modifier le corps de la méthode.

Exemple de classe abstraite avec une méthode abstraite : Dans cet exemple , Bike est une classe abstraite qui ne contient qu'une seule exécution de méthode abstraite. Sa mise en œuvre est assurée par la classe 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();
}
}

Classe abstraite ayant un constructeur, un membre de données et des méthodes : une classe abstraite peut avoir un membre de données, une méthode abstraite, un corps de méthode (méthode non abstraite), un constructeur et même une méthode 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();
}
}

Maintenant, la question principale se pose. Si les interfaces et les classes abstraites aident à l’abstraction, laquelle est-il préférable d’utiliser ? La réponse est que Java ne prend pas en charge l’héritage multiple comme le fait C++. Autrement dit, si nous devons obtenir un héritage multiple, nous devons alors utiliser des interfaces. En d’autres termes, les classes abstraites aident dans 1 à 100 % des cas, et les interfaces dans 100 % des cas. Si nous avons besoin d'un comportement, nous devons utiliser une interface. Si nous parlons d'un objet conceptuel, nous devons utiliser une classe abstraite.

Exemple d'interface Java

Dans cet exemple, l' interface Drawable n'a qu'une seule méthode. Son implémentation est assurée par les classes Rectangle et Circle . Dans un scénario réel, l'interface est définie par quelqu'un d'autre et son implémentation est assurée par différents fournisseurs d'implémentation. De plus, il est utilisé par quelqu'un d'autre. Une partie de l'implémentation est masquée par l'utilisateur utilisant l'interface.

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

Héritage multiple en Java à l'aide de l'interface

Si une classe implémente plusieurs interfaces ou si une interface étend plusieurs interfaces, on parle d'héritage multiple.

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

Question : L'héritage multiple n'est pas pris en charge via une classe en Java, mais il est possible via une interface, pourquoi ? Comme déjà expliqué dans la section sur l'héritage, l'héritage multiple n'est pas pris en charge dans l'exemple de classe en raison d'une ambiguïté. Cependant, il est pris en charge par l'exemple d'interface car il ne contient aucune ambiguïté. La raison en est que son implémentation est assurée par la classe d'implémentation.