Comment résoudre le problème des références directes illégales en Java

java signale une référence avancée illégale

Ce n'est pas le bon code :

class BB
{
    static int a = 0 ;
    public BB()
    {
        a++ ;
        System.out.println("执行BB" + a) ;
    }
    public void printA()
    {
        System.out.println("a= " + a) ;
    }
}
public class CC
{
    static
    {
        a = new BB() ;
        a.printA() ;　　　　//报错说非法的前向引用
    }
    static BB a = new BB() ;
    public staic void main(String args[])
    {
        CC c = new CC() ;
    }
}

Pourquoi est-ce que j'initialise a dans le bloc de code statique et j'obtiens toujours une erreur ?

La raison implique les restrictions de Java sur les variables membres pendant le processus d'initialisation :

Si la variable membre a répond aux quatre points suivants, elle doit être le membre avant utilisation Déclarer la variable# 🎜🎜#

• Définissez C comme classe ou interface qui contient directement la variable membre

• Si un apparaît en C ou Initialisation d'un membre statique/membre non statique ou bloc de code statique ou non statique de C

• Si a n'est pas une lvalue d'une inégalité d'affectation#🎜 🎜##🎜🎜 #
  Accès par nom simple

• Dans le code que j'ai écrit, a.printA() apparaît L'emplacement est dans le bloc de code statique ; de CC, auquel on accède directement via un nom simple (c'est-à-dire directement en utilisant a), et ce n'est pas une lvalue de l'inégalité d'affectation, donc l'erreur "référence avant illégale" sera signalée

Il s'agit du code original dans la spécification du langage Java (le chinois qu'il contient est ma propre annotation) :

class UseBeforeDeclaration
{
    static
    {
        x = 100;
        // ok - assignment , 赋值表达式的左值
        int y = x + 1;
        // error - read before declaration , 赋值表达式的右值
        int v = x = 3;
        // ok - x at left hand side of assignment , 左值
        int z = UseBeforeDeclaration.x * 2;
        // ok - not accessed via simple name , 是通过类.静态变量 的形式访问, 而非直接简单访问
        Object o = new Object()
        {
            void foo()
            {
                x++;
            }
            // ok - occurs in a different class , 不是CC的代码块或成员初始化中,而是在一个全新的内部类的函数中
            {
                x++;
            }
            // ok - occurs in a different class , 在一个内部类的代码块中, 和上一个类似
        };
    }
    {
        j = 200;
        // ok - assignment
        j = j + 1;
        // error - right hand side reads before declaration , 第二个右值
        int k = j = j + 1;
        // error - illegal forward reference to j , 第三个是右值
        int n = j = 300;
        // ok - j at left hand side of assignment , 左值
        int h = j++; 
        // error - read before declaration , 右值, 并参与了自增运算
        int l = this.j * 3;
        // ok - not accessed via simple name 通过this.j进行访问, 非直接简单访问
        Object o = new Object()
        {
            void foo()
            {
                j++;
            }
            // ok - occurs in a different class
            {
                j = j + 1;
            }
            // ok - occurs in a different class
        };
    }
    int w = x = 3;
    // ok - x at left hand side of assignment
    int p = x;
    // ok - instance initializers may access static fields
    static int u =
        (new Object()
    {
        int bar()
        {
            return x;
        }
    }).bar();
    // ok - occurs in a different class
    static int x;
    int m = j = 4;
    // ok - j at left hand side of assignment
    int o =
        (new Object()
    {
        int bar()
        {
            return j;
        }
    }).bar();
    // ok - occurs in a different class
    int j;
}

Méthode de référence directe illégale en Java

Exemple de référence directe illégale ：

Alors pourquoi le code est-il comme i="1234" ? possible?

C'est parce que Java a des "concessions" pour certaines de ces situations, dont "Les variables référencées par des noms simples peuvent apparaître dans les positions lvalue, mais pas dans la position rvalue", donc le code précédent fonctionne, mais pas System.out.println(i); car il s'agit d'une référence rvalue.

Le but est d'éviter l'initialisation de la boucle et d'autres comportements d'initialisation anormaux.

Qu'est-ce qu'une référence circulaire ? Jetez un œil à l'exemple suivant :

privateinti=j;
privateintj=i;

S'il n'y a pas de vérification obligatoire mentionnée ci-dessus, alors ces deux lignes de code sera compilé. Mais il est facile de voir que i et j ne sont pas réellement attribués, car les deux variables ne sont pas initialisées (Java stipule que toutes les variables doivent être initialisées avant utilisation)

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!