Explication détaillée de l'utilisation des mots clés statiques et des classes internes en Java

Cet article vous apporte des connaissances pertinentes sur java et présente en détail l'utilisation de mots-clés statiques et de classes internes en Java. L'exemple de code dans l'article est expliqué en détail. J'espère que ce sera le cas. être utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

1. Mot-clé statique

En Java, les membres modifiés par static sont appelés membres statiques ou membres de classe, qui n'appartiennent pas à un objet spécifique et sont partagés par tous. objets.

1. Variables membres modifiées statiques

Les variables membres modifiées statiquement sont appelées variables membres statiques

[Caractéristiques des variables membres statiques] :

• n'appartient pas à un objet spécifique, c'est un attribut de la classe, tout objets Partagés, non stockés dans l'espace d'un objet
• Peut être accessible soit via la référence d'objet (non recommandé) soit via le nom de classe, mais il est généralement recommandé d'utiliser le nom de classe pour accéder
• Les variables de classe sont stockées dans la zone de méthode
• Le cycle de vie suit la vie de la classe (c'est-à-dire qu'il est créé lorsque la classe est chargée et détruit lorsque la classe est déchargée)

public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "rj2104";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }

    // ...
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);

    }
}

2. Méthodes de membres modifiés statiques

Membres de données dans les classes générales. sont définis sur private. La méthode membre est définie sur public. En Java, la méthode membre modifiée par static est appelée méthode membre statique. Il s'agit d'une méthode de classe et n'est pas unique à un objet.

Les membres statiques sont généralement accessibles via des méthodes statiques.

public class Student2{
    // ...
    private static String classRoom = "rj2104";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}

class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student2.getClassRoom());
    }
}

[Caractéristiques de la méthode statique] :

n'appartient pas à un objet spécifique, c'est une méthode de classe

• peut être appelée via l'objet, ou via le nom de la méthode statique (...) méthode, il est plus recommandé d'utiliser cette dernière
• Vous ne pouvez accéder à aucune variable membre non statique ni à aucune méthode membre non statique dans les méthodes statiques ; car les méthodes non statiques ont ce paramètre par défaut, mais vous ne pouvez pas transmettre cette référence lors de l'appel en statique. méthodes ; sauf si vous créez un nouvel objet dans la méthode statique, puis accédez à cet objet via la référence d'objet
• Les méthodes statiques ne peuvent pas être remplacées et ne peuvent pas être utilisées pour implémenter le polymorphisme

3. Les variables membres ne sont généralement pas initialisées dans le constructeur, ce qui est initialisé dans la méthode constructeur, ce sont les attributs d'instance liés à l'objet. L'initialisation des variables membres statiques est divisée en deux types : l'initialisation sur place et l'initialisation de bloc de code statique.

Initialisation sur place : donnez la valeur initiale directement lors de la définition

public class Student2{
    // ...
    //就地初始化
    private static String classRoom = "rj2104";
    //...
}

Utilisez un bloc de code statique pour terminer l'initialisation

public class Student2{
    // ...
    private static String classRoom;
    
    //静态代码块初始化
    static {
        classRoom = "rj2104";
    }

    // ...
}

2. Classe interne

En Java, une classe peut être définie à l'intérieur d'une autre classe ou d'une méthode, la la première est appelée classe interne et la seconde est appelée classe externe. Les classes internes sont également une manifestation de l'encapsulation.

Les classes internes et les classes externes partagent le même fichier source Java, mais après compilation, la classe interne formera un fichier de bytecode distinct. Le nom de fichier de bytecode généralement formé est : nom de classe externe $ nom de classe interne.class

.

public class OutClass {
    class InnerClass{
    }
}
// OutClass是外部类
// InnerClass是内部类

Selon les différents emplacements où les classes internes sont définies, elles peuvent généralement être divisées sous les formes suivantes :

1. Classes internes membres (classes internes ordinaires)

Classes internes d'instance : classes internes membres qui n'ont pas été modifiées statiquement.

Classe interne statique : classe interne de membre modifiée par static

2. Classe interne locale

3. Classe interne anonyme

1. La classe interne d'instance

est une classe interne membre qui n'est pas modifiée de manière statique.

【Remarque】 :

Tout membre de la classe externe est directement accessible dans la méthode de classe interne de l'instance

Il ne peut pas y avoir de variables membres statiques dans la classe interne de l'instance si elles doivent être définies, elles ne peuvent être que statiques ; final Constantes statiques modifiées, les constantes sont déterminées lors de la compilation du programme

L'emplacement de la classe interne de l'instance est le même que l'emplacement du membre de la classe externe, il est donc également soumis aux contraintes des qualificatifs d'accès publics, privés et autres

L'objet de classe interne de l'instance doit Il ne peut être créé que s'il existe d'abord un objet de classe externe. La méthode non statique de la classe interne de l'instance contient une référence à l'objet de classe externe et une référence à l'objet de classe interne de son. propre instance par défaut. Accédez au même nom dans la méthode de classe interne de l'instance. Lors de l'accès aux membres d'une classe externe, la priorité est donnée à l'accès à la sienne. Si vous souhaitez accéder à un membre de la classe externe portant le même nom, vous devez le faire. : nom de classe externe.this.Membre du même nom auquel accéder
• Dans la classe externe, vous ne pouvez pas accéder directement aux membres de la classe interne de l'instance. Si vous souhaitez accéder, vous devez d'abord créer un objet de l'instance interne. classe.

• public class OutClass {
      private int a;
      static int b;
      int c;
  
      public void methodA() {
          a = 10;
          System.out.println(a);
      }
  
      public static void methodB() {
          System.out.println(b);
      }
  
      // 实例内部类：未被static修饰
      class InnerClass {
          int c;
  //实例内部类当中 不能有静态的成员变量. 非要定义，那么只能是被static final修饰的
          public static final int d = 6;
  
          public void methodInner() {
  // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
              a = 100;
              b = 200;
              methodA();
              methodB();
              System.out.println(d);
  // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
              c = 300;
              System.out.println(c);
  // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
              OutClass.this.c = 400;
              System.out.println(OutClass.this.c);
          }
      }
  
      public static void main(String[] args) {
  // 外部类：对象创建 以及 成员访问
          OutClass outClass = new OutClass();
  
          System.out.println(outClass.a);
          System.out.println(outClass.b);
          System.out.println(outClass.c);
          outClass.methodA();
          outClass.methodB();
          System.out.println("=============实例内部类的访问=============");
  // 要访问实例内部类中成员，必须要创建实例内部类的对象
  // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
  // 创建实例内部类对象
          OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
          innerClass1.methodInner();
  // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
          OutClass.InnerClass innerClass2 = outClass.new InnerClass();
          innerClass2.methodInner();
      }
  }

• 2. Classe interne statique
• La classe membre interne modifiée par static est appelée une classe interne statique. ,
• [Remarque] :
• Dans une classe interne statique, vous ne pouvez accéder qu'aux membres statiques de la classe externe, sauf si vous créez un nouvel objet de la classe externe dans la classe interne et accédez aux membres non statiques via la référence de l'objet de classe externe.
• Lors de la création d'un objet de classe interne statique, il n'est pas nécessaire de créer d'abord un objet de classe externe

public class OuterClass2 {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;

    public void test() {
        System.out.println("out::test()");
    }

    // 静态内部类：被static修饰的成员内部类
    static class InnerClass2 {
        public int data4 = 4;
        int data5 = 5;
        public static int data6 = 6;

        public void func() {
            System.out.println("out::func()");

            //test();
            // 编译失败，在静态内部类中不能直接访问外部类中的非静态成员
            //System.out.println(data1);
            //System.out.println(data2);

            //外部类的非静态成员，需要通过外部类的对象的引用才能访问。
            OuterClass2 outerClass = new OuterClass2();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            outerClass.test();

            // 在静态内部类中只能访问外部类的静态成员
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data5);
            System.out.println(data6);

        }
    }
    public static void main(String[] args) {
        // 静态内部类对象创建 和 成员访问
        OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();
        innerClass2.func();

    }
}

3 Les classes internes locales

sont définies dans le corps de la méthode ou { } de la classe externe et sont généralement très utilisées. rarement.

【Remarques】

局部内部类只能在所定义的方法体内部使用

不能被public、static等修饰符修饰

局部内部类生成的字节码文件稍有区别：外部类名字$数字内部类名字.class

ppublic class OutClass {
    int a = 10;
    
    public void method(){
        int b = 10;
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    
    public static void main(String[] args) {
    // OutClass.InnerClass innerClass = null; 编译失败
    }
}

4. 匿名内部类

匿名内部类，就是没有名字的一种嵌套类

匿名内部类形成的字节码文件文件名为：外部类名字$数字.class

4.1 使用匿名内部的好处与演示

在实际开发中，我们会遇到下面的情况：

一个接口/类的方法的某个执行过程在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写方法。

代码中为了这一次的使用去创建一个类，未免太过麻烦，此时就可以使用匿名内部类来解决这个问题

首先来看我们正常的实现逻辑，假设有一个接口，接口当中只有一个方法

public interface Interface {
    void show();
}

为了使用该接口的show方法，我们需要去创建一个实现类，重写show方法的具体实现

public class Test implements Interface{
    @Override
    public void show() {
        System.out.println("只执行一次show()");
    }
}

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        test.show();
    }
}

如果实现类Test在程序中只使用一次，那么为了这一次的使用去创建一个类太过繁琐，这种情况下就可以用匿名内部类来实现，无需创建新的类，减少代码冗余，

看下面代码：

class Main {
    public static void main(String[] args) {
        //写法一
        Interface in = new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        };
        //调用接口方法
        in.show();
        
        //写法二
        new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        }.show();//调用接口方法
    }
}

4.2 匿名内部类的定义格式和使用

定义格式1：

接口名称 引用名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

引用名.方法调用

定义格式2：

new 接口名称() {
    // 覆盖重写所有抽象方法
}.方法调用;

对格式“new 接口名称() {…}”的理解：

new代表创建一个新的对象对象

接口名称就是匿名内部类需要实现哪个接口

{…}中是匿名内部类的内容

【注意事项】：

• 匿名内部类，在【创建对象】的时候，只能使用唯一 一次。
• 匿名对象，在【调用方法】的时候，只能调用唯一 一次。
• 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
• 匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求。

public class Class {
    public void show(String s){
        System.out.println("Class::show()");
    }
}

public abstract class AbstractClass {
    abstract void show(String s);
}

public interface Interface {
    void show(String s);
}

public class TestDome {
    public static void main(String[] args) {

        //重写普通类的方法
        new Class(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("普通类");

        //重写抽象类的抽象方法
        new AbstractClass(){
            @Override
            void show(String s) {
                System.out.println(s);
            }
        }.show("抽象类");

        //实现接口的抽象方法
        new Interface(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("接口");

    }
}

执行结果：

推荐学习：《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!