Pourquoi la méthode principale Java est-elle statique?

https://stackoverflow.com/questions/146576

02-07-2019
|

Question

La signature de méthode d'une méthode main () Java est:

public static void main(String[] args){
    ...
}

Y a-t-il une raison pour que cette méthode soit statique?

La solution

La méthode est statique car sinon, il y aurait une ambiguïté: quel constructeur devrait être appelé? Surtout si votre classe ressemble à ceci:

public class JavaClass{
  protected JavaClass(int x){}
  public void main(String[] args){
  }
}

La machine virtuelle Java doit-elle appeler new JavaClass(int)? Que doit-il passer pour x?

Si ce n'est pas le cas, la machine virtuelle Java doit-elle instancier JavaClass sans exécuter de méthode de constructeur? Je pense que ce ne devrait pas être le cas, car cela concernera votre classe tout entière. Parfois, vous avez une instance qui n’a pas été initialisée et vous devez la rechercher dans chaque méthode qui peut être appelée.

Il y a trop de cas d'extrémité et d'ambiguïtés pour qu'il soit logique que la JVM instancie une classe avant que le point d'entrée ne soit appelé. C'est pourquoi main est statique.

Je ne sais pas pourquoi public est toujours marqué <=> bien.

Autres conseils

Ceci est juste une convention. En fait, même le nom main () et les arguments transmis sont purement conventionnels.

Lorsque vous exécutez java.exe (ou javaw.exe sous Windows), deux appels JNI (Java Native Interface) se produisent réellement. Ces appels chargent la DLL qui est vraiment la machine virtuelle (c'est vrai - java.exe n'est pas la machine virtuelle). JNI est l'outil que nous utilisons lorsque nous devons faire un pont entre le monde de la machine virtuelle et le monde de C, C ++, etc ... L'inverse est également vrai - il n'est pas possible (du moins à ma connaissance) d'obtenir une JVM s'exécutant sans utiliser JNI.

Fondamentalement, java.exe est une application C très simple qui analyse la ligne de commande, crée un nouveau tableau de chaînes dans la JVM pour contenir ces arguments, analyse le nom de la classe que vous avez spécifiée comme contenant main (), utilise les appels JNI. pour trouver la méthode main () elle-même, puis appelle la méthode main () en transmettant le tableau de chaînes nouvellement créé en tant que paramètre. C’est très, très semblable à ce que vous faites lorsque vous utilisez la réflexion depuis Java. Elle utilise simplement des appels de fonctions natives qui portent un nom confus.

Il serait parfaitement légal pour vous d'écrire votre propre version de java.exe (le source est distribué avec le JDK) et de le faire faire quelque chose de complètement différent. En fait, c’est exactement ce que nous faisons avec toutes nos applications Java.

Chacune de nos applications Java a son propre lanceur. Nous le faisons principalement pour obtenir notre propre icône et nom de processus, mais cela s’est avéré utile dans d’autres situations où nous souhaitons faire quelque chose en plus de l’appel main () habituel pour que tout se passe bien (par exemple, dans un cas, nous le faisons Interopérabilité COM, et nous passons en fait un handle COM dans main () au lieu d’un tableau de chaînes).

Donc, long et court: la raison pour laquelle il est statique est b / c qui est pratique. La raison pour laquelle on l'appelle 'main' est que cela devait être quelque chose, et main () est ce qu'ils faisaient à l'époque de C (et à cette époque, le nom de la fonction était important) . Je suppose que java.exe aurait pu vous permettre de spécifier un nom de méthode principal pleinement qualifié, au lieu de simplement la classe (java com.mycompany.Foo.someSpecialMain) - mais cela rend simplement plus difficile pour les IDE de détecter automatiquement le ' 'launchable' classes dans un projet.

Les méthodes main() dans C++, C# et Java sont statiques
Puisqu'ils peuvent ensuite être appelés par le moteur d'exécution sans que l'instanciation soit nécessaire, le code dans le corps de <=> fera le reste.

Pourquoi public static void main (String [] args)?

C’est ainsi que le langage Java est conçu et que la machine virtuelle Java est conçue et écrite.

Spécification du langage Java Oracle

Découvrez Chapitre 12 Exécution - Section 12.1.4 Invocation Test.main :

Enfin, une fois l'initialisation de la classe Test terminée (au cours de laquelle d'autres chargement, liaison et initialisation consécutifs peuvent s'être produits), la méthode principale de Test est appelée.

La méthode main doit être déclarée publique, statique et vide. Il doit accepter un seul argument qui est un tableau de chaînes. Cette méthode peut être déclarée soit comme
public static void main(String[] args)
ou
public static void main(String... args)

Spécification de la machine virtuelle Java d'Oracle

Découvrez Chapitre 2 Concepts du langage de programmation Java - Section 2.17 Exécution :

La machine virtuelle Java commence l'exécution en appelant la méthode main d'une classe spécifiée et en lui transmettant un seul argument, qui est un tableau de chaînes. La classe spécifiée est alors chargée (& # 167; 2.17.2), liée (& # 167; 2.17.3) à d'autres types qu'elle utilise et initialisée (& # 167; 2.17. 4) La méthode main doit être déclarée publique, statique et vide.

Source Oracle OpenJDK

Téléchargez et extrayez le fichier jar source et voyez comment la machine virtuelle Java est écrite, consultez ../launcher/java.c, qui contient du code C natif derrière la commande java [-options] class [args...]:

/*
 * Get the application's main class.
 * ... ...
 */
if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);

... ...

    mainClass = LoadClass(env, classname);
    if(mainClass == NULL) { /* exception occured */

... ...

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                   "([Ljava/lang/String;)V");

... ...

{    /* Make sure the main method is public */
    jint mods;
    jmethodID mid;
    jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                            mainID, JNI_TRUE);

... ...

/* Build argument array */
mainArgs = NewPlatformStringArray(env, argv, argc);
if (mainArgs == NULL) {
    ReportExceptionDescription(env);
    goto leave;
}

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

... ...

Supposons simplement que static ne serait pas requis comme point d'entrée de l'application.

Une classe d'application ressemblerait alors à ceci:

class MyApplication {
    public MyApplication(){
        // Some init code here
    }
    public void main(String[] args){
        // real application code here
    }
}

La distinction entre le code constructeur et la main méthode est nécessaire car, en langage OO, un constructeur doit uniquement s’assurer que l’instance est initialisée correctement. Après l’initialisation, l’instance peut être utilisée pour le & Quot; service & Quot; prévu. Mettre le code complet de l'application dans le constructeur gâcherait cela.

Cette approche forcerait donc trois contrats différents sur l'application:

Il doit être un constructeur par défaut. Sinon, la machine virtuelle Java ne saura pas quel constructeur appeler et quels paramètres doivent être fournis.
Il doit exister une abstract méthode ¹. Ok, ce n’est pas surprenant.
La classe ne doit pas être <=>. Sinon, la machine virtuelle Java ne pourrait pas l'instancier.

L’approche <=> requiert un seul contrat:

Il doit exister une <=> méthode ¹.

Ici, ni <=> ni plusieurs constructeurs ne comptent.

Étant donné que Java a été conçu pour être un langage simple pour l'utilisateur , il n'est pas surprenant que le point d'entrée de l'application ait également été conçu de manière simple à l'aide de un contrat et pas de manière complexe avec trois contrats indépendants et fragiles.

Remarque: cet argument ne ne concerne pas la simplicité à l'intérieur de la machine virtuelle ou à l'intérieur du JRE. Cet argument concerne la simplicité pour l'utilisateur .

¹ Ici, la signature complète compte pour un seul contrat.

Si ce n'était pas le cas, quel constructeur devrait être utilisé s'il y en a plus d'un?

Des informations supplémentaires sur l'initialisation et l'exécution des programmes Java sont disponibles dans Spécification du langage Java .

Avant l'appel de la méthode main, aucun objet n'est instancié. Avoir le mot clé static signifie que la méthode peut être appelée sans créer d’objets au préalable.

Parce que sinon, il faudrait une instance de l'objet à exécuter. Mais il doit être appelé à partir de zéro, sans construire l’objet d’abord, car c’est généralement la tâche de la fonction main () (bootstrap), d’analyser les arguments et de construire l’objet, généralement à l’aide de ces arguments / paramètres de programme.

Quel est le sens de public static void main(String args[])?

public est un spécificateur d'accès, ce qui signifie que tout le monde peut y accéder / l'invoquer, tel que JVM (Java Virtual Machine.

static permet à main() d'être appelé avant la création d'un objet de la classe. Cela est nécessaire car void est appelé par la machine virtuelle avant que tous les objets soient créés. Comme il est statique, il peut être directement appelé via la classe.

class demo {    
    private int length;
    private static int breadth;
    void output(){
        length=5;
        System.out.println(length);
    }

    static void staticOutput(){
        breadth=10; 
        System.out.println(breadth);
    }

    public static  void main(String args[]){
        demo d1=new demo();
        d1.output(); // Note here output() function is not static so here
        // we need to create object
        staticOutput(); // Note here staticOutput() function is  static so here
        // we needn't to create object Similar is the case with main
        /* Although:
        demo.staticOutput();  Works fine
        d1.staticOutput();  Works fine */
    }
}

De même, nous utilisons parfois des méthodes statiques pour les méthodes définies par l'utilisateur afin d'éviter de créer des objets.

String[] args indique que la méthode args en cours de déclaration ne renvoie pas de valeur.
String spécifie le seul paramètre de la <=> méthode.

<=> - paramètre contenant un tableau d'objets de type de classe <=>.

Permettez-moi d'expliquer ces choses d'une manière beaucoup plus simple:

public static void main(String args[])

Toutes les applications Java, à l'exception des applets, démarrent leur exécution à partir de main().

Le mot clé public est un modificateur d'accès permettant au membre d'être appelé de l'extérieur de la classe.

static est utilisé car il permet d'appeler void sans avoir à instancier une instance particulière de cette classe.

<=> indique que <=> ne renvoie aucune valeur.

Des applets, des midlets, des servlets et des beans de différents types sont construits et des méthodes de cycle de vie sont ensuite utilisées. L'appel de main est tout ce qui est fait pour la classe principale. Il n'est donc pas nécessaire qu'un état soit maintenu dans un objet appelé plusieurs fois. Il est tout à fait normal d'épingler main sur une autre classe (bien que ce ne soit pas une bonne idée), ce qui gênerait l'utilisation de la classe pour créer l'objet principal.

Ce n'est qu'une convention, mais probablement plus pratique que l'alternative. Avec un principal statique, tout ce que vous devez savoir pour appeler un programme Java est le nom et l'emplacement d'une classe. Si ce n’est pas statique, vous devez également savoir comment instancier cette classe ou exiger que la classe ait un constructeur vide.

Si la méthode principale n’est pas statique, vous devez créer un objet de votre classe principale en dehors du programme. Comment voudriez-vous faire cela?

Lorsque vous exécutez la machine virtuelle Java (JVM) avec la commande java,

java ClassName argument1 argument2 ...

Lorsque vous exécutez votre application, vous spécifiez son nom de classe en tant qu'argument de la commande java, comme ci-dessus

la machine virtuelle Java tente d'appeler la méthode principale de la classe que vous spécifiez

& # 8212; à ce stade, aucun objet de la classe n'a été créé.

Déclarer main comme statique allows la machine virtuelle Java à invoke principale without créant   un instance de la classe.

revenons à la commande

ClassName est un command-line argument élément de la machine virtuelle qui lui indique quelle classe exécuter. Après le nom de la classe, vous pouvez également spécifier un list of Strings (séparé par des espaces) en tant qu'arguments de ligne de commande que la machine virtuelle Java passera à votre application. -De tels arguments peuvent être utilisés pour spécifier des options (par exemple, un nom de fichier) pour exécuter l'application. C'est pourquoi il existe un paramètre appelé String[] args dans l'élément principal

Références: Java & # 8482; Comment programmer (premiers objets), Dixième édition

Je pense que le mot clé 'static' fait de la méthode principale une méthode de classe. Les méthodes de classe n'en ont qu'une copie et peuvent être partagées par tous. De plus, aucun objet n'est requis pour la référence. Ainsi, lorsque la classe de pilote est compilée, la méthode main peut être invoquée. (Je suis juste au niveau alphabétique de Java, désolé si je me trompe)

main () est statique car; à ce stade du cycle de vie de l'application, la pile d'applications est de nature procédurale car il n'y a pas encore d'objets instanciés.

C'est une table rase. Votre application est en cours d'exécution à ce stade, même sans qu'aucun objet ne soit déclaré (rappelez-vous, il existe des modèles de procédure et de codage OO). En tant que développeur, vous transformez l’application en une solution orientée objet en créant des instances de vos objets et en fonction du code compilé à l'intérieur.

Orienté objet est idéal pour des millions de raisons évidentes. Cependant, le temps où la plupart des développeurs VB utilisaient régulièrement des mots clés tels que & "; Goto &"; dans leur code. " goto " est une commande procédurale en VB qui est remplacée par son homologue OO: invocation de méthode.

Vous pouvez également considérer le point d’entrée statique (principal) en tant que liberté pure. Si Java avait été suffisamment différent pour instancier un objet et ne vous présenter que cette instance, vous n'auriez pas le choix MAIS écrire une application procédurale. Aussi inimaginable que cela puisse paraître pour Java, il est possible que de nombreux scénarios appellent des approches procédurales.

C’est probablement une réponse très obscure. Rappelez-vous, & Quot; class & Quot; est seulement une collection de code interconnecté. " instance " est une génération isolée, vivante et autonome de cette classe.

Le prototype public static void main(String[]) est une convention définie dans le JLS :

La méthode main doit être déclarée publique, statique et vide. Il doit spécifier un paramètre formel (& # 167; 8.4.1) dont le type déclaré est array of String.

Dans la spécification JVM, 5.2. Démarrage de la machine virtuelle , nous pouvons lire:

La machine virtuelle Java démarre en créant une classe initiale, spécifiée de manière dépendante de l'implémentation, à l'aide du chargeur de classes d'amorçage (& # 167; 5.3.1). La machine virtuelle Java lie ensuite la classe initiale, l'initialise et appelle la méthode de classe publique void main (String []) . L'appel de cette méthode entraîne toute exécution ultérieure. L'exécution des instructions de la machine virtuelle Java constituant la méthode principale peut entraîner la liaison (et par conséquent la création) de classes et d'interfaces supplémentaires, ainsi que l'appel de méthodes supplémentaires.

Chose amusante, dans la spécification JVM, il n'est pas mentionné que la méthode principale doit être statique. Mais la spécification indique également que la machine virtuelle Java effectue les 2 étapes précédentes:

relie la classe initiale ( 5.4 Créer des liens )
l'initialise ( 5.5. Initialisation )

L’initialisation d’une classe ou d’une interface consiste à exécuter sa méthode d’initialisation de la classe ou de l’interface.

Dans 2.9. Méthodes spéciales :

Une méthode d'initialisation de classe ou d'interface est définie:

Une classe ou une interface a au plus une méthode d'initialisation de classe ou d'interface et est initialisée (& # 167; 5.5) en appelant cette méthode. La méthode d’initialisation d’une classe ou d’une interface porte le nom spécial <clinit>, ne prend aucun argument et est vide.

Et une méthode d'initialisation de classe ou d'interface est différente d'une méthode d'initialisation d'instance définie comme suit:

Au niveau de la machine virtuelle Java, chaque constructeur écrit dans le langage de programmation Java (JLS & # 167; 8.8) apparaît en tant que méthode d’initialisation d’instance ayant le nom spécial <init>.

La JVM initialise donc une méthode d'initialisation de classe ou d'interface et non une méthode d'initialisation d'instance qui est en réalité un constructeur. Ils n'ont donc pas besoin de mentionner que la méthode principale doit être statique dans les spécifications de la machine virtuelle Java, car elle est implicite du fait qu'aucune instance n'est créée avant l'appel de la méthode principale.

Récemment, une question similaire a été postée sur Programmers.SE

Pourquoi une méthode principale statique en Java et en C # plutôt qu'un constructeur?

Vous recherchez une réponse définitive d’une source primaire ou secondaire pour expliquer pourquoi (notamment) Java et C # ont décidé d’avoir une méthode statique comme point d’entrée & # 8211; plutôt que de représenter une instance d'application par une instance d'une Application classe, le point d'entrée étant un constructeur approprié?

TL; DR fait partie de la réponse acceptée est,

En Java, la raison de public static void main(String[] args) est que


Gosling voulait

le code écrit par une personne expérimentée en C (pas en Java)

à exécuter par une personne habituée à exécuter PostScript sur NeWS






& nbsp;
  Pour C #, le raisonnement est transitoirement similaire pour ainsi dire. Les concepteurs de langues ont conservé le point d'entrée du programme syntaxe familière pour les programmeurs venant de Java. En tant qu'architecte C #, Anders Hejlsberg le dit ,


... notre approche avec C # a simplement consisté à offrir une alternative ... aux programmeurs Java ...


...

Ce n'est qu'une convention. La JVM pourrait certainement traiter avec des méthodes principales non statiques si cela aurait été la convention. Après tout, vous pouvez définir un initialiseur statique sur votre classe et instancier un zillion d’objets avant d’avoir accès à votre méthode main ().

Le mot clé public est un modificateur d'accès permettant au programmeur de contrôler la visibilité des membres de la classe. Lorsqu'un membre de la classe est précédé de private, alors ce membre peut être accédé par le code en dehors de la classe dans laquelle il est déclaré.

L'opposé de main() est static, ce qui empêche un membre d'être utilisé par du code défini en dehors de sa classe.

Dans ce cas, void doit être déclaré comme <=>, car il doit être appelé par code en dehors de sa classe lorsque le programme est démarré.

Le mot clé <=> permet <=> à appeler sans avoir à instancier une instance particulière de la classe. Cela est nécessaire car <=> est appelé par l'interpréteur Java avant la création d'objets.

Le mot clé <=> indique simplement au compilateur que <=> ne renvoie pas de valeur.

Le véritable point d’entrée de toute application est une méthode statique. Si le langage Java prenait en charge une méthode d'instance en tant que & "; Point d'entrée &" ;, le runtime aurait alors besoin de l'implémenter en interne en tant que méthode statique qui construirait une instance de l'objet, suivie de l'appel de la méthode. / p>

Cela étant réglé, j'examinerai la raison pour laquelle j'ai choisi l'une des trois options suivantes:

A static void main() comme nous le voyons aujourd'hui.
Une méthode d'instance void main() appelée sur un objet nouvellement construit.
En utilisant le constructeur d'un type comme point d'entrée (par exemple, si la classe d'entrée était appelée Program, l'exécution consisterait en réalité en new Program()).

Ventilation:

main()

Appelle le constructeur statique de la classe englobante.
Appelle la méthode statique new ClassName().

<=>

Appelle le constructeur statique de la classe englobante.
Construit une instance de la classe englobante en appelant effectivement <=>.
Appelle la méthode d'instance <=>.

<=>

Appelle le constructeur statique de la classe englobante.
Construit une instance de la classe (puis ne fait rien avec elle et retourne simplement).

Justification:

Je vais aller dans l'ordre inverse pour celui-ci.

Gardez à l’esprit que l’un des objectifs de la conception de Java était de mettre l’accent sur (dans la mesure du possible, de bonnes pratiques) de programmation orientée objet. Dans ce contexte, le constructeur d'un objet initialise l'objet, mais ne devrait pas être responsable du comportement de l'objet. Par conséquent, une spécification qui donne un point d’entrée de <=> perturberait la situation des nouveaux développeurs Java en forçant une exception à la conception d’un & "Idéal &"; constructeur sur chaque application.

En faisant de <=> une méthode d'instance, le problème ci-dessus est certainement résolu. Cependant, cela crée une complexité en obligeant la spécification à répertorier la signature du constructeur de la classe d'entrée ainsi que la signature de la méthode <=>.

En résumé, spécifier un <=> crée une spécification la moins complexe possible tout en respectant le principe de placement du comportement dans les méthodes . Compte tenu de la simplicité avec laquelle il est possible d'implémenter une méthode <=> qui construit elle-même une instance d'une classe et appelle une méthode d'instance, il n'y a aucun avantage réel à spécifier <=> en tant que méthode d'instance.

static - Lorsque la machine virtuelle Java appelle la méthode main, il n'existe pas d'objet pour la classe appelée. Elle doit donc avoir une méthode statique pour autoriser l'appel de la classe.

Je ne sais pas si la machine virtuelle Java appelle la méthode principale avant l'instanciation des objets ... Mais il existe une raison beaucoup plus puissante pour laquelle la méthode main () est statique ... Lorsque la machine virtuelle Java appelle la méthode principale du classe (par exemple, personne). il l'invoque par " Person.main () " ;. Vous voyez, la JVM l'invoque par le nom de la classe. C’est pourquoi la méthode main () est supposée être statique et publique afin que la machine virtuelle puisse l’accéder.

J'espère que ça a aidé. Si c'est le cas, faites-le moi savoir en commentant.

Les méthodes statiques ne nécessitent aucun objet. Il fonctionne directement, donc principal fonctionne directement.

Le mot clé statique dans la méthode principale est utilisé car il n'y a pas d'instanciation dans la méthode principale. Mais l'objet est construit plutôt que l'invocation. En conséquence, nous utilisons le mot clé statique dans la méthode principale. Dans jvm, la mémoire contextuelle est créée lors du chargement de la classe. Tous les membres statiques sont présents dans cette mémoire. si nous faisons la statique principale maintenant, elle sera en mémoire et pourra être accessible à jvm (class.main (..)) afin que nous puissions appeler la méthode main sans avoir besoin de créer un tas.

C’est juste une convention comme on peut le voir ici:

La méthode doit être déclarée publique et statique , elle ne doit en retourner aucun. value, et il doit accepter un tableau String en tant que paramètre. Par défaut, le premier argument sans option est le nom de la classe à appeler. Un nom de classe complet doit être utilisé. Si l'option -jar est spécifié, le premier argument non-option est le nom d'une archive JAR contenant des fichiers de classe et de ressources pour l’application, avec le classe de démarrage indiquée par l'en-tête de manifeste Main-Class.

http://docs.oracle. com / javase / 1.4.2 / docs / tooldocs / windows / java.html # description

Les mots-clés voic statiques publics signifient que l'interpréteur de machine virtuelle Java (JVM) peut appeler la méthode principale du programme pour démarrer le programme (public) sans créer d'instance de la classe (statique). Le programme ne renvoie pas données vers l'interpréteur Java VM (void) à la fin.

Source: Essentials, partie 1, leçon 2: création d'applications

Fondamentalement, nous définissons les DONNEES MEMBRES et les FONCTIONS MEMBRES comme STATIQUES qui n’effectuent aucune tâche liée à un objet. Et dans le cas de la méthode main, nous le faisons en tant que STATIC car cela n’a rien à voir avec un objet, car la méthode main est toujours exécutée, que nous créons un objet ou non.

Toute méthode déclarée statique en Java appartient à la classe elle-même. Encore une fois, la méthode statique d’une classe particulière est accessible uniquement en faisant référence à la classe comme Class_name.method_name();

Il n'est donc pas nécessaire d'instancier une classe avant d'accéder à une méthode statique.

La méthode main () est donc déclarée comme static afin de pouvoir y accéder sans créer d'objet de cette classe.

Puisque nous sauvegardons le programme avec le nom de la classe où la méthode principale est présente (ou à partir duquel le programme doit commencer son exécution, applicable pour les classes sans main() méthode () (niveau avancé)). Donc, de la manière mentionnée ci-dessus:

Class_name.method_name();

la méthode principale est accessible.

En résumé, lorsque le programme est compilé, il recherche la String méthode ayant main(String args[]) des arguments tels que: <=> dans la classe mentionnée (c'est-à-dire par le nom du programme) et depuis le début, elle a pas de portée pour instancier cette classe, donc la méthode main () est déclarée comme statique.

De java.sun.com (plus d'informations sur le site):

La méthode principale est statique pour donner à l'interpréteur Java un moyen de démarrer la classe sans créer au préalable une instance de la classe de contrôle. Des instances de la classe de contrôle sont créées dans la méthode principale après le démarrage du programme.

Ma compréhension a toujours été simplement que la méthode principale, comme toute méthode statique, peut être appelée sans créer d'instance de la classe associée, ce qui lui permet de s'exécuter avant tout le reste du programme. Si ce n'était pas statique, vous devriez instancier un objet avant de l'appeler, ce qui crée un problème de «poule et d'oeuf», car la méthode principale est généralement celle que vous utilisez pour instancier des objets au début du programme.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow