Java 클래스와 객체

안녕하세요! 오늘은 Java 프로그래밍의 핵심 개념인 클래스와 객체에 대해 적어보겠습니다.

 

1. 클래스와 객체란 무엇인가?

1.1. 클래스(Class)

클래스는 객체를 생성하기 위한 템플릿 또는 청사진입니다. 클래스는 데이터(필드)와 동작(메서드)을 정의하여 객체의 상태와 행동을 규정합니다. 클래스는 사용자 정의 데이터 타입으로, 객체 지향 프로그래밍의 기본 단위입니다.

클래스를 선언하는 기본 문법은 다음과 같습니다:

public class Car {
    // 필드(멤버 변수)
    String color;
    String model;
    int year;
    
    // 생성자
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }
    
    // 메서드
    public void displayDetails() {
        System.out.println("Color: " + color);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }
}

 

1.2. 객체(Object)

객체는 클래스로부터 생성된 인스턴스입니다. 객체는 클래스에 정의된 필드와 메서드를 사용하여 실제 동작을 수행합니다. 객체는 메모리에 할당되며, 클래스의 구조를 따릅니다.

객체를 생성하고 사용하는 예제는 다음과 같습니다:

public class Main {
    public static void main(String[] args) {
        // 객체 생성
        Car car = new Car("Red", "Toyota", 2020);
        
        // 메서드 호출
        car.displayDetails();
    }
}

위 예제에서 `Car` 클래스는 `Car` 객체를 생성하는 데 사용되었고, `car` 객체는 `displayDetails` 메서드를 호출하여 정보를 출력합니다.

 

 

2. 클래스의 구성 요소

클래스는 여러 구성 요소로 이루어져 있습니다. 주요 구성 요소는 다음과 같습니다:

2.1. 필드(Field)
필드는 클래스의 상태를 나타내는 변수입니다. 필드는 클래스 내에서 선언되며, 객체가 가지는 속성을 정의합니다.

public class Person {
    String name;
    int age;
}

 

2.2. 생성자(Constructor)
생성자는 객체가 생성될 때 호출되는 특별한 메서드로, 객체의 초기화를 담당합니다. 생성자는 클래스 이름과 동일하며, 반환 타입이 없습니다.

public class Person {
    String name;
    int age;
    
    // 생성자
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

2.3. 메서드(Method)
메서드는 객체의 동작을 정의하는 함수입니다. 메서드는 클래스 내에서 선언되며, 특정 작업을 수행합니다.

public class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 메서드
    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

2.4. 접근 제한자(Access Modifier)
접근 제한자는 클래스, 필드, 메서드에 대한 접근 수준을 제어하는 데 사용됩니다. 주요 접근 제한자는 다음과 같습니다:

- `public`: 모든 클래스에서 접근 가능
- `protected`: 같은 패키지 또는 서브 클래스에서 접근 가능
- `default` (접근 제한자를 명시하지 않음): 같은 패키지에서 접근 가능
- `private`: 해당 클래스 내에서만 접근 가능

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

 

3. 객체 지향 프로그래밍의 4대 원칙

객체 지향 프로그래밍은 클래스와 객체를 사용하여 프로그래밍하는 패러다임입니다. 주요 원칙은 다음과 같습니다:

3.1. 캡슐화(Encapsulation)
캡슐화는 데이터와 메서드를 하나의 단위로 묶고, 데이터에 대한 접근을 제한하는 원칙입니다. 이를 통해 데이터의 무결성을 보호하고, 코드의 유지보수성을 높입니다.

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

3.2. 상속(Inheritance)

상속은 기존 클래스(부모 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스)가 물려받는 기능입니다. 상속을 통해 코드의 재사용성을 높이고, 계층 구조를 형성할 수 있습니다.

public class Animal {
    String name;
    
    public void eat() {
        System.out.println("Eating...");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Barking...");
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat();
        dog.bark();
    }
}

3.3. 다형성(Polymorphism)
다형성은 같은 인터페이스나 부모 클래스를 상속받은 객체가 다양한 형태를 가질 수 있는 특성입니다. 이를 통해 동일한 인터페이스로 다양한 객체를 다룰 수 있습니다.

public class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.makeSound();
        myCat.makeSound();
    }
}

3.4. 추상화(Abstraction)
추상화는 복잡한 시스템에서 핵심적인 개념만을 모델링하여 단순화하는 과정입니다. 추상화는 인터페이스나 추상 클래스를 사용하여 구현됩니다.

abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.makeSound();
        myCat.makeSound();
    }
}

 

4. 클래스와 객체의 활용

4.1. 상속과 다형성을 활용한 예제
상속과 다형성을 활용하여 동물원 관리 시스템을 구현해보겠습니다.

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Lion extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Roar");
    }
}

class Elephant extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Trumpet");
    }
}

public class Zoo {
    public void listenToAnimal(Animal animal) {
        animal.makeSound();
    }
    
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        
        Animal lion = new Lion();
        Animal elephant = new Elephant();
        
        zoo.listenToAnimal(lion);
        zoo.listenToAnimal(elephant);
    }
}

4.2. 캡슐화를 활용한 은행 계좌 시스템
캡슐화를 활용하여 은행 계좌 시스템을 구현해보겠습니다.

public class BankAccount {
    private double balance;
    
    public BankAccount(double initialBalance) {
        if (initialBalance > 0) {
            balance = initialBalance;
        }
    }
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
    
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Balance: " + account.getBalance());
    }
}