un objet est un module qui a l'état et le comportement. L'état d'un objet est contenu dans les variables de membre et le comportement est mis en application par ses méthodes. Les programmes de Java que vous écrivez créeront beaucoup de différents objets par le calibre, ces calibres sont connus comme classes. Les objets créés agissent l'un sur l'autre les uns avec les autres en envoyant des messages. En raison de messag, la méthode est invocated qui effectuera une certaine action ou elle peut également modifier l'état d'objet qui reçoit le message. Par des ces l'interaction des objets, votre code de Java peut mettre en application une interface utilisateur graphique, courir des animations, ou peut également envoyer et recevoir l'information au-dessus du réseau. Une fois que l'objet termine les travaux qu'il a été créé pour, il est détruit et toutes ressources assignées à lui sont réutilisées pour l'usage, par quelques autres objets.

Une classe est un calibre qui peut être employé pour créer beaucoup d'objets. L'exécution de classe comporte de deux composants : déclaration de classe et corps de classe.

La déclaration de classe, déclare le nom d'une classe avec quelques autres attributs comme les superclass de la classe, et si la classe est finale, public, ou abstrait. La déclaration de classe devrait contenir le mot-clé de classe et le nom de la classe que vous définissez. Par conséquent la déclaration minimum de classe ressemblera à ceci :

Le corps de classe suit la déclaration de classe et est toujours enfoncé dans les croisillons bouclés {et} suivant les indications de l'exemple ci-dessus. Le corps de classe contient des déclarations pour les variables qui sont des membres de la classe, des déclarations de méthodes et des implemenatations de la classe. Nous discuterons maintenant deux méthodes spéciales que vous pouvez déclarer dans un corps de classe : Les constructeurs et mènent () la méthode à bonne fin.

Ce sont certaines des règles sur des constructeurs :

• « privé » utilisé par mot-clé privé de constructeurs () -, personne instantiate de bidon la classe comme objet. Mais peut encore exposer des méthodes statiques publiques, et ces méthodes peuvent construire l'objet et le renvoyer, mais personne d'autre peuvent faire ceci.
• les constructeurs de paquet () - aucune de elles en dehors de votre paquet peuvent construire un exemple avec de votre classe. C'est utile quand vous voulez avoir des classes en votre paquet qui peut faire de nouveaux yourClass () et ne veut pas a laissé autrement n'importe qui faire ceci.
• le mot-clé protégé de constructeurs () - a employé « protégé » seulement les sous-classes de votre classe peut se servir de ce paquet.
• le « public » utilisé par mot-clé public de constructeurs () - le constructeur générique emploiera ces derniers.

Un objet maintient son état par les variables définies dans cette classe. Ces variables sont connues comme variables de membre. Tout en déclarant les variables de membre pour la classe, vous pouvez indiquer une foule de différents « attributs » au sujet de ces variables : son nom, son type, autorisation d'accès lui a assigné, et ainsi de suite.
La déclaration variable de membre ressemble à ceci :

Les mots indiqués à l'intérieur de la parenthèse définit les aspects suivants des variables :

• accessSpecifier définit cela que toutes autres classes ont accès à la variable de tahat
• la charge statique indique que la variable avouée est variable de membre de classe par opposition aux variables de membre d'exemple.
• la finale indique que la variable est constante.
• les variables passagères ne sont pas une partie de l'état persistant de l'objet.
• le moyen volatil la variable est modifié asynchronously.

Dans Java nous définissons des méthodes dans le corps d'une classe pour laquelle il met en application le comportement. Nous déclarons habituellement des méthodes après ses variables dans le corps de classe bien que non requis. Semblable à l'exécution de classe, une exécution de méthode se compose également de deux parts : déclaration de méthode et corps de méthode.

Au minimum, le composant de déclaration de méthode a un type de retour qui indique le type de données de valeur retourné par la méthode, et le nom de la méthode.

Cosider par exemple, le code suivant déclare une méthode simple appelée isEmpty () dans la classe de pile qui renvoie la valeur booléenne (vrai ou faux).

La déclaration de méthode montrée dans l'exemple ci-dessus est très de base. Les méthodes ont beaucoup d'autres attributs comme le contrôle d'accès, arguments et ainsi de suite. Cette section couvrira ces matières.

Dans le corps de méthode que toute action d'une méthode a lieu, le corps de méthode contient toutes les instructions légales de Java qui applique la méthode. Par exemple, voici une classe de pile avec l'exécution pour () la méthode isEmpty.

Dans le corps de méthode, vous pouvez faire l'utilisation « ceci » de se référer l'objet courant.

En tant que d'autres langages de programmation orientés objectivement dans Java, une classe peut être dérivée de l'autre classe. Par exemple, vous supposer hav une classe appelée MouseEvent qui représente l'événement quand l'utilisateur appuie sur le bouton de souris dans l'environnement de fenêtre de GUI. Plus tard, alors que l'application se développante, vous se rendent compte que vous avez besoin d'une classe pour représenter l'événement quand pression d'utilisateur une clef sur le clavier. Vous pouvez écrire la classe de KeyboardEvent à partir de zéro, mais puisque MouseEvent et les classes de KeyboardEvent partagent certains états et comportements comme lesquels le bouton ou la clef de souris a été serré, le temps que l'événement s'est produit, et ainsi de suite, nous peut aller pour reproduire la classe de MouseEvent plutôt que de réinventer la roue, vous pouvez profiter de subclassing et de transmission. .and ainsi vous créez un événement de classe dont MouseEvent et KeyboardEvent peuvent être dérivent

L'événement est maintenant des superclass des classes de MouseEvent et de KeyboardEvent. MouseEvent et KeyboardEvent s'appellent maintenant les sous-classes de l'événement de classe. L'événement contient tous états et comportement qui sont communs aux événements de souris et aux événements de clavier. Les sous-classes, MouseEvent et KeyboardEvent, héritent de l'état et du comportement des superclass. Considérer par exemple, MouseEvent et KeyboardEvent tous les deux hérite de l'attribut de timbre de temps de l'événement superbe de classe.

Vous déclarez qu'une classe est sous-classe d'une autre classe dans la déclaration de classe. Supposer que vous avez voulu créer une sous-classe appelée « ImaginaryNumber » de la « classe de nombre ». (où la classe de nombre est une partie de paquet de java.lang et est classe basse pour des flotteurs, des nombres entiers et d'autres nombres.). Vous pouvez maintenant écrire :

Cette ligne déclare ImaginaryNumber comme sous-classe de classe de nombre

Java nous permet de déclarer notre classe en tant que finale ; c'est-à-dire, la classe avouée comme finale ne peut pas être subclassed. Il y a deux raisons pour lesquelles on veut faire ceci : but de sécurité et de conception.

• Sécurité : Pour renverser des systèmes, un des intrus de mécanisme emploient est, crée des sous-classes d'une classe et substitue leur classe à l'original. La sous-classe regarde mêmes que la classe originale mais elle exécutera des choses énormément différentes, endommageant ou entrant dans l'information privée probablement. Pour empêcher cette subversion, vous devriez déclarer votre classe comme finale et empêcher les sous-classes l'unes des d'être créé.
• Conception : Une autre raison nous de déclarer une classe comme finale est raison orientée objectivement de conception. Quand nous estimons que notre classe est « perfectionner » et ne pas devoir avoir des sous-classes plus loin. Nous pouvons déclarer notre classe en tant que finale.

Pour indiquer que la classe est une classe finale, nous devrions employer le mot-clé « finale » avant le mot-clé de classe dans la déclaration de classe. Si nous voulons déclarer la classe d'ImaginaryNumber en tant que calss finals, sa déclaration devrait ressembler à ceci :

Si des tentatives suivantes sont faites à la sous-classe ImaginaryNumber, elle aura comme conséquence une erreur de compilateur en tant que ce qui suit :

Si créer la classe finale semble lourd pour vos besoins, et vous voulez juste protéger certaines des classes que les méthodes étant overriden, vous pouvez employer le mot-clé final dans la déclaration de méthode pour indiquer le compilateur que la méthode ne peut pas être dépassée par des sous-classes.

Parfois vous pouvez vouloir modeler seulement des concepts abstraits mais ne voulez pas créer un exemple de la classe. Comme discuté plus tôt la classe de nombre en paquet de java.lang représente seulement le concept abstrait des nombres. Nous des numéros de type de bidon dans un programme, mais lui ne semblerons aucun raisonnable de créer un objet générique de nombre. Au lieu de cela, la classe de nombre se comporte en tant que des superclass aux classes de nombre entier et de flotteur qui font la caisse spécifique d'instruments de nombres. Les classes aiment le nombre, celui met en application seulement les concepts abstraits et ne devrait pas être ainsi instantiated, s'appellent les classes abstraites.
Une classe abstraite est une classe qui peut seulement être subclassed et ne peut pas être instantiated.

Pour déclarer la classe comme classe abstraite nous employons le mot-clé « abstrait » devant la classe de mot-clé dans la déclaration de classe :

Si n'importe quelle tentative est faite à l'instantiate une classe abstraite, la volonté de compilateur montre l'erreur comme montré ci-dessous et refuse de compiler le programme :

Une classe abstraite peut contenir des méthodes abstraites, des méthodes abstraites sont les méthodes, sans l'exécution. Par conséquent une classe abstraite peut définir toute son interface de programmation et fournir ainsi ses sous-classes les déclarations de méthode pour toutes méthodes qui sont nécessaires pour mettre en application l'interface de programmation. Cependant, une classe abstraite peut laisser des détails d'exécution des méthodes aux sous-classes.

Vous déclareriez une classe abstraite, GraphicObject, qui fournit les variables et les méthodes de membre qui sont partagées par toutes les sous-classes. GraphicObject peut également déclarer des méthodes abstraites pour les méthodes, telles que l'aspiration (), qui doit être mise en application par les sous-classes, mais des manières entièrement différentes. La classe de GraphicObject ressemblerait à ceci :

Une classe abstraite n'est pas d'avoir une méthode abstraite dans elle. Mais la classe l'une des qui ont une méthode abstraite dans elle ou dans les superclasses l'uns des devrait être déclarée comme classe abstraite. Chaque sous-classe non-abstraite de GraphicObject, tel que le cercle et le rectangle, shoul fournissent une exécution pour la méthode d'aspiration ().

Les interfaces fournit un mécanisme pour permettre les classes hiérarchiquement indépendantes appliquent le même ensemble de méthodes. Une interface est la collection de définitions de méthode et des valeurs de constante qui est exempte de la dépendance sur une classe spécifique ou une hiérarchie de classe. Les interfaces sont utiles pour le but suivant :

• déclarant les méthodes qu'un ou plusieurs qu'une classe sont prévus pour mettre en application
• indiquant l'interface de programmation de l'objet sans indiquer sa classe (les objets comme ces derniers les objets anonymes appelés et sont utiles tout en embarquant un paquet des classes aux autres réalisateurs)
• capturant les similitudes entre les classes indépendantes sans forcer le rapport de classe

Créer une interface est semblable à celui de créer une nouvelle classe. Une définition d'interface se compose de deux composants : déclaration d'interface et corps d'interface.

L'interfaceDeclaration déclare de divers attributs au sujet de l'interface telle que son nom et s'il prolonge une autre interface. L'interfaceBody contient les déclarations de constante et de méthode dans l'interface.

Une interface est employée quand la classe prétend mettre en application cette interface. Une classe déclare toutes interfaces qui sont mises en application dans la déclaration de classe. Pour déclarer que la classe met en application une ou plusieurs interfaces, se servir du mot-clé « instruments » suivis de la liste virgule-délimitée des interfaces mises en application par la classe.

Supposer que nous écrivons une classe qui met en application une file d'attente de fifo. Puisque la classe de file d'attente de fifo est une collection d'objets (un objet qui contient d'autres objets) il doesnot sembler n'importe quel raisonnable de mettre en application le comptable connectent. La classe de FIFOQueue déclarerait qu'elle font des instruments l'interface comptable comme montré ci-dessous :

Et garantissant de ce fait qu'elle fournit des implemenations pour le currentCount (), l'incrementCount (), le setCount (), et les méthodes de decrementCount ().