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

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 paquet privé. Cela se situe entre protégé et privé, permettant seulement les classes dans le même accès paquet. (protégé, c'est comme ça, mais aussi en permettant l'accès aux sous-classes à l'extérieur du paquet.)

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

   void calc() {  // package private method

   }
}

pour les membres de l'interface (champs et méthodes), l'accès par défaut est public. Mais notez que la déclaration d'interface elle-même par défaut à package private.

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
{

}

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

si aucun spécificateur d'accès n'est donné, c'est l'accès au niveau du paquet (il n'y a pas de spécificateur explicite pour cela) pour les classes et les membres de classe. Les méthodes d'Interface sont implicitement publiques.

la visibilité par défaut (Pas de mot clé) est paquet ce qui signifie qu'il sera disponible pour chaque classe qui se trouve dans le même paquet.

il est intéressant de noter que protégé ne limite pas la visibilité aux sous-classes mais aussi aux autres classes du même paquet

cela dépend de ce qu'est la chose.

• les types de premier niveau (c'est-à-dire les classes, les enums, les interfaces et les types d'annotation non déclarés dans un autre type) sont paquet-privé 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 type imbriquées) et les constructeurs sont paquet-privé 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 mal étiqueté comme étant toujours public, mais dans de rares cas ce n'est pas équivalent.

• dans enums, les constructeurs sont privé par défaut. En effet, enum contructors doit être privé, et c'est une erreur de les spécifier en tant que public ou protégé. Les constantes d'Enum sont toujours public , et ne permettent aucun spécificateur d'accès. Les autres membres de enums sont colis-privé par défaut. ( JLS §8.9 )

• dans les types d'interfaces et d'annotations, tous les membres (encore une fois, cela signifie 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 nommées classes déclarée à l'intérieur d'une méthode, constructeur, ou d'initialiseur de bloc. Ils sont scoped à la { .. } bloc dans lequel ils sont déclarés et ne permettent aucun spécificateur d'accès. ( JLS §14.3 ) en utilisant la réflexion, vous pouvez instancier des classes locales d'ailleurs, et ils sont package-private , bien que je ne suis pas sûr si ce détail est dans le JLS.

• Anonymous les classes 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 ne permet aucun spécificateur d'accès. En utilisant la réflexion, vous pouvez instancier des classes anonymes d'ailleurs, et à la fois eux et leurs constructeurs générés sont paquet-privé , bien que je ne suis pas sûr si ce détail est dans le JLS.

• Instance et les blocs statiques d'initialisation n'ont pas de spécificateurs d'accès au niveau de la langue ( JLS §8.6 & 8.7 ), mais les blocs statiques d'initialisation sont implémentés comme une méthode appelée <clinit> ( JVMS §2.9 ), donc 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 en utilisant un éditeur hex et j'ai trouvé que les deux génèrent la méthode comme paquet-privé . Cependant, vous ne pouvez pas appeler <clinit>() dans le langage parce que les caractères < et > sont invalides dans un nom de méthode, et les méthodes de réflexion sont câblées pour nier son existence, donc effectivement son spécificateur d'accès est no access . La méthode ne peut être appelée que par la VM, pendant l'initialisation de la classe. Instance les blocs initializer ne sont pas compilés en tant que méthodes séparées; leur code est copié dans chaque constructeur, donc ils ne peuvent pas être consultés individuellement, même par réflexion.

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

le spécificateur d'accès par défaut est package .Les Classes peuvent accéder aux membres d'autres classes dans le même paquet.mais en dehors du paquet il apparaît comme privé

Voici une citation à propos de la visibilité au niveau des paquets d'une interview avec James Gosling, le créateur de Java:

Bill Venners : Java a quatre niveaux d'accès. La valeur par défaut est forfait. Je je me suis toujours demandé si le fait de rendre l'accès au paquet par défaut était pratique. parce que les trois mots-clés que les gens de C++ connaissais déjà étaient privés, protégés et publics. Ou si vous en aviez particulier raison que vous avez ressenti paquet l'accès doit être la valeur par défaut.

James Gosling : un paquet est généralement un ensemble de choses qui sont en quelque sorte écrit ensemble. Donc, de façon générique, j'aurais pu faire une de deux choses. L'un était de vous forcer 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 rend un défaut raisonnable? Et j'ai tendance à aller pour ce qui est le moins quelque chose de dangereux.

So publique aurait été une très mauvaise chose pour rendre la valeur par défaut. Privé aurait probablement été une mauvaise chose à faire défaut, si seulement parce que les gens n'écrivent pas souvent des méthodes privées. Et la même chose avec protégé. Et en regardant un tas de code J'ai eu, j'ai décidé que la meilleure chose qui était raisonnablement sûr était dans le package. Et C++ n'avait pas de mot clé pour ça, parce que ils n'avaient aucune notion des paquets.

Mais Je aimé plutôt que la notion d'amis, parce qu'avec des amis tu dois en quelque sorte énumérer qui sont tous tes amis, et donc si vous ajoutez une nouvelle classe à un paquet, puis vous finissez généralement par devoir allez à toutes les classes de ce paquet et mettez à jour leurs amis, ce que j'ai toujours trouvé être une vraie plaie.

mais la liste d'amis elle-même cause une sorte de problème de version. Et il y avait donc cette notion de classe amicale. Et la belle chose que Je faisais que le défaut -- je vais résoudre le problème alors ce qui devrait le mot-clé?

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

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

mise à jour Java 8 utilisation de default mot-clé: Comme beaucoup d'autres ont noté la visibilité par défaut (Pas de mot clé)

le champ sera accessible de l'intérieur du même paquet auquel le classe appartient.

à ne pas confondre avec la nouvelle fonctionnalité Java 8 ( Default Methods ) qui permet à une interface de fournir une implémentation lorsque son étiqueté avec le default mot clé.

voir: modificateurs d'accès

il y a un modificateur d'accès appelé" default " en JAVA, qui permet la création d'instance directe de cette entité uniquement dans ce paquet.

Voici un lien utile:

Java Modificateurs D'Accès/Prescripteurs

Public est un mot clé qui est utilisé comme modificateur d'accès pour les méthodes et les variables. Une variable (champ) ou une méthode déclarée publique est visible et peut être consultée par toutes les classes définies dans différents paquets.

le mot-clé public est utilisé dans de nombreux langages de programmation orientés objet (OOPL), y compris C++, Java, C# et Visual Basic.NET (VB.NET). Un membre du public est vaguement lié à une classe et moins restrictif qu'un membre privé. Les Variables ou les champs qui sont déclarés publics n'ont aucune restriction d'accessibilité. Un membre privé, cependant, est seulement visible dans sa classe.

modificateur d'accès public Les champs, les méthodes et les constructeurs déclarés publics (les moins restrictifs) dans une classe publique sont visibles par n'importe quelle classe du programme Java, que ces classes soient dans le même paquet ou dans un autre paquet.

Autres accès modificateurs

1. privé
2. protégé
3. par défaut

Le privé (la plus restrictive) de champs ou de méthodes ne peuvent pas être utilisés pour les classes et les Interfaces. Il ne peut pas non plus être utilisé pour des champs et des méthodes au sein d'une interface. Les champs, les méthodes ou les constructeurs déclarés privés sont strictement contrôlés, ce qui signifie qu'ils ne peuvent pas être accessibles par n'importe quel endroit en dehors de la classe englobante. Une stratégie de conception standard est de rendre tous les domaines privés et de fournir des méthodes publiques getter pour eux.

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 des champs et des méthodes au sein d'une interface. Les champs, les méthodes et les constructeurs déclarés protégés dans une superclasse ne peuvent être consultés que par des sous-classes dans d'autres paquets. Les Classes d'un même paquet peuvent aussi accéder à des champs protégés, les méthodes et les constructeurs aussi, même s'ils ne sont pas une sous-classe de la classe du membre protégé.

Java fournit un spécificateur par défaut 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 paquet. Le modificateur par défaut n'est pas utilisé pour les champs et les méthodes d'une interface. Modificateur d'accès par défaut signifie que nous ne le faisons pas explicitement déclarer un modificateur d'accès pour une classe, un champ, une méthode, etc.

en Java, que faire si la classe comme aucun modificateur?

si une classe n'a pas de modificateur d'accès, elle sera traitée sous modificateur d'accès par défaut .

dans les langages de programmation orientés objet, l'encapsulation est utilisée pour renvoyer à l'une de deux notions liées mais distinctes, et parfois à la combinaison des deux:

un mécanisme de langage pour restreindre l'accès direct à certains composants de l'objet Une construction linguistique qui facilite le groupement des 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_ programme informatique)

https://www.quora.com/In-Java-what-is-the-difference-between-public-class-and-class https://www.techopedia.com/definition/24018/public-java

https://www.geeksforgeeks.org/access-modifiers-java /

tout d'Abord, permettez-moi de dire une chose n'existe pas de terme comme "l'Accès spécificateur" en java. On devrait tout appeler "modificateurs". Comme nous savons que final, statique, synchronisé, volatile.... sont appelés modificateurs, même publics, privés, protégés, par défaut, abstraits doivent également être appelés modificateurs . La valeur par défaut est un tel modificateur lorsque l'existence physique n'est pas là mais qu'aucun modificateur n'est placé alors il doit être traité comme modificateur par défaut.

à justifier cela prendre un exemple:

public class Simple{  
    public static void main(String args[]){  
     System.out.println("Hello Java");  
    }  
}  

sortie sera: Hello Java

maintenant changer public en privé et voir quelle erreur de compilateur vous obtenez: Il est dit "Modificateur privé n'est pas autorisé ici" Quelle conclusion est quelqu'un peut se tromper ou un tutoriel peut se tromper mais le compilateur ne peut pas se tromper. Donc, on peut dire qu'il n'y a pas de spécificateur d'accès par terme en java.tout est modificateur.