Peut-il exister deux méthodes principales dans un programme Java?
Peut-il exister deux méthodes principales dans un programme Java? Seulement par la différence dans leurs arguments comme:
public static void main(String[] args)
et le second peut être
public static void main(StringSecond[] args)
Si c'est possible, quelle méthode sera utilisée comme point d'entrée? Comment l'identifier? veuillez aider.
Tant que les paramètres de méthode (nombre (ou type)) sont différents, oui, ils le peuvent. Il s'appelle surcharge .
Les méthodes surchargées sont différenciées par le nombre et le type des arguments passés dans la méthode
public static void main(String[] args)
seule méthode principale avec un seul String[] (ou) String... as param sera considéré comme le point d'entrée du programme.
Ici, vous pouvez voir qu'il y a 2 public static void main (String args[]) dans un seul fichier avec le nom Test.Java (Spécifiquement n'a pas utilisé le nom du fichier comme l'un des 2 noms de classes) et les 2 classes sont avec le spécificateur d'accès par défaut.
class Sum {
int add(int a, int b) {
return (a+b);
}
public static void main (String args[]) {
System.out.println(" using Sum class");
Sum a = new Sum();
System.out.println("Sum is :" + a.add(5, 10));
}
public static void main (int i) {
System.out.println(" Using Sum class main function with integer argument");
Sum a = new Sum();
System.out.println("Sum is :" + a.add(20, 10));
}
}
class DefClass {
public static void main (String args[]) {
System.out.println(" using DefClass");
Sum a = new Sum();
System.out.println("Sum is :" + a.add(5, 10));
Sum.main(null);
Sum.main(1);
}
}
Lorsque nous compilons le code Test.Java, il générera 2 fichiers .class (À savoir Sum.class Et DefClass.class) Et si nous exécutons Test.Java, nous ne pouvons pas l'exécuter comme il le gagnera ' t ne trouvez aucune classe principale portant le nom Test. Au lieu de cela, si nous faisons Java Sum Ou Java DefClass, Les deux donneront des sorties différentes en utilisant différentes main(). Pour utiliser la méthode principale de la classe Sum, nous pouvons utiliser le nom de classe Sum.main(null) ou Sum.main(1)//Passing integer value in the DefClass main().
Dans une portée de classe, nous ne pouvons avoir qu'une seule public static void main (String args[]) par classe car une méthode statique d'une classe appartient à une classe et non à ses objets et est appelée en utilisant son nom de classe. Même si nous créons plusieurs objets et appelons les mêmes méthodes statiques en les utilisant, alors l'instance de la méthode statique à laquelle ces appels se réfèrent sera la même.
Nous pouvons également faire la surcharge de la méthode principale en passant différents ensembles d'arguments dans le main. L'exemple similaire est fourni dans le code ci-dessus mais par défaut, le flux de contrôle commencera par la public static void main (String args[]) du fichier de classe que nous avons invoquée en utilisant Java classname. Pour appeler la méthode principale avec un autre ensemble d'arguments, nous devons l'appeler explicitement à partir d'autres classes.
Il peut y avoir plusieurs méthodes principales dans un même programme. D'autres sont surchargés. Cette méthode surchargée fonctionne bien sous une seule méthode principale
public class MainMultiple{
public static void main(String args[]){
main(122);
main('f');
main("hello Java");
}
public static void main(int i){
System.out.println("Overloaded main()"+i);
}
public static void main(char i){
System.out.println("Overloaded main()"+i);
}
public static void main(String str){
System.out.println("Overloaded main()"+str);
}
}
Ce serait du code compilable, tant que StringSecond serait une classe. Cependant, si par "méthode principale" vous entendez un deuxième point d'entrée dans le programme, alors la réponse à votre question est toujours non. Seule la première option (public static void main(String[] args)) peut être le point d'entrée dans votre programme.
Notez, cependant, que si vous deviez placer une deuxième méthode main(String[]) dans une classe différente (mais dans le même projet), vous pourriez avoir plusieurs points d'entrée possibles dans le projet parmi lesquels vous pourriez alors choisir. Mais cela ne peut pas entrer en conflit avec les principes de neutralisation ou de surcharge.
Notez également qu'une source de confusion dans ce domaine, en particulier pour les programmeurs d'introduction, est que public static void main(String[] args) et public static void main(String ... args) sont tous deux utilisés comme points d'entrée et sont traités comme ayant la même signature de méthode.
Seule public static void main(String[] args) compte. C'est la seule signature considérée comme le vrai main () (comme point d'entrée du programme, je veux dire).
En Java, vous pouvez avoir juste un public static void main(String[] args) par classe . Ce qui signifie, si votre programme a plusieurs classes, chaque classe peut avoir public static void main(String[] args). Voir JLS pour plus de détails.
Oui, vous pouvez avoir autant de méthodes principales que vous le souhaitez. Vous pouvez avoir des méthodes principales avec des signatures différentes de main(String[]) qui est appelée surcharge, et la JVM ignorera ces méthodes principales.
public class TwoMain {
public static void main(String args1[])
{
System.out.println("First main");
}
public static void main(String args2[])
{
System.out.println("Second main");
}
}
La signature de la méthode principale doit être
public static void main(String[] args)
- Le nom du paramètre peut être n'importe quel nom valide
- Les positions des mots clés statiques et publics peuvent être échangées
- Le tableau String peut également utiliser la syntaxe varargs
Une classe peut définir plusieurs méthodes avec le nom main. La signature de ces méthodes ne correspond pas à la signature de la méthode principale. Ces autres méthodes avec des signatures différentes ne sont pas considérées comme la méthode "principale".
Oui, il est possible d'avoir deux principaux () dans le même programme. Par exemple, si j'ai une classe Demo1 comme ci-dessous. La compilation de ce fichier générera un fichier Demo1.class. Et une fois que vous l'exécutez, il exécutera le principal () ayant un tableau d'arguments String par défaut. Il ne reniflera même pas au main () avec l'argument int.
class Demo1 {
static int a, b;
public static void main(int args) {
System.out.println("Using Demo1 class Main with int arg");
a =30;
b =40;
System.out.println("Product is: "+a*b);
}
public static void main(String[] args) {
System.out.println("Using Demo1 class Main with string arg");
a =10;
b =20;
System.out.println("Product is: "+a*b);
}
}
Output:
Using Demo1 class Main with string arg
Product is: 200
Mais si j'ajoute une autre classe nommée Anonym et enregistre le fichier sous Anonym.Java. À l'intérieur, j'appelle la classe Demo1 main () [soit un argument int soit un argument chaîne]. Après avoir compilé ce fichier Anonym.class est généré.
class Demo1 {
static int a, b;
public static void main(int args) {
System.out.println("Using Demo1 class Main with int arg");
a =30;
b =40;
System.out.println("Product is: "+a*b);
}
public static void main(String[] args) {
System.out.println("Using Demo1 class Main with string arg");
a =10;
b =20;
System.out.println("Product is: "+a*b);
}
}
class Anonym{
public static void main(String arg[])
{
Demo1.main(1);
Demo1.main(null);
}
}
Output:
Using Demo1 class Main with int arg
Product is: 1200
Using Demo1 class Main with string arg
Product is: 200
Le code ci-dessous dans le fichier " Locomotive.Java " sera compilé et exécuté avec succès, avec les résultats d'exécution affichés
2<SPACE>
Comme mentionné dans le post ci-dessus, les règles de surcharge fonctionnent toujours pour la méthode principale. Cependant, le point d'entrée est le fameux psvm (public static void main (String [] args))
public class Locomotive {
Locomotive() { main("hi");}
public static void main(String[] args) {
System.out.print("2 ");
}
public static void main(String args) {
System.out.print("3 " + args);
}
}
Oui! Toute classe de Java peut avoir plusieurs méthodes principales. Elle s'appelle surcharge (les méthodes surchargées sont des méthodes de même nom mais avec des signatures différentes) mais il ne devrait y avoir qu'une seule méthode principale avec des paramètres comme celui-ci: - (String [] args) ou (String args [])
Par exemple: -public class E {
public static void main(String args){
System.out.println("Print A");
}
public static void main(String [] args){
System.out.println("Print B");
}
public static void main(int garbage){
System.out.println("Print C");
}
public static void main(int i){
System.out.println("Print D")
}
}
La sortie du programme ci-dessus sera "Imprimer B" car seule cette méthode principale contient la signature de méthode correcte identifiée par le compilateur Javac et il compile cela uniquement et laisse le reste.
La réponse est non; il ne peut y avoir qu'une seule méthode "principale" - où "principal" signifie un point d'entrée que vous pouvez "exécuter".
Vous pouvez coder des versions surchargées comme dans votre exemple, mais elles ne peuvent pas être "exécutées".
La réponse est oui, mais vous devriez considérer les 3 points suivants.
Aucun paramètre de méthode principal ne doit être le même
Par exemple.
public static void main(int i)public static void main(int i, int j)public static void main(double j)public static void main(String[] args)
La méthode principale actuelle de Java est celle avec
(String[] args), Donc l'exécution réelle commence à partir de void public statique principal (String [] args), donc la méthode principale avec(String[] args)est obligatoire dans une classe sauf s'il ne s'agit pas d'une classe enfant.Pour que d'autres méthodes principales s'exécutent, vous devez les appeler de l'intérieur du
(String[] args)méthode principale.
Voici une vidéo détaillée sur le même: https://www.youtube.com/watch?v=Qlhslsluhg4&feature=youtu.be
la possibilité de deux méthodes principales (String [] args) dans la même portée crée de la confusion pour la JVM. Il ne parvient pas à les utiliser comme méthodes surchargées. Les signatures en termes de paramètres doivent donc être différentes.
Il peut y avoir plusieurs méthodes principales dans un même programme. Mais la JVM appelle toujours la méthode main () de l'argument String []. D'autres méthodes agiront comme une méthode surchargée. Ces méthodes surchargées que nous devons appeler explicitement.