Java (2)

안녕하세요! 오늘은 자바 프로그래밍에서 중요한 개념인 생성자(Constructor)에 대해 알아보겠습니다. 

생성자는 클래스가 인스턴스화 될 때 객체를 초기화하는데 사용되며, 객체 지향 프로그래밍의 핵심 개념 중 하나입니다.

 실생활 예시를 통해 생성자를 자세하고 쉽게 이해해봅시다.

1. 생성자(Constructor)란 무엇인가?
생성자는 클래스의 인스턴스를 생성할 때 호출되는 특별한 메소드입니다. 

생성자를 사용하면 인스턴스 생성 과정에서 속성을 초기화하거나 객체에 필요한 설정 작업을 수행할 수 있습니다. 

생성자의 이름은 클래스 이름과 동일하며, 반환 타입을 명시하지 않습니다.

예시: 학생 클래스 생성하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Student {
    // 속성 (멤버 변수)
    String name;
    int age;
    String major;
 
    // 생성자
    public Student(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
    }
 
    // 행동 (메소드)
    void introduce() {
        System.out.println("Hi, my name is " + name + ", I'm " + age + " years old and my major is " + major + ".");
    }
}
cs
위의 예시에서는 학생을 나타내는 Student 클래스를 생성했습니다. 이 클래스는 학생의 이름(name), 나이(age), 전공(major) 등의 속성을 갖고 있으며, 학생을 소개하는(introduce) 행동을 정의하고 있습니다. 또한 생성자를 사용하여 인스턴스 생성 시 속성을 초기화하도록 설정했습니다.

 

2. 생성자를 사용하여 인스턴스 생성하기


생성자를 정의한 후에는 이를 사용하여 인스턴스를 생성하고 속성을 초기화할 수 있습니다.

예시: 학생 클래스를 이용해 인스턴스 생성하기

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    // 인스턴스 생성 및 속성 초기화
    Student student1 = new Student("Alice"20"Computer Science");
    Student student2 = new Student("Bob"22"Mathematics");
 
    // 행동 수행
    student1.introduce();
    student2.introduce();
}
cs
위의 코드에서는 Student 클래스를 바탕으로 두 개의 서로 다른 인스턴스(student1, student2)를 생성했습니다. 생성자를 사용하여 인스턴스 생성과 동시에 속성을 초기화했습니다. 이렇게 생성자를 사용하면 인스턴스 생성과 속성 초기화를 동시에 처리할 수 있어 코드가 간결해집니다.

 

3, 생성자 오버로딩(Constructor Overloading)


생성자 오버로딩은 하나의 클래스에 여러 개의 생성자를 정의하는 것입니다. 

생성자 오버로딩을 사용하면 인스턴스 생성 시 다양한 방법으로 속성을 초기화할 수 있습니다.

 

예시: 학생 클래스에 생성자 오버로딩 적용하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Student {
    // 속성 (멤버 변수)
    String name;
    int age;
    String major;
 
    // 생성자 1
    public Student(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
    }
 
    // 생성자 2 (기본 생성자)
    public Student() {
        this.name = "Unknown";
        this.age = 0;
        this.major = "Unknown";
    }
 
    // 행동 (메소드)
    void introduce() {
        System.out.println("Hi, my name is " + name + ", I'm " + age + " years old and my major is " + major + ".");
    }
}
cs
위의 예시에서는 학생 클래스에 두 개의 생성자를 정의했습니다. 첫 번째 생성자는 이름, 나이, 전공을 매개변수로 받아 초기화하며, 두 번째 생성자는 기본 생성자로, 매개변수를 받지 않고 기본값으로 초기화합니다.

예시: 생성자 오버로딩을 사용하여 인스턴스 생성하기

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
    // 인스턴스 생성 및 속성 초기화 (생성자 1 사용)
    Student student1 = new Student("Alice"20"Computer Science");
    // 인스턴스 생성 및 기본값으로 속성 초기화 (생성자 2 사용)
    Student student2 = new Student();
 
    // 행동 수행
    student1.introduce();
    student2.introduce();
}
cs
이 예시에서는 생성자 오버로딩을 사용하여 student1 인스턴스는 매개변수를 전달하여 속성을 초기화하고, student2 인스턴스는 기본 생성자를 사용하여 기본값으로 초기화했습니다.

4. 기본 생성자(디폴트 생성자)
기본 생성자는 매개변수가 없는 생성자를 말합니다. 

기본 생성자는 클래스 내에서 명시적으로 정의되어 있지 않은 경우, 컴파일러가 자동으로 생성해줍니다. 

기본 생성자를 사용하면 속성을 초기화하지 않거나 기본값으로 초기화할 수 있습니다.

예시: 기본 생성자를 사용한 학생 클래스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Student {
    // 속성 (멤버 변수)
    String name;
    int age;
    String major;
 
    // 기본 생성자 (디폴트 생성자)
    public Student() {
        this.name = "Unknown";
        this.age = 0;
        this.major = "Unknown";
    }
 
    // 행동 (메소드)
    void introduce() {
        System.out.println("Hi, my name is " + name + ", I'm " + age + " years old and my major is " + major + ".");
    }
}
cs
위의 예시에서는 기본 생성자를 사용하여 학생 클래스의 속성을 기본값으로 초기화했습니다. 기본 생성자를 사용할 때는 생성자의 매개변수를 비워두어야 합니다.

 

예시: 기본 생성자를 사용하여 인스턴스 생성하기

1
2
3
4
5
6
7
public static void main(String[] args) {
    // 인스턴스 생성 및 기본값으로 속성 초기화 (기본 생성자 사용)
    Student student = new Student();
 
    // 행동 수행
    student.introduce();
}
cs
이 예시에서는 기본 생성자를 사용하여 인스턴스를 생성하고, 속성을 기본값으로 초기화했습니다. 이렇게 기본 생성자를 사용하면 클래스의 사용자가 속성을 초기화하지 않아도 인스턴스를 생성할 수 있습니다.

 

 

 

이상으로 생성자에 대한 설명을 마칩니다.

 

생성자를 이해하고 사용하는 것은 객체 지향 프로그래밍의 핵심이므로, 이를 기반으로 자바 프로그래밍 능력을 향상시킬 수 있을 것입니다. 

'[JAVA] > ┃ⓑ KEYWORDS' 카테고리의 다른 글

[JAVA] 캡슐화(Encapsulation)  (0) 2023.03.18
[JAVA] this  (0) 2023.03.18
[JAVA] 인스턴스 (Instance)  (0) 2023.03.18
[JAVA] 메서드(method)  (0) 2023.03.18
[JAVA] 클래스(Class)  (0) 2023.03.17

안녕하세요! 오늘은 자바 프로그래밍의 핵심 개념 중 하나인 클래스(Class)에 대해 알아보겠습니다. 클래스는 객체 지향 프로그래밍(Object-Oriented Programming)에서 빠질 수 없는 중요한 개념입니다. 실생활 예시를 통해 클래스를 자세하고 쉽게 이해해봅시다.

1. 클래스(Class)란 무엇인가?
클래스는 객체를 만들기 위한 '틀' 혹은 '설계도'입니다. 

클래스는 객체의 속성(Attribute)과 행동(Method)을 정의하며, 실제로 메모리에 할당되지 않습니다. 

클래스를 기반으로 여러 개의 객체(인스턴스)를 생성할 수 있습니다.

예시: 음료 클래스 생성하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Beverage {
    // 속성 (멤버 변수)
    String name;
    String type;
    int price;
 
    // 행동 (메소드)
    void serve() {
        System.out.println(name + " is served!");
    }
 
    void applyDiscount(int discount) {
        price -= discount;
    }
}
cs
위의 예시에서는 음료를 나타내는 Beverage 클래스를 생성했습니다. 이 클래스는 음료의 이름(name), 종류(type), 가격(price) 등의 속성을 갖고 있으며, 음료를 제공(serve)하고 할인(applyDiscount)을 적용하는 행동을 정의하고 있습니다.


2. 인스턴스(Instance) 생성하기


클래스를 정의한 후에는 이를 바탕으로 실제 객체(인스턴스)를 생성할 수 있습니다. 

인스턴스는 클래스의 구조를 따르며, 각각 고유한 속성을 가지고 있습니다. 

인스턴스 생성은 'new' 키워드를 사용하여 이루어집니다.

예시: 음료 클래스를 이용해 인스턴스 생성하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args) {
    // 인스턴스 생성
    Beverage coffee = new Beverage();
    Beverage tea = new Beverage();
 
    // 속성 설정
    coffee.name = "Americano";
    coffee.type = "Coffee";
    coffee.price = 3000;
 
    tea.name = "Green Tea";
    tea.type = "Tea";
    tea.price = 2500;
 
    // 행동 수행
    coffee.serve();
    tea.serve();
    tea.applyDiscount(500);
}
cs
위의 코드에서는 Beverage 클래스를 바탕으로 두 개의 서로 다른 인스턴스(coffee, tea)를 생성했습니다. 각 인스턴스는 서로 다른 속성을 가지고 있지만, 동일한 클래스를 기반으로 만들어졌기 때문에 같은 행동(메소드)를 공유합니다.

3. 생성자(Constructor) 사용하기


생성자는 클래스가 인스턴스화 될 때 호출되는 특별한 메소드입니다. 

생성자를 사용하면 인스턴스 생성 과정에서 속성을 초기화하거나 객체에 필요한 설정 작업을 수행할 수 있습니다. 

생성자의 이름은 클래스 이름과 동일하며, 반환 타입을 명시하지 않습니다.

예시: 음료 클래스에 생성자 추가하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Beverage {
    // 속성 (멤버 변수)
    String name;
    String type;
    int price;
 
    // 생성자
    public Beverage(String name, String type, int price) {
        this.name = name;
        this.type = type;
        this.price = price;
    }
 
    // 행동 (메소드)
    void serve() {
        System.out.println(name + " is served!");
    }
 
    void applyDiscount(int discount) {
        price -= discount;
    }
}
cs
위의 코드에서는 Beverage 클래스에 생성자를 추가했습니다. 생성자는 인스턴스 생성 시 name, type, price를 매개변수로 받아 객체의 속성을 초기화합니다.

예시: 생성자를 이용해 음료 인스턴스 생성하기

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
    // 인스턴스 생성
    Beverage coffee = new Beverage("Americano""Coffee"3000);
    Beverage tea = new Beverage("Green Tea""Tea"2500);
 
    // 행동 수행
    coffee.serve();
    tea.serve();
    tea.applyDiscount(500);
}
cs
위의 코드에서는 생성자를 사용하여 인스턴스를 생성하고 속성을 초기화했습니다. 이렇게 생성자를 사용하면 인스턴스 생성과 속성 초기화를 동시에 처리할 수 있어 코드가 간결해집니다.

5. 접근 제어자(Access Modifier)와 캡슐화(Encapsulation)


클래스의 속성과 메소드에 접근 제어자(Access Modifier)를 사용하면 외부에서의 접근을 제한할 수 있습니다. 

이를 캡슐화(Encapsulation)라고 하며 캡슐화를 통해 객체의 내부 데이터를 보호하고 코드의 안정성을 높일 수 있습니다.
자바에서는 public, protected, private, 그리고 기본(default) 접근 제어자를 사용할 수 있습니다. 

일반적으로 속성은 private으로 설정하고, 필요한 경우 getter와 setter 메소드를 통해 간접적으로 접근하게 합니다.

예시: 음료 클래스에 접근 제어자와 캡슐화 적용하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class Beverage {
    // 속성 (멤버 변수) - private으로 설정
    private String name;
    private String type;
    private int price;
 
    // 생성자
    public Beverage(String name, String type, int price) {
        this.name = name;
        this.type = type;
        this.price = price;
    }
 
    // getter와 setter 메소드
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getType() {
        return type;
    }
 
    public void setType(String type) {
        this.type = type;
    }
 
    public int getPrice() {
        return price;
    }
 
    public void setPrice(int price) {
        this.price = price;
    }
 
    // 행동 (메소드)
    public void serve() {
        System.out.println(name + " is served!");
    }
 
    public void applyDiscount(int discount) {
        price -= discount;
    }
}
cs
위의 코드에서는 음료 클래스의 속성(name, type, price)을 private으로 설정하여 외부에서의 접근을 제한했습니다. 대신 getter와 setter 메소드를 사용하여 속성에 간접적으로 접근할 수 있게 하였습니다.

예시: 음료 인스턴스 생성 및 캡슐화된 속성 접근하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
    // 인스턴스 생성
    Beverage coffee = new Beverage("Americano""Coffee"3000);
    Beverage tea = new Beverage("Green Tea""Tea"2500);
 
    // getter와 setter를 사용하여 속성에 접근
    System.out.println(coffee.getName());
    System.out.println(tea.getName());
 
    tea.setName("Chamomile Tea");
    System.out.println(tea.getName());
 
    // 행동 수행
    coffee.serve();
    tea.serve();
    tea.applyDiscount(500);
}
cs
이제 완성된 음료 클래스를 사용하여 인스턴스를 생성하고, 캡슐화된 속성에 getter와 setter 메소드를 사용하여 접근하는 방법을 확인하였습니다.

 

 

이상으로 클래스에 대한 설명을 마칩니다. 

클래스를 이해하는 것은 객체 지향 프로그래밍의 핵심이므로, 이를 기반으로 자바 프로그래밍 능력을 향상시킬 수 있을 것입니다.

'[JAVA] > ┃ⓑ KEYWORDS' 카테고리의 다른 글

[JAVA] this  (0) 2023.03.18
[JAVA] 생성자(Constructor)  (0) 2023.03.18
[JAVA] 인스턴스 (Instance)  (0) 2023.03.18
[JAVA] 메서드(method)  (0) 2023.03.18
[JAVA] 객체(Object)  (0) 2023.03.17
1