자바 대상 초기 화

머리말
자바 에서 한 대상 이 사용 되 기 전에 정확하게 초기 화 되 어야 한 다 는 점 은 자바 규범 에 규정된 것 이다.
자동 초기 화 (기본 값)
하나의 클래스 의 모든 기본 데이터 구성원 이 초기 화 됩 니 다. 다음 예 를 실행 하면 기본 값 을 볼 수 있 습 니 다.

class Default{
  boolean t;
  char c;
  byte b;
  short s;
  int i;
  long l;
  float f;
  double d;
  public void show() {
    System.out.println("          
"+
            "boolean" + t +"
" +
            "char" + c +"
" +
            "byte" + b + "
" +
            "short" + s + "
" +
            "int" + i + "
" +
            "long" + l + "
" +
            "float" + f + "
" +
            "double" + d + "
"
    );

  }
}
public class InitValue {
  public static void main(String[] args) {
    Default d = new Default();
    d.show();
  }
}

[실행 결과]:
기본 유형   초기 화 값
booleanfalse
char
byte0
short0
int0
long0
float0.0
double0.0
그 중에서 char 형식의 기본 값 은 비어 있 습 니 다 (null).
기본 데이터 형식 이 아 닌 경우 대상 의 핸들 도 초기 화 됩 니 다.

class Person {
  private String name;
  // setter
}
class Default {
  Person p;
  public void show() {
    System.out.println("Person" + p);
  }
}
public class InitValue {
  public static void main(String[] args) {
    Default d = new Default();
    d.show();
  }
}

[실행 결과]:
Personnull
이 를 통 해 알 수 있 듯 이 핸들 초기 화 값 은 null 입 니 다.p 에 초기 화 값 을 지정 하지 않 으 면 p.setName 과 유사 한 방법 을 호출 하면 이상 이 생 긴 다 는 것 이다.
규정 초기 화
변수 에 초기 값 을 부여 해 야 한다 면 변 수 를 정의 하 는 동시에 값 을 부여 할 수 있 습 니 다.

class Default{
  boolean t = true;
  char c = 'A';
  byte b = 47;
  short s = 0xff;
  int i = 24;
  long l = 999;
  float f = 1.2f;
  double d = 1.732;
  public void show() {
    System.out.println(
            "boolean" + t +"
" +
            "char" + c +"
" +
            "byte" + b + "
" +
            "short" + s + "
" +
            "int" + i + "
" +
            "long" + l + "
" +
            "float" + f + "
" +
            "double" + d + "
"
    );

  }
}
public class InitValue {
  public static void main(String[] args) {
    Default d = new Default();
    d.show();
  }
}

심지어 한 가지 방법 으로 초기 화 할 수 있다.

class Person {
  int i = set();
  //...
}

이 방법 들 도 독립 변 수 를 사용 할 수 있다.

class Person {
  int i;
  int j = set(i);
  //...
}

빌 더 초기 화
빌 드 가 초기 화 되 는 장점 은 실행 기간 에 초기 화 값 을 결정 할 수 있다 는 것 이다.예 를 들 면:

class Person {
  int age;
  Person() {
    age = 89;
  }
}

age 는 먼저 0 으로 초기 화 되 고 89 로 변 합 니 다.모든 기본 유형 과 대상 의 문형 에 대해 서 는 이러한 상황 이 성립 된다.
초기 화 순서
한 클래스 에서 초기 화 순 서 는 변수 가 클래스 내 에서 정의 하 는 순서 에 의 해 결 정 됩 니 다.변수 정의 가 방법 정의 의 중간 에 대량으로 퍼 져 있 더 라 도 변 수 는 모든 방법 (구조 함수 포함) 을 호출 하기 전에 초기 화 됩 니 다.예 를 들 면:

class Pet {
  Pet(int age) {
    System.out.println("Pet(" + age + ")");
  }
}

class Person {
  Pet t1 = new Pet(1);

  Person() {
    System.out.println("---Person()---");
    t3 = new Pet(33);
  }

  Pet t2 = new Pet(2);
  void show() {
    System.out.println("show----running");
  }
  Pet t3 = new Pet(3);
}


public class OrderOfInitialization {
  public static void main(String[] args) {
    Person p = new Person();
    p.show();
  }
}

[실행 결과]:
Pet(1)
Pet(2)
Pet(3)
---Person()---
Pet(33)
show----running
상례 에서 t1, t2, t3 의 정 의 는 클래스 에 널리 퍼 져 있 지만 초기 화 된 우선 순 서 는 t1, t2, t3 의 정의 순서 에 의 해 결정 된다 (스스로 t1, t2, t3 를 바 꾸 어 결 과 를 본다). 또한 초기 화 는 구축 기 보다 우선 하고 Person 의 구축 기 를 호출 할 때 t3 는 다시 초기 화 된다.
정적 데이터 초기 화
데이터 가 정적 (static) 이면 같은 과정 도 실 행 됩 니 다.기본 유형 에 속 하고 초기 화 되 지 않 으 면 표준 기본 유형의 초기 값 을 자동 으로 얻 을 수 있 습 니 다.대상 을 가리 키 는 핸들 이 라면 대상 을 만 들 고 연결 하지 않 으 면 빈 값 (null) 을 얻 을 수 있 습 니 다.정의 할 때 초기 화 되면 비정 상 값 과 다른 방식 을 사용 합 니 다. 이것 은 static 에 저장 영역 이 하나 밖 에 없 기 때 문 입 니 다.예 를 들 면:

class Bowl {
  Bowl(int marker) {
    System.out.println("Bowl(" + marker + ")");
  }
  void f(int marker) {
    System.out.println("f(" + marker + ")");
  }
}

class Table {
  static Bowl b1 = new Bowl(1);
  Table() {
    System.out.println("Table()");
    b2.f(1);
  }
  void f2(int marker) {
    System.out.println("f2(" + marker + ")");
  }
  static Bowl b2 = new Bowl(2);
}

class Cupboard {
  Bowl b3 = new Bowl(3);
  static Bowl b4 = new Bowl(4);
  Cupboard() {
    System.out.println("Cupboard()");
    b4.f(2);
  }
  void f3 (int marker) {
    System.out.println("f3(" + marker + ")");
  }
  static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
  public static void main(String[] args) {
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    t2.f2(1);
    t3.f3(1);
  }
  static Table t2 = new Table();
  static Cupboard t3 = new Cupboard();
}

[실행 결과]:
Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)
정적 코드 블록
자바 는 다른 static 초기 화 작업 을 클래스 내 특수 한 코드 블록 으로 나 눌 수 있 습 니 다. 이 코드 블록 의 형식 은 static 키워드 이 고 그 다음 에 하나의 방법 주 체 를 따라 정적 코드 블록 이 라 고 부 릅 니 다.정적 코드 블록 은 그 클래스 의 대상 을 처음 만 들 거나 그 클래스 에 속 하 는 static 멤버 를 처음 방문 할 때 만 실 행 됩 니 다.예 를 들 면:

class Person {
  Person(int age) {
    System.out.println("Person(" + age + ")");
  }
  void f(int age) {
    System.out.println("f(" + age + ")");
  }
}

class Persons {
  static Person p1;
  static Person p2;
  static {
    p1 = new Person(1);
    p2 = new Person(2);
  }
  Persons() {
    System.out.println("Persons()");
  }
}

public class ExplicitStatic {
  public static void main(String[] args) {
    System.out.println("Inside main()");
    Persons.p1.f(18);//1
  }
  static Persons x = new Persons();//2
  static Persons y = new Persons();//2
}

1 로 표 시 된 줄 에서 static 대상 p1 에 접근 할 때 나 줄 1 에 주석 이 달 려 있 거나 줄 2 에 주석 이 달 려 있 지 않 으 면 Persons 에 사용 할 static 초기 화 모듈 이 실 행 됩 니 다.1 과 2 가 모두 주석 되 어 있 으 면 Persons 에 사용 되 는 정적 코드 블록 은 실행 되 지 않 습 니 다.
정적 속성 과 정적 코드 블록 이 실 행 된 우선 순위

class Person {
  Person(int age) {
    System.out.println("Person("+age+")");
  }
}
class Persons {
  static Person p = new Person(2); // 1
  static {
    p = new Person(3);
  }
  static Person p = new Person(2); // 2

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

  }
  static Persons x = new Persons();
}

주석 1 보존 2, 주석 2 보존 1 의 결과 분석 을 통 해 알 수 있 듯 이 정적 속성 과 정적 코드 블록 의 실행 순 서 는 인 코딩 의 순서 에 달 려 있다.앞 에 있 는 사람 이 먼저 집행 하 라.
비정 상 속성의 초기 화

class Animal {
  Animal(int age) {
    System.out.println("Animal(" + age + ")");
  }
  void f(int age) {
    System.out.println("f(" + age + ")");
  }
}
public class NotStaticInit {
  Animal a1;
  Animal a2;
  {
    a1 = new Animal(1);
    a2 = new Animal(2);
    System.out.println("a1 & a2 initialized");
  }
  NotStaticInit() {
    System.out.println("NotStaticInit");
  }
  public static void main(String[] args) {
    System.out.println("Inside main()");
    NotStaticInit x = new NotStaticInit();
  }
}

정적 코드 블록 과 유사 합 니 다. 익명 코드 블록 과 비 정적 속성의 초기 화 순 서 는 인 코딩 순서 에 달 려 있 습 니 다.
계승 중인 대상 초기 화 과정

class Insect {
  int i = 1;
  int j;

  Insect() {
    prt("i = " + i + ", j = " + j);
    j = 2;
  }

  static int x1 = prt("static Insect.x1 initialized");

  static int prt(String s) {
    System.out.println(s);
    return 3;
  }
}

public class Beetle extends Insect {
  int k = prt("Beeklt.k initialized");

  Beetle() {
    prt("k = " + k);
    prt("j = " + j);
  }

  static int x2 = prt("static Bootle.x2 initialized");
  static int prt(String s) {
    System.out.println(s);
    return 4;
  }

  public static void main(String[] args) {
    prt("Beetle constructor");
    Beetle b = new Beetle();
  }
}

[실행 결과]:
static Insect.x1 initialized
static Bootle.x2 initialized
Beetle constructor
i = 1, j = 0
Beeklt.k initialized
k = 4
j = 2
Beetle 에서 자바 를 실행 할 때 발생 하 는 첫 번 째 일 은 프로그램 을 불 러 와 서 그 종 류 를 찾 는 것 입 니 다.불 러 오 는 과정 에서 불 러 오 는 프로그램 이 기본 클래스 를 발 견 했 기 때문에 불 러 옵 니 다.기본 클래스 의 대상 을 만 들 든 말 든 이 과정 은 실 행 될 것 이다.만약 에 기초 류 에 다른 기초 류 가 포함 되 어 있다 면 다른 기초 류 도 곧 불 러 올 것 이 고 이런 식 으로 유추 할 것 이다.다음은 루트 기본 클래스 에서 static 초기 화 를 실행 하고 다음 파생 클래스 에서 실행 합 니 다.파생 클래스 의 초기 화 는 기본 클래스 구성원 의 초기 화 에 의존 해 야 하기 때문이다.
클래스 를 불 러 오 면 대상 을 만 들 수 있 습 니 다.우선, 이 대상 의 모든 기본 데이터 형식 은 기본 값 으로 설정 되 며, 대상 핸들 은 null 로 설 정 됩 니 다.그리고 기본 클래스 의 구축 기 를 실행 합 니 다.이 경우 자동 으로 완 성 됩 니 다.기본 클래스 구축 기 가 완료 되면 파생 클래스 인 스 턴 스 변 수 는 원래 의 순서에 따라 초기 화 된 다음 에 구축 기의 나머지 주체 부분 을 실행 합 니 다.
총 결 대상 생 성 과정:
    정적 은 클래스 로 딩 할 때 만 실행 되 고 한 번 만 실 행 됩 니 다.
    비정 상 태 는 실례 화 될 때 만 실행 되 고 대상 을 만 들 때마다 실 행 됩 니 다.
    정적 은 비정 상 이전에 실행 되 고 기본 클래스 의 정적 은 파생 클래스 의 정적 집행 보다 우선 합 니 다.
    정적 속성 과 정적 코드 블록 의 실행 속성 은 클래스 의 위치 에 달 려 있 고 누가 먼저 누 구 를 실행 하 느 냐 에 달 려 있다.
    비 정적 속성 과 구조 블록 의 실행 순 서 는 클래스 의 위치, 누가 앞에서 누 구 를 실행 하 느 냐 에 달 려 있다.
총결산
위의 소 개 를 통 해 우 리 는 자바 에서 대상 을 초기 화 하 는 몇 가지 방식 과 어떤 방식 으로 초기 화 코드 를 실행 하 는 지 알 게 되 었 으 며, 어떤 상황 에서 우리 가 초기 화 되 지 않 은 변 수 를 사용 할 수 있 는 지 에 대해 서도 소개 했다.이러한 문제 에 대해 상세 하 게 알 게 된 후에 인 코딩 에서 위험 을 피하 고 한 대상 이 볼 수 있 기 전에 완전히 초기 화 될 수 있 도록 할 수 있다.