Introduction à la programmation orientée d'objet (OOP)

Share

|

La transition d'une langue de programmation procédurale (de non-OOP) à un langage de programmation orienté objectivement est une grande étape pour beaucoup de programmeurs. Il est vrai que les deux méthodes de programmation puissent finalement réaliser les mêmes buts, mais vous trouverez OOP est une manière plus ordonnée et plus rapide de programmer, il est plus approprié au travail d'équipe, et il est habituellement plus facile concevoir des programmes en utilisant l'approche orientée objectivement. Avec OOP dans Java, vous constaterez que la programmation est provocante pour commencer par, pourtant très facile et en vous récompensant très une fois maîtrisez-la.

Quel est un objet ?

Les objets sont les modules qui composent un programme. Il est difficile d'expliquer exactement ce qu'est un objet parce qu'un objet peut être quelque chose que vous voulez. Par exemple, vous pouvez créer un objet qui représente un étranger qui peut juger toute l'information liée à l'étranger et également contenir la fonctionnalité liée à lui. Vous pouvez inclure des données telles que le nombre de vies où l'étranger a et également la fonctionnalité pour affecter les données, telles que le code pour tuer l'étranger, qui pourrait enlever une des vies.

Les éléments essentiels qui composent un objet sont des variables et des méthodes. Les variables sont des membres de données, ou des attributs, qui contiennent des données concernant l'objet, tel qu'une corde des textes ou une valeur numérique. Les méthodes fournissent la fonctionnalité de l'objet et peuvent être employées pour agir l'un sur l'autre avec les attributs. Des méthodes sont également connues comme fonctions ou procédures dans de divers autres langages de programmation.

Programmation Objet-Orientée dans Java
La langue de Java est complètement objet orienté. Ceci signifie qu'il n'y a aucun rapport global quelque (bien que des membres statiques peuvent être conçus comme étant légèrement global.we discutera les membres statiques plus tard). Tous les attributs ou méthodes doivent être définis en tant qu'élément d'une classe ou d'une interface.

Une classe dans Java est employée pour définir la structure d'un objet. Une classe peut être décomposée en trois parts principales : constructeurs, attributs (propriétés), et méthodes.

Maintenant regardons un exemple d'une structure de classe très simple contenant ces trois pièces avant que nous allions plus loin. Un exemple d'une classe pourrait être une personne, qui pourrait décrire les attributs et les méthodes qu'une personne pourrait avoir associés à eux. Un objet peut alors être créé de la classe de personne, comme vous ou moi, ou même de votre associé (si vous n'avez pas un associé, jaillissent alors fait ; vous êtes un programmeur vrai).

Afin de créer un objet, nous devons d'abord créer une classe. Ne vous inquiétez de compiler aucun de ce code en ce moment ; reposez-vous juste en arrière, saisissez un café, et l'essai pour comprendre quelques fondations.

Voici le commencement de notre classe de "personne" :

personne de classe {}

Maintenant, au moment où, nous avons le code d'ensemble pour une classe de personne. D'abord nous devrions ajouter quelques attributs. Ajoutons un attribut numérique à la classe pour stocker l'âge d'une personne.

classez la personne {âge interne ; }

Les stands internes de mot-clé pour le nombre entier, représentant un type de données numérique. En ce moment, la classe de personne est tous les attributs et aucune fonctionnalité (se dirigeant clairement à une carrière dans la politique). Nous pouvons ajouter une méthode à la classe comme suit, qui peut être employée pour changer la valeur dans l'âge :

classez la personne {newAge vide de setAge(int de public) 
{// ensemble que l'âge à la valeur entreposé dans l'âge de newAge 
= le newAge ; } âge interne ; }

Maintenant nous avons une classe appelée Person, contenant un setAge appelé par méthode et un âge appelé par attribut. Le setAge de méthode peut être employé pour assigner une nouvelle valeur à l'âge de la personne. Encore, ne vous inquiétez pas trop de la façon dont les méthodes fonctionnent pour l'instant ; votre café devrait juste être assez frais pour boire environ maintenant.

Afin de créer un objet (ou un exemple, pendant qu'on le connaît également) de la classe de personne, un constructeur doit être appelé. Toutes les classes contiennent un constructeur de défaut, qui ne fait rien et peut être surchargé avec beaucoup de types de constructeur, car nous verrons.

Constructeurs

Le constructeur est une méthode qui s'appelle quand l'objet est créé et employé pour initialiser l'état de l'objet. Le constructeur doit être déclaré avec le même nom comme la classe dans laquelle elle est contenue et ne peut pas avoir une valeur de retour. Nous ajouterons maintenant deux constructeurs à la classe de personne :

classez la personne {newAge public public de Person() {// 
âge de base de constructeur est placé à 0 par défaut} Person(int) 
{// contructor qui place l'âge à un setAge(newAge) indiqué de 
valeur ; } newAge vide de setAge(int de public) {// ensemble 
l'âge à la valeur stockée dans l'âge de newAge = le newAge ; 
} âge interne ; }

Vous pouvez déclarer une référence à un objet de personne comme suit :

BillyGate de personne ;
Au moment où, vous avez une référence à un objet du type personne, qui actuellement ne met en référence aucun objet. Les membres de l'objet ne peuvent pas être consultés, comme l'âge d'attribut, parce qu'aucun objet n'a été créé. Notez que le billyGate variable de référence est réellement égal à la nulle en ce moment.

Un appel à un constructeur doit être fait pour créer un nouvel objet de type personne, assignant le billyGate variable pour mettre en référence le nouvel objet.

Si aucun constructeur n'est déclaré pour une classe, un constructeur de défaut est disponible que des prises aucuns paramètres et crée simplement un objet de défaut de la classe une fois appelé. Dans notre extrait de code nous avons créé notre propre constructeur Person() de défaut, qui ne contient aucun code, et un deuxième constructeur a également appelé le newAge de Person(int), qui contient le code qui place l'âge de valeur chez la personne que l'objet à un nouvel âge a indiquée par une valeur de paramètre.

Notez nous a eus a seulement déclaré le deuxième constructeur et a omis le premier constructeur, là ne serait plus un constructeur de défaut disponible qui ne prend aucun paramètre, car le constructeur de défaut existe seulement si la classe ne contient aucun constructeur défini pour l'utilisateur.

Pour créer un objet de la classe de personne, nous pourrions employer la ligne suivante du code :

//employant le deuxième constructeur, a placé la valeur 
d'âge au billyGate de 21 personnes = nouveau Person(21) ;

Cette ligne de code déclare une marque appelée le billyGate du type personne et crée un "nouvel" objet de personne en utilisant le deuxième constructeur dans la classe de personne pour initialiser l'objet, plaçant la valeur d'âge dans le nouvel objet de personne à 21.

Nous pourrions également employer le code suivant à la place, cette fois en utilisant le premier constructeur (de défaut) pour initialiser l'objet et puis pour placer la valeur de l'âge en utilisant la méthode de setAge, qui est un membre de l'objet nouvellement créé.

//premier billyGate de personne constructeur d'utilisation
= nouveau Person() ; //membre setAge d'utilisation pour placer 
l'âge à 21 billyGate.setAge(21) ; //ensemble la valeur de 
l'âge à 21

Nous pouvons également accéder à l'âge variable et réglé sa valeur directement, comme suit :

billyGate.age = 21 ;

Note vous ne pouvez pas avoir deux constructeurs avec la même signature.

Jusqu'ici nous avons vu l'instantiation, qui est le terme employé pour décrire la création d'un objet ou d'un exemple d'une classe. Le diagramme suivant vous aidera si tout va bien à comprendre ceci mieux, comme il montre le rapport entre la classe de personne et les objets créés de lui.

Un membre d'objet est un membre qui est créé quand l'objet est créé. Ceci signifie qu'il peut seulement être consulté une fois que l'objet a été créé parce qu'autrement il n'existe pas. L'exemple que nous avons juste vu crée un exemple de la personne de classe référencée par le billyGate. Nous pourrions avoir également créé beaucoup plus d'exemples de la classe de personne. Supposez que nous avons dit que l'objet de billyGate était la seule personne que nous jamais devrions ou voudrions créer ; alors nous pourrions ferrailler la classe de personne tout à fait et créer simplement une nouvelle classe a appelé BillyGate à la place.

classez BillyGate {newAge vide statique public de 
setAge(int) {// ensemble que l'âge à la valeur entreposé dans 
l'âge de newAge = le newAge ; } âge statique interne ; 
}

Notez que nous avons enlevé les constructeurs et avons ajouté le mot-clé statique aux deux membres définis. C'est parce que nous ne devons plus créer un exemple de cette classe. Nous pouvons juste accéder aux membres statiques en utilisant le nom de classe. Par exemple :

BillyGate.setAge(21) ;

Ces membres statiques sont connus comme membres de classe, tandis qu'avant que nous ayons eu des membres d'objet.

Les exemples que nous avons employés jusqu'ici contiennent seulement des membres d'objet ou des membres de classe ; vous pouvez naturellement employer tous les deux. Laissez-nous de retour à notre classe de personne maintenant et ajoutez un attribut statique. L'attribut statique doit être quelque chose qui va être le même pour toute la personne objecte que nous créons. Ainsi nous pourrions ajouter une variable de nombre entier appelée daysInAYear.

personne de classe {// code comme avant daysInAYear 
interne statique ; }

Nous pouvons accéder à l'attribut daysInAYear avant que nous créions tous les objets de la classe de personne. Par exemple :

Person.daysInAYear = 365 ;

Si nous créons de nouveaux exemples de personne, alors ils aussi peuvent accéder au daysInAYear variable statique.

Person(21) glennMurphy = nouveau de personne ; 
AndrewMulholland de personne = nouveau Person(20) ; 
glennMurphy.daysInAYear = 366 ; //c'est une année 
bissextile System.out.println(andrewMullholland.daysInAYear) ;

Ce code créera deux nouveaux exemples de personne, référencés par glennMurphy et l'andrewMulholland. L'objet glennMurphy place alors le daysInAYear variable statique à 366, et l'objet d'andrewMulholland accédera à daysInAYear, imprimant sa valeur à la fenêtre de console. Le nombre qui sera imprimé à la fenêtre de console est 366, qui signifie cela daysInAYear n'appartient pas à n'importe lequel de ces seuls objets ; il appartient à tous, et les changements faits à partir d'un affectent l'autre. Il y a seulement une part de mémoire contenant la valeur 366 à laquelle ils tous se réfèrent. En bref, c'est le même attribut cependant qu'il est consulté.

Références

Pour accéder à des objets (rappelez-vous qu'ils sont des exemples des classes) dans Java, nous employons ce qui sont connus comme références. Nous avons employé trois références jusqu'ici dans nos exemples de code : billyGate, glennMurphy, et andrewMulholland. Ce n'étaient pas les objets réels que nous avons créés mais mettent en référence simplement (également connu en tant que poignées) aux objets créés. Prenez le code suivant par exemple :

andrewMulholland = glennMurphy ; //il ne sera jamais
mon égale

Ce code fait simplement l'andrewMulholland mettre en référence le même objet qui des références glennMurphy ; par conséquent vous pourriez alors accéder au même objet en utilisant l'une ou l'autre des deux références.

L'objet avec l'âge égal à 20 que l'andrewMulholland une fois référencé est maintenant perdu, mais ne s'inquiètent pas de libérer la mémoire ; ceci est pris en compte par le collecteur des ordures de Java.