Explication détaillée des classes internes Java

Classes internes ordinaires

Il y a deux points principaux qui doivent être maîtrisés dans les classes internes ordinaires

tient le parent référence de classe, donc Variables et méthodes pouvant accéder à tous les droits d'accès de la classe parent

Comment les classes internes sont créées en dehors de la classe parent

public class Main{
    public static void main(String args[]){
        Outer outer = new Outer();
        //外部类外部创建内部类
        Outer.Inner inner = outer.new Inner();
        inner.method();
    }
}
class Outer{
    private String value = "OuterValue";
    class Inner{
        public void method(){
            //持有父类引用,可以访问父类private变量value
            System.out.println(value);
        }
        //利用.this关键字,可以返回父类对象引用
        public Outer outerObject(){
            return Outer.this;
        }
    }
}

(Tutoriel recommandé : Programme de démarrage Java )

Classe interne de méthode

Classe interne

définie directement dans la méthode a les mêmes autorisations que la méthode et peut accéder aux autres méthodes et les variables membres de la classe externe.

peut accéder aux paramètres de cette méthode. Après la version 1.8, les paramètres n'ont pas besoin d'être définis sur final

a les mêmes autorisations que les variables locales de la méthode et peut accéder aux variables locales. défini devant lui

La classe interne de la méthode n'est accessible que dans la portée de la méthode

public class Main{
    public static void main(String args[]){
        Outer outer = new Outer();
        outer.outerMethod("param");
    }
}
class Outer{
    public void outerMethod(String value){
        class Inner {
            public void innerMethod(){
                //可以访问方法参数
                //1.8以后，内部类访问的方法参数不必设置为final
                System.out.println(value);
            }
        }
        new Inner().innerMethod();
    }
}

Classe interne anonyme

La classe interne anonyme est en fait un point clé, et c'est aussi un point de connaissance que nous utilisons souvent .

Par exemple, créer un nouveau fil

public class Main{
    public static void main(String args[]){
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("thread a is running;");
            }
        });
        a.start();
    }
}

Le code ci-dessus signifie créer un objet de classe anonyme qui implémente l'interface Runnable, ce qui est équivalent au code suivant en raison de la commodité d'écriture. , nous utilisons souvent le deuxième type

public class Main{
    public static void main(String args[]){
        Thread a = new Thread(new RunnableImp());
        a.start();
    }
    static class RunnableImp implements Runnable{
        @Override
        public void run(){
            System.out.println("thread a is running;");
        }
    }
}

Classe interne statique

Rappelez-vous les deux points suivants

Pour créer un objet de classe interne statique, vous faites pas besoin d'un objet de la classe externe (les classes internes ordinaires nécessitent)

Impossible d'accéder aux méthodes de classe externe non statiques ou aux variables membres à partir d'une classe interne statique

public class Main{
    Outer.Inner inner = new Outer.Inner();
}

class Outer{
    private String ordValue;
    private static String staValue;
    static class Inner{
        {
            System.out.println(staValue);

            //这句编译通不过
            //System.out.println(ordValue);
        }
    }
}

Recommandations de didacticiels vidéo associées : vidéo 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!