Java의 정적 키워드 및 내부 클래스 사용에 대한 자세한 설명

이 기사에서는 java에 대한 관련 지식을 제공하고 Java에서 정적 키워드 및 내부 클래스의 사용을 자세히 소개합니다. 기사의 샘플 코드에 대해 자세히 살펴보겠습니다. 모두에게 도움이 되십시오.

추천 학습: "java 비디오 튜토리얼"

1.정적 키워드

Java에서는 static에 의해 수정된 멤버를 정적 멤버 또는 클래스 멤버라고 하며 특정 객체는 모두가 공유합니다. 사물.

1. 정적 수정 멤버 변수

정적 수정 멤버 변수를 정적 멤버 변수라고 합니다.

[정적 멤버 변수의 특징]:

• 특정 객체에 속하지 않고 클래스의 속성입니다. 모든 객체 공유됨, 객체의 공간에 저장되지 않음
• 객체 참조(권장하지 않음) 또는 클래스 이름을 통해 액세스할 수 있지만 일반적으로 액세스하려면 클래스 이름을 사용하는 것이 좋습니다
• 클래스 변수는 메소드에 저장됩니다. 영역
• 라이프 사이클은 클래스의 수명을 따릅니다(즉, 클래스가 로드될 때 생성되고 클래스가 언로드될 때 소멸됩니다)

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. 정적 수정 멤버 메서드

일반적인 데이터 멤버 클래스는 private으로 설정됩니다. 멤버 메서드는 public으로 설정됩니다. Java에서는 static으로 수정되는 멤버 메서드를 정적 멤버 메서드라고 하며 개체에 고유하지 않습니다.

정적 멤버는 일반적으로 정적 메서드를 통해 액세스됩니다.

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());
    }
}

[정적 메소드 특징]:

은 특정 객체에 속하지 않고 클래스 메소드입니다.

• 객체를 통해 호출할 수도 있고, 클래스 이름(...) 메소드를 통해 호출할 수도 있습니다. 후자를 사용하는 것이 더 좋습니다.
• 비정적 메서드에는 기본적으로 이 매개 변수가 있기 때문에 정적 메서드에서 비정적 멤버 변수와 비정적 멤버 메서드에 액세스할 수 없습니다. 그러나 정적 메서드를 호출할 때는 이 참조를 전달할 수 없습니다. 정적 메서드에서 새 개체를 만든 다음 개체 참조를 통해 이 개체에 액세스하지 않는 한
• 정적 메서드는 재정의될 수 없으며 다형성을 구현하는 데 사용할 수 없습니다

3 정적 멤버 변수 초기화. 멤버 변수는 일반적으로 초기화를 위해 생성자에 배치되지 않으며 생성자 메소드에서 초기화되는 것은 객체와 관련된 인스턴스 속성입니다. 정적 멤버 변수의 초기화는 내부 초기화와 정적 코드 블록 초기화의 두 가지 유형으로 나뉩니다.

In-place 초기화 : 정의 시 초기값을 직접 부여

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

정적 코드 블록을 사용하여 초기화 완료

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

    // ...
}

2. 내부 클래스

Java에서는 클래스를 다른 클래스나 메소드 내부에서 정의할 수 있으며, 전자를 내부 클래스라고 하고 후자를 외부 클래스라고 합니다. 내부 클래스도 캡슐화의 표현입니다.

내부 클래스와 외부 클래스는 동일한 Java 소스 파일을 공유하지만 컴파일 후 내부 클래스는 별도의 바이트코드 파일을 구성합니다. 일반적으로 형성된 바이트코드 파일 파일 이름은 외부 클래스 이름 $ 내부 클래스 이름.클래스

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

내부 클래스가 정의되는 위치에 따라 일반적으로 다음과 같은 형태로 나눌 수 있습니다.

1. 멤버 내부 클래스(일반 내부 클래스)

인스턴스 내부 클래스: 정적으로 수정되지 않은 멤버 내부 클래스

Static 내부 클래스: static으로 수정된 멤버 내부 클래스

3. 익명 내부 클래스

1. 인스턴스 내부 클래스

는 static으로 수정되지 않은 멤버 내부 클래스입니다.

【참고】:

외부 클래스의 모든 멤버는 인스턴스 내부 클래스 메서드에서 직접 액세스할 수 있습니다.인스턴스 내부 클래스에는 정적 멤버 변수를 정의해야 할 경우 정적 멤버 변수만 있을 수 있습니다. final 수정된 정적 상수, 프로그램이 컴파일될 때 상수가 결정됩니다

인스턴스 내부 클래스의 위치는 외부 클래스 멤버의 위치와 동일하므로 public, private 및 기타 액세스 한정자의 제약 조건도 적용됩니다.

인스턴스 내부 클래스 개체는 반드시 외부 클래스 개체가 있는 경우에만 생성될 수 있습니다. 인스턴스 내부 클래스의 비정적 메서드에는 외부 클래스 개체에 대한 참조와 해당 클래스의 내부 클래스 개체에 대한 참조가 포함되어 있습니다. 기본적으로 인스턴스의 내부 클래스 메서드에서 동일한 이름에 액세스합니다. 외부 클래스의 멤버에 액세스할 때 동일한 이름을 가진 외부 클래스의 멤버에 액세스하려면 우선순위가 부여됩니다. : 외부 클래스 이름.this.동일한 이름의 멤버가 접근합니다.

외부 클래스에서는 인스턴스의 내부 클래스 멤버에 직접 접근할 수 없습니다. 접근하려면 먼저 내부 클래스의 객체를 생성해야 합니다. 수업.

• 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. 정적 내부 클래스
• 정적으로 수정된 내부 멤버 클래스를 정적 ​​내부 클래스라고 합니다. ,
• [참고]:
• 정적 내부 클래스에서는 내부 클래스에서 외부 클래스의 새 개체를 만들고 참조를 통해 비정적 멤버에 액세스하지 않는 한 외부 클래스의 정적 멤버에만 액세스할 수 있습니다. 외부 클래스 객체의 .
• 정적 내부 클래스 객체를 생성할 때 먼저 외부 클래스 객체를 생성할 필요가 없습니다

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. 로컬 내부 클래스

는 외부 클래스의 메소드 본문이나 { }에 정의되어 있으며 일반적으로 매우 많이 사용됩니다. 드물게.

【주의사항】

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

不能被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视频教程》

위 내용은 Java의 정적 키워드 및 내부 클래스 사용에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!