Quelle est la fonction du mot-clé statique Java ?

En Java, static est un modificateur, utilisé pour modifier les méthodes membres de classe et les variables membres de classe. De plus, les blocs de code statiques peuvent être écrits pour optimiser les performances du programme ; doit s'appuyer sur l'objet pour l'accès. Tant que la classe est chargée, elle est accessible via le nom de la classe.

(Tutoriel recommandé : Tutoriel d'introduction à Java)

1. Caractéristiques du mot-clé statique :

Il y a ce passage à la page P86 de "Java Programming Thoughts":

"Une méthode statique est une méthode sans cela. Les méthodes non statiques ne peuvent pas être appelées à l'intérieur d'une méthode statique, et l'inverse est possible. Et vous pouvez simplement appeler la méthode statique via la classe elle-même sans créer d'objets. C'est en fait l'objectif principal de la méthode statique "

Bien que ce paragraphe n'explique que la méthode statique. Spécial, mais vous pouvez voir la fonction de base du mot-clé static. En bref, la description en une phrase est :

Il est pratique d'appeler (méthode/variable) sans créer d'objet.

Évidemment, les méthodes ou variables modifiées par le mot-clé static n'ont pas besoin de s'appuyer sur des objets pour y accéder. Tant que la classe est chargée, elle est accessible via le nom de la classe.

static est un modificateur utilisé pour modifier les méthodes des membres de la classe et les variables des membres de la classe. De plus, des blocs de code statiques peuvent être écrits pour optimiser les performances du programme

(Recommandation du didacticiel vidéo : java ; tutoriel vidéo)

1. Méthodes membres statiques modifiées

Les méthodes statiques modifiées sont généralement appelées méthodes statiques puisque les méthodes statiques sont accessibles sans s'appuyer sur aucun objet, donc pour les méthodes statiques. , il n'y a pas de this, car il n'est attaché à aucun objet. Puisqu'il n'y a pas d'objet, il n'y a pas de this. Et en raison de cette fonctionnalité, les variables membres non statiques et les méthodes membres non statiques de la classe ne sont pas accessibles dans les méthodes statiques, car les méthodes/variables membres non statiques doivent s'appuyer sur des objets spécifiques avant de pouvoir être appelées.

Mais il convient de noter que bien que les méthodes membres non statiques et les variables membres non statiques ne soient pas accessibles dans les méthodes statiques, les méthodes/variables membres statiques sont accessibles dans les méthodes membres non statiques. Par exemple :

Dans le code ci-dessus, puisque la méthode print2 existe indépendamment de l'objet, elle peut être appelée directement avec le nom de la classe.

Si les méthodes/variables non statiques sont accessibles dans les méthodes statiques, alors s'il y a l'instruction suivante dans la méthode principale :

MyObject.print2();

À l’heure actuelle, il n’y a aucun objet et str2 n’existe pas du tout, donc une contradiction se produira. Il en va de même pour les méthodes. Étant donné que vous ne pouvez pas prédire si les variables membres non statiques sont accédées dans la méthode print1, l'accès aux méthodes membres non statiques dans les méthodes membres statiques est également interdit.

Pour les méthodes membres non statiques, il n'y a évidemment aucune restriction sur l'accès aux méthodes/variables membres statiques.

Par conséquent, si vous souhaitez appeler une méthode sans créer d'objet, vous pouvez définir cette méthode sur statique. Notre méthode statique la plus courante est la méthode main. Quant à savoir pourquoi la méthode main doit être statique, c'est maintenant clair. Étant donné que le programme ne crée aucun objet lors de l'exécution de la méthode principale, il n'est accessible que via le nom de la classe.

2. Variables membres statiques modifiées

Les variables statiques modifiées sont également appelées variables statiques. La différence entre les variables statiques et les variables non statiques est que les variables statiques sont partagées par tous les objets et qu'il n'y en a que. un dans la mémoire. Une copie qui sera initialisée si et seulement si la classe est chargée pour la première fois. Les variables non statiques appartiennent aux objets et sont initialisées lors de la création de l'objet. Il existe plusieurs copies et les copies appartenant à chaque objet ne s'affectent pas les unes les autres.

L'ordre d'initialisation des variables membres statiques est initialisé dans l'ordre défini.

3. Bloc de code modifié statique

Un autre rôle important du mot-clé static est de former un bloc de code statique pour optimiser les performances du programme. Un bloc statique peut être placé n’importe où dans une classe et il peut y avoir plusieurs blocs statiques dans une classe. Lorsqu'une classe est chargée pour la première fois, chaque bloc statique sera exécuté dans l'ordre des blocs statiques, et ne sera exécuté qu'une seule fois.

Le bloc statique peut optimiser les performances du programme de par ses caractéristiques : il ne sera exécuté qu'une seule fois lors du premier chargement de la classe. Comme suit :

class Person{
    private Date birthDate;

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        Date startDate = Date.valueOf("1946");
        Date endDate = Date.valueOf("1964");
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

isBornBoomer est utilisé pour déterminer si une personne est née entre 1946 et 1964. Chaque fois que isBornBoomer est appelé, deux objets, startDate et BirthDate, seront générés, provoquant une perte d'espace si vous. change Ce sera plus efficace comme suit :

class Person {
    private Date birthDate;
    private static Date startDate, endDate;

    static {
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        return birthDate.compareTo(startDate) >= 0 && birthDate.compareTo(endDate) < 0;
    }
}

Par conséquent, certaines opérations d'initialisation qui ne doivent être effectuées qu'une seule fois sont souvent placées dans des blocs de code statiques.

二、static关键字的误区

1. 与C/C++中的static不同，Java中的static关键字不会影响到变量的变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected这几个关键字。示例如下：

提示错误，说明static关键字并不会改变变量和方法的访问权限。

2. 虽然对于静态方法来说没有this，但是我们在非静态方法中能够通过this访问静态方法成员变量。如下：

public class Test {

    static int value = 11;

    public static void main(String[] args) {

        new Test().printValue();

    }

    private void printValue() {
        int value = 22;
        System.out.println(this.value);
    }
}

输出的结果是：11

这里的this表示的是当前对象，那么通过new Test()来调用printValue的话，当前对象就是通过new Test()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是11。在printValue方法内部的value是局部变量，根本不可能与this关联，所以输出11。需要记住的是：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要权限足够）。

3. 在C/C++中static关键字是可以作用于局部变量的，但是在Java中是不允许使用static修饰局部变量的。这是Java语法的规定。

更多编程相关知识，请访问：编程教学！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!