Menu

OOP Java: Introduction à la programmation orientée objet en Java

  • Principal
  • Autre
  • OOP Java: Introduction à la programmation orientée objet en Java

oop java introduction object oriented programming java

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel vidéo présentera les concepts de POO (programmation orientée objet) en Java tels que l'objet, la classe, l'héritage, le polymorphisme, l'abstraction, l'encapsulation, etc.:

En programmation logicielle, nous avons différents types de langages de programmation. Les principaux langages parmi eux sont de nature procédurale ou orientée objet.

Dans les langages de programmation procédurale, les plus gros problèmes sont décomposés en petits problèmes résolubles. Ces petits problèmes sont convertis en procédures ou en fonctions. De cette façon, le langage de programmation procédurale met l'accent sur les fonctions plutôt que sur les données. Ainsi, les langages procéduraux ont complètement négligé les données et ne garantissent donc pas du tout la sécurité des données.

Ce problème a été résolu par le langage de programmation orienté objet. La programmation orientée objet est une façon de concevoir et de programmer un logiciel en manipulant des objets et les objets sont la partie principale de la programmation.

Découvrez toute notre série de tutoriels Java pour les débutants Ici .

Concept OOPS en Java

Ce que vous apprendrez:

Tutoriels vidéo sur les concepts OOPS

Concept OOPS en Java - Partie 1:

Examen approfondi du concept OOPS en Java - Partie 2:

Les langages de programmation orientés objet mettent davantage l'accent sur les données que sur les fonctions. La programmation orientée objet (POO) tourne autour d'objets, c'est-à-dire une entité en temps réel.

Cet objet regroupe les données et les méthodes qui opèrent sur ces données dans une seule unité. De cette façon, les données sont protégées du monde extérieur en ayant les méthodes à l'intérieur de l'objet. En POO, les objets communiquent entre eux via des messages.

Tout langage POO prend en charge les fonctionnalités suivantes:

  • Des classes
  • Encapsulation
  • Abstraction
  • Héritage
  • Polymorphisme

Toutes ces fonctionnalités garantissent que les données sont sécurisées et en même temps, nous pouvons également écrire des applications robustes. Smalltalk, C ++, Java, etc. sont quelques-uns des langages de programmation orientés objet.

Dans ce tutoriel, nous aborderons les bases de la POO concernant le langage Java.

Programmation orientée objet (POO) en Java

Java est actuellement la compétence de programmation la plus recherchée. En Java, tout est basé sur l'objet. Java a une classe racine appelée Object à partir de laquelle toutes les fonctionnalités de Java sont dérivées. Ainsi dans ce tutoriel, nous aborderons les principales fonctionnalités de la POO concernant Java.

Lecture recommandée => Questions et réponses d'entrevue POO

Ici, nous allons discuter de la manière dont Java prend en charge les fonctionnalités POO suivantes.

  • Objet et classe
  • Classer
  • Héritage
  • Polymorphisme
  • Abstraction
  • Encapsulation

Décrivons en détail chacun de ces concepts Java POO.

Objet et classe

Une classe peut être définie comme un prototype de conception ou un plan. Les objets sont créés à partir de ces plans. Il définit essentiellement un type commun constitué de propriétés et de méthodes qui opèrent sur ces propriétés pour ce type commun. Ensuite, nous définissons les instances de cette classe appelées objets.

Une classe comporte de nombreux composants, comme illustré dans la figure suivante.

Objet et classe - Composants

Un objet représente une entité réelle. En Java, un objet est une instance d'une classe. Ainsi, une classe qui est un plan peut être utilisée pour créer de nombreux objets. Ces objets communiquent souvent les uns avec les autres en se transmettant des messages via des méthodes.

Tutoriel vidéo: classes et objets

Un objet a généralement:

  1. Un état: Les propriétés ou attributs d'un objet à un moment donné.
  2. Comportement: Les méthodes représentent le comportement d'un objet. Les méthodes définissent également la manière dont les objets communiquent.
  3. Identité: Identifie l'objet en lui donnant un nom unique.

Par exemple, si nous avons une classe PetAnimals.

Ensuite, nous pouvons définir un objet de cette classe comme suit:

PetAnimals pig = nouveau PetAnimals.

Ici, l'identité de l'objet est un cochon.

Ci-dessous est un programme qui montre la classe et l'objet.

//student class class Student{ int roll_No; String student_name; } class Main{ public static void main(String args()){ //Create objects of class Student Student student1=new Student(); Student student2=new Student(); //Initialize Student class objects student1.roll_No=101; student1.student_name='Lisa'; student2.roll_No=102; student2.student_name='Dan'; //Print object data System.out.println('Student 1 Details: ' + student1.roll_No+' '+student1.student_name); System.out.println('Student 2 Details: ' + student2.roll_No+' '+student2.student_name); } }

Production

sortie - Objet et classe

Dans la classe ci-dessus, nous avons défini une classe Student avec deux propriétés roll_No et student_name. Ensuite, dans la méthode principale, nous déclarons deux objets de classe, à savoir étudiant1 et étudiant2. Notez que ces objets sont créés à l'aide d'un nouvel opérateur. Une fois les objets créés, nous attribuons des données aux deux propriétés de l'objet.

Enfin, nous imprimons le contenu de l’objet à l’aide de l’opérateur ‘.’ (Point).

Nous en apprendrons plus sur les classes et les objets dans nos rubriques spécifiques des didacticiels POO.

Héritage

L'héritage est l'une des caractéristiques les plus importantes de la POO. Grâce à l'héritage, Java favorise la réutilisabilité du code.

Alors, qu'est-ce qu'un héritage en Java?

L'héritage est un mécanisme en Java dans lequel une classe peut hériter des propriétés d'une autre classe. Les propriétés qui peuvent être héritées incluent les membres de données et les méthodes de la classe.

La classe qui hérite des propriétés d'une autre classe est appelée la sous-classe. La classe héritée est connue sous le nom de classe «super» en Java.

En héritant de la classe, la sous-classe non seulement hérite des propriétés mais réutilise également le code car le programmeur n'a pas besoin d'écrire à nouveau le code lorsqu'il peut en hériter directement en utilisant l'héritage.

En Java, l'héritage est obtenu en utilisant le mot-clé «extend». Ce mot-clé extend est utilisé dans la définition de la classe et est suivi du nom de classe qui doit être hérité.

Par exemple,s'il y a deux classes, A et B, et A doit être hérité par B alors cet héritage est écrit en Java comme:

class B extends A { …… }

Comme déjà mentionné, ici A est la superclasse ou la classe de base ou la classe parente. B est une sous-classe, une classe dérivée ou une classe enfant.

L'héritage est divisé selon les types suivants.

Héritage - Types

Java prend en charge l'héritage unique, multi-niveaux et hiérarchique.

Notez que Java ne prend pas en charge les héritages multiples. Java ne prend pas non plus en charge l'héritage hybride, qui est une combinaison d'héritages multiples et hiérarchiques.

Vous trouverez ci-dessous un exemple de programme d'héritage unique en Java.

//base class class Employee{ float salary=50000; } //derived class class Developer extends Employee{ int bonus=20000; } class Main{ public static void main(String args()){ //declare Developer class object and access properties of base and derived class Developer p=new Developer(); System.out.println('Inheritance in Java'); System.out.println('Developer salary: '+p.salary); System.out.println('Bonus declared for Developer: '+p.bonus); System.out.println('Developer Total Earnings: ' + (p.salary + p.bonus)); } }

Production

sortie - Héritage en Java

Dans le programme ci-dessus, nous avons un employé de classe de base. Nous avons une autre classe Developer qui hérite de la classe Employee. Dans la méthode principale, nous pouvons voir qu'en déclarant un objet de la classe Developer, nous pouvons accéder non seulement aux propriétés de la classe Developer, mais également à la classe Employee telle qu'elle est héritée par la classe Developer.

Polymorphisme

Le polymorphisme est encore une autre caractéristique importante de la POO. Le polymorphisme est la capacité du langage à permettre aux objets ou aux entités de prendre plusieurs formes. Par exemple, une méthode qui a diverses implémentations est polymorphe en Java.

Le polymorphisme est de deux types en Java:

  • Surcharge ou polymorphisme au moment de la compilation: Dans le polymorphisme à la compilation, l'appel à la méthode polymorphe ou surchargée est résolu au moment de la compilation.
  • Polymorphisme de remplacement ou d'exécution: Dans le polymorphisme d'exécution, l'appel à une méthode remplacée dans le programme Java est résolu au moment de l'exécution.

Nous aborderons le polymorphisme en détail dans nos prochains tutoriels.

Vous trouverez ci-dessous un exemple de polymorphisme à la compilation en Java dans lequel nous avons une méthode add qui est surchargée pour effectuer une addition avec différents types d'opérandes.

class Numbers_Sum { //add method : takes two int parameters public int add(int val1, int val2) { return (val1 + val2); } // overloaded add : takes three int parameters public int add(int val1, int val2, int val3) { return (val1 + val2 + val3); } //overloaded add: takes two double parameters public double add(double val1, double val2) { return (val1 + val2); } } class Main{ public static void main(String args()) { //create an object of Numbers_Sum class and call overloaded functions Numbers_Sum numsum = new Numbers_Sum(); System.out.println('Polymorphism in Java'); System.out.println('add(int, int): ' + numsum.add(15, 18)); System.out.println('add(int, int, int): ' + numsum.add(5, 10, 20)); System.out.println('add(double,double): ' + numsum.add(5.5, 15.5)); } }

Production

sortie 3

Dans ce programme, nous avons trois méthodes surchargées nommées add. La première méthode prend deux paramètres int, la méthode suivante prend trois paramètres int et la troisième méthode prend deux paramètres doubles. En fonction du nombre de paramètres, l'appel de méthode est résolu au moment de la compilation et l'appel approprié est effectué.

Abstraction

En utilisant l'abstraction des données, nous exposons uniquement les parties essentielles de l'application qui sont rendues accessibles à l'utilisateur. Par exemple, si nous avons une voiture, nous ne sommes pas préoccupés par les composants internes de la voiture, mais nous ne considérons que la voiture dans son ensemble.

En utilisant un mécanisme d'abstraction de données, nous identifions uniquement les détails nécessaires et ignorons les détails non pertinents. Java utilise des classes abstraites et des interfaces pour réaliser l'abstraction. Les interfaces sont 100% abstraites car elles n'ont que des prototypes de méthodes et non leur définition.

L'exemple ci-dessous montre une classe abstraite et son utilisation.

// Abstract class declaration abstract class PetAnimal { // Abstract method: should be defined in derived class public abstract void animalSound(); // non-abstract method public void print() { System.out.println('This method is example of abstraction'); } } // Derived class class Dog extends PetAnimal { //abstract method defined here public void animalSound() { System.out.println('The doggy barks'); } } class Main { public static void main(String() args) { Dog doggy = new Dog(); // Instantiate derived class and call methods doggy.animalSound(); doggy.print(); } }

Production

sortie - Abstraction en Java

Dans le programme ci-dessus, nous avons une classe abstraite PetAnimals. En cela, nous avons une méthode abstraite «animalSound». Ensuite, nous créons une classe Dog et héritons de la classe PetAnimals. Dans la classe Dog, nous remplaçons la méthode animalSound.

combien de types de fichiers existe-t-il? python

Encapsulation

L'encapsulation cache des données ou protège les données. En programmation, nous réalisons l'encapsulation en enveloppant les données et les méthodes opérant sur ces données sous une seule unité.

Tutoriel vidéo: Encapsulation et polymorphisme en Java

Une classe peut être considérée comme une unité d'encapsulation, c'est-à-dire que nous avons des éléments de données et des méthodes opérant sur ces éléments de données regroupés dans une seule unité.

Une encapsulation appropriée peut être obtenue en rendant les membres des données privés et en faisant en sorte que les méthodes opérant sur ces données soient publiques afin que les données soient complètement protégées des entités extérieures.

Le programme Java ci-dessous illustre le concept d'encapsulation.

class Customer_Account { //private data of class private long customer_accountNo; private String customer_name,customer_email; private float customer_salary; //public getter/setter methods to access private data public long getAcc_no() { return customer_accountNo; } public void setAcc_no(long acc_no) { this.customer_accountNo = acc_no; } public String getName() { return customer_name; } public void setName(String name) { this.customer_name = name; } public String getEmail() { return customer_email; } public void setEmail(String email) { this.customer_email = email; } public float getSalary() { return customer_salary; } public void setSalary(float salary) { this.customer_salary = salary; } } public class Main { public static void main(String() args) { //create an object of customer_Account class Customer_Account acc=new Customer_Account(); //use setter methods to set values acc.setAcc_no(123458765432L); acc.setName('SoftwareTestingHelp'); acc.setEmail('sth@sth.com'); acc.setSalary(65000f); //use getter methods to read values System.out.println('Customer Account Number: ' + acc.getAcc_no()); System.out.println('Customer Account Details:'); System.out.println(' Customer Name: '+acc.getName()+' '+ ' Customer Email: ' + acc.getEmail()+' ' + ' Customer Salary: ' +acc.getSalary()); } }

Production

sortie - Encapsulation en Java

Dans le programme ci-dessus, nous avons une classe Customer_Account.

Dans cette classe, nous avons des membres de données qui sont tous privés. Ensuite, pour chaque champ privé, nous fournissons des méthodes getter et setter pour lire et définir des valeurs respectivement. Ces getters et setters sont publics. De cette façon, nous protégeons les champs de données en ne leur permettant aucun accès depuis l'extérieur de la classe directement.

Ils ne sont accessibles que via les getters et les setters. Cela démontre l'encapsulation que nous avons décrite ci-dessus.

Questions fréquemment posées

Q # 1) Qu'entend-on par programmation orientée objet?

Répondre: La programmation orientée objet (POO) est un paradigme logiciel qui tourne autour des données. En POO, l'accent est mis sur les données et donc les problèmes sont exprimés en termes d'objets qui sont des entités constituées de données ou de champs et de méthodes qui opèrent sur ces champs de données.

Ce faisant, plusieurs caractéristiques distinctives de la POO telles que l'héritage, le polymorphisme, l'abstraction et l'encapsulation sont appliquées pour assurer la sécurité des données, la réutilisabilité, etc.

Q # 2) Quels sont les 4 principes de base de la POO?

Répondre:La programmation orientée objet (POO) repose sur quatre principes de base:

  • Héritage
  • Polymorphisme
  • Abstraction
  • Encapsulation

Ils sont également appelés quatre piliers de la POO.

Q # 3) Pourquoi Java s'appelle-t-il orienté objet?

Répondre: Java a un objet de classe racine duquel nous dérivons toutes les autres fonctionnalités de Java. Ainsi sans classe et objet, nous ne pouvons pas avoir de programme Java. Par conséquent, Java est appelé langage OOP.

Q # 4) Java est-il purement orienté objet?

Répondre: Non, Java n'est pas un pur langage orienté objet. Comme Java fournit également des types de données primitifs tels que int, char, float, double, long, etc., il n'est pas classé comme un pur langage POO.

Q # 5) Quelle est la différence entre C ++ et Java?

Répondre: C ++ et Java sont des langages orientés objet et prennent en charge les fonctionnalités POO. Mais C ++ est un langage compilé. Java, quant à lui, est compilé ainsi qu'un langage interprété.

L'interpréteur Java exécute le code d'octet au moment de l'exécution et génère une sortie qui le rend indépendant de la plate-forme. Cependant, C ++ dépend de la plate-forme.

En savoir plus sur le concept OOPS

Classer

La classe est un plan / prototype d'un objet du monde réel et modélise l'état et le comportement de cet objet du monde réel.

Déclaration de classe

class MyClass { // field, constructor, and // method declarations } Class room(){ //room should have dimension. Dimension is attribute. //in the room, we are going keep things. Keeping is the function we are going to do. Keepthings (); this is a method in java. }

Déclaration de classe

Objet

Les objets logiciels sont comme des objets réels avec un état et un comportement. L'état sera stocké sous forme de champ et exposera son comportement en tant que méthodes.

Ici, la pièce est comme la conception générale. Dans cette pièce, vous devez concevoir un salon, une cuisine, une chambre.

Class CookingRoom(){ Dimension is attribute. //here we should have method to keep cooking things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold cooking items. } cooking(); } Class LivingRoom(){ Dimension is attribute. //here we should have method to keep Living Room things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold living room items(like tv etc). } watching tv(); }

Ici, la méthode «Keepthings ()» devrait faire les fonctionnalités de base requises pour la pièce et elle devrait avoir des spécifications supplémentaires selon les exigences de la classe «living room» et «cooking room». Les deux classes doivent donc hériter des méthodes de la classe «room».

objet

Héritage

Le comportement (méthodes) et l'état d'une classe hérités de l'autre classe sont appelés héritage. Les méthodes et l'état sont hérités de la classe parent vers la classe enfant.

Alors,

Class CookingRoom extends Room{ } Class LivingRoom extends Room{ }

Polymorphisme

En biologie, le polymorphisme fait référence aux épices qui peuvent avoir de nombreuses formes différentes.

Avec le même concept dans la programmation orientée objet, la classe enfant peut hériter de ses méthodes de classe parent, elle peut également ajouter des fonctionnalités uniques à ce comportement. Le polymorphisme peut être obtenu par surcharge ou substitution de méthode.

Surcharge

public class OverloadDemo { public int add( int a,int b) { int rs=a+b; return rs; } public int add( int a,int b,int c) { int rs=a+b+c; return rs; } public static void main(String() args) { OverloadDemo ov=new OverloadDemo(); System.out.println(ov.add(23,56,45)); System.out.println(ov.add(23,56)); } }

surcharge

Primordial

public class Bicycle { int wheels=2; String seat; public void riding() { System.out.println('bicycle is used for riding'); } }

écrasant1

public class RoadBicycle extends Bicycle{ public void riding() { System.out.println('RoadBicycle is used for road riding'); } }

écrasant2

public class TestBicycle { public static void main(String() args) { Bicycle b=new RoadBicycle(); b.riding(); } }

vélo d

PRODUCTION: Ici, la méthode de classe enfant remplace la méthode de classe parent.

sortie - remplacement

Super mot-clé

Le mot clé Super est une variable de référence qui est utilisée pour faire référence à l'objet de classe parent immédiat. Avec super mot-clé, vous pouvez faire référence à la méthode de classe parent ou aux variables ou au constructeur.

Ce mot-clé

Ce mot-clé est utilisé pour faire référence à l'objet de classe actuel. À l'aide de ce mot-clé, vous pouvez accéder à la variable d'instance de classe actuelle ou à la méthode de classe actuelle. Cela peut être passé comme argument dans l'appel de méthode.

public class DemoThisKeyword { private int accno; private int balance; public void setvalues(int accno,int balance) { this.accno=accno; this.balance=balance; } public int showdata() { System.out.println(accno); System.out.println(balance); return balance; } public static void main(String() args) { // TODO Auto-generated method stub DemoThisKeyword obj =new DemoThisKeyword(); obj.setvalues(11, 100); obj.showdata(); System.out.println(obj.showdata()); } }

ce mot-clé

Constructeur

Les constructeurs Java sont comme des méthodes qui seront appelées lorsque l'objet est créé pour la classe. Le constructeur doit avoir le même nom que la classe.

Class Myclass{ Myclass(); Method1() { } }

constructeur

Lors de la création d'un objet pour la classe, Myclass myobj = new Myclass ();

La méthode constructeur sera appelée. Le constructeur est automatiquement créé par le compilateur Java pour toutes les classes par défaut.

public class ConstructorExampleProgram { int employee_age; String employee_name; int employee_salary; //Default constructor ConstructorExampleProgram(){ this.employee_name=Bob'; this.employee_age=30; this.employee_salary=7000; } //Parameterized constructor ConstructorExampleProgram(String n,int a,int b){ this.employee_name=n; this.employee_age=a; this.employee_salary=b; } public static void main(String args()){ ConstructorExampleProgram obj1 = new ConstructorExampleProgram(); ConstructorExampleProgram obj2 = new ConstructorExampleProgram('clare', 56,7500); System.out.println(obj1.employee_name+' '+obj1.employee_age+' '+obj1.employee_salary); System.out.println(obj2.employee_name+' '+obj2.employee_age+' '+obj2.employee_salary); } }

Exemple de programme constructeur

Règles à suivre pour le constructeur:

  • Le constructeur doit avoir le même nom que le nom de la classe.
  • Le constructeur ne doit pas avoir d'instruction return.

Points à noter:

  • Dans la programmation orientée objet, les objets sont la partie principale de la programmation.
  • Les concepts de POO sont objet, classe, héritage, polymorphisme, constructeur.
  • super mot-clé utilisé pour faire référence aux membres de la classe parents, et cette Le mot clé est utilisé pour faire référence à un objet de classe courant.
  • Les constructeurs sont comme des méthodes qui seront appelées lorsque l'objet est créé pour la classe.

Conclusion

Ce didacticiel a couvert les bases des fonctionnalités orientées objet importantes prises en charge par Java. Ceci est juste un tutoriel d'introduction sur OOPS en Java. Nous couvrirons tous les sujets en détail dans nos tutoriels ultérieurs. Java prend en charge quatre piliers de la POO, à savoir le polymorphisme, l'héritage, l'abstraction et l'encapsulation.

En dehors de ces fonctionnalités, Java prend également en charge les autres fonctionnalités et constructions POO telles que le confinement, l'agrégation, le passage de messages, etc. qui seront abordés dans nos prochains tutoriels.

lecture recommandée

^