[Java] 자바 클래스 - 인스턴스, 필드, 메소드, 생성자

객체 지향 프로그래밍(OOP, Object-Oriented Programming)

• 객체 지향 프로그래밍에서는 모든 데이터를 객체(object)로 취급하며, 이러한 객체가 바로 프로그래밍의 중심이 된다.
• 객체(object)란 실생활에서 우리가 인식할 수 있는 사물로 설명할 수 있으며, 객체의 상태(state)와 행동(behavior)을 구체화하는 형태의 프로그래밍이 바로 객체 지향 프로그래밍이다.

 

클래스(class)란?

• 자바에서 클래스(class)란 객체를 정의하는 틀 또는 설계도와 같은 의미로 사용된다. 자바에서는 설계도인 클래스를 가지고, 여러 객체를 생성하여 사용한다.
• 클래스는 객체의 상태를 나타내는 필드(field)와 객체의 행동을 나타내는 메소드(method)로 구성된다. 필드(field)란 클래스에 포함된 변수(variable)를 의미하고, 메소드(method)란 어떠한 특정 작업을 수행하기 위한 명령문의 집합이라 할 수 있다.

클래스의 구성 요소

• 자바에서 클래스는 멤버(member)로 속성을 표현하는 필드(field)와 기능을 표현하는 메소드(method)를 가진다.
• 그리고 클래스는 생성된 객체의 필드를 초기화해주는 특별한 메소드인 생성자(constructor)를 가진다.

class Car {                    // 클래스 이름
    private String modelName;  // 필드
    private int modelYear;     // 필드

    Car(String modelName, int modelYear) { // 생성자
        this.modelName = modelName;
        this.modelYear = modelYear;
    }

    public String getModel() { // 메소드
        return this.modelYear + "년식 " + this.modelName + " " + this.color;
    }
}

클래스의 선언

• 클래스(class)란 객체 지향 프로그래밍의 추상화(abstraction)라는 개념을 직접 구현한 것이라 할 수 있다.
• 자바에서는 개발자의 편의를 위해 유용하게 사용할 수 있는 많은 수의 클래스를 미리 정의하여 제공하고 있으며, 개발자가 원하는 동작을 하는 새로운 클래스를 손쉽게 작성할 수도 있다.
• 자바에서 클래스를 선언하는 방법은 접근 제어자와 함께 class 키워드를 사용하면 된다.

접근제어자 class 클래스이름 {
    접근제어자 필드1의타입 필드1의이름;
    접근제어자 필드2의타입 필드2의이름;
    ...
    접근제어자 메소드1의 원형
    접근제어자 메소드2의 원형
    ...
};

• 접근 제어자는 객체 지향 프로그래밍의 특징 중 하나인 정보 은닉(data hiding)을 위한 키워드다. public 멤버는 모든 객체에서 접근할 수 있지만, private 멤버는 해당 객체 내의 멤버 변수나 메소드만이 접근할 수 있다.

 

인스턴스(instance)란?

• 자바에서 클래스를 사용하기 위해서는 우선 해당 클래스 타입의 객체(object)를 선언해야 한다. 이렇게 클래스로부터 객체를 선언하는 과정을 클래스의 인스턴스 화라고 하며, 이렇게 선언된 해당 클래스 타입의 객체를 인스턴스(instance)라고 한다. 즉, 인스턴스란 메모리에 할당된 객체를 의미한다.
• 자바에서는 하나의 클래스로부터 여러 개의 인스턴스를 생성할 수 있는데, 이렇게 생성된 인스턴스는 독립된 메모리 공간에 저장된 자신만의 필드를 가질 수 있지만 해당 클래스의 모든 메소드(method)는 해당 클래스에서 생성된 모든 인스턴스가 공유하게 된다.

인스턴스의 생성

• 선언된 클래스의 정의를 가지고 객체의 인스턴스를 생성할 수 있다.
• 1. 먼저 객체를 참조하기 위한 참조 변수를 먼저 선언한다. 2. 그리고 new 키워드를 사용하여 인스턴스를 생성하고, 해당 인스턴스의 주소를 미리 선언한 참조 변수에 저장하여 사용한다.

클래스이름 객체참조변수이름;
Car myCar;

객체참조변수이름 = new 클래스이름();
myCar = new Car();

• 아니면 아래와 같이 참조 변수의 선언과 인스턴스의 생성을 동시에 할 수도 있다.

클래스이름 객체참조변수이름 = new 클래스이름();
Car myCar = new Car();

 

필드(field)

• 클래스의 필드(field)란 클래스에 포함된 변수(variable)를 의미한다.

변수 구분

• 클래스 변수(static variable): 클래스 영역에 위치한 변수 중에서 static 키워드를 가지는 변수를 클래스 변수(static variable)라고 한다. 클래스 변수는 인스턴스를 생성하지 않고도 바로 사용할 수 있고, 생성된 모든 인스턴스가 같은 값을 공유하기 때문에 공유 변수(shared variable)라고도 한다. 클래스 변수는 해당 클래스의 모든 인스턴스가 공유해야 하는 값을 유지하기 위해 사용된다.
• 인스턴스 변수(instance variable): 클래스 영역에 위치한 변수 중 static 키워드를 가지지 않는 변수는 인스턴스 변수(instance variable)라고 한다. 인스턴스 변수는 인스턴스마다 가져야 하는 고유한 값을 유지하기 위해 사용되며, 인스턴스마다 고유한 값을 가진다.
• 지역 변수(local variable): 메소드나 생성자, 초기화 블록 내에 위치한 변수를 지역 변수(local variable)라고 한다.

• 클래스 변수와 인스턴스 변수는 초기화를 하지 않아도 변수의 타입에 맞게 자동으로 초기화되지만, 지역 변수는 사용하기 전에 초기화하지 않으면 오류를 발생시킨다.

class Field {
    static int classVar = 10; // 클래스 변수 선언
    int instanceVar = 20;     // 인스턴스 변수 선언
}

public class Member01 {
    public static void main(String[] args) {
        int var = 30;                            // 지역 변수 선언
        System.out.println(var);                 // 지역 변수 참조      // 30

        Field myField1 = new Field();            // 인스턴스 생성
        Field myField2 = new Field();            // 인스턴스 생성

        System.out.println(Field.classVar);      // 클래스 변수 참조    // 10
        System.out.println(myField1.classVar);                      // 10
        System.out.println(myField2.classVar);                      // 10

        myField1.classVar = 100;                 // 클래스 변수 값 변경

        System.out.println(Field.classVar);      // 클래스 변수 참조    // 100
        System.out.println(myField1.classVar);                      // 100
        System.out.println(myField2.classVar);                      // 100

        System.out.println(myField1.instanceVar); // 인스턴스 변수 참조  // 20
        System.out.println(myField2.instanceVar);                    // 20

        myField1.instanceVar = 200;               // 인스턴스 변수 값 변경

        System.out.println(myField1.instanceVar); // 인스턴스 변수 참조   // 200
        System.out.println(myField2.instanceVar);                     // 20
    }
}

this 참조 변수

• this 참조 변수는 인스턴스가 바로 자기 자신을 참조하는 데 사용하는 변수로, 이러한 this 참조 변수는 해당 인스턴스의 주소를 가리킨다.
• 자바에서는 this 참조 변수를 사용하여 인스턴스 변수에 접근할 수 있으며, this 참조 변수를 사용할 수 있는 영역은 인스턴스 메소드뿐이며, 클래스 메소드에서는 사용할 수 없다. 모든 인스턴스 메소드에는 this 참조 변수가 숨겨진 지역 변수로 존재하고 있다.

class Car {
    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;

    // 생성자 매개변수명과 인스턴스 변수명이 같은 경우, 인스턴스 변수 앞에 this 키워드를 붙여 구분 
    Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    }
    ...
}

필드의 초기화

• 자바에서 필드는 초기화하지 않아도 변수의 타입에 맞는 초깃값으로 자동으로 초기화되지만, 지역 변수와 마찬가지로 적절한 값으로 초기화한 후에 사용하는 것이 좋다.
• 필드는 지역 변수와는 달리 1. 명시적 초기화, 2. 생성자를 이용한 초기화, 3. 초기화 블록을 이용해 초기화할 수 있다.

명시적 초기화

• 명시적 초기화는 지역 변수를 초기화하는 방법과 마찬가지로 필드를 선언과 동시에 초기화하는 방법이다.

class Field {
    static int classVar = 10; // 클래스 변수의 명시적 초기화
    int instanceVar = 20;     // 인스턴스 변수의 명시적 초기화
}

생성자를 이용한 초기화

• 생성자를 이용한 초기화는 객체의 생성과 동시에 필드를 초기화하는 방법으로, 인스턴스를 생성할 때까지 필드를 초기화할 수 없다.

초기화 블록(initialization block)을 이용한 초기화

• 초기화 블록(initialization block)이란 클래스 필드의 초기화만을 담당하는 중괄호({})로 둘러싸인 블록을 의미한다. 초기화 블록에는 다양한 명령문 및 제어문을 사용할 수 있으므로, 복잡한 초기화를 해야 할 경우 유용하게 사용된다.
• 초기화 블록은 생성자보다 먼저 호출되며, static 키워드의 유무에 따라 1. 인스턴스 초기화 블록와 2. 클래스 초기화 블록로 구분된다
• 인스턴스 초기화 블록: 인스턴스 초기화 블록은 단순히 중괄호({})만을 사용하여 정의할 수 있다. 인스턴스 초기화 블록은 생성자와 마찬가지로 인스턴스가 생성될 때마다 실행되지만, 언제나 인스턴스 초기화 블록이 생성자보다 먼저 실행된다. 생성자와 인스턴스 초기화 블록의 차이는 거의 없으므로 인스턴스 초기화 블록은 잘 사용되지 않는다. 단, 여러 개의 생성자가 있으면 모든 생성자에서 공통으로 수행되어야 할 코드를 인스턴스 초기화 블록에 포함하여 코드의 중복을 막을 수 있다.

// 인스턴스 초기화 블록을 이용하여 여러 생성자에서 공통된 부분을 분리
class Car {
    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;

    {                                 // 인스턴스 초기화 블록
        this.currentSpeed = 0;
    }

    Car() {}
    Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
 
    public int getSpeed() {
        return currentSpeed;
    }
}

public class Member03 {
    public static void main(String[] args) {
        Car myCar = new Car();                // 인스턴스 생성
        System.out.println(myCar.getSpeed()); // 인스턴스 메소드의 호출
    }
}

>> 0

• 클래스 초기화 블록: 클래스 초기화 블록은 인스턴스 초기화 블록에 static 키워드를 추가하여 정의할 수 있다. 클래스 초기화 블록은 클래스가 처음으로 메모리에 로딩될 때 단 한 번만 실행된다. 클래스 초기화 블록은 생성자나 인스턴스 초기화 블록으로는 수행할 수 없는 클래스 변수의 초기화를 수행할 때 사용된다.

// 클래스 초기화 블록을 이용하여 클래스 변수를 초기화
class InitBlock {
    static int classVar; // 클래스 변수
    int instanceVar;     // 인스턴스 변수

    static { // 클래스 초기화 블록을 이용한 초기화
        classVar = 10;
    }
}

public class Member04 {
    public static void main(String[] args) {
        System.out.println(InitBlock.classVar); // 클래스 변수에 접근
    }
}

>> 10

• 클래스 필드가 여러 번 초기화될 가능성이 있는데, 자바에서 필드는 아래와 같은 순서로 초기화 된다. 필드를 여러 번 초기화하면, 제일 마지막으로 초기화한 값만이 남는다.
  1. 클래스 변수 : 기본값 → 명시적 초기화 → 클래스 초기화 블록
  2. 인스턴스 변수 : 기본값 → 명시적 초기화 → 인스턴스 초기화 블록 → 생성자

class InitBlock {
    static int classVar = 10;         // 클래스 변수의 명시적 초기화
    int instanceVar = 10;             // 인스턴스 변수의 명시적 초기화
    
    static { classVar = 20; }         // 클래스 초기화 블록을 이용한 초기화
    { instanceVar = 20; }             // 인스턴스 초기화 블록을 이용한 초기화
    
    InitBlock() { instanceVar = 30; } // 생성자를 이용한 초기화
}

public class Member05 {
    public static void main(String[] args) {
        System.out.println(InitBlock.classVar);
        InitBlock myInit = new InitBlock();
        System.out.println(myInit.instanceVar);
    }
}

>> 20
>> 30

 

메소드(method)

• 클래스에서 메소드(method)란 어떠한 특정 작업을 수행하기 위한 명령문의 집합이라 할 수 있다.
• 메소드를 사용하면 중복되는 코드의 반복적인 프로그래밍을 피할 수 있고, 모듈화로 인해 전체적인 코드의 가독성이 좋아지며, 손쉬운 유지보수를 할 수 있게 된다.
• 메소드를 작성할 때는 되도록 하나의 메소드가 하나의 기능만을 수행하도록 작성하는 것이 좋다.

메소드 정의

접근제어자 반환타입 메소드이름(매개변수목록) { // 선언부
    // 구현부
}

class Car {
    private int currentSpeed;
    private int accelerationTime;
    ...
    public void accelerate(int speed, int second) { // 선언부
        // 구현부
        System.out.println(second + "초간 속도를 시속 " + speed + "(으)로 가속함!!");
    }
    ...
}

• 접근 제어자 : 해당 메소드에 접근할 수 있는 범위를 명시한다.
• 반환 타입(return type) : 메소드가 모든 작업을 마치고 반환하는 데이터의 타입을 명시한다.
• 메소드 이름 : 메소드를 호출하기 위한 이름을 명시한다. 자바에서는 하나의 클래스에 같은 이름의 메소드를 둘 이상 정의할 수 없습지만 메소드 오버로딩(overloading)을 이용하면, 같은 이름의 메소드를 중복하여 정의할 수 있다. 메소드 오버로딩이란 매개변수의 개수나 타입을 다르게 하여 같은 이름의 또 다른 메소드를 작성하는 것이다.
• 매개변수 목록(parameters) : 메소드 호출 시에 전달되는 인수의 값을 저장할 변수들을 명시한다.
• 구현부 : 메소드의 고유 기능을 수행하는 명령문의 집합이다.

메소드 호출

• 자바에서 위와 같은 방법으로 정의한 메소드는 멤버 참조 연산자(.)를 사용하여 호출할 수 있다.

1. 객체참조변수이름.메소드이름();                  // 매개변수가 없는 메소드의 호출
2. 객체참조변수이름.메소드이름(인수1, 인수2, ...);   // 매개변수가 있는 메소드의 호출

Car myCar = new Car();   // 객체를 생성
myCar.accelerate(60, 3); // myCar 인스턴스의 accelerate() 메소드를 호출

메소드 구분

• 클래스 메소드(static method): static 키워드를 가지는 메소드를 클래스 메소드(static method)라고 한다. 클래스 메소드는 클래스 변수와 마찬가지로 인스턴스를 생성하지 않고도 바로 사용할 수 있기에, 클래스 메소드는 메소드 내부에서 인스턴스 변수를 사용할 수 없다. 그러므로 메소드 내부에서 인스턴스 변수나 인스턴스 메소드를 사용하지 않는 메소드를 클래스 메소드로 정의하는 것이 일반적이다. 클래스 메소드는 인스턴스 변수를 사용하지 않고, 전달된 매개변수만으로 동작하는 메소드다.
• 인스턴스 메소드(instance method): static 키워드를 가지지 않는 메소드는 인스턴스 메소드(instance method)라고 한다.

class Method {
    int a = 10, b = 20;                            // 인스턴스 변수
    int add() { return a + b; }                    // 인스턴스 메소드
    static int add(int x, int y) { return x + y; } // 클래스 메소드
}

public class Member02 {
    public static void main(String[] args) {
        System.out.println(Method.add(20, 30)); // 클래스 메소드의 호출
        Method myMethod = new Method();         // 인스턴스 생성
        System.out.println(myMethod.add());     // 인스턴스 메소드의 호출
    }
}

this() 메소드

• this() 메소드는 생성자 내부에서만 사용할 수 있으며, 같은 클래스의 다른 생성자를 호출할 때 사용한다.
• this() 메소드에 인수를 전달하면, 생성자 중에서 메소드 시그니처가 일치하는 다른 생성자를 찾아 호출해 준다. 메소드 시그니처(method signature)란 메소드의 이름과 메소드의 원형에 명시되는 매개변수 리스트를 가리킨다.
• this() 메소드는 내부적으로 다른 생성자를 호출하여 인스턴스 변수를 초기화할 수 있다. 단, 한 생성자에서 다른 생성자를 호출할 때에는 반드시 해당 생성자의 첫 줄에서만 호출할 수 있다.

class Car {
    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;
 
    Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName;          // this 참조변수로 인스턴스 변수에 접근
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    }
 
    Car() {
        this("소나타", 2012, "검정색", 160);   // this()메소드로 첫번째 생성자 호출
    }
 
    public String getModel() {
        return this.modelYear + "년식 " + this.modelName + " " + this.color;
    }
}

public class Method05 {
    public static void main(String[] args) {
        Car tcpCar = new Car(); System.out.println(tcpCar.getModel());
    }
}

>> 2012년식 소나타 검정색

메소드 오버로딩(overloading)

• 메소드 오버로딩(overloading)이란 같은 이름의 메소드를 중복하여 정의하는 것을 의미한다.
• 자바에서는 원래 한 클래스 내에 같은 이름의 메소드를 둘 이상 가질 수 없다. 하지만 매개변수의 개수나 타입을 다르게 하면, 하나의 이름으로 메소드를 작성할 수 있다. 즉, 메소드 오버로딩은 서로 다른 시그니처를 갖는 여러 메소드를 같은 이름으로 정의하는 것이라고 할 수 있다.
• 메소드 오버로딩을 사용함으로써 메소드에 사용되는 이름을 절약할 수 있고, 메소드를 호출할 때 전달해야 할 매개변수의 타입이나 개수에 대해 크게 신경을 쓰지 않고 호출할 수 있게 된다.
• 메소드 오버로딩은 객체 지향 프로그래밍의 특징 중 하나인 다형성(polymorphism)을 구현하는 방법 중 하나다.
• 자바에서 메소드 오버로딩이 성립하기 위해서는 1. 메소드의 이름이 같아야 하고, 2. 메소드의 시그니처, 즉 매개변수의 개수 또는 타입이 달라야 한다.
• 메소드 오버로딩은 반환 타입과는 관계가 없다. 그래서 메소드의 시그니처는 같은데 반환 타입만이 다른 경우에는 오버로딩이 성립하지 않는다.

메소드 시그니처(method signature)란?
메소드 시그니처란 메소드의 선언부에 명시되는 매개변수의 리스트를 가리킨다. 만약 두 메소드가 매개변수의 개수와 타입, 그 순서까지 모두 같다면, 이 두 메소드의 시그니처는 같다고 할 수 있다.

class Test {
   static void display(int num1) { System.out.println(num1); }
   static void display(int num1, int num2) { System.out.println(num1 * num2); }
   static void display(int num1, double num2) { System.out.println(num1 + num2); }
}

public class Method06 {
    public static void main(String[] args) {
        Test myfunc = new Test();

        myfunc.display(10);                  // 10
        myfunc.display(10, 20);              // 200
        myfunc.display(10, 3.14);            // 13.14
        // 2, 3 둘 다 가능 but 더 작은 표현 범위를 가지는 int형으로 자동 타입 변환
        myfunc.display(10, 'a');             // 970   // a 아스키 코드값 97
    }
}

• 자바 컴파일러는 사용자가 오버로딩된 함수를 호출하면, 전달된 매개변수의 개수와 타입과 같은 시그니처를 가지는 메소드를 찾아 호출한다.

재귀 호출(recursive call)

• 재귀 호출(recursive call)이란 메소드 내부에서 해당 메소드가 또다시 호출되는 것을 의미한다. 재귀 호출은 자기가 자신을 계속해서 호출하므로 끝없이 반복되므로, 메소드 내에 재귀 호출을 중단하도록 조건이 변경될 명령문을 반드시 포함해야 한다.

// 실행 직후 스택 오버플로우(stack overflow)에 의해 종료
int recursiveSum(int n) {
    if (n == 1) {                 // n이 1이면, 그냥 1을 반환
        return 1;
    }
    return n + recursiveSum(n-1); // n이 1이 아니면, n을 1부터 (n-1)까지의 합과 더한 값을 반환
}

>> 55

 

생성자(constructor)

• 클래스를 가지고 객체를 생성하면, 해당 객체는 메모리에 즉시 생성된다. 하지만 이렇게 생성된 객체는 모든 인스턴스 변수가 아직 초기화되지 않은 상태다. 자바에서 클래스 변수와 인스턴스 변수는 별도로 초기화하지 않으면 각 변수의 초깃값으로 자동 초기화된다.
• 하지만 사용자가 원하는 값으로 인스턴스 변수를 초기화하려면, 일반적인 초기화 방식으로는 초기화할 수 없다. 인스턴스 변수 중에는 private 변수도 있는데, private 변수에는 사용자나 프로그램이 직접 접근할 수 없기 때문이다. 그래서 private 인스턴스 변수에도 접근할 수 있는 초기화만을 위한 public 메소드가 필요하다. 이러한 초기화만을 위한 메소드는 객체가 생성된 후부터 사용되기 전까지 반드시 인스턴스 변수의 초기화를 위해 호출되어야 한다.
• 그래서 자바에서는 객체의 생성과 동시에 인스턴스 변수를 원하는 값으로 초기화할 수 있는 생성자(constructor)라는 메소드를 제공한다.
• 자바에서 생성자(constructor)의 이름은 해당 클래스의 이름과 같아야 한다.

생성자 특징

• 생성자는 반환값이 없지만, 반환 타입을 void형으로 선언하지 않는다.
• 생성자는 초기화를 위한 데이터를 인수로 전달받을 수 있다.
• 객체를 초기화하는 방법이 여러 개 존재할 경우에는 하나의 클래스가 여러 개의 생성자를 가질 수 있다. 즉, 생성자도 하나의 메소드이므로 메소드 오버로딩이 가능하다.

// Car 클래스를 선언하면서 여러 개의 생성자를 선언
Car(String modelName) {}
Car(String modelName, int modelYear) {}
Car(String modelName, int modelYear, String color) {}
Car(String modelName, int modelYear, String color, int maxSpeeds) {}

생성자 선언

• 클래스의 생성자(constructor)는 어떠한 반환값도 명시하지 않는다.

1. 클래스이름() { ... }                  // 매개변수가 없는 생성자 선언
2. 클래스이름(인수1, 인수2, ...) { ... }   // 매개변수가 있는 생성자 선언

Car(String modelName, int modelYear, String color, int maxSpeeds) {
    this.modelName = modelName;
    this.modelYear = modelYear;
    this.color = color;
    this.maxSpeed = maxSpeed;
    this.currentSpeed = 0;
}

생성자 호출

• 자바에서는 new 키워드를 사용하여 객체를 생성할 때 자동으로 생성자가 호출된다.

class Car {
    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;

    Car(String modelName, int modelYear, String color, int maxSpeed) {   // 생성자
        this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    }

    public String getModel() {
        return this.modelYear + "년식 " + this.modelName + " " + this.color;
    }
}

public class Method02 {
    public static void main(String[] args) {
        Car myCar = new Car("아반떼", 2016, "흰색", 200);            // 생성자의 호출
        System.out.println(myCar.getModel());                     // 생성자에 의해 초기화되었는지 확인
    }
}

>> 2016년식 아반떼 흰색

기본 생성자(default constructor)

• 자바의 모든 클래스에는 하나 이상의 생성자가 정의되어 있어야 하지만, 특별히 생성자를 정의하지 않고도 인스턴스를 생성할 수 있다. 이것은 자바 컴파일러가 기본 생성자(default constructor)라는 것을 기본적으로 제공해 주기 때문이다.
• 기본 생성자는 매개변수를 하나도 가지지 않으며, 아무런 명령어도 포함하고 있지 않기에 기본적으로 아무런 동작도 하지 않는다. 자바 컴파일러는 컴파일 시 클래스에 생성자가 하나도 정의되어 있지 않으면, 자동으로 다음과 같은 기본 생성자를 추가한다.

클래스이름() {}

// Car 클래스에 생성자를 정의하지 않고, 기본 생성자를 호출하는 예제
class Car {
    private String modelName = "소나타";           // 인스턴스 변수를 클래스 필드에서 바로 초기화
    private int modelYear = 2016;
    private String color = "파란색";

    public String getModel() {
        return this.modelYear + "년식 " + this.color + " " + this.modelName;
    }
}

public class Method03 {
    public static void main(String[] args) {
        Car myCar = new Car();                // 기본 생성자의 호출
        System.out.println(myCar.getModel()); // 2016년식 파란색 소나타
    }
}

>> 2016년식 파란색 소나타

• 만약 매개변수를 가지는 생성자를 하나라도 정의했다면, 기본 생성자는 자동으로 추가되지 않는다.

class Car {
    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;
    
    // 4개의 매개변수를 갖는 생성자를 정의 -> 별도의 기본 생성자를 추가하지 않음
    Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    }
    
    public String getModel() {
        return this.modelYear + "년식 " + this.modelName + " " + this.color;
    }
}

public class Method04 {
    public static void main(String[] args) {
        Car myCar = new Car(); // 기본 생성자의 호출
        // Car myCar = new Car("아반떼", 2016, "흰색", 200); // 생성자의 호출

        System.out.println(myCar.getModel());             // 생성자에 의해 초기화되었는지를 확인
    }
}

 

Reference

• http://www.tcpschool.com/