web-dev-qa-db-fra.com

Quel est le spécificateur d'accès par défaut en Java?

Donc, je viens de commencer à lire un livre en Java et je me suis demandé; quel spécificateur d'accès est celui par défaut si aucun n'est spécifié?

javaaccess-specifier
97
bennedich

La visibilité par défaut est connue sous le nom de «paquet privé» (bien que vous ne puissiez pas l'utiliser explicitement), ce qui signifie que le champ sera accessible depuis l'intérieur du même paquet auquel la classe appartient.

Comme l'a souligné mdma, ce n'est pas vrai pour les membres de l'interface, pour lesquels la valeur par défaut est "public".

Voir Spécificateurs d'accès de Java

107
KeatsPeeks

Le spécificateur par défaut dépend du contexte. 

Pour les classes et les déclarations d'interface, la valeur par défaut est package private. Cela se situe entre protégé et privé, n'autorisant que les classes du même accès au package. (protected est comme ça, mais permet également l'accès à des sous-classes en dehors du paquet.)

class MyClass   // package private
{
   int field;    // package private field

   void calc() {  // package private method

   }
}

Pour les membres d'interface (champs et méthodes), l'accès par défaut est public. Mais notez que la déclaration d’interface elle-même est par défaut un paquet privé.

interface MyInterface  // package private
{
   int field1;         // static final public

   void method1();     // public abstract
}

Si nous avons alors la déclaration

public interface MyInterface2 extends MyInterface
{

}

Les classes utilisant MyInterface2 peuvent alors voir field1 et method1 à partir de la super interface, car elles sont publiques, même si elles ne peuvent pas voir la déclaration de MyInterface elle-même.

75
mdma

Si aucun spécificateur d'accès n'est donné, il s'agit d'un accès au niveau du package (il n'existe aucun spécificateur explicite pour cela) pour les classes et les membres de la classe. Les méthodes d'interface sont implicitement publiques.

13
Michael Borgwardt

La visibilité par défaut (sans mot-clé) est package , ce qui signifie qu'il sera disponible pour toutes les classes situées dans le même package.

La note latérale intéressante est que protected ne limite pas la visibilité sur les sous-classes mais également sur les autres classes du même paquet.

8
Johannes Wachter

Cela dépend de ce que la chose est.

  • Les types de niveau supérieur (c'est-à-dire les classes, les énumérations, les interfaces et les types d'annotation non déclarés dans un autre type) sont package-private par défaut. ( JLS §6.6.1 )

  • Dans les classes, tous les membres (c'est-à-dire les champs, les méthodes et les déclarations de types imbriqués) et les constructeurs sont package-private par défaut. ( JLS §6.6.1 )

    • Lorsqu'une classe n'a pas de constructeur explicitement déclaré, le compilateur insère un constructeur par défaut à argument zéro qui a le même spécificateur d'accès que la classe. ( JLS §8.8.9 ) Le constructeur par défaut est généralement erroné: il est toujours public, mais dans de rares cas ce n'est pas équivalent.

  • Dans les énumérations, les constructeurs sont private _ par défaut. En effet, les enum constructeurs doivent être privés et c’est une erreur de les spécifier comme publics ou protégés. Les constantes Enum sont toujours public, et n'autorisent aucun spécificateur d'accès. Les autres membres des énumérations sont package-private par défaut. ( JLS §8.9 )

  • Dans les types d'interface et d'annotation, tous les membres (encore une fois, cela signifie que les champs, les méthodes et les déclarations de type imbriquées) sont public par défaut. En effet, les membres des interfaces et des types d'annotation doivent être publics, et c'est une erreur de les spécifier comme privés ou protégés. ( JLS §9.3 à 9.5 )

  • Les classes locales sont des classes nommées déclarées dans une méthode, un constructeur ou un bloc d'initialisation. Ils sont portés au bloc {..} dans lequel ils sont déclarés} et n'autorisent aucun spécificateur d'accès. ( JLS §14.3 ) En utilisant réflexion, vous pouvez instancier des classes locales d’ailleurs, elles sont package-private, bien que je ne sache pas si ce détail se trouve dans le JLS.

  • Les classes anonymes sont des classes personnalisées créées avec new qui spécifient un corps de classe directement dans l'expression. ( JLS §15.9.5 ) Leur syntaxe n'autorise aucun spécificateur d'accès. En utilisant la réflexion, vous pouvez instancier des classes anonymes d’ailleurs, et les constructeurs qu’ils ont générés sont package-private, bien que je ne sache pas si ces détails se trouvent dans le JLS.

  • Les blocs d'initialisation statiques et statiques n'ont pas de spécificateurs d'accès au niveau de langue ( JLS §8.6 & 8.7 ), mais les blocs d'initialisation statiques sont implémentés en tant que méthode nommée <clinit> ( JVMS §2.9 ), de sorte que la méthode doit, en interne, avoir un spécificateur d'accès. J'ai examiné les classes compilées par javac et par le compilateur d'Eclipse à l'aide d'un éditeur hexadécimal et constaté qu'elles généraient la méthode sous la forme package-private. Cependant, vous ne pouvez pas appeler <clinit>() dans la langue car les caractères < et > ne sont pas valides dans un nom de méthode et les méthodes de réflexion sont câblées pour nier son existence. Son spécificateur d'accès est donc effectivement aucun accès La méthode ne peut être appelée que par la VM, lors de l'initialisation de la classe. Les blocs d'initialisation d'instance ne sont pas compilés en tant que méthodes séparées; leur code est copié dans chaque constructeur, il est donc impossible d'y accéder individuellement, même par réflexion.

6
Boann

Voir ici pour plus de détails. La valeur par défaut est no privé/public/protégé, mais une spécification d'accès complètement différente. Il n'est pas largement utilisé et je préfère être beaucoup plus spécifique dans mes définitions d'accès.

3
Brian Agnew

le spécificateur d'accès par défaut est package . Les classes peuvent accéder aux membres d'autres classes du même package.mais en dehors du package, il apparaît sous la forme private

2
lil_pgmr

Voici une citation sur la visibilité au niveau du paquetage extraite d'une interview de James Gosling, le créateur de Java:

Bill Venners: Java a quatre niveaux d’accès. La valeur par défaut est package. JE se sont toujours demandé si rendre l’accès au paquet par défaut était pratique parce que les trois mots-clés que les gens de C++ connaissaient déjà étaient privés, protégés et publics. Ou si vous aviez un particulier raison pour laquelle vous pensiez que l’accès au paquet devrait être la valeur par défaut.

James Gosling: Un paquet est généralement un ensemble de choses qui sont un peu genre écrit ensemble. Donc, de manière générique, j'aurais pu faire l'une des deux choses . On était forcé de toujours mettre dans un mot-clé qui vous donne le domaine. Ou j'aurais pu avoir une valeur par défaut. Et puis la question est, qu'est-ce qui fait un défaut raisonnable? Et j'ai tendance à aller pour ce qui est le moins chose dangereuse.

Donc, le public aurait été une très mauvaise chose de faire le défaut . Privé aurait probablement été une mauvaise chose de faire un défaut, si c'est uniquement parce que les gens n'écrivent pas de méthodes privées qui souvent . Et même chose avec protégé. Et en regardant un tas de code que J'ai eu, j'ai décidé que la chose la plus commune qui était raisonnablement sûre était dans le paquet. Et C++ n'avait pas de mot-clé pour cela, parce que ils n'avaient pas la notion de colis.

Mais je l’ai aimé plutôt que la notion d’amis, car avec des amis vous devez en quelque sorte énumérer qui sont tous vos amis, et donc si vous ajoutez une nouvelle classe à un paquet, vous finissez généralement par devoir allez dans toutes les classes de ce paquet et mettez à jour leurs amis, que j'avais toujours trouvé être une douleur complète dans les fesses.

Mais la liste d'amis elle-même pose en quelque sorte un problème de version. Et il y avait donc cette notion de classe amicale. Et la bonne chose que Je faisais cela par défaut - je vais résoudre le problème alors que devrait le mot clé soit?

Pendant un moment, il y avait en fait un mot clé convivial. Mais parce que tous les d'autres commencent par "P", c'était "phriendly" avec un "PH". Mais c'était seulement là-bas pour peut-être un jour.

http://www.artima.com/intv/gosling2P.html

2
Vitalii Fedorenko

Mise à jour Java 8 utilisation du mot clé default: Comme d'autres l'ont noté, la visibilité par défaut (aucun mot clé)

le champ sera accessible depuis l'intérieur du même package que celui auquel le la classe appartient.

Ne pas confondre avec la nouvelle fonctionnalité Java 8 ( Méthodes par défaut ) qui permet à une interface de fournir une implémentation lorsqu'elle est étiquetée avec le mot clé default.

Voir: Modificateurs d'accès

1
Ahmad Sanie

Public est un mot clé utilisé comme modificateur d'accès pour les méthodes et les variables. Une variable (champ) ou une méthode déclarée public est visible et accessible à toutes les classes définies dans des packages différents.

Le mot clé public est utilisé dans de nombreux langages de programmation orientés objet (OOPL), notamment C++, Java, C # et Visual Basic.NET (VB.NET). Un membre public est vaguement lié à une classe et moins restrictif qu'un membre privé. Les variables ou champs déclarés publics n'ont aucune restriction d'accessibilité. Un membre privé, cependant, n'est visible que dans sa classe.

Modificateur d'accès public Les champs, méthodes et constructeurs déclarés publics (les moins restrictifs) d'une classe publique sont visibles par toutes les classes du programme Java, que ces classes se trouvent dans le même package ou dans un autre.

Autres modificateurs d'accès 

  1. privé
  2. protégé
  3. default

Les champs ou méthodes privés (les plus restrictifs) ne peuvent pas être utilisés pour les classes et les interfaces. Il ne peut pas non plus être utilisé pour les champs et les méthodes dans une interface. Les champs, méthodes ou constructeurs déclarés privés sont strictement contrôlés, ce qui signifie qu'ils ne peuvent être consultés nulle part en dehors de la classe englobante. Une stratégie de conception standard consiste à rendre tous les champs privés et à leur fournir des méthodes de lecture publiques.

Les champs protégés ou les méthodes ne peuvent pas être utilisés pour les classes et les interfaces. Il ne peut pas non plus être utilisé pour les champs et les méthodes dans une interface. Les champs, méthodes et constructeurs déclarés protégés dans une superclasse sont accessibles uniquement aux sous-classes d'autres packages. Les classes d'un même package peuvent également accéder aux champs, méthodes et constructeurs protégés, même si elles ne sont pas une sous-classe de la classe du membre protégé.

Java fournit un spécificateur default qui est utilisé lorsqu'aucun modificateur d'accès n'est présent. Toute classe, champ, méthode ou constructeur qui n'a pas de modificateur d'accès déclaré n'est accessible que par les classes du même package. Le modificateur par défaut n'est pas utilisé pour les champs et les méthodes dans une interface. Le modificateur d'accès par défaut signifie que nous ne déclarons pas explicitement un modificateur d'accès pour une classe, un champ, une méthode, etc.

En Java, que se passe-t-il si la classe est sans modificateur?

Si une classe n'a pas de modificateur d'accès, elle sera traitée sous le nom de modificateur d'accès default.

Dans les langages de programmation orientés objet, l'encapsulation est utilisée pour faire référence à l'une des deux notions liées mais distinctes, et parfois à la combinaison de celles-ci:

Un mécanisme de langage pour limiter l'accès direct à certains composants de l'objet Une construction de langage facilitant le regroupement de données avec les méthodes (ou d'autres fonctions) opérant sur ces données.

//Java program to illustrate default modifier
package p1;

//Class Geeks is having Default access modifier
class Geek
{
    void display()
       {
           System.out.println("Hello World!");
       }
}

..

//Java program to illustrate error while 
//using class from different package with
//default modifier
package p2;
import p1.*;

//This class is having default access modifier
class GeekNew
{
    public static void main(String args[])
       {  
          //accessing class Geek from package p1
          Geeks obj = new Geek();

          obj.display();
       }
}

..

 //Java program to illustrate error while 
//using class from different package with
//private modifier
package p1;

class A
{
   private void display()
    {
        System.out.println("GeeksforGeeks");
    }
}

class B
{
   public static void main(String args[])
      {
          A obj = new A();
          //trying to access private method of another class
          obj.display();
      }
}

..

 //Java program to illustrate
    //protected modifier
    package p1;

//Class A
public class A
{
   protected void display()
    {
        System.out.println("GeeksforGeeks");
    }
}


    //Java program to illustrate
    //protected modifier
    package p2;
    import p1.*; //importing all classes in package p1

    //Class B is subclass of A
    class B extends A
    {
       public static void main(String args[])
       {  
           B obj = new B();  
           obj.display();  
       }  

    }

..

//Java program to illustrate
//public modifier
package p1;
public class A
{
   public void display()
      {
          System.out.println("GeeksforGeeks");
      }
}
package p2;
import p1.*;
class B
{
    public static void main(String args[])
      {
          A obj = new A;
          obj.display();
      }
}

https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)
https://www.quora.com/In-Java- what-is-the-difference-between-public-class-and-classhttps: //www.techopedia .com/Définition/24018/public-Java
https://www.geeksforgeeks.org/access-modifiers-Java/

1
Amadeu Antunes

Il existe un modificateur d'accès appelé "default" en Java, qui permet la création directe d'instance de cette entité uniquement dans ce package.

Voici un lien utile:

Modificateurs d'accès Java/Spécificateurs

0
kg11