Tableau de comparaison
| Base de comparaison | Paquets | Des interfaces |
|---|---|---|
| De base | Les packages sont un groupe de classes et / ou d'interfaces. | Interfaces est un groupe de méthodes abstraites et de champs constants. |
| Mot-clé | Les packages sont créés à l'aide du mot clé "Package". | Les interfaces sont créées à l'aide du mot clé "Interface". |
| Syntaxe | package nom_package; Classe publique class_name { . (corps de classe) . } | interface nom_interface { déclaration de variable; déclaration de méthode; } |
| Accès | Un paquet peut être importé | Une interface peut être étendue par une autre interface et implémentée par la classe. |
| Mot clé d'accès | Les packages peuvent être importés à l'aide du mot clé "import". | Les interfaces peuvent être implémentées en utilisant le mot-clé "implémenter". |
Définition des forfaits
Les packages sont des collections ou des groupes de la variété des classes et des interfaces. Les classes dans les packages sont liées les unes aux autres dans une certaine portée ou par héritage. Vous pouvez également créer votre package et l'utiliser pour votre programme.
Créer un package
Pour créer un package, suivez simplement les étapes suivantes.
- Ouvrez un fichier puis déclarez le nom du paquet en haut du fichier, comme [package nom_package; ] le nom du paquet est le nom que vous voulez donner au paquet.
- Ensuite, vous définissez une classe que vous souhaitez placer dans le package et vous vous rappelez que vous la déclarez publique.
- Enregistrez le fichier en tant que fichier .java, puis compilez-le, puis «.class» est obtenu pour ce fichier.
- Pour créer un package pour ce fichier, la commande utilisée est “javac -d. nom_fichier.java. Vous pouvez voir que le package est créé et qu'il contient un fichier ”.class” dans le répertoire actuel. Pour le placer dans le répertoire parent, utilisez “javac -d. . nom_fichier.java ”.
- Vous pouvez également créer un sous-package en déclarant le nom du sous-package comme suit: [package nom_package1. nom_package2; ] en haut du fichier.
package Mypackage; public class myclass {public void displayMypackage () {system.out.println ("méthode displayMypackage de la classe myclass du package Mypackage"); } Utiliser le paquet
Les packages créés ou disponibles dans le répertoire peuvent être utilisés dans le programme à l'aide d'une instruction d'importation. Le mot clé utilisé pour importer un package dans votre programme est "import". La déclaration d'importation peut être écrite de deux manières, ou vous pouvez dire qu'il existe deux manières d'accéder à un package. Tout d'abord, si vous souhaitez utiliser une classe particulière d'un package, le mot-clé «import» est suivi du nom du package, suivi de l'opérateur point et du nom de la classe que vous souhaitez utiliser à partir du package. Deuxièmement, si vous souhaitez utiliser de nombreuses classes contenues dans les packages, le mot-clé import est suivi du nom du package, suivi du point et de l'opérateur "*".
importer nom_package. nom du cours; ou importez nom_package. *;
Dans le code ci-dessus, vous pouvez voir le signe * qui indique que la deuxième méthode importe toutes les classes contenues dans les packages.
Voyons maintenant l'utilisation du paquet avec un exemple.
importer Mypackage. myclass {class TestMypackage {public statique void main (string args []) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // méthode de sortie displayMypackage de la classe myclass du package Mypackage. Dans le code ci-dessus, la classe TestMypackage a importé le package Mypackage et utilisé sa méthode displayMypackage ().
Définition d'interface
L'interface est une sorte de classe, mais diffère en ce sens que les méthodes déclarées dans l'interface sont abstraites, ce qui signifie qu'elles ne sont que déclarées mais non définies. Les champs de l'interface sont toujours publics, statiques, finaux. Les champs doivent être initialisés au moment de la déclaration. Les méthodes déclarées par l'interface sont définies par la classe qui implémente cette interface en fonction de ses besoins. Comme les méthodes de l'interface n'effectuent aucune fonction, il est donc inutile de créer un objet de l'interface. Par conséquent, aucun objet ne peut être créé pour l'interface.
L'interface peut également hériter de l'autre interface, mais la classe qui hérite d'une telle interface doit également implémenter toutes les méthodes de l'interface héritée. Comme les champs sont initialisés au moment de leur déclaration dans l'interface, aucun constructeur n'est nécessaire dans l'interface et l'interface ne contient donc aucun constructeur. Voyons l'exemple de la création et de l'utilisation d'une interface.
zone d'interface {float pi = 3.14; float find_area (float a, float b) {} la classe Circle implémente Area {float find_area (float a, float b) {return (pi * a * a); } Class Shapes {public static void main (string args []) {Area A = new Area (); Cercle C = nouveau cercle (); A = C; float F = Surface. find_area (10, 10); system.out.println ("La zone du cercle est:" + F); } Dans le code ci-dessus, nous avons créé une zone d'interface et la classe Circle a implémenté cette zone. Le champ "pi" a été initialisé dans l'interface au moment de sa déclaration. La classe Circle a défini la méthode abstraite de la zone de classe en fonction de ses besoins.
Différences clés entre les packages et les interfaces en Java
- Un package est un groupe de classes et d'interfaces, alors qu'une interface est un groupe de méthodes abstraites.
- Le package est créé à l'aide d'un package de mots clés , tandis qu'une interface est créée à l'aide d'une interface de mots clés.
- Si une classe ou une interface à l'intérieur d'un package doit être utilisée, le package doit être importé tandis qu'une interface doit être implémentée.
Conclusion:
Les paquets et l'interface sont les conteneurs. Package réduit la taille du code car nous importons simplement la classe à utiliser au lieu de la définir à nouveau. Alors que l'interface réduit les confusions survenues lors d'héritages multiples car, dans le cas d'héritages multiples, la classe qui hérite n'a pas à décider de la méthode dont elle doit hériter, mais définit sa propre méthode.
