Que fait le mot clé "statique" dans une classe?

cela signifie qu'il n'y a qu'une seule instance de" clock "dans Hello, pas une par chaque instance séparée de la classe" Hello", ou plus-donc, cela signifie qu'il y aura une référence commune de" clock "parmi toutes les instances de la classe" Hello".

donc si vous deviez faire un "nouveau Bonjour" n'importe où dans votre code: A - dans le premier scénario (avant le changement, sans utiliser "static"), il ferait une nouvelle horloge chaque fois qu'un "nouveau Bonjour" est appelé, mais B - dans la seconde scénario (après le changement, en utilisant "static"), chaque instance "New Hello" partagerait et utiliserait toujours la référence initiale et la même "horloge" créée.

à moins que vous ayez besoin de "Horloge" quelque part en dehors de main, cela fonctionnerait aussi bien:

package hello;
public class Hello
{
    public static void main(String args[])
    {
      Clock clock=new Clock();
      clock.sayTime();    
    }
}

le mot-clé static signifie que quelque chose (un champ, une méthode ou une classe imbriquée) est lié au type plutôt que n'importe quelle instance du type. Ainsi par exemple, on appelle Math.sin(...) sans aucune instance de la classe Math , et en effet vous ne pouvez pas créer une instance de la classe Math .

pour plus d'informations, voir le Java Tutorial .

Sidenote

Java malheureusement vous permet d'accéder aux membres statiques comme s'ils étaient des membres d'instance, par exemple

// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);

qui le fait regarder comme si sleep est une méthode d'instance, mais il est en fait une méthode statique - il toujours fait le fil courant dormir. Il est préférable de le préciser dans le code d'appel:

// Clearer
Thread.sleep(5000);

le mot-clé static en Java signifie que la variable ou la fonction est partagée entre toutes les instances de cette classe car elle appartient au type , pas les objets eux-mêmes.

donc si vous avez une variable: private static int i = 0; et que vous l'incrémentez ( i++ ) dans une seule instance, le changement sera reflété dans toutes les instances. i sera désormais 1 dans tous les cas.

peuvent être utilisées sans l'instanciation d'un objet.

utilisation de Base de la statique des membres...

public class Hello
{
    // value / method
    public static String staticValue;
    public String nonStaticValue;
}

class A
{
    Hello hello = new Hello();
    hello.staticValue = "abc";
    hello.nonStaticValue = "xyz";
}

class B
{
    Hello hello2 = new Hello(); // here staticValue = "abc"
    hello2.staticValue; // will have value of "abc"
    hello2.nonStaticValue; // will have value of null
}

C'est comme ça que vous pouvez avoir des valeurs partagées dans tous les membres de la classe sans envoyer l'instance Hello à une autre classe. Et whit static vous n'avez pas besoin de créer une instance de classe.

Hello hello = new Hello();
hello.staticValue = "abc";

vous pouvez simplement appeler des valeurs statiques ou des méthodes par le nom de classe:

Hello.staticValue = "abc";

statique signifie que vous n'avez pas à créer une instance de la classe pour utiliser les méthodes ou variables associées à la classe. Dans votre exemple, vous pouvez appeler:

Hello.main(new String[]()) //main(...) is declared as a static function in the Hello class

directement, au lieu de:

Hello h = new Hello();
h.main(new String[]()); //main(...) is a non-static function linked with the "h" variable

de l'intérieur d'une méthode statique (qui appartient à une classe) vous ne pouvez pas accéder à des membres qui ne sont pas statiques, puisque leurs valeurs dépendent de votre instanciation de la classe. Un objet D'horloge non statique, qui est une instance Membre, aurait une valeur/référence différente pour chaque instance de votre classe Hello, et donc vous ne pouviez pas y accéder à partir de la partie statique de la classe.

Statique en Java:

Statique est un Non Modificateur d'Accès. Le mot-clé statique appartient à la classe que l'instance de la classe. peut être utilisé pour attacher une Variable ou une Méthode d'une Classe.

le mot-clé statique peut être utilisé avec:

Méthode

Variable

classe imbriquée dans une autre classe

Initialisation de la Bloc

ne peut pas être utilisé avec:

Classe (Non Emboîtée)

constructeur

Interfaces

méthode Classe intérieure locale (différence puis classe imbriquée)

Intérieure méthodes de la Classe

Instance Variables

Variables Locales

exemple:

imaginez l'exemple suivant qui a une variable d'instance appelée count qui est incrémentée dans le constructeur:

package pkg;

class StaticExample {
    int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

sortie:

1 1 1

puisque la variable d'instance reçoit la mémoire au moment de la création de l'objet, chaque objet aura la copie de la variable d'instance, si elle est incrémentée, elle ne reflétera pas à d'autres objet.

maintenant si nous changer le nombre de variables d'instance à une statique alors le programme produira une sortie différente:

package pkg;

class StaticExample {
    static int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

sortie:

1 2 3

dans ce cas, la variable statique n'obtiendra la mémoire qu'une seule fois, si un objet change la valeur de la variable statique, il conservera sa valeur.

statique avec Finale:

la variable globale qui est déclarée comme finale et statique reste inchangée pour l'exécution entière. Parce que, les membres statiques sont stockés dans la mémoire de la classe et ils ne sont chargés qu'une seule fois dans toute l'exécution. Ils sont communs à tous les objets de la classe. Si vous déclarez des variables statiques comme définitive, aucun des objets ne peuvent pas changer leur valeur finale. Par conséquent, les variables déclarées comme finale et statique sont parfois appelés constantes. Tous les champs d'interfaces sont appelés constantes, car ils sont finaux et statiques par défaut.

Image Ressource : "1519850920 Final" Statique

cette discussion a jusqu'à présent ignoré les considérations classloader. À proprement parler, les champs statiques Java sont partagés entre toutes les instances D'une classe pour un classloader .

pour ajouter aux réponses existantes, laissez-moi essayer avec une image:

un taux d'intérêt de 2% est appliqué à tous les comptes d'épargne. Par conséquent, il est statique .

Un équilibre doit être individu , il est pas statique.

Un champ peuvent être attribuées à la classe ou une instance d'une classe. Par défaut, les champs sont des variables d'instance. En utilisant static le champ devient une variable de classe, donc il y a une et une seule clock . Si vous faites un changement à un endroit, il est visible partout. Les variables d'Instance sont modifiées indépendamment les unes des autres.

en Java, le mot-clé static peut être simplement considéré comme indiquant ce qui suit:

"sans égard ou de la relation d'un cas particulier"

si vous pensez à static de cette façon, il devient plus facile de comprendre son utilisation dans les différents contextes dans lesquels il est rencontré:

• Un static champ est un champ qui appartient à la classe plutôt qu'à un cas particulier

• Un static est une méthode qui n'a aucune notion de this ; elle est définie sur la classe et ne savez pas au sujet de toute instance de cette classe, sauf si une référence est passé

• Un static membre de la classe est une classe imbriquée sans aucune notion ou la connaissance d'une instance de sa classe englobante (à moins qu'une référence à un enfermant instance de classe est passé)

Statique rend l'horloge membre un membre de la classe au lieu d'un membre de l'instance. Sans le mot-clé statique, vous auriez besoin de créer une instance de la classe Hello (qui a une variable membre clock) - par exemple

Hello hello = new Hello();
hello.clock.sayTime();

les méthodes statiques n'utilisent Aucune variable d'instance de la classe dans laquelle elles sont définies. Une très bonne explication de la différence peut être trouvée sur cette page

j'ai développé un goût pour les méthodes statiques (seulement, si possible) dans les classes" helper".

la classe calling n'a pas besoin de créer une autre variable member (instance) de la classe helper. Vous appelez juste les méthodes de la classe helper. Aussi la classe helper est améliorée parce que vous n'avez plus besoin d'un constructeur, et vous n'avez pas besoin de membre (exemple) variables.

Il y a probablement d'autres avantages.

le mot-clé static est utilisé pour désigner un champ ou une méthode comme appartenant à la classe elle-même et non l'instance. En utilisant votre code, si l'objet Clock est statique, toutes les instances de la classe Hello partageront ce Clock membre de données (champ) en commun. Si vous le rendez non statique, chaque instance individuelle de Hello peut avoir un champ unique Clock .

le problème est que vous avez ajouté un principal méthode de votre classe Hello afin que vous puissiez exécuter le code. Le problème ici est que la méthode principale est statique et en tant que telle, elle ne peut pas se référer à des champs non-statiques ou des méthodes à l'intérieur de celui-ci. Vous pouvez résoudre cela de deux façons:

1. Faire tous les champs et méthodes de la Hello classe statique de sorte qu'ils peuvent être renvoyés à l'intérieur de la principal la méthode. Ce n'est vraiment pas une bonne chose pour faire (ou de la mauvaise raison que t en faire un terrain et/ou une méthode statique)
2. créez une instance de votre classe Hello à l'intérieur de la méthode principale et accédez à tous ses champs et méthodes de la façon dont ils étaient prévus en premier lieu.

pour vous, cela signifie le changement de code suivant:

package hello;

public class Hello {

    private Clock clock = new Clock();

    public Clock getClock() {
        return clock;
    }

    public static void main(String args[]) {
        Hello hello = new Hello();
        hello.getClock().sayTime();
    }
}

peut aussi penser à des membres statiques n'ayant pas de pointeur" ceci". Elles sont partagées entre toutes les instances.

comprendre les concepts statiques

public class StaticPractise1 {
    public static void main(String[] args) {
        StaticPractise2 staticPractise2 = new StaticPractise2();
        staticPractise2.printUddhav(); //true
        StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */

        StaticPractise2.printUddhavsStatic1(); //true
        staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static  things and it organizes in its own heap. So, class static methods, object can't reference */

    }
}

Deuxième Classe

public class StaticPractise2 {
    public static void printUddhavsStatic1() {
        System.out.println("Uddhav");
    }

    public void printUddhav() {
        System.out.println("Uddhav");
    }
}

main() est une méthode statique qui comporte deux restrictions fondamentales:

1. la méthode statique ne peut pas utiliser un élément de données non statique ou appeler directement une méthode non statique.

2. this() et super() ne peut pas être utilisé dans le contexte statique.

   class A {  
       int a = 40; //non static
       public static void main(String args[]) {  
           System.out.println(a);  
       }  
   }
   

Sortie: Erreur De Compilation Dans Le Temps

les Variables statiques ne peuvent être consultées que dans les méthodes statiques, donc quand nous déclarons les variables statiques ces méthodes getter et setter seront des méthodes statiques

méthodes statiques est un niveau de classe que nous pouvons accéder en utilisant le nom de classe

exemple pour les variables statiques Getters et Setters:

public class Static 
{

    private static String owner;
    private static int rent;
    private String car;
    public String getCar() {
        return car;
    }
    public void setCar(String car) {
        this.car = car;
    }
    public static int getRent() {
        return rent;
    }
    public static void setRent(int rent) {
        Static.rent = rent;
    }
    public static String getOwner() {
        return owner;
    }

    public static void setOwner(String owner) {
        Static.owner = owner;
    }

}

quand exécuter quelque projet d'abord charger des choses statiques (variables, méthodes, blocs..).

lors de l'exécution de ce projet principale méthode charge d'abord. Parce que c'est static method . Puis il regarde objet "a" object .Mais l'objet d'un définissent pas encore. En raison de sa non-statiques. Alors viens comme cette erreur.

//Here is an example 

public class StaticClass 
{
    static int version;
    public void printVersion() {
         System.out.println(version);
    }
}

public class MainClass 
{
    public static void main(String args[]) {  
        StaticClass staticVar1 = new StaticClass();
        staticVar1.version = 10;
        staticVar1.printVersion() // Output 10

        StaticClass staticVar2 = new StaticClass();
        staticVar2.printVersion() // Output 10
        staticVar2.version = 20;
        staticVar2.printVersion() // Output 20
        staticVar1.printVersion() // Output 20
    }
}