Abstraction en Java

Dans la technologie Java principalement construite avec les concepts oops. L'abstraction également l'un des concepts oops (système de programmation orienté objet) est désigné comme le processus de masquage des données, certains détails ne seront pas affichés mais il s'affichera avec le écran utilisateur uniquement pour les informations associées liées aux données masquées. L'abstraction en Java, nous pouvons utiliser ces concepts à l'aide de "classes abstraites et interfaces", ces deux types seront utilisés en même temps dans Java ou bien, en fonction des besoins de l'utilisateur, nous pouvons utiliser n'importe lequel des types à certains moments, les deux processus seront utilisé dans les programmes.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

L'abstraction sera utilisée pour deux types différents de syntaxe utilisés dans les programmes Java.

import packages;
abstract class names
{
-----some logic codes---
}
interface  names
{
----Some logic codes----
}

Les codes ci-dessus constituent la syntaxe de base pour l'abstraction applicable dans les programmes Java. Lorsque nous utilisons la classe abstraite, elle utilisera à la fois les méthodes abstraites et non abstraites, mais l'interface n'accepte que les méthodes non abstraites. Ils présentent des différences similaires entre ces deux concepts.

Comment utiliser l'abstraction en Java ?

Dans Abstraction, il cache les détails indésirables dans l'objet Java, il affiche uniquement les informations pertinentes sur le sujet, il est principalement comparé à l'interface de collection Java appelée map dans l'interface map, il a les classes dérivées comme hashmap, il stockera les paires de valeurs clés dans les données utilisateur en utilisant certaines méthodes comme les méthodes get() et put() pour stocker et récupérer les données du backend.

L'abstraction fournit principalement deux manières différentes : 1. l'abstraction des données et 2. l'abstraction du contrôle. Dans l'abstraction des données, elle est utilisée pour créer des types de données difficiles, elle sera utilisée pour exposer certains contenus utiles à l'exposition à l'écran, y compris les types de données. Dans l'abstraction de contrôle, le processus d'écriture de certaines données dans d'autres langages de programmation se déroule dans différents scénarios avec plusieurs fois l'écriture des codes pour stocker et récupérer les données afin que ces types de données doivent être identifiés et combinés avec un seul travail. comme abstraction de contrôle.

Bien que nous utilisions les types d'interface pour réaliser l'abstraction, cela signifie que cela doit être réalisé dans la plupart des cas, mais dans les classes abstraites, ce n'est pas entièrement réalisé dans le processus d'abstraction, il doit être partiellement complet. Si nous utilisons une classe abstraite, nous ne pouvons pas créer une instance de ces classes si nous voulons l'utiliser pour les instances de ces classes de manière complète ou concrète en l'étendant à elles. En utilisant Abstraction, nous avons déclaré que l'implémentation des méthodes peut varier tandis que nous utilisons un nouvel opérateur pour créer une instance de la classe abstraite, cela générera une erreur de compilation.

Exemples d'abstraction en Java

Voici les exemples suivants mentionnés ci-dessous :

Exemple n°1

Code :

public abstract class Main {
private String names;
private String city;
public Main(String nm, String cty){
this.names=nm;
this.city=cty;
}
public abstract void work();
@Override
public String toString(){
return "Names="+this.names+"::City="+this.city;
}
public void changeName(String newNames) {
this.names = newNames;
}
}
public class ClientMain extends Main {
private int empId;
public ClientMain(String nm, String cty, int id) {
super(nm, cty);
this.empId=id;
}
@Override
public void work() {
if(empId == 0){
System.<em>out</em>.println("Invalid name");
}else{
System.<em>out</em>.println("Employees List!!");
}
}
public static void main(String args[]){
//coding in terms of abstract classes
Main m = new ClientMain("siva","tirupur",1);
Main m1 = new ClientMain("raman","chennai",234);
m.work();
m1.work();
//using method implemented in abstract class - inheritance
m1.changeName("Sivaraman");
System.<em>out</em>.println(m1.toString());
}
}

Sortie :

Exemple n°2

Code :

interface Animals {
public void animalSounds();
public void sleep();
}
class Sample implements Animals {
public void animalSounds() {
System.<em>out</em>.println("Animal Sounds");
}
public void sleep() {
System.<em>out</em>.println("Beep");
}
}
class ClientMain {
public static void main(String[] args) {
Sample s = new Sample();
s.animalSounds();
s.sleep();
}
}

Sortie :

Exemple #3

Code :

@FunctionalInterface
interface SquareofNumbers
{
int numbers(int x);
}
class ClientMain
{
public static void main(String args[])
{
int a = 6;
SquareofNumbers  s = (int i)->i*i;
int result = s.numbers(a);
System.<em>out</em>.println(result);
}
}

Sortie :

Dans les trois exemples ci-dessus, nous avons utilisé les utilisations de base de la classe abstraite et des interfaces pour implémenter l'abstraction dans l'application Java. Dans le dernier exemple, nous avons utilisé le concept appelé interface fonctionnelle utilisé en Java pour mettre au carré les nombres donnés. L'interface fonctionnelle est la même que le concept d'interface mais en ce sens qu'il n'autorise pas plus d'une méthode abstraite dans le programme, si nous supposons que nous avons utilisé plus d'une méthode abstraite, cela signifie qu'il générera une erreur comme « annotation inattendue de l'interface @fonctionnelle » pendant que nous utilisons l'interface fonctionnelle, nous déclarons également l'annotation cela est très utile pour les données sur le concept de données. Pendant que nous avons besoin de la technologie des métadonnées en Java, nous avons utilisé ce type de technologie appelée annotation et nous avons également utilisé un autre concept appelé expressions lambda que nous avons utilisé dans l'exemple final pour le réduisez l'espace de code afin que la redondance des codes soit très simple et que la complexité des programmes soit également moindre, il est facilement compréhensible pour écrire les codages complexes.

Si nous définissons l'une des méthodes de la classe, nous devons déclarer la classe également abstraite et aussi si nous étendons la classe abstraite et l'utilisons dans l'une des méthodes des classes internes, avant cela, nous devons implémenter toutes les méthodes de la classe. classes abstraites dans la technologie Java, nous ne pouvons pas créer l'instance des classes abstraites, nous ne pouvons pas déclarer la classe abstraite comme modificateurs d'accès final ou mots-clés en Java, car lorsque nous utilisons final dans une classe abstraite ou l'une des méthodes de la classe, cela peut 'être modifié dans tout le processus d'exécution des candidatures. Les modificateurs privés ne sont pas non plus autorisés dans l'abstraction, cela affectera l'héritage de la relation parent-enfant qui devrait être affecté dans les classes abstraites car les fonctions/méthodes ne sont pas autorisées pour les sous-classes.

Conclusion

Les concepts d'abstraction ci-dessus sont une compréhension de base des oops alors que nous implémentons la même chose dans la technologie Java, ils doivent être utilisés avec les interfaces et la classe abstraite pour réaliser l'abstraction, mais dans les dernières versions de Java, cela peut varier en fonction des nouvelles fonctionnalités. .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!