분류 전체보기 (21)

안녕하세요! 오늘은 자바 프로그래밍에서 중요한 개념인 생성자(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

안녕하세요! 

오늘은 자바 프로그래밍에서 중요한 개념인 인스턴스(Instance)에 대해 알아보겠습니다. 

클래스와 인스턴스는 객체 지향 프로그래밍의 핵심 개념으로, 이를 이해하는 것이 자바 프로그래밍 능력을 향상시키는데 큰 도움이 됩니다. 실생활 예시를 통해 인스턴스를 자세하고 쉽게 이해해봅시다.

1. 인스턴스(Instance)란 무엇인가?


인스턴스는 클래스를 바탕으로 생성된 객체입니다. 

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

인스턴스를 생성하려면 클래스를 먼저 정의해야 합니다. 

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

예시: 도서 클래스 생성하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Book {
    // 속성 (멤버 변수)
    String title;
    String author;
    int price;
 
    // 행동 (메소드)
    void read() {
        System.out.println("Reading " + title + " by " + author + ".");
    }
 
    void applyDiscount(int discount) {
        price -= discount;
    }
}
cs
위의 예시에서는 도서를 나타내는 Book 클래스를 생성했습니다. 이 클래스는 도서의 제목(title), 저자(author), 가격(price) 등의 속성을 갖고 있으며, 도서를 읽는(read) 행동과 할인(applyDiscount)을 적용하는 행동을 정의하고 있습니다.

 

2. 인스턴스 생성하기


클래스를 정의한 후에는 이를 바탕으로 실제 객체(인스턴스)를 생성할 수 있습니다.
예시: 도서 클래스를 이용해 인스턴스 생성하기

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) {
    // 인스턴스 생성
    Book book1 = new Book();
    Book book2 = new Book();
 
    // 속성 설정
    book1.title = "To Kill a Mockingbird";
    book1.author = "Harper Lee";
    book1.price = 15000;
 
    book2.title = "The Great Gatsby";
    book2.author = "F. Scott Fitzgerald";
    book2.price = 12000;
 
    // 행동 수행
    book1.read();
    book2.read();
    book2.applyDiscount(2000);
}
cs
위의 코드에서는 Book 클래스를 바탕으로 두 개의 서로 다른 인스턴스(book1, book2)를 생성했습니다. 각 인스턴스는 서로 다른 속성을 가지고 있지만, 동일한 클래스를 기반으로 만들어졌기 때문에 같은 행동(메소드)을 수행할 수 있습니다.

book1 인스턴스는 "To Kill a Mockingbird"이라는 제목, "Harper Lee"라는 저자, 그리고 15000원의 가격을 갖고 있습니다. 반면에 book2 인스턴스는 "The Great Gatsby"라는 제목, "F. Scott Fitzgerald"라는 저자, 그리고 12000원의 가격을 갖고 있습니다.

인스턴스를 생성한 후에는 해당 인스턴스의 속성에 접근하여 값을 설정하거나 가져올 수 있습니다. 또한 인스턴스의 메소드를 호출하여 행동을 수행할 수 있습니다.

예시 코드에서는 book1 인스턴스의 read() 메소드를 호출하여 "Reading To Kill a Mockingbird by Harper Lee."라는 메시지를 출력했습니다. 또한 book2 인스턴스의 applyDiscount() 메소드를 호출하여 가격에 2000원의 할인을 적용했습니다.

이렇게 인스턴스를 생성하고 사용하는 과정을 통해 클래스를 정의한 후 실제 객체를 만들어 사용할 수 있습니다. 

인스턴스를 사용하면 코드를 재사용하고 유지 보수하기 쉬운 객체 지향 프로그래밍을 구현할 수 있습니다.

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

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

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

[JAVA] this  (0) 2023.03.18
[JAVA] 생성자(Constructor)  (0) 2023.03.18
[JAVA] 메서드(method)  (0) 2023.03.18
[JAVA] 클래스(Class)  (0) 2023.03.17
[JAVA] 객체(Object)  (0) 2023.03.17

자바에서 메서드는 객체 지향 프로그래밍의 핵심 요소 중 하나입니다. 이 글에서는 메서드의 개념과 작성 방법, 그리고 예제를 통해 자바 메서드의 활용법을 자세히 알아보도록 하겠습니다.

 

1.  메서드란 무엇인가?


메서드는 클래스 내에서 수행할 작업을 정의하는 코드 블록입니다. 일반적으로 메서드는 입력값을 받아서 처리한 후 결과를 반환하는 역할을 합니다. 메서드는 코드의 재사용성과 가독성을 높이며, 프로그램의 구조를 체계적으로 만들어줍니다.
예시:

1
2
3
4
public static int add(int a, int b) {
    return a + b;
}
 
cs

 

2. 메서드의 구성 요소


반환 타입 (Return Type): 메서드가 수행한 결과를 반환하는 데이터 타입입니다. 

반환할 값이 없는 경우 'void'를 사용합니다.

  • 메서드 이름 (Method Name): 메서드를 호출할 때 사용하는 이름입니다.
  • 매개 변수 (Parameters): 메서드에 전달되는 값을 받는 변수입니다. 여러 개의 매개변수가 있을 수 있습니다.
  • 메서드 본문 (Method Body): 중괄호 {} 안에 들어가는 코드입니다.

예시:

1
2
3
4
public static double calculateArea(double radius) {
    double area = Math.PI * Math.pow(radius, 2);
    return area;
}
cs

 

3. 메서드 호출하기


메서드를 사용하려면 호출해야 합니다.

호출하는 방법은 메서드 이름을 사용하고, 괄호 안에 매개변수를 전달합니다.

예시:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class MethodCallingExample {
 
    public static void main(String[] args) {
        int sum = add(57);
        System.out.println("The sum is: " + sum);
 
        double area = calculateArea(5.0);
        System.out.println("The area of the circle is: " + area);
    }
 
    public static int add(int a, int b) {
        return a + b;
    }
 
    public static double calculateArea(double radius) {
        double area = Math.PI * Math.pow(radius, 2);
        return area;
    }
}
    }
}
cs
main 메서드에서 두 가지 메서드를 호출하고 있습니다.
add 메서드: 두 정수를 더하는 메서드로, 두 개의 정수 매개변수를 받습니다. 이 예시에서는 5와 7을 매개변수로 전달하고 있으며, 결과로 반환되는 값을 sum 변수에 저장합니다.
calculateArea 메서드: 원의 넓이를 계산하는 메서드로, 반지름 값을 매개변수로 받습니다. 이 예시에서는 5.0을 매개변수로 전달하고 있으며, 결과로 반환되는 값을 area 변수에 저장합니다.
메서드 호출은 메서드 이름을 사용하고, 괄호 안에 매개변수를 전달함으로써 이루어집니다. 반환 값이 있는 경우, 해당 값을 변수에 저장하거나 바로 출력 등의 작업에 사용할 수 있습니다.

4. 메서드 오버로딩


메서드 오버로딩은 같은 이름의 메서드를 매개변수의 유형과 개수가 다르게 여러 개 정의하는 것입니다. 

이를 통해 코드의 가독성과 유연성이 향상됩니다.

예시:

1
2
3
4
5
6
7
8
9
10
11
public static int add(int a, int b) {
    return a + b;
}
 
public static double add(double a, double b) {
    return a + b;
}
 
public static int add(int a, int b, int c) {
    return a + b + c;
}
cs

 

5. 메서드와 스코프


메서드 내에서 정의된 변수는 해당 메서드의 지역 변수입니다. 

지역 변수는 메서드가 종료되면 소멸됩니다. 메서드 외부에서 지역 변수를 사용할 수 없습니다.

1
2
3
4
5
6
7
8
9
10
11
12
public class MethodAndScopeExample {
 
    public static void main(String[] args) {
        printHello();
        System.out.println(message); // 오류 발생! message 변수는 printHello() 메서드의 지역 변수이므로 여기에서 사용할 수 없습니다.
    }
 
    public static void printHello() {
        String message = "Hello, Java!";
        System.out.println(message); // 이 곳에서는 message 변수를 사용할 수 있습니다.
    }
}
cs
printHello() 메서드 내에서 정의된 message 변수는 지역 변수입니다. 이 변수는 해당 메서드 내에서만 사용할 수 있으며, 메서드가 종료되면 소멸됩니다. 따라서 main 메서드에서 message 변수를 직접 사용하려고 하면 오류가 발생합니다.
메서드 외부에서 지역 변수에 접근하려면 메서드의 반환 값이나 매개변수를 통해 값을 전달할 수 있습니다.

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

[JAVA] this  (0) 2023.03.18
[JAVA] 생성자(Constructor)  (0) 2023.03.18
[JAVA] 인스턴스 (Instance)  (0) 2023.03.18
[JAVA] 클래스(Class)  (0) 2023.03.17
[JAVA] 객체(Object)  (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

안녕하세요! 오늘은 자바에서 매우 중요한 개념인 객체(Object)에 대해 알아보겠습니다.

객체 지향 프로그래밍(Object-Oriented Programming)을 배우는 데 있어 핵심이 되는 객체를 실생활 예시를 통해 자세하고 쉽게 이해해봅시다.

 

  

1. 객체(Object)란 무엇인가?  

자바에서 객체는 현실 세계에 존재하는 개체(Entity)를 컴퓨터 세계에서 표현하기 위한 구조입니다. 

객체는 속성(Attribute)과 행동(Method)로 구성되어 있습니다. 

예를 들어, 자동차라는 객체가 있다고 생각해보겠습니다.

속성(Attribute) : 차종, 색상, 배기량, 속도 등
행동(Method) : 가속하기, 멈추기, 방향 전환 등

이처럼 객체는 어떤 대상의 특성과 그 대상이 수행하는 기능을 모두 포함합니다.

 

2. 클래스(Class)와 인스턴스(Instance)

객체를 생성하기 위해서는 먼저 클래스(Class)라는 '틀'이 필요합니다. 

클래스는 객체의 속성과 행동을 정의하며, 인스턴스는 클래스를 바탕으로 생성된 실체입니다. 

동일한 클래스를 바탕으로 여러 개의 인스턴스를 생성할 수 있습니다. 

예를 들어, 자동차라는 클래스를 가지고 여러 대의 서로 다른 자동차 인스턴스를 만들 수 있습니다.

 

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

public class Car {
    // 속성 (멤버 변수)
    String brand;
    String color;
    int speed;

    // 행동 (메소드)
    void accelerate() {
        speed += 10;
    }

    void brake() {
        speed -= 10;
    }

    void turn(String direction) {
        System.out.println("Turning " + direction);
    }
}

public static void main(String[] args) {
    // 인스턴스 생성
    Car myCar = new Car();
    Car yourCar = new Car();

    // 속성 설정
    myCar.brand = "Hyundai";
    myCar.color = "Blue";
    myCar.speed = 0;

    yourCar.brand = "Kia";
    yourCar.color = "Red";
    yourCar.speed = 0;

    // 행동 수행
    myCar.accelerate();
    myCar.turn("left");
    yourCar.brake();
}

위의 코드에서 Car 클래스를 정의하고, main 메소드에서 두 개의 서로 다른 인스턴스(myCar, yourCar)를 생성했습니다. 

각 인스턴스는 서로 다른 속성을 가지고 있지만, 동일한 클래스를 기반으로 만들어졌기 때문에 같은 행동(메소드)를 공유합니다. 

이렇게 클래스를 사용하면 비슷한 객체들을 쉽게 생성하고 관리할 수 있습니다.

 

3. 캡슐화(Encapsulation)
객체 지향 프로그래밍에서는 캡슐화라는 개념이 중요합니다. 

캡슐화는 객체의 속성과 행동을 하나의 단위로 묶어 외부에서 직접 접근할 수 없도록 하는 것입니다. 

이를 통해 코드의 안정성과 유지 보수성이 향상됩니다.

예시: 캡슐화를 적용한 자동차 클래스

public class Car {
    // 속성 (멤버 변수) - private으로 설정
    private String brand;
    private String color;
    private int speed;

    // 행동 (메소드) - public으로 설정
    public void accelerate() {
        speed += 10;
    }

    public void brake() {
        speed -= 10;
    }

    public void turn(String direction) {
        System.out.println("Turning " + direction);
    }

    // 속성에 접근하기 위한 Getter와 Setter 메소드
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }
}

위의 코드에서 속성은 private로 설정하여 외부에서 직접 접근할 수 없게 하였습니다. 대신, 각 속성에 대한 Getter와 Setter 메소드를 정의하여 간접적으로 접근할 수 있도록 했습니다. 이를 통해 객체의 내부 데이터를 보호하고 외부에서의 변경을 제어할 수 있습니다.

 

4. 상속(Inheritance)
상속은 한 클래스의 속성과 행동을 다른 클래스가 물려받는 것입니다. 

이를 통해 코드의 중복을 줄이고, 기존 클래스를 수정하지 않고도 새로운 기능을 추가할 수 있습니다.

예시: 상속을 이용한 전기 자동차 클래스 생성

public class ElectricCar extends Car {
    private int batteryCapacity;

    public int getBatteryCapacity() {
        return batteryCapacity;
    }

    public void setBatteryCapacity(int batteryCapacity) {
        this.batteryCapacity = batteryCapacity;
    }

    public void charge() {
        System.out.println("Charging the electric car...");
    }
}

위의 코드에서 ElectricCar 클래스는 Car 클래스를 상속받았습니다. 이로 인해 ElectricCar 클래스는 기존 Car 클래스의 속성(brand, color, speed)과 행동(accelerate, brake, turn)을 모두 물려받게 되며, 추가로 전기 자동차에만 해당되는 속성(batteryCapacity)과 충전(charge)을 정의할 수 있습니다.

public static void main(String[] args) {
    ElectricCar tesla = new ElectricCar();

    // Car 클래스의 메소드 사용
    tesla.setBrand("Tesla");
    tesla.setColor("White");
    tesla.setSpeed(0);
    tesla.accelerate();

    // ElectricCar 클래스에서 추가된 메소드 사용
    tesla.setBatteryCapacity(100);
    tesla.charge();
}

 

Main 메소드에서는 ElectricCar 클래스의 인스턴스(tesla)를 생성하고, 상속받은 Car 클래스의 메소드(setBrand, setColor, setSpeed, accelerate)와 ElectricCar 클래스에서 추가한 메소드(setBatteryCapacity, charge)를 사용할 수 있습니다.

 

5.다형성(Polymorphism)
다형성은 한 객체가 여러 가지 타입을 가질 수 있는 것을 의미합니다. 

다형성을 이용하면 동일한 인터페이스에 대해 서로 다른 구현을 할 수 있어 코드의 유연성이 증가합니다.



예시: 다형성을 이용한 자동차 클래스

public interface Drivable {
    void drive();
}

public class Car implements Drivable {
    // 기존 Car 클래스 코드

    @Override
    public void drive() {
        System.out.println("Driving a car...");
    }
}

public class ElectricCar extends Car {
    // 기존 ElectricCar 클래스 코드

    @Override
    public void drive() {
        System.out.println("Driving an electric car...");
    }
}

public static void main(String[] args) {
    Drivable myCar = new Car();
    Drivable yourCar = new ElectricCar();

    myCar.drive(); // 출력: Driving a car...
    yourCar.drive(); // 출력: Driving an electric car...

위의 코드에서 Car 클래스와 ElectricCar 클래스는 Drivable 인터페이스를 구현하였습니다. main 메소드에서 Drivable 타입의 변수에 각각 Car와 ElectricCar 인스턴스를 할당하고, drive 메소드를 호출하였습니다. 이렇게 하면 각 인스턴스에 따라 서로 다른 drive 메소드가 실행되는 다형성을 구현할 수 있습니다.

 



이상으로 자바 객체에 대한 설명을 마칩니다. 객체 지향 프로그래밍의 핵심 개념인 객체, 클래스, 캡슐화, 상속, 다형성을 실생활 예시를 통해 자세하고 쉽게 이해해보았습니다. 이를 기반으로 자바 프로그래밍 능력을 더욱 향상시킬 수 있을 것입니다.  감사합니다.

'[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] 클래스(Class)  (0) 2023.03.17
1 2 3