Pourquoi d’autres méthodes peuvent-elles être "statiques" mais pas un constructeur?
Je ne comprends pas pourquoi la méthode principale doit être statique. Je comprends les variables statiques, mais il m'est difficile de comprendre les méthodes statiques. Existe-t-il une méthode statique permettant de créer deux méthodes portant le même nom dans deux classes différentes qui ne se heurtent pas?
De plus, je ne comprends pas pourquoi je ne peux pas créer de constructeur statique.
Quelqu'un pourrait-il aider à expliquer ce concept?
Java a [constructeurs statiques] blocs d'initialisation statiques pouvant être considérés comme un "constructeur statique":
class Foo {
static String Bar;
static {
// "static constructor"
Bar = "Hello world!";
}
}
Dans tous les cas, la seule méthode de la classe principale qui doit être statique est la méthode main. En effet, il est appelé sans en créant d'abord une instance de la "classe principale". Une technique courante, et celle que je préfère, consiste à rapidement sortir du contexte statique:
class Main {
int argCount;
// constructor
public Main (String[] args) {
// and back to boring ol' non-static Java
argCount = args.length;
}
void runIt () {
System.out.println("arg count: " + argCount);
}
// must be static -- no Main instance created yet
public static void main (String[] args) {
Main me = new Main(args);
me.runIt();
}
}
En outre, statique n'a rien à voir avec les "conflits de noms". Une méthode statique (ou variable) est simplement une méthode (ou variable) qui est not associée à une instance spécifique d'un type. Je vous recommanderais de lire le Didacticiel Java de classes et d'objets et la section Comprendre les variables d'instance et de classe .
Bonne codage.
Je partage l'une des raisons "pourquoi ne pas un constructeur Java être statique".
Dire simplement: "Un constructeur Java est toujours non statique" car,
L'objectif du constructeur est uniquement d'initialiser/construire l'objet et de rendre l'héritage possible. Pour ce faire, nous devons utiliser les deux mots-clés Java utiles (cum variables non statiques) tels que this et super. Nous allons utiliser 'this' pour initialiser l'objet . Nous/Java utiliserons super (ofcourse super ()) pour appeler le constructeur de la super classe afin que le super objet (ou la classe Object) crée d’abord l’objet enfant (d’où l’héritage) Si le constructeur est statique, nous ne pouvons utiliser que deux mots-clés (variables non statiques) à l'intérieur du constructeur (les informations non statiques ne peuvent pas être référencées à partir d'un contexte statique)
Les constructeurs Java ne doivent donc pas être statiques.
Le constructeur est utilisé pour créer des objets.
Statique est généralement le même pour tous les objets.
Donc, si nous avons eu des constructeurs statiques, la création d'un objet affectera tous les autres objets existants.
Les méthodes statiques ne font référence qu'à des variables statiques. Par conséquent, tous les paramètres initiaux que vous indiquez pour créer un objet sont modifiés pour tous les objets. Il ne sert à rien de créer des objets similaires sans utilité.
J'espère que cela t'aides.... :)
Les méthodes statiques appartiennent à une classe et non à un objet. La méthode main doit être statique car elle est appelée en premier, avant l'exécution de tout autre code pour instancier des objets. Il fournit un point d'entrée au programme. Les méthodes statiques sont appelées de l'extérieur du conteneur d'un objet. Il en va de même pour les variables de classe statiques. Une seule copie existe pour la classe entière, par opposition à une variable membre, créée une fois pour chaque objet créé à partir d'une classe. Ils sont utilisés pour stocker des données pour la classe, par exemple le nombre d'instances d'objet créées et non détruites. Ces données appartiennent à la classe. Un bon exemple de méthode statique est le modèle singleton, où le constructeur est privé et accessible uniquement par une fonction membre statique. Une fonction en dehors de la classe serait incapable de répliquer cette fonctionnalité. Cette méthode agit sur les données et les objets de la classe. Elle appartient donc logiquement à la même classe. Tout cela se résume à l'encapsulation. Une classe n'est responsable que d'elle-même et ne connaît que soi-même.
D'autre part, les méthodes objet sont censées agir sur les données associées à une seule instance d'une classe, un objet. Les constructeurs sont le code utilisé pour initialiser un objet et définir ses données à un état initial. Ils sont exécutés immédiatement (et automatiquement) après que la mémoire a été allouée pour stocker un nouvel objet. Même si vous ne définissez pas explicitement un constructeur, une sorte de "constructeur par défaut" est exécutée afin de mapper les variables membres de l'objet et le code de méthode de l'objet au nouvel objet.
J'espère que cela t'aides.
Constructeur est la propriété d'un objet alors que statique n'a rien à voir avec objet. C'est pourquoi il n'y a rien de tel que constructeur statique . Mais nous avons un bloc statique pour effectuer la même tâche que le constructeur, à savoir l’initialisation des champs, etc.
La méthode main(String[]) a un prototype spécifique dicté par le fonctionnement de l'environnement d'exécution Java. Lorsque vous appelez Java MyApplication à partir de la ligne de commande, Java VM recherchera une méthode statique main(String[]) contenue dans cette classe afin d'exécuter l'application. Si cette méthode n'est pas trouvée, Java VM ne peut pas exécuter la classe en tant qu'application. C'est comme ça que le langage est défini. Cela signifie également que Java VM ne crée pas d'instance de votre classe d'application afin de l'exécuter.
Maintenant, si vous voulez que votre classe soit utilisable en tant qu'application autonome ou en tant qu'instance créée par autre chose, vous pouvez demander à votre classe d'implémenter l'interface Runnable et de fournir une méthode main qui exécute la méthode run exemple.
public class MyRunnableThing implements Runnable
{
// Define whatever variables your runnable thing needs here as
// private instance fields.
/** Fulfills requirements of Runnable interface. */
public void run()
{
System.out.println( "I'm running..." ) ;
}
/** Also makes the class runnable from the console. */
public static void main( String[] args )
{
MyRunnableThing runMeNow = new MyRunnableThing() ;
runMeNow.run() ;
}
}
Maintenant, la classe toute pourrait potentiellement créer une instance de MyRunnableThing et utiliser sa méthode run() pour produire le même comportement qui aurait été vu en exécutant Java MyRunnablething.
Voir aussi: Travailler avec Static Constructor en Java . Quelques faits saillants de cette période de questions:
- Un constructeur est utilisé pour créer une instance de la classe, c'est donc une méthode d'instance, pas une méthode statique.
- Vous pouvez créer une méthode statique qui crée une instance de la classe à l'aide du constructeur. C'est ainsi que fonctionnent les nouvelles classes "constructeurs" à la mode.
- Vous pouvez créer une méthode statique qui renvoie une instance unique singleton persistante.
- Si votre classe a des membres statiques, vous pouvez créer un initialiseur static pour initialiser les valeurs de ces membres.
Le but de Constructor est de construire un objet, c’est-à-dire d’initialiser les variables d’instance de la classe, soit leurs valeurs par défaut, soit par leurs valeurs initialisées. Les variables d'instance non statiques ne sont pas accessibles aux méthodes statiques. Donc, le constructeur n'est pas statique.
Jetez simplement un coup d’oeil sur ce lien, il vous aidera certainement à comprendre: Pourquoi ne peut-on pas créer un constructeur statique?
ET
Le constructeur est appelé au moment de l'exécution lorsque nous créons des objets . Static est identique pour tous les objets, mais tous les objets ont leur propre état et propriétés . Ainsi, si nous avions eu des constructeurs statiques, la création d'un seul autres objets existants . Remarque: statique correspond au niveau de la classe lorsque les constructeurs sont associés aux objets.
par exemple.
public class Foo
{
String name;
int id;
// define constructors
Foo (String name, int id)
{
this.name = name;
this.id = id;
}
p s v m(String[] arg)
{
Foo f1 = new Foo("Amit",001);
Foo f2 = new Foo("Rahul",002);
}
}
Si nous créons un constructeur statique, les deux objets (f1 également) contiendront la dernière valeur mise à jour concernant name et id sous la forme Rahul et 002.
La méthode déclarée comme statique ne nécessite aucune création d'objet. Comme nous ne créons pas d'objet pour la méthode principale, elle est déclarée comme statique.
le constructeur est appelé implicitement pour initialiser un objet. Il est donc inutile de disposer d'un constructeur statique.
J'ai écrit un exemple simple comme réponse à une question connexe hier, ce qui peut aider à rendre les choses plus compréhensibles: quel est l'intérêt du constructeur Java?
Le point essentiel des méthodes statiques est qu'elles peuvent être appelées sans créer d'instance de classe, alors que les méthodes d'instance "normales" sont associées à une instance et ne peuvent pas être appelées sans une instance.
Étant donné que la méthode Main de la classe Main est le point d’entrée du programme, aucune instance ne peut éventuellement avoir encore été créée. Il est donc naturel que vous ne puissiez pas y accéder via une instance. Par conséquent, il est statique et peut donc être exécuté au démarrage du programme.
Un constructeur ne peut pas être statique, car dans un langage OO, le processus de création d'un objet est le suivant:
- allouer l'objet
- appeler le constructeur pour initialiser l'objet nouvellement alloué
Les constructeurs ne sont utilisés nulle part ailleurs (un langage sûr pour le type devrait l'imposer), donc il s'ensuit qu'un constructeur sera toujours appelé dans un contexte non statique.
Si un constructeur était statique, il ne recevrait pas de référence à l'objet nouvellement alloué et ne pourrait donc pas l'initialiser.
Ainsi, un constructeur peut toujours être non statique (comme il est toujours appelé depuis un contexte non statique) et doit toujours être non statique (sinon, il serait incapable d'accomplir sa tâche).
Java ne permet pas de déclarer un constructeur comme statique. Voici les raisons.
Statique signifie pour la même classe. c'est-à-dire que les méthodes statiques ne peuvent pas être héritées.
Avec static, "cette" référence (mot-clé) ne peut pas être utilisée. "this" est toujours lié à un objet. Un constructeur appartient toujours à un objet.
Si un constructeur est statique, un objet de sous-classe ne peut pas y accéder. Si static est autorisé avec constructeur, il est accessible dans la classe mais pas par sous-classe.