Comme son nom l'indique, le concept de programmation orientée objet ou Java POO fait référence à des langages qui utilisent des objets dans la programmation, ils utilisent des objets comme source principale pour implémenter ce qui doit se passer dans le code. Les objets sont vus par le spectateur ou l'utilisateur, qui effectue les tâches que vous lui assignez.

La programmation orientée objet vise à implémenter des entités du monde réel comme l'héritage, le masquage, le polymorphisme, etc. En programmation. L'objectif principal de la POO est de relier les données et les fonctions qui y opèrent afin qu'aucune autre partie du code ne puisse accéder à ces données à l'exception de cette fonction.

Discutons des prérequis en peaufinant les concepts de déclaration de méthode et de transmission de messages. En commençant par la déclaration de méthode, elle se compose de six composants :

• Modificateur d'accès : Définit le Type d'accès de la méthode, c'est-à-dire d'où elle est accessible dans votre application. En Java, il existe 4 types de spécificateurs d'accès :
  
  • publique: Accessible dans toutes les classes de votre candidature.
  • protégé: Accessible au sein du package dans lequel il est défini et dans son sous-classe(s) (y compris les sous-classes déclarées en dehors du package) .
  • privé: Accessible uniquement au sein de la classe dans laquelle il est défini.
  • par défaut (déclaré/défini sans utiliser de modificateur) : Accessible au sein de la même classe et du même package dans lesquels sa classe est définie.
• Le type de retour : Le type de données de la valeur renvoyée par la méthode ou void si elle ne renvoie pas de valeur.
• Nom de la méthode : Les règles relatives aux noms de champs s'appliquent également aux noms de méthodes, mais la convention est un peu différente.
• Liste des paramètres : Liste séparée par des virgules des paramètres d'entrée définis, précédés de leur type de données, entre parenthèses. S'il n'y a pas de paramètres, vous devez utiliser des parenthèses vides ().
• Liste d'exceptions : Les exceptions que vous attendez de la méthode. Vous pouvez spécifier ces exceptions.
• Corps de la méthode : Il s'agit du bloc de code, entouré d'accolades, que vous devez exécuter pour effectuer les opérations prévues.

Passage de messages : Les objets communiquent entre eux en s’envoyant et en recevant des informations. Un message pour un objet est une demande d'exécution d'une procédure et invoquera donc une fonction dans l'objet récepteur qui génère les résultats souhaités. Le passage de message consiste à préciser le nom de l'objet, le nom de la fonction et les informations à envoyer.

Maîtriser la POO en Java Écrivez du code Java plus propre, plus modulaire et réutilisable en établissant une base en programmation orientée objet avec le cours interactif d'Educative Learn. Programmation orientée objet en Java . Inscrivez-vous sur Educative.io avec le code GEEKS10 pour économiser 10% sur votre abonnement.

Maintenant que nous avons couvert les prérequis de base, nous allons passer aux 4 piliers des POO qui sont les suivants. Mais commençons par découvrir les différentes caractéristiques d’un langage de programmation orienté objet.

Les concepts OOPS sont les suivants :

1. Classe
2. Objet
3. Méthode et passage de méthode
4. Piliers des POO
   • Abstraction
   • Encapsulation
   • Héritage
   • Polymorphisme
     • Polymorphisme au moment de la compilation
     • Polymorphisme d'exécution

UN classe est un plan ou un prototype défini par l'utilisateur à partir duquel les objets sont créés. Il représente l'ensemble des propriétés ou méthodes communes à tous les objets d'un même type. À l'aide de classes, vous pouvez créer plusieurs objets ayant le même comportement au lieu d'écrire leur code plusieurs fois. Cela inclut les classes pour les objets apparaissant plusieurs fois dans votre code. En général, les déclarations de classe peuvent inclure ces composants dans l'ordre :

1. Modificateurs : Une classe peut être publique ou avoir un accès par défaut (Reportez-vous à ce pour plus de détails).
2. Nom du cours: Le nom de la classe doit commencer par la lettre initiale en majuscule par convention.
3. Superclasse (le cas échéant) : Le nom du parent (superclasse) de la classe, le cas échéant, précédé du mot-clé extends. Une classe ne peut étendre (sous-classe) qu'un seul parent.
4. Interfaces (le cas échéant) : Une liste d'interfaces séparées par des virgules implémentées par la classe, le cas échéant, précédée du mot clé Implements. Une classe peut implémenter plusieurs interfaces.
5. Corps: Le corps de la classe est entouré d'accolades, { }.

Un objet est une unité de base de la programmation orientée objet qui représente des entités réelles. Un programme Java typique crée de nombreux objets qui, comme vous le savez, interagissent en appelant des méthodes. Les objets sont ce qui exécute votre code, ils sont la partie de votre code visible pour le spectateur/utilisateur. Un objet est principalement constitué de :

1. État : Il est représenté par les attributs d'un objet. Il reflète également les propriétés d'un objet.
2. Comportement : Il est représenté par les méthodes d'un objet. Il reflète également la réponse d'un objet à d'autres objets.
3. Identité : C'est un nom unique donné à un objet qui lui permet d'interagir avec d'autres objets.
4. Méthode : Une méthode est un ensemble d'instructions qui effectuent une tâche spécifique et renvoient le résultat à l'appelant. Une méthode peut effectuer une tâche spécifique sans rien retourner. Les méthodes nous permettent de réutilisation le code sans le retaper, c'est pourquoi ils sont considérés gain de temps . En Java, chaque méthode doit faire partie d'une classe, ce qui est différent des langages comme C , C++ , et Python .

classe et objets un simple programme Java :

public class GFG {    static String Employee_name;  static float Employee_salary;  static void set(String n, float p) {  Employee_name = n;  Employee_salary = p;  }  static void get() {  System.out.println('Employee name is: ' +Employee_name );  System.out.println('Employee CTC is: ' + Employee_salary);  }  public static void main(String args[]) {  GFG.set('Rathod Avinash', 10000.0f);  GFG.get();  } }>

Employee name is: Rathod Avinash Employee CTC is: 10000.0>

Parlons maintenant des 4 piliers des POO :

Pilier 1 : Abstraction

Données Abstraction est la propriété en vertu de laquelle seuls les détails essentiels sont affichés à l'utilisateur. Les unités triviales ou non essentielles ne sont pas affichées à l'utilisateur. Ex : Une voiture est considérée comme une voiture plutôt que comme ses composants individuels.
L'abstraction des données peut également être définie comme le processus consistant à identifier uniquement les caractéristiques requises d'un objet, en ignorant les détails non pertinents. Les propriétés et les comportements d'un objet le différencient des autres objets de type similaire et aident également à classer/regrouper l'objet.

Prenons l’exemple réel d’un homme conduisant une voiture. L'homme sait seulement qu'appuyer sur les accélérateurs augmentera la vitesse de la voiture ou que l'application des freins arrêtera la voiture, mais il ne sait pas comment, en appuyant sur l'accélérateur, la vitesse augmente réellement. Il ne connaît pas le mécanisme interne de la voiture ni la mise en œuvre des accélérateurs, des freins, etc. dans la voiture. C’est ça l’abstraction.

En Java, l'abstraction est réalisée par interfaces et cours abstraits . Nous pouvons atteindre 100 % d’abstraction en utilisant des interfaces.

La méthode abstraite contient uniquement la déclaration de méthode mais pas l'implémentation.

comment vérifier les numéros bloqués sur Android

Démonstration de la classe abstraite

caractère Java en chaîne

//abstract class abstract class GFG{  //abstract methods declaration  abstract void add();  abstract void mul();  abstract void div(); }>

Pilier 2 : Encapsulation

Il est défini comme le regroupement des données sous une seule unité. C'est le mécanisme qui lie le code et les données qu'il manipule. Une autre façon d’envisager l’encapsulation est qu’il s’agit d’un bouclier de protection qui empêche l’accès aux données par le code en dehors de ce bouclier.

• Techniquement, dans encapsulation , les variables ou les données d'une classe sont masquées de toute autre classe et ne sont accessibles que via n'importe quelle fonction membre de la classe dans laquelle elles sont déclarées.
• Dans l'encapsulation, les données d'une classe sont masquées des autres classes, ce qui est similaire à ce qui se passe. masquage de données fait. Ainsi, les termes encapsulation et masquage de données sont utilisés de manière interchangeable.
• L'encapsulation peut être réalisée en déclarant toutes les variables d'une classe comme privées et en écrivant des méthodes publiques dans la classe pour définir et obtenir les valeurs des variables.

Démonstration d'encapsulation :

//Encapsulation using private modifier  //Employee class contains private data called employee id and employee name class Employee {  private int empid;  private String ename; }>

Pilier 3 : Héritage

Héritage est un pilier important de la POO (Programmation Orientée Objet). C'est le mécanisme en Java par lequel une classe est autorisée à hériter des fonctionnalités (champs et méthodes) d'une autre classe. Nous obtenons l'héritage en utilisant s'étend mot-clé. L'héritage est également appelé est un relation.

Discutons de quelques terminologies importantes fréquemment utilisées :

• Superclasse : La classe dont les fonctionnalités sont héritées est appelée superclasse (également appelée classe de base ou classe parent).
• Sous-classe : La classe qui hérite de l’autre classe est appelée sous-classe (également appelée classe dérivée ou étendue ou classe enfant). La sous-classe peut ajouter ses propres champs et méthodes en plus des champs et méthodes de la superclasse.
• Réutilisabilité : L'héritage prend en charge le concept de réutilisabilité, c'est-à-dire que lorsque nous voulons créer une nouvelle classe et qu'il existe déjà une classe qui inclut une partie du code que nous souhaitons, nous pouvons dériver notre nouvelle classe de la classe existante. En faisant cela, nous réutilisons les champs et les méthodes de la classe existante.

Démonstration d'Héritage :

//base class or parent class or super class class A{  //parent class methods  void method1(){}  void method2(){} } //derived class or child class or base class class B extends A{ //Inherits parent class methods  //child class methods  void method3(){}  void method4(){} }>

Pilier 4 : Polymorphisme

Il fait référence à la capacité des langages de programmation orientés objet à différencier efficacement les entités portant le même nom. Ceci est réalisé par Java à l'aide de la signature et de la déclaration de ces entités. La capacité d'apparaître sous de nombreuses formes s'appelle polymorphisme .

Par exemple.

sleep(1000) //millis sleep(1000,2000) //millis,nanos>

Note: Le polymorphisme en Java est principalement de 2 types :

1. Surcharge
2. Primordial

Exemple

// Java program to Demonstrate Polymorphism // This class will contain // 3 methods with same name, // yet the program will // compile & run successfully public class Sum {  // Overloaded sum().  // This sum takes two int parameters  public int sum(int x, int y)  {  return (x + y);  }  // Overloaded sum().  // This sum takes three int parameters  public int sum(int x, int y, int z)  {  return (x + y + z);  }  // Overloaded sum().  // This sum takes two double parameters  public double sum(double x, double y)  {  return (x + y);  }  // Driver code  public static void main(String args[])  {  Sum s = new Sum();  System.out.println(s.sum(10, 20));  System.out.println(s.sum(10, 20, 30));  System.out.println(s.sum(10.5, 20.5));  } }>

30 60 31.0>

Conclusion

Le concept de programmation orientée objet (POO) en Java est un moyen puissant d'organiser et d'écrire du code. Il utilise des idées clés telles que les classes, les objets, l'héritage, le polymorphisme, l'encapsulation et l'abstraction pour créer un code flexible et réutilisable. En utilisant le concept Java POO, les programmeurs peuvent créer des applications complexes plus efficacement, rendant le code plus facile à gérer, à comprendre et à modifier. Dans l’ensemble, les concepts POO de Java aident à créer des solutions logicielles robustes et évolutives.

Concept de programmation orientée objet (POO) en Java – FAQ

Qu’est-ce que le concept de POO en Java ?

La POO (Object-Oriented Programming) est un paradigme de programmation basé sur la notion d'objets, qui peut contenir des données sous forme de champs (attributs ou propriétés) et du code sous forme de procédures (méthodes ou fonctions). En Java, les concepts de POO incluent l'encapsulation, l'héritage, le polymorphisme et l'abstraction.

Pourquoi les POO sont-elles importantes en Java ?

Les POO aident à organiser et à structurer le code de manière plus gérable, facilitant ainsi la maintenance et la mise à l'échelle des applications Java. Il favorise également la réutilisabilité, la modularité et la flexibilité du code, conduisant à un développement logiciel efficace et robuste.

Quels sont les grands principes des POO en Java ?

Les grands principes des POO en Java sont l'encapsulation, l'héritage, le polymorphisme et l'abstraction. L'encapsulation garantit que l'état interne d'un objet est masqué et accessible uniquement via des méthodes publiques. L'héritage permet à une classe d'hériter des propriétés et du comportement d'une autre. Le polymorphisme permet aux objets d'être traités comme des instances de leur classe parent. L'abstraction se concentre sur le masquage des détails de mise en œuvre et l'affichage uniquement des informations nécessaires au monde extérieur.

Comment les POO sont-elles implémentées en Java ?

En Java, la POO est implémentée via des classes et des objets. Une classe sert de modèle pour créer des objets, qui sont des instances de cette classe. Chaque objet possède son propre ensemble d'attributs (variables) et de méthodes (fonctions). En suivant les concepts de la POO tels que l'encapsulation, l'héritage, le polymorphisme et l'abstraction, les développeurs Java peuvent concevoir un code bien structuré et maintenable.

Quels sont les avantages de l’utilisation des POO en Java ?

Certains avantages de l'utilisation des POO en Java incluent la réutilisabilité du code, la modularité, la flexibilité, l'évolutivité et une maintenance plus facile. Les POO permettent aux développeurs de modéliser des entités du monde réel en tant qu'objets, conduisant à un code plus intuitif et organisé. Il prend également en charge des fonctionnalités telles que l'héritage et le polymorphisme, qui améliorent l'extensibilité et la lisibilité des applications Java.

Pouvez-vous fournir un exemple d’implémentation du concept de POO en Java ?

Bien sûr! Un exemple d'implémentation du concept de POO en Java consiste à créer une classe « Car » avec des attributs tels que « make », « model » et « year », ainsi que des méthodes telles que « start() », « accelerate() » et « stop ». ()'. En instanciant des objets de la classe « Car » et en appelant ses méthodes, nous pouvons simuler le comportement de différentes instances de voiture de manière structurée et orientée objet.