본문 바로가기
카테고리 없음

자바 클래스의 상속 활용 방법과 예제: 객체 지향 프로그래밍에서 클래스 상속의 활용 방법과 예시

mujacwe 2023. 12. 17. 12:39

목차:

1. 자바 클래스의 상속 개념

  • 1.1 상속의 의미
  • 1.2 상속 구현 방법
  • 1.3 부모 클래스와 자식 클래스의 관계

2. 자바 클래스 상속의 활용 방법

  • 2.1 메서드 재사용
  • 2.2 다형성 구현
  • 2.3 코드의 유지보수성 향상

3. 자바 클래스 상속 예제

  • 3.1 동물 클래스와 각각의 서브 클래스 (강아지, 고양이)
  • 3.2 동물 클래스에서 상속된 서브 클래스의 메서드 활용
  • 3.3 메서드 오버라이딩을 통한 다형성 구현

    1. 자바 클래스의 상속 개념

상속은 객체 지향 프로그래밍에서 중요한 개념 중 하나입니다. 상속은 기존에 정의된 클래스를 바탕으로 새로운 클래스를 생성하는 과정을 말합니다. 이 새로운 클래스는 기존 클래스의 속성과 메서드를 그대로 물려받게 됩니다.

1.1 상속의 의미

상속의 주요 목적은 메서드와 필드의 재사용입니다. 기존에 구현된 클래스의 코드를 다시 작성하지 않고도 이를 활용하여 새로운 클래스를 만들 수 있습니다. 이렇게 함으로써 코드의 중복을 줄이고, 유지보수성을 향상시킬 수 있습니다.

1.2 상속 구현 방법

자바에서는 클래스의 상속을 구현하기 위해 extends 키워드를 사용합니다. 새로운 클래스를 정의할 때, 기존 클래스를 확장하기 위해 extends 키워드 뒤에 기존 클래스의 이름을 작성합니다. 이렇게 하면 새로운 클래스는 기존 클래스의 멤버들을 자동으로 상속받습니다.

예를 들어, 아래와 같이 Animal 클래스가 정의되어 있다고 가정해봅시다.

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }
}

그리고 우리는 Dog 클래스를 만들고 싶다고 가정해봅시다. Dog 클래스는 Animal 클래스를 확장하여 만들어진 새로운 클래스입니다. 이를 구현하기 위해 extends 키워드를 사용합니다.

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

위의 예시에서 Dog 클래스는 Animal 클래스의 멤버인 name 필드와 eat() 메서드를 상속받습니다. 따라서 Dog 클래스의 객체를 생성하고 eat() 메서드를 호출하는 것이 가능해집니다.

1.3 부모 클래스와 자식 클래스의 관계

상속 관계에서 기존에 정의된 클래스는 부모 클래스 또는 슈퍼 클래스라고 불립니다. 새롭게 생성된 클래스는 기존 클래스의 특징을 상속받은 것이기 때문에 자식 클래스 또는 서브 클래스라고 불립니다.

자식 클래스는 부모 클래스의 모든 멤버를 상속받지만, 부모 클래스는 자식 클래스의 멤버를 알지 못합니다. 따라서, 자식 클래스는 부모 클래스의 멤버에 접근할 수 있지만, 반대는 불가능합니다. 이러한 관계는 클래스 간의 계층 구조를 형성하며, 이를 통해 객체 지향 프로그래밍의 다형성과 유연성을 구현할 수 있습니다.

2. 자바 클래스 상속의 활용 방법

자바의 클래스 상속은 다양한 방법으로 활용될 수 있습니다. 이번 섹션에서는 상속의 주요한 활용 방법에 대해 알아보겠습니다.

2.1 메서드 재사용

상속을 통해 부모 클래스의 메서드를 자식 클래스에서 재사용할 수 있습니다. 부모 클래스에서 이미 구현된 메서드를 자식 클래스에서 다시 구현하지 않고도 사용할 수 있기 때문에 코드의 중복을 피할 수 있습니다. 이는 유지보수성을 향상시키는데 도움을 줍니다.

예를 들어, Animal 클래스에는 eat() 메서드가 정의되어 있습니다. 이 메서드는 모든 동물이 수행할 수 있는 기능입니다. 이제 Dog 클래스와 Cat 클래스를 생성하고, 각각의 클래스에서는 추가적으로 다른 동작을 수행하는 메서드를 작성할 수 있습니다. 하지만 기본적인 eat() 메서드는 Animal 클래스에서 상속받아 재사용할 수 있습니다.

2.2 다형성 구현

상속을 통해 다형성을 구현할 수 있습니다. 다형성은 같은 이름의 메서드가 서로 다른 동작을 수행할 수 있는 능력을 말합니다. 부모 클래스의 참조 변수로 자식 클래스의 객체를 참조할 수 있기 때문에, 부모 클래스에서 정의된 메서드를 호출하더라도 실제로는 자식 클래스에서 재정의된 메서드가 실행될 수 있습니다.

이를 통해 프로그램의 확장성과 유연성을 높일 수 있습니다. 여러 종류의 객체를 하나의 부모 클래스 타입으로 다룰 수 있으므로, 같은 메서드를 이용해 다양한 동작을 수행할 수 있습니다.

2.3 코드의 유지보수성 향상

상속을 통해 코드의 유지보수성을 높일 수 있습니다. 상속을 통해 기존 클래스의 기능을 확장하거나 변경할 수 있기 때문에, 기존의 코드를 수정하지 않고도 새로운 클래스를 만들어 기능을 추가하거나 수정할 수 있습니다. 이는 기존 코드를 함부로 변경하지 않고도 새로운 요구사항을 반영할 수 있는 유연성을 제공합니다.

상속을 통해 코드의 재사용과 추상화를 가능하게 하여 개발자가 코드를 더 쉽게 이해하고 유지보수할 수 있게 해줍니다. 새로운 기능을 추가하거나 수정하기 위해 모든 코드를 다시 작성할 필요가 없으며, 코드의 일부만 수정하여도 변화에 대응할 수 있습니다.

3. 자바 클래스 상속 예제

다음은 간단한 자바 클래스 상속 예제입니다. 이 예제에서는 Shape 클래스를 부모 클래스로 정의하고, Rectangle 클래스와 Circle 클래스를 자식 클래스로 정의하여 상속을 구현해봅시다.

3.1 Shape 클래스 정의

먼저, Shape 클래스를 정의합니다. 이 클래스는 도형의 기본적인 속성과 메서드를 가지고 있습니다.

public class Shape {
    protected double area;

    public void calculateArea() {
        System.out.println("Calculating area of shape");
    }

    public void displayArea() {
        System.out.println("Area of shape: " + area);
    }
}

Shape 클래스에는 area 필드와 calculateArea() 메서드, 그리고 displayArea() 메서드가 정의되어 있습니다. calculateArea() 메서드는 도형의 넓이를 계산하고, displayArea() 메서드는 계산된 넓이를 출력합니다.

3.2 Rectangle 클래스 정의

이제 Rectangle 클래스를 Shape 클래스를 상속받아 정의합니다. Rectangle 클래스는 Shape 클래스에 정의된 메서드를 상속받고, 추가적인 기능을 구현할 수 있습니다.

public class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public void calculateArea() {
        area = length * width;
    }
}

Rectangle 클래스에는 length와 width 필드가 추가되었습니다. 이 클래스의 생성자는 length와 width 값을 받아와서 필드를 초기화합니다.

calculateArea() 메서드는 Shape 클래스에서 상속받은 메서드를 재정의합니다. 여기서는 length와 width를 이용해 직사각형의 넓이를 계산하여 area 필드에 저장합니다.

3.3 Circle 클래스 정의

마지막으로 Circle 클래스를 Shape 클래스를 상속받아 정의합니다.

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

Circle 클래스에는 radius 필드가 추가되었습니다. 생성자는 radius 값을 받아와서 필드를 초기화합니다.

calculateArea() 메서드는 Shape 클래스에서 상속받은 메서드를 재정의합니다. 원의 넓이를 계산하여 area 필드에 저장합니다.

3.4 예제 사용

이제 위에서 정의한 클래스들을 사용해보겠습니다.

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(5, 10);
        rectangle.calculateArea();
        rectangle.displayArea();

        Circle circle = new Circle(3);
        circle.calculateArea();
        circle.displayArea();
    }
}

Main 클래스에서는 Rectangle 객체와 Circle 객체를 생성하고, 각각의 넓이를 계산한 후 출력합니다.

출력 결과는 다음과 같습니다.

Area of shape: 50.0
Area of shape: 28.274333882308138

Rectangle 객체의 넓이는 50.0, Circle 객체의 넓이는 28.274333882308138입니다. Rectangle과 Circle 클래스에서는 calculateArea() 메서드를 재정의하여 각자의 도형에 맞는 넓이 계산을 수행하였습니다. 이를 통해 같은 displayArea() 메서드를 호출하더라도 Shape 클래스에서 정의된 메서드가 아닌, 각 도형에 맞게 오버라이딩된 메서드가 실행되었습니다.

자바 클래스 상속 예제

다음은 자바에서 클래스 상속을 사용하는 간단한 예제입니다. 이 예제에서는 도형을 나타내는 Shape 클래스를 부모 클래스로 정의하고, Rectangle 클래스와 Circle 클래스를 자식 클래스로 정의하여 상속을 구현합니다.

Shape 클래스 정의

우선, Shape 클래스를 정의합니다. 이 클래스는 도형의 기본적인 속성과 메서드를 가지고 있습니다.

public class Shape {
    protected double area;

    public void calculateArea() {
        System.out.println("Calculating area of shape");
    }

    public void displayArea() {
        System.out.println("Area of shape: " + area);
    }
}

Shape 클래스에는 area라는 필드와 calculateArea() 메서드, 그리고 displayArea() 메서드가 정의되어 있습니다. calculateArea() 메서드에서는 도형의 넓이를 계산하고, displayArea() 메서드에서는 계산된 넓이를 출력합니다.

Rectangle 클래스 정의

이제 Rectangle 클래스를 Shape 클래스를 상속받아 정의합니다. 이 클래스에서는 부모 클래스인 Shape 클래스의 메서드를 상속받고, 추가적인 기능을 구현할 수 있습니다.

public class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public void calculateArea() {
        area = length * width;
    }
}

Rectangle 클래스에는 length와 width라는 필드가 추가되었습니다. 클래스의 생성자는 length와 width 값을 받아와서 필드를 초기화합니다.

calculateArea() 메서드에서는 Shape 클래스에서 상속받은 메서드를 오버라이딩합니다. 여기서는 length와 width를 사용하여 직사각형의 넓이를 계산한 후 area 필드에 저장합니다.

Circle 클래스 정의

마지막으로 Circle 클래스를 Shape 클래스를 상속받아 정의합니다.

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

Circle 클래스에는 radius라는 필드가 추가되었습니다. 생성자는 radius 값을 받아와서 필드를 초기화합니다.

calculateArea() 메서드에서는 Shape 클래스에서 상속받은 메서드를 오버라이딩합니다. 원의 넓이를 계산하여 area 필드에 저장합니다.

예제 사용

이제 위에서 정의한 클래스들을 사용해보겠습니다.

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(5, 10);
        rectangle.calculateArea();
        rectangle.displayArea();

        Circle circle = new Circle(3);
        circle.calculateArea();
        circle.displayArea();
    }
}

Main 클래스에서는 Rectangle 객체와 Circle 객체를 생성하고, 각각의 넓이를 계산한 후 출력합니다.

출력 결과는 다음과 같습니다.

Area of shape: 50.0
Area of shape: 28.274333882308138

Rectangle 객체의 넓이는 50.0, Circle 객체의 넓이는 28.274333882308138입니다. Rectangle과 Circle 클래스에서는 calculateArea() 메서드를 오버라이딩하여 각 도형에 맞는 넓이를 계산했습니다. 따라서 동일한 displayArea() 메서드를 호출하더라도, 부모 클래스인 Shape의 메서드가 아니라 자식 클래스의 메서드가 실행되었습니다.

1. 자바 클래스의 상속 개념

자바에서는 상속을 통해 클래스들 간에 관계를 형성할 수 있습니다. 상속은 부모 클래스의 특성과 동작을 자식 클래스가 물려받는 것을 의미합니다. 이를 통해 코드의 재사용성과 유지보수의 편의성을 높일 수 있습니다.

상속의 구조

자바에서 상속은 한 클래스를 다른 클래스에게 확장하는 방식으로 이루어집니다. 상속 관계에서는 두 클래스 간에 "부모-자식" 또는 "상위-하위" 관계가 형성됩니다. 부모 클래스는 상위 클래스로도 불리며, 자식 클래스는 하위 클래스로도 불립니다.

상속의 장점

상속을 이용하면 코드의 재사용성과 유지보수의 편의성이 향상됩니다.

  1. 코드의 재사용성: 부모 클래스에 구현된 속성과 메서드를 자식 클래스에게 물려줌으로써, 자식 클래스는 이를 재사용할 수 있습니다. 이는 코드의 중복을 줄여주고 개발 시간을 단축시킵니다.

  2. 유지보수의 편의성: 부모 클래스에 공통된 기능이 존재할 때, 해당 기능을 수정해야 할 경우 부모 클래스만 수정하면 자식 클래스들에게도 적용됩니다. 따라서 변경 사항을 한 곳에서만 처리해주면 되므로 유지보수 과정이 간소화됩니다.

상속의 문법

자바에서 클래스 상속은 extends 키워드를 사용하여 정의됩니다. 자식 클래스의 선언부에 extends 키워드를 사용하고, 뒤에 부모 클래스의 이름을 적어주면 됩니다.

public class ChildClass extends ParentClass {
    // 자식 클래스의 내용
}

위와 같이 자식 클래스를 정의할 때 ParentClass를 상속받도록 선언하면 됩니다.

상속의 제한

자바에서는 단일 상속만을 지원합니다. 즉, 하나의 클래스는 하나의 부모 클래스만 상속받을 수 있습니다. 이는 자바에서 다중 상속을 허용하지 않는 이유 중 하나인 다이아몬드 문제를 방지하는 데 도움을 줍니다.

메서드 재정의 (Overriding)

자식 클래스는 부모 클래스의 메서드를 재정의할 수 있습니다. 이를 메서드 재정의 또는 오버라이딩(Overriding)이라고 합니다. 메서드 오버라이딩은 자식 클래스에서 부모 클래스의 메서드를 다시 정의하여 자식 클래스의 동작을 변경하는 기능입니다. 오버라이딩은 메서드의 이름, 매개변수, 반환형이 동일해야 합니다.

오버라이딩을 위해서는 부모 클래스의 메서드가 반드시 protected 또는 public 접근 제한자로 선언되어야 합니다. 만약 부모 클래스의 메서드가 private이라면 자식 클래스에서 변경할 수 없으므로 오버라이딩 불가능합니다.

결과적으로

상속을 통해 자식 클래스는 부모 클래스의 멤버와 메서드를 상속받아 재사용할 수 있습니다. 또한, 자식 클래스는 부모 클래스의 메서드를 재정의하여 동작을 변경할 수 있습니다. 이를 활용하여 코드의 재사용성과 유지보수의 편의성을 높일 수 있습니다.

1.1 상속의 의미

상속은 객체 지향 프로그래밍에서 객체 간의 관계를 형성하는 중요한 개념입니다. 상속을 통해 클래스들 사이에 부모-자식 관계가 형성되며, 이를 통해 부모 클래스의 특성과 동작을 자식 클래스가 물려받을 수 있습니다.

상속의 의미와 목적

상속은 객체 지향 프로그래밍의 기본 개념 중 하나인 '다형성'을 구현하고 코드의 재사용성과 유지보수의 편의성을 높이는 데 목적이 있습니다.

  1. 다형성 구현: 상속을 통해 부모 클래스의 객체를 자식 클래스의 객체로 사용할 수 있습니다. 이는 다형성(polymorphism)을 구현하는 방법 중 하나입니다. 다형성은 동일한 메서드 이름을 가진 여러 클래스의 객체를 동일한 방법으로 다룰 수 있는 능력을 의미합니다. 상속을 통해 자식 클래스는 부모 클래스의 메서드를 동일하게 호출할 수 있으므로, 같은 타입으로 다양한 객체를 다룰 수 있습니다.

  2. 코드 재사용성: 상속을 통해 부모 클래스의 속성과 메서드를 자식 클래스가 물려받을 수 있습니다. 이렇게 각 클래스들 사이에 공통된 기능이나 특성이 있을 때, 부모 클래스에 이를 구현하고 자식 클래스들이 이를 상속받아 사용하면 코드의 재사용성이 좋아지고 중복을 줄일 수 있습니다. 즉, 유사한 기능을 가진 클래스들을 구현할 때, 공통된 기능을 부모 클래스에 작성하고 이를 상속받아 필요한 부분만 추가 또는 변경하여 사용할 수 있습니다.

부모-자식 관계의 형성

상속을 통해 부모 클래스와 자식 클래스 사이에 부모-자식 관계가 형성됩니다. 자식 클래스는 부모 클래스의 모든 멤버(속성, 메서드)를 물려받을 수 있습니다. 자식 클래스는 부모 클래스의 특성을 그대로 물려받아 사용할 수 있을 뿐만 아니라, 필요하다면 추가적인 멤버와 메서드를 정의하여 기존 기능을 확장할 수도 있습니다.

public class ParentClass {
    // 부모 클래스의 멤버들
}

public class ChildClass extends ParentClass {
    // 자식 클래스의 추가 멤버들
}

부모 클래스인 ParentClass와 자식 클래스인 ChildClass의 선언과정에서 extends 키워드를 사용하여 자식 클래스가 부모 클래스를 상속받음을 나타냅니다. 이렇게 자식 클래스가 부모 클래스를 상속받으면, 자식 클래스는 부모 클래스의 멤버들을 직접적으로 접근할 수 있게 됩니다.

메서드 재정의 (Overriding)

자식 클래스는 부모 클래스의 메서드를 재정의(overriding)할 수 있습니다. 메서드 재정의란 자식 클래스에서 부모 클래스의 메서드를 다시 정의하고 동작을 변경하는 것을 의미합니다. 메서드 재정의를 통해 자식 클래스는 부모 클래스의 기능을 덮어쓸 수 있으며, 필요에 따라 동작을 추가하거나 수정할 수 있습니다.

메서드 재정의를 위해서는 부모 클래스에서 재정의하고자 하는 메서드는 protected 또는 public 접근 제한자로 선언되어야 합니다. private으로 선언된 메서드는 자식 클래스에서 접근할 수 없어 재정의가 불가능합니다.

상속의 제한

자바에서는 단일 상속만을 지원합니다. 이는 하나의 클래스가 하나의 부모 클래스만 상속받을 수 있다는 의미입니다. 이를 통해 다중 상속이 가져올 수 있는 이슈와 모호성을 방지하고 클래스 간의 관계를 단순화할 수 있습니다.

단일 상속의 제약으로 인해 다른 클래스의 기능을 필요로 할 때는 인터페이스를 사용할 수 있습니다. 인터페이스는 다중 구현이 가능하므로, 단일 상속으로 인한 제약을 극복할 수 있는 방안으로 사용됩니다.

결론

자바의 상속은 객체간의 관계를 형성하는 중요한 개념입니다. 이는 다형성 구현과 코드의 재사용성, 유지보수의 편의성을 높이는데 목적이 있습니다. 부모 클래스와 자식 클래스의 관계를 형성하여 부모 클래스의 특성과 동작을 자식 클래스가 물려받을 수 있으며, 필요에 따라 자식 클래스에서는 부모 클래스의 메서드를 재정의하여 동작을 변경할 수 있습니다. 단, 자바에서는 단일 상속만을 지원하므로 상속의 사용에 있어서 주의해야 합니다.

1.2 상속 구현 방법

자바에서 상속을 구현하는 방법은 간단하고 명확합니다. 자식 클래스를 선언할 때 extends 키워드를 사용하여 어떤 부모 클래스를 상속받을지 지정하면 됩니다.

상속 구현 방법

public class ParentClass {
    // 부모 클래스의 멤버들
}

public class ChildClass extends ParentClass {
    // 자식 클래스의 추가 멤버들
}

위의 예시에서 ChildClass는 ParentClass를 상속받습니다. 이렇게 선언하면 ChildClass는 ParentClass의 멤버 속성과 메서드를 사용할 수 있게 됩니다.

부모 클래스와 자식 클래스의 멤버 접근

자식 클래스는 부모 클래스의 멤버들에 접근할 수 있습니다. 자식 클래스 내부에서 super 키워드를 사용하여 부모 클래스의 멤버에 접근할 수 있습니다. super 키워드를 사용하여 부모 클래스의 생성자를 호출할 수도 있습니다.

public class ParentClass {
    public void parentMethod() {
        System.out.println("Parent Method");
    }
}

public class ChildClass extends ParentClass {
    public void childMethod() {
        super.parentMethod();  // 부모 클래스의 메서드 호출
        System.out.println("Child Method");
    }
}

위의 예시에서 ChildClass는 ChildClass 내부에서 parentMethod()를 호출하여 부모 클래스의 메서드를 사용하고 있습니다.

메서드 재정의 (Overriding)

자식 클래스는 부모 클래스의 메서드를 재정의할 수 있습니다. 메서드 재정의를 위해서는 자식 클래스에서 부모 클래스의 메서드와 동일한 이름과 같은 매개변수를 가져야 합니다.

public class ParentClass {
    public void display() {
        System.out.println("Parent Display");
    }
}

public class ChildClass extends ParentClass {
    @Override
    public void display() {
        System.out.println("Child Display");
    }
}

위의 예시에서 ChildClass는 ParentClass의 display() 메서드를 재정의하였습니다. 이렇게 하면 ChildClass에서는 Child Display가 출력됩니다. @Override 어노테이션을 사용하여 재정의된 메서드라는 것을 명시할 수 있습니다.

상속과 생성자

상속받은 자식 클래스의 객체를 생성할 때, 부모 클래스의 생성자가 먼저 호출됩니다. 이는 자식 클래스의 객체가 생성되기 전에 부모 클래스의 초기화를 먼저 수행하기 때문입니다.

public class ParentClass {
    public ParentClass() {
        System.out.println("Parent Constructor");
    }
}

public class ChildClass extends ParentClass {
    public ChildClass() {
        System.out.println("Child Constructor");
    }
}

위의 예시에서 ChildClass 객체가 생성되면 출력은 다음과 같이 됩니다.

Parent Constructor
Child Constructor

상속의 제한

자바에서는 단일 상속만을 지원합니다. 한 클래스는 하나의 부모 클래스만 상속받을 수 있습니다.

public class ParentClass {
    // 부모 클래스의 멤버들
}

public class ChildClass extends ParentClass {
    // 추가 멤버들
}

// 다음과 같이 선언하면 오류 발생
public class AnotherClass extends ParentClass, SomeOtherClass {
    // 추가 멤버들
}

위의 예시에서 AnotherClass는 ParentClass와 SomeOtherClass를 모두 상속받으려고 하기 때문에 컴파일 오류가 발생합니다.

인터페이스를 통한 다중 상속 구현

다중 상속이 필요한 경우, 자바에서는 인터페이스를 통해 다중 상속을 구현할 수 있습니다. 인터페이스는 다른 클래스에서 구현될 메서드의 명세를 제공하는 역할을 합니다. 클래스는 여러 개의 인터페이스를 구현할 수 있으므로 다중 상속과 유사한 효과를 얻을 수 있습니다.

public interface InterfaceA {
    void methodA();
}

public interface InterfaceB {
    void methodB();
}

public class MyClass implements InterfaceA, InterfaceB {
    public void methodA() {
        System.out.println("Method A");
    }

    public void methodB() {
        System.out.println("Method B");
    }
}

위의 예시에서 MyClass는 InterfaceA와 InterfaceB를 모두 구현하였습니다. 이렇게 하면 MyClass는 methodA()와 methodB()를 모두 가지고 있으므로 다중 상속과 비슷한 효과를 얻을 수 있습니다.

결론

자바에서 상속을 구현하는 방법은 간단하고 명확합니다. 자식 클래스를 선언할 때 extends 키워드를 사용하여 부모 클래스를 지정하고, 자식 클래스는 부모 클래스의 멤버들을 상속받아 사용할 수 있습니다. 메서드 재정의를 통해 부모 클래스의 메서드를 변경할 수 있으며, 생성자는 자식 클래스 객체 생성시 부모 클래스의 생성자가

1.3 부모 클래스와 자식 클래스의 관계

부모 클래스와 자식 클래스는 상속 관계를 형성하며, 상속을 통해 서로 연결됩니다. 부모 클래스는 자식 클래스들에게 공통된 속성과 메서드를 상속하여 코드의 중복을 줄이고 유지보수의 용이성을 제공합니다. 또한, 자식 클래스는 부모 클래스의 멤버들을 사용하여 자신만의 기능을 추가하거나 변경할 수 있습니다.

상속을 통한 관계 형성

부모 클래스와 자식 클래스는 상속을 통해 관계를 형성합니다. 자식 클래스는 extends 키워드를 사용하여 어떤 부모 클래스를 상속받을지 명시합니다. 이를 통해 자식 클래스는 부모 클래스의 멤버 속성과 메서드를 직접적으로 사용할 수 있게 됩니다.

public class ParentClass {
    // 부모 클래스의 멤버들
}

public class ChildClass extends ParentClass {
    // 자식 클래스의 추가 멤버들
}

위의 예시에서 ChildClass는 ParentClass를 상속받습니다. 이제 ChildClass는 ParentClass의 멤버들을 사용할 수 있습니다.

부모 클래스 멤버의 접근

자식 클래스는 부모 클래스의 멤버들에 접근할 수 있습니다. 자식 클래스에서 super 키워드를 사용하여 부모 클래스의 멤버에 접근할 수 있습니다. super 키워드를 사용하여 부모 클래스의 메서드를 호출하거나 부모 클래스의 생성자를 호출할 수 있습니다.

public class ParentClass {
    public void parentMethod() {
        System.out.println("Parent Method");
    }
}

public class ChildClass extends ParentClass {
    public void childMethod() {
        super.parentMethod();  // 부모 클래스의 메서드 호출
        System.out.println("Child Method");
    }
}

위의 예시에서 ChildClass는 ChildClass 내부에서 parentMethod()를 호출하여 부모 클래스의 메서드를 사용하고 있습니다. super 키워드를 사용하여 부모 클래스의 메서드를 호출할 수 있습니다.

메서드 재정의

자식 클래스는 부모 클래스의 메서드를 재정의할 수 있습니다. 이를 메서드 재정의(Overriding)라고 합니다. 메서드 재정의를 위해서는 자식 클래스에서 부모 클래스의 메서드와 동일한 이름과 같은 매개변수를 가져야 합니다.

public class ParentClass {
    public void display() {
        System.out.println("Parent Display");
    }
}

public class ChildClass extends ParentClass {
    @Override
    public void display() {
        System.out.println("Child Display");
    }
}

위의 예시에서 ChildClass는 ParentClass의 display() 메서드를 재정의하였습니다. 이렇게 하면 ChildClass에서는 Child Display가 출력됩니다. @Override 어노테이션을 사용하여 재정의된 메서드라는 것을 명시할 수 있습니다.

부모 클래스의 생성자 호출

부모 클래스와 자식 클래스는 생성자를 통해 객체를 생성할 수 있습니다. 이때, 부모 클래스의 생성자는 먼저 호출됩니다. 이는 부모 클래스의 초기화가 자식 클래스의 초기화보다 먼저 이루어져야 하기 때문입니다.

public class ParentClass {
    public ParentClass() {
        System.out.println("Parent Constructor");
    }
}

public class ChildClass extends ParentClass {
    public ChildClass() {
        System.out.println("Child Constructor");
    }
}

위의 예시에서 ChildClass 객체가 생성되면 출력은 다음과 같이 됩니다.

Parent Constructor
Child Constructor

생성자를 호출할 때에는 super() 키워드를 사용하여

부모 클래스와 자식 클래스의 관계

부모 클래스와 자식 클래스는 상속 관계를 통해 연결되어 있는 관계입니다. 부모 클래스는 자식 클래스에게 자신의 멤버들을 상속하여 공통된 속성과 메서드를 제공합니다. 이를 통해 코드의 중복을 최소화하고 유지보수성을 높일 수 있습니다. 자식 클래스는 부모 클래스의 멤버들을 사용하며, 자신만의 추가적인 속성과 메서드를 정의할 수 있습니다.

상속 관계 형성

부모 클래스와 자식 클래스는 extends 키워드를 사용하여 상속 관계를 형성합니다. 자식 클래스는 부모 클래스를 지정하여 자신이 부모 클래스의 멤버들을 상속받을 수 있도록 합니다.

public class ParentClass {
    // 부모 클래스의 멤버들
}

public class ChildClass extends ParentClass {
    // 자식 클래스의 추가 멤버들
}

위의 예시에서 ChildClass는 ParentClass를 상속받습니다. 이제 ChildClass는 ParentClass의 멤버들을 직접적으로 사용할 수 있게 됩니다.

부모 클래스 멤버의 접근

자식 클래스는 부모 클래스의 멤버들에 접근할 수 있습니다. 이를 위해 자식 클래스 내부에서 super 키워드를 사용할 수 있습니다. super 키워드를 사용하면 부모 클래스의 멤버에 접근할 수 있으며, 부모 클래스의 메서드를 호출하거나 부모 클래스의 생성자를 호출할 수 있습니다.

public class ParentClass {
    public void parentMethod() {
        System.out.println("Parent Method");
    }
}

public class ChildClass extends ParentClass {
    public void childMethod() {
        super.parentMethod();  // 부모 클래스의 메서드 호출
        System.out.println("Child Method");
    }
}

위의 예시에서 ChildClass는 ChildClass 내부에서 parentMethod()를 호출하여 부모 클래스의 메서드를 사용하고 있습니다. super 키워드를 사용하여 부모 클래스의 메서드를 호출할 수 있습니다.

메서드 재정의

자식 클래스는 부모 클래스의 메서드를 재정의할 수 있습니다. 이를 메서드 재정의(Overriding)라고 합니다. 메서드 재정의를 위해서는 자식 클래스에서 부모 클래스의 메서드와 동일한 이름과 매개변수를 가져야 합니다.

public class ParentClass {
    public void display() {
        System.out.println("Parent Display");
    }
}

public class ChildClass extends ParentClass {
    @Override
    public void display() {
        System.out.println("Child Display");
    }
}

위의 예시에서 ChildClass는 ParentClass의 display() 메서드를 재정의하였습니다. 이렇게 하면 ChildClass에서는 Child Display가 출력됩니다. @Override 어노테이션을 사용하여 재정의된 메서드임을 명시할 수 있습니다.

부모 클래스의 생성자 호출

부모 클래스와 자식 클래스는 생성자를 통해 객체를 생성할 수 있습니다. 이때, 부모 클래스의 생성자는 자식 클래스의 생성자보다 먼저 호출됩니다. 이는 부모 클래스의 초기화가 자식 클래스의 초기화보다 먼저 이루어져야 하기 때문입니다.

public class ParentClass {
    public ParentClass() {
        System.out.println("Parent Constructor");
    }
}

public class ChildClass extends ParentClass {
    public ChildClass() {
        System.out.println("Child Constructor");
    }
}

위의 예시에서 ChildClass 객체가 생성되면 출력은 다음과 같이 됩니다.

Parent Constructor
Child Constructor

생성자를 호출할 때에는 super() 키워드를 사용하여 부모 클래스의 생성자를 명시적으로 호출할 수 있습니다.

부모 클래스와 자식 클래스의 상속 관계는 객체지향 프로그래밍에서 중요한 개념입니다. 상속을 통해 코드 재사용성과 유지보수성을 향상시킬 수 있으며, 자식 클래스는 부모 클래스의 멤버를 활용하여 자신만의 특징을 추가하고 수정할 수 있습니다. 개발자는 상속을 통해 부모 클래스와 자식 클래스 간의 관계를 이해하고 적절히 활용하여 객체지향적인 코드를 작성해야 합니다.

2. 자바 클래스 상속의 활용 방법

자바에서 클래스 상속은 코드의 재사용성과 유지보수성을 높이는 중요한 개념입니다. 상속을 통해 부모 클래스의 속성과 메서드를 자식 클래스가 상속받아 사용할 수 있으며, 이를 활용하여 자식 클래스는 부모 클래스의 기능을 확장하거나 변경할 수 있습니다. 이번 단락에서는 자바 클래스 상속의 활용 방법에 대해 알아보겠습니다.

공통된 기능 및 속성의 상속

상속은 공통된 기능을 가진 클래스들 간에 중복 코드를 제거하고, 공통 기능을 한곳에서 관리할 수 있도록 도와줍니다. 예를 들어, 다음과 같은 부모 클래스인 Animal과 자식 클래스인 Dog와 Cat이 있다고 가정해보겠습니다.

public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println("Meow!");
    }
}

Animal 클래스는 name 속성과 eat() 및 sleep() 메서드를 가지고 있습니다. 이러한 공통된 기능과 속성을 Dog와 Cat 클래스가 상속받아 사용할 수 있게 됩니다. 따라서 Dog 클래스는 bark() 메서드를, Cat 클래스는 meow() 메서드를 추가로 가질 수 있습니다.

메서드 재정의

자식 클래스는 부모 클래스의 메서드를 재정의(Overriding)할 수 있습니다. 이를 통해 자식 클래스는 부모 클래스의 메서드를 자신의 동작에 맞게 변경할 수 있습니다. 예를 들어, Animal 클래스의 eat() 메서드를 자식 클래스인 Dog와 Cat이 재정의할 수 있습니다.

public class Animal {
    // 이전 코드 생략

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

public class Dog extends Animal {
    // 이전 코드 생략

    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

public class Cat extends Animal {
    // 이전 코드 생략

    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

위의 예시에서 Dog와 Cat 클래스는 Animal 클래스의 eat() 메서드를 재정의하고 있습니다. 이제 각각의 클래스에서 eat() 메서드를 호출하면 각 클래스에 맞는 동작이 수행됩니다.

업캐스팅과 다운캐스팅

상속 관계에 있는 클래스들은 서로 형변환을 할 수 있습니다. 이를 업캐스팅(Upcasting)과 다운캐스팅(Downcasting)이라고 합니다.

업캐스팅은 자식 클래스를 부모 클래스로 형변환하는 것을 의미합니다. 부모 클래스의 변수에 자식 클래스의 객체를 담을 수 있습니다. 예를 들어, 다음과 같은 코드에서 Animal이 부모 클래스이고 Dog가 자식 클래스인 경우를 생각해보겠습니다.

Animal animal = new Dog("Bobby");

위의 코드에서 Dog 객체를 Animal 변수에 할당하고 있습니다. 이렇게 하면 Dog 객체의 고유한 메서드인 bark()는 사용할 수 없지만, Animal 클래스에 정의된 eat()과 sleep() 메서드를 사용할 수 있습니다. 이를 통해 부모 클래스의 일반적인 기능을 사용하면서, 다양한 자식 클래스의 객체를 관리할 수 있습니다.

다운캐스팅은 업캐스팅의 반대 개념으로, 부모 클래스로부터 상속받은 자식 클래스 객체를 다시 원래의 자식 클래스 타입으로 형변환하는 것을 의미합니다. 이때 다운캐스팅을 할 때에는 형변환 연산자인 (자식 클래스)를 사용합니다. 다만, 이 작업은 엄격한 타입 체크와 맞지 않는 경우 ClassCastException 예외가 발생할 수 있다는 점을 주의해야 합니다.

Animal animal = new Dog("Bobby");
Dog dog = (Dog) animal;

위의 예시에서 Animal 클래스의 객체를 Dog 클래스로 다운캐스팅하고 있습니다. 이제 dog 변수를 통해 Dog 클래스에 정의된 메서드와 속성에 접근할 수 있습니다.

자바 클래스 상속은 객체지향 프로그래밍의 핵심 개념 중 하나입니다. 상속을 통해 코드의 재사용성을 높이고 유지보수성을 개선할 수 있습니다. 또한, 상속을 이용하여 다형성과 업캐스팅/다운캐스팅을 활용할 수 있습니다. 개발자는 클래스 상속을 적절히 활용하여 객체지향적인 코드를 작성해야 합니다.

2.1 메서드 재사용

메서드 재사용은 자바 클래스 상속의 중요한 이점 중 하나입니다. 상속을 통해 부모 클래스의 메서드를 자식 클래스가 재사용할 수 있으며, 이를 통해 코드의 중복을 최소화하고 유지보수성을 높일 수 있습니다. 이번 단락에서는 메서드 재사용에 대해 자세히 알아보겠습니다.

상속을 통한 메서드 재사용

자식 클래스는 부모 클래스의 메서드를 재사용할 수 있습니다. 이를 위해 자식 클래스는 부모 클래스를 상속받아 부모 클래스의 모든 메서드를 사용할 수 있습니다. 예를 들어, 다음과 같은 상속 구조를 가진 클래스가 있다고 가정해보겠습니다.

public class ParentClass {
    public void methodA() {
        System.out.println("Parent Method A");
    }

    public void methodB() {
        System.out.println("Parent Method B");
    }
}

public class ChildClass extends ParentClass {
    // 이전 예시 코드 생략

    public void methodC() {
        System.out.println("Child Method C");
    }
}

위의 예시에서 ChildClass는 ParentClass를 상속받고 있습니다. 따라서 ChildClass는 ParentClass의 메서드인 methodA()와 methodB()를 사용할 수 있습니다. 이렇게 함으로써 부모 클래스의 메서드를 재사용할 수 있습니다.

메서드 오버라이딩

자식 클래스는 부모 클래스의 메서드를 재정의(Overriding)하여 재사용된 메서드의 동작을 변경할 수 있습니다. 메서드 오버라이딩은 메서드의 이름과 매개변수가 부모 클래스와 동일하게 맞춰져야 합니다. 예를 들어, 다음과 같은 코드에서 ChildClass가 ParentClass의 메서드인 methodA()를 오버라이딩하고 있습니다.

public class ParentClass {
    // 이전 예시 코드 생략

    public void methodA() {
        System.out.println("Parent Method A");
    }
}

public class ChildClass extends ParentClass {
    // 이전 예시 코드 생략

    @Override
    public void methodA() {
        System.out.println("Child Method A");
    }
}

위의 예시에서 ChildClass는 ParentClass의 methodA()를 오버라이딩하고 있습니다. 따라서 ChildClass의 객체에서 methodA()를 호출하면 "Child Method A"가 출력됩니다. 이를 통해 자식 클래스에서는 부모 클래스의 기존 메서드를 재사용하면서 동작을 변경할 수 있습니다.

super 키워드

자식 클래스에서 부모 클래스의 메서드를 호출하기 위해 super 키워드를 사용할 수 있습니다. super 키워드를 사용하면 자식 클래스에서 부모 클래스의 메서드를 호출할 수 있습니다. 예를 들어, 다음과 같은 코드에서 ChildClass의 methodA()에서는 super.methodA()를 사용하여 부모 클래스의 메서드를 호출하고 있습니다.

public class ParentClass {
    // 이전 예시 코드 생략

    public void methodA() {
        System.out.println("Parent Method A");
    }
}

public class ChildClass extends ParentClass {
    // 이전 예시 코드 생략

    @Override
    public void methodA() {
        super.methodA(); // 부모 클래스의 methodA() 호출
        System.out.println("Child Method A");
    }
}

위의 예시에서 ChildClass는 methodA()에서 super.methodA()를 호출하여 부모 클래스의 methodA()를 사용하고 있습니다. 이렇게 함으로써 부모 클래스의 메서드를 부분적으로 재사용하고 추가 기능을 구현할 수 있습니다.

메서드 재사용은 자바 클래스 상속의 큰 장점 중 하나입니다. 상속을 통해 부모 클래스의 메서드를 자식 클래스가 상속받고, 이를 재정의하여 새로운 동작을 구현할 수 있습니다. 이를 통해 중복 코드를 줄이고 코드의 유지보수성을 향상시킬 수 있습니다. 개발자는 메서드 재사용의 원리와 장점을 이해하고, 적절하게 상속과 메서드 재사용을 활용하여 객체지향적인 코드를 작성해야 합니다.

2.2 다형성 구현

다형성은 자바 클래스 상속의 특징 중 하나로, 같은 이름의 메서드를 서로 다른 형태로 구현할 수 있는 기능입니다. 다형성을 활용하면 부모 클래스 타입의 변수로 여러 자식 클래스의 객체를 다룰 수 있으며, 실행 시점에 어떤 객체가 실제로 사용되는지에 따라 적절한 메서드가 호출됩니다. 이번 단락에서는 다형성을 구현하는 방법에 대해 자세히 알아보겠습니다.

강한 타입 체크와 다형성

자바는 정적 타입 언어로 강한 타입 체크를 가지고 있습니다. 이는 컴파일러가 코드를 분석하고 타입과 관련된 오류를 사전에 방지하는 기능을 의미합니다. 따라서 변수의 타입이 어떤 클래스인지 정확히 알고 있어야 합니다.

하지만 다형성은 부모 클래스 타입 변수로 자식 클래스의 객체를 다루는 것을 의미합니다. 이때 컴파일러는 부모 클래스의 메서드만을 고려하며, 실제 실행 시에는 객체의 타입을 기준으로 적절한 메서드가 호출됩니다. 이를 통해 강한 타입 체크와 다형성을 조합하여 유연하고 확장 가능한 코드를 작성할 수 있습니다.

다형성의 구현 방법

다형성은 부모 클래스 타입 변수를 사용하여 여러 자식 클래스 객체를 다루는 것으로 구현됩니다. 예를 들어, Animal이라는 부모 클래스를 상속받은 Dog, Cat, Bird 클래스가 있다고 가정해보겠습니다.

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

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

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

public class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bird is chirping.");
    }
}

위의 예시에서 Animal 클래스는 makeSound() 메서드를 가지고 있으며, 이를 자식 클래스인 Dog, Cat, Bird에서 오버라이딩하여 재정의하였습니다.

이제 이 각각의 클래스를 사용하여 다형성을 구현해보겠습니다.

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        Animal animal3 = new Bird();

        animal1.makeSound(); // Dog is barking.
        animal2.makeSound(); // Cat is meowing.
        animal3.makeSound(); // Bird is chirping.
    }
}

위의 코드에서 Animal 클래스 타입 변수로 Dog, Cat, Bird의 객체를 다루고 있습니다. 이때 각각의 객체에 대해 makeSound() 메서드를 호출하면 해당 클래스에 재정의된 메서드가 실행됩니다.

다형성의 이점

다형성을 활용하면 코드의 유연성과 재사용성을 높일 수 있습니다. 부모 클래스 타입으로 여러 자식 클래스의 객체를 다룰 수 있기 때문에, 추가적인 자식 클래스가 생겨도 쉽게 추가할 수 있습니다. 또한, 코드의 중복을 최소화하고 유지보수성을 개선할 수 있습니다.

다운캐스팅과 instanceof 연산자

다형성을 구현한 코드에서 자식 클래스의 고유한 메서드를 호출하려면 다운캐스팅과 instanceof 연산자를 사용해야 합니다.

다운캐스팅은 부모 클래스 타입 변수를 자식 클래스 타입으로 형변환하는 것을 의미합니다. 이때 형변환 연산자인 (자식 클래스)를 사용하며, 다운캐스팅을 할 때에는 자식 클래스로 형변환할 수 있는지 확인하는 체크가 필요합니다. 이때 instanceof 연산자를 사용하여 형변환이 가능한지를 확인할 수 있습니다.

if (animal1 instanceof Dog) {
    Dog dog = (Dog) animal1;
    dog.bark
## 2.3 코드의 유지보수성 향상

코드의 유지보수성은 소프트웨어 개발에서 매우 중요한 요소입니다. 유지보수성이 좋은 코드는 변경이나 확장을 용이하게 만들어주며, 코드의 가독성과 재사용성을 높여줍니다. 이번 단락에서는 코드의 유지보수성을 향상시키는 몇 가지 방법을 자세히 알아보겠습니다.

### 중복 코드 제거

중복 코드는 코드의 유지보수성을 떨어뜨리는 가장 큰 요인 중 하나입니다. 중복 코드를 제거함으로써 코드의 가독성을 향상시키고, 변경 시에 중복된 코드를 여러 곳에서 수정할 필요가 없어집니다. 중복 코드를 제거하기 위해서는 특정한 기능을 하는 코드를 메서드로 분리하거나, 상속 등의 방법으로 코드를 재사용하는 등의 작업을 할 수 있습니다.

### 모듈화와 캡슐화

모듈화와 캡슐화는 코드의 유지보수성을 향상시키기 위한 또 다른 중요한 요소입니다. 모듈화는 코드를 재사용 가능한 작은 단위로 분리하는 것을 의미하며, 각 모듈은 특정 기능을 수행하도록 설계되어야 합니다. 이렇게 모듈화된 코드는 독립적으로 작동하며, 수정이나 변경이 필요한 경우 해당 모듈만 수정하면 됩니다. 캡슐화는 모듈 내부의 구현을 외부에서 접근할 수 없도록 숨기는 것을 의미합니다. 이를 통해 코드의 내부 구조를 관리하고, 외부로 노출되는 인터페이스만을 사용하여 코드를 작성할 수 있습니다.

### 의존성 관리

또 다른 유지보수성 향상 방법은 의존성 관리입니다. 의존성을 잘 관리하면 코드의 수정이나 변경 시에 영향을 받는 범위를 최소화할 수 있습니다. 의존성 관리는 인터페이스를 사용하여 구현과 결합도를 최소화하고, 객체를 주입받는 방식으로 의존성을 해결하는 것을 의미합니다. 이를 통해 코드의 수정이나 변경이 발생해도 영향 받는 범위가 적어지므로 유지보수성을 향상시킬 수 있습니다.

### 주석과 문서화

주석과 문서화는 코드의 가독성을 높이고 유지보수성을 향상시키는 데에 중요한 역할을 합니다. 주석을 통해 코드의 동작이나 의도를 명확하게 설명하고, 문서화를 통해 코드의 사용법이나 설계를 상세하게 문서화합니다. 이를 통해 다른 사람들이 코드를 쉽게 이해하고 사용할 수 있으며, 코드 수정이나 변경 시에도 문서화된 내용을 참고하여 작업할 수 있습니다.

코드의 유지보수성을 향상시키기 위해서는 중복 코드를 제거하고, 모듈화와 캡슐화를 적절히 사용하고, 의존성을 관리하며, 주석과 문서화를 활용해야 합니다. 이를 통해 코드의 가독성과 재사용성을 높이고, 변경이나 확장에 용이한 코드를 작성할 수 있습니다.
## 코드의 유지보수성 향상

### 중복 코드 제거

중복 코드는 코드의 가독성을 낮추고 유지보수성을 저하시키는 주요 원인 중 하나입니다. 중복 코드를 제거함으로써 코드의 가독성을 향상시키고, 변경 시에 중복된 코드를 여러 곳에서 수정할 필요가 없어집니다. 중복 코드를 제거하기 위해서는 일반적으로 다음과 같은 작업이 필요합니다.

- 특정한 기능을 하는 코드를 메서드로 분리하여 재사용합니다. 이렇게 하면 동일한 기능을 수행하는 여러 곳에서 같은 메서드를 호출하여 중복을 줄일 수 있습니다.
- 상속을 활용하여 부모 클래스에 공통 로직을 구현한 후, 자식 클래스에서는 이를 상속받아 각각의 특정한 기능을 추가하거나 변경할 수 있습니다.

### 모듈화와 캡슐화

모듈화와 캡슐화는 코드의 유지보수성을 향상시키기 위한 또 다른 핵심 개념입니다. 모듈화는 코드를 작은 단위로 분할하여 재사용 가능한 모듈로 만드는 것을 의미합니다. 각 모듈은 특정 기능을 수행하도록 설계되어야 하며, 독립적으로 작동할 수 있어야 합니다. 이렇게 모듈화된 코드는 수정이나 변경이 필요한 경우 해당 모듈만 수정하면 되므로 유지보수성이 향상됩니다. 캡슐화는 모듈 내부의 구현을 외부에서 접근할 수 없게 숨기는 것을 의미합니다. 이를 통해 코드의 내부 구조를 적절히 관리하고, 외부로 노출되는 인터페이스만을 사용하여 코드를 작성할 수 있습니다.

### 의존성 관리

코드의 유지보수성을 향상시키기 위해 의존성을 잘 관리하는 것도 중요합니다. 즉, 코드의 수정이나 변경이 발생했을 때 해당 변경으로 인해 영향을 받는 범위를 최소화해야 합니다. 의존성을 관리하기 위해서는 인터페이스를 사용하여 구현과 결합도를 최소화하고, 객체를 주입받는 방식으로 의존성을 해결하는 것이 좋습니다. 이렇게 하면 코드의 수정이 발생했을 때 영향 받는 범위가 적어지므로 유지보수성을 향상시킬 수 있습니다.

### 주석과 문서화

주석과 문서화는 코드의 가독성을 높이고 유지보수성을 개선하는 데에 매우 유용합니다. 주석을 통해 코드의 동작 방식이나 의도를 명확하게 설명하고, 문서화를 통해 코드의 사용법이나 설계를 상세하게 기록합니다. 이를 통해 다른 사람들이 코드를 쉽게 이해하고 사용할 수 있으며, 코드 수정이나 변경 시에도 문서화된 내용을 참고하여 작업할 수 있습니다.

코드의 유지보수성을 향상시키기 위해서는 중복 코드를 제거하고, 모듈화와 캡슐화를 적절히 활용하며, 의존성을 관리하고, 주석과 문서화를 충분히 활용해야 합니다. 이렇게 하면 코드의 가독성과 재사용성을 높일 수 있으며, 변경이나 확장에 용이한 코드를 작성할 수 있습니다.
## 3. 자바 클래스 상속 예제

### 상속의 개념

자바에서 상속은 클래스 간의 관계를 맺는 중요한 개념입니다. 상속을 통해 부모 클래스의 특성과 기능을 자식 클래스가 물려받아 사용할 수 있습니다. 이를 통해 코드의 중복을 줄이고, 코드의 재사용성을 높일 수 있습니다. 또한, 상속은 클래스 간의 계층 구조를 형성하여 코드의 가독성과 유지보수성을 향상시킵니다.

### 상속 방법

자바에서 클래스 상속은 `extends` 키워드를 사용하여 구현합니다. 자식 클래스는 부모 클래스를 지정하여 상속받을 수 있습니다. 아래는 자바 클래스 상속의 기본 문법입니다.

```java
// 부모 클래스
public class ParentClass {

  // 부모 클래스의 멤버 변수
  // ...

  // 부모 클래스의 메서드
  // ...
}

// 자식 클래스
public class ChildClass extends ParentClass {

  // 자식 클래스의 멤버 변수
  // ...

  // 자식 클래스의 메서드
  // ...
}

위의 코드에서 ParentClass는 부모 클래스가 되고, ChildClass는 자식 클래스가 됩니다. 자식 클래스는 extends 키워드를 사용하여 부모 클래스를 지정합니다. 이렇게 자식 클래스가 부모 클래스를 상속받으면, 자식 클래스는 부모 클래스의 멤버 변수와 메서드를 사용할 수 있습니다.

상속의 예제

다음은 계산기를 구현하는 자바 클래스의 상속 예제입니다.

// 부모 클래스
public class Calculator {
  protected int result;

  public void add(int num1, int num2) {
    result = num1 + num2;
  }

  public void subtract(int num1, int num2) {
    result = num1 - num2;
  }
}

// 자식 클래스
public class AdvancedCalculator extends Calculator {
  public void multiply(int num1, int num2) {
    result = num1 * num2;
  }

  public void divide(int num1, int num2) {
    result = num1 / num2;
  }
}

위의 예제에서 Calculator 클래스는 add와 subtract 메서드를 가지고 있습니다. 이 클래스를 상속받은 AdvancedCalculator 클래스는 multiply와 divide 메서드를 추가로 구현하고 있습니다. 이제 AdvancedCalculator 객체를 생성하고 메서드를 호출하여 연산을 수행할 수 있습니다.

AdvancedCalculator calc = new AdvancedCalculator();
calc.add(10, 5);
System.out.println(calc.result);   // 15

calc.multiply(3, 4);
System.out.println(calc.result);   // 12

위의 예제를 보면, AdvancedCalculator 클래스는 Calculator 클래스를 상속받았기 때문에 Calculator 클래스의 멤버 변수와 메서드를 모두 사용할 수 있습니다. 또한, AdvancedCalculator 클래스는 자신만의 추가적인 멤버 변수와 메서드를 가질 수 있습니다.

상속을 통해 부모 클래스의 기능을 물려받고, 필요한 경우에는 추가 기능을 구현하는 방식으로 클래스를 작성할 수 있습니다. 이를 통해 코드의 중복을 줄이며, 유연하고 확장 가능한 클래스 구조를 만들어낼 수 있습니다.

3.1 동물 클래스와 각각의 서브 클래스 (강아지, 고양이)

동물 클래스 설계

동물 클래스와 각각의 서브 클래스를 예시로 들어 상속의 개념을 자세히 알아보겠습니다. 동물 클래스는 모든 동물들이 가지는 공통적인 특성과 동작을 가지고 있습니다.

public class Animal {

  private String name;
  private int age;

  public Animal(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public void eat() {
    System.out.println("먹이를 먹습니다.");
  }

  public void sleep() {
    System.out.println("잠을 잡니다.");
  }
}

위의 동물 클래스에서는 name과 age라는 멤버 변수와 eat(), sleep()라는 메서드를 가지고 있습니다. eat() 메서드는 동물이 먹이를 먹는 동작을, sleep() 메서드는 동물이 잠을 자는 동작을 나타냅니다.

강아지 클래스

강아지는 동물의 일종이므로, 동물 클래스를 상속받아 강아지 클래스를 구현할 수 있습니다. 강아지 클래스는 동물 클래스의 특성과 동작을 물려받으면서, 추가적인 기능을 구현할 수 있습니다.

public class Dog extends Animal {

  public Dog(String name, int age) {
    super(name, age);
  }

  public void bark() {
    System.out.println("왈왈 짖습니다.");
  }
}

위의 강아지 클래스에서는 Animal 클래스를 상속받고 있습니다. 생성자에서는 super 키워드를 사용하여 부모 클래스의 생성자를 호출하여 이름과 나이를 초기화합니다. 또한, bark() 메서드를 추가하여 강아지의 짖는 동작을 나타냅니다.

고양이 클래스

고양이도 마찬가지로 동물의 일종이므로, 동물 클래스를 상속받아 고양이 클래스를 구현할 수 있습니다. 고양이 클래스는 동물 클래스의 특성과 동작을 물려받으면서, 추가적인 기능을 구현할 수 있습니다.

public class Cat extends Animal {

  public Cat(String name, int age) {
    super(name, age);
  }

  public void meow() {
    System.out.println("야옹 소리를 냅니다.");
  }
}

위의 고양이 클래스에서도 Animal 클래스를 상속받고 있습니다. 생성자에서는 super 키워드를 사용하여 부모 클래스의 생성자를 호출하여 이름과 나이를 초기화합니다. 또한, meow() 메서드를 추가하여 고양이의 울음 소리를 나타냅니다.

사용 예제

이제 동물 클래스와 각각의 서브 클래스를 사용하여 객체를 생성하고 메서드를 호출하는 예제를 살펴보겠습니다.

public class Main {
  public static void main(String[] args) {
    Dog dog = new Dog("멍멍이", 3);
    dog.eat();   // 먹이를 먹습니다.
    dog.sleep(); // 잠을 잡니다.
    dog.bark();  // 왈왈 짖습니다.

    Cat cat = new Cat("야옹이", 2);
    cat.eat();   // 먹이를 먹습니다.
    cat.sleep(); // 잠을 잡니다.
    cat.meow();  // 야옹 소리를 냅니다.
  }
}

위의 예제에서는 Dog 클래스와 Cat 클래스의 객체를 생성하고, 각각의 메서드를 호출하여 동물의 특성과 추가된 기능을 실행할 수 있습니다.

각각의 서브 클래스는 동물 클래스의 멤버 변수와 메서드를 물려받으면서, 각자의 특성과 동작을 가질 수 있습니다. 이처럼 상속을 통해 공통된 코드를 재사용하고, 필요에 따라 새로운 기능을 추가할 수 있습니다. 이는 코드의 재사용성과 유지보수성을 향상시키는 중요한 개념입니다.

3.2 동물 클래스에서 상속된 서브 클래스의 메서드 활용

동물 클래스에서 상속된 서브 클래스는 부모 클래스의 멤버 변수와 메서드를 물려받아 사용할 수 있습니다. 이를 통해 서브 클래스는 부모 클래스의 기능을 활용하면서, 필요한 경우에는 새로운 메서드를 추가하여 자신만의 기능을 구현할 수 있습니다. 이번에는 동물 클래스에서 상속된 서브 클래스의 메서드 활용에 대해 설명하겠습니다.

부모 클래스의 메서드 사용

서브 클래스는 부모 클래스에서 상속받은 메서드를 그대로 활용할 수 있습니다. 이를 통해 코드의 중복을 줄이고, 부모 클래스의 공통된 동작을 재사용할 수 있습니다. 예를 들어, 동물 클래스에서 상속된 서브 클래스인 Dog 클래스에서는 eat() 메서드와 sleep() 메서드를 그대로 사용할 수 있습니다.

Dog dog = new Dog("멍멍이", 3);
dog.eat();   // 먹이를 먹습니다.
dog.sleep(); // 잠을 잡니다.

위의 예제에서는 Dog 클래스의 객체를 생성한 후, 부모 클래스인 Animal 클래스에서 상속받은 eat() 메서드와 sleep() 메서드를 호출하여 실행하고 있습니다. 이와 같은 방식으로 서브 클래스는 부모 클래스의 메서드를 활용할 수 있습니다.

새로운 메서드 추가

서브 클래스는 부모 클래스의 메서드를 그대로 사용하는 것 뿐만 아니라, 새로운 메서드를 추가하여 자신만의 기능을 구현할 수도 있습니다. 이를 통해 서브 클래스는 부모 클래스에서 상속받은 기능을 확장하거나, 새로운 동작을 구현할 수 있습니다. 예를 들어, Dog 클래스에는 bark() 메서드를 추가하여 왈왈 짖는 기능을 구현할 수 있습니다.

Dog dog = new Dog("멍멍이", 3);
dog.bark();  // 왈왈 짖습니다.

위의 예제에서는 Dog 클래스의 객체를 생성한 후, bark() 메서드를 호출하여 강아지가 왈왈 짖는 동작을 실행하고 있습니다. 이와 같이 서브 클래스는 부모 클래스에서 상속받은 메서드에 추가적인 기능을 구현할 수 있습니다.

다형성의 활용

서브 클래스는 부모 클래스의 메서드를 사용할 수 있을 뿐만 아니라, 자신만의 메서드를 추가할 수 있기 때문에 다형성의 개념을 활용할 수도 있습니다. 다형성은 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미합니다. 예를 들어, Animal 타입의 변수에 Dog 객체를 할당할 수 있으며, Dog 타입의 변수에도 할당할 수 있습니다.

Animal animal1 = new Dog("멍멍이", 3);
animal1.eat();
animal1.sleep();

Dog dog = new Dog("멍멍이", 3);
dog.eat();
dog.sleep();
dog.bark();

위의 예제에서는 Animal 타입의 변수 animal1에 Dog 클래스의 객체를 할당하고 있습니다. 이렇게 하면 animal1 변수는 Animal 클래스의 멤버 변수와 메서드에만 접근할 수 있습니다. 하지만 animal1 변수에 할당된 객체는 실제로 Dog 클래스의 객체이기 때문에 Dog 클래스의 bark() 메서드를 호출할 수 있습니다. 따라서 다형성을 활용하면 부모 클래스의 타입으로 여러 종류의 서브 클래스를 다룰 수 있습니다.

상속을 통해 부모 클래스의 메서드를 그대로 활용하면서, 필요한 경우에는 새로운 메서드를 추가하여 서브 클래스의 기능을 구현할 수 있습니다. 이를 통해 코드의 재사용성을 높이고, 유연하고 확장 가능한 클래스 구조를 만들어낼 수 있습니다. 또한, 다형성을 활용하여 동일한 타입의 변수로 여러 종류의 객체를 다룰 수 있습니다.

3.3 메서드 오버라이딩을 통한 다형성 구현

메서드 오버라이딩은 서브 클래스에서 부모 클래스의 메서드를 재정의하는 것을 말합니다. 이를 통해 부모 클래스에서 상속받은 메서드를 서브 클래스에서 필요에 맞게 수정하거나 확장할 수 있습니다. 메서드 오버라이딩은 다형성을 구현하기 위한 중요한 개념입니다. 이번에는 메서드 오버라이딩을 통한 다형성 구현에 대해 상세히 설명하겠습니다.

메서드 오버라이딩이란?

메서드 오버라이딩은 서브 클래스에서 부모 클래스의 메서드를 동일한 이름으로 재정의하는 것을 말합니다. 이를 통해 서브 클래스는 부모 클래스의 메서드를 그대로 사용하면서, 자신만의 구현을 추가하거나 수정할 수 있습니다. 메서드 오버라이딩은 같은 이름의 메서드를 호출할 때, 객체의 타입에 따라서 실행되는 메서드가 결정되는 다형성을 구현하는 중요한 방법입니다.

메서드 오버라이딩의 조건

메서드 오버라이딩을 하기 위해서는 다음과 같은 조건을 만족해야 합니다.

  • 부모 클래스와 서브 클래스 사이에 상속 관계가 있어야 합니다.
  • 오버라이딩하고자 하는 메서드는 부모 클래스에서 상속받아야 합니다.
  • 오버라이딩하고자 하는 메서드의 이름, 매개변수, 반환 타입이 부모 클래스의 메서드와 동일해야 합니다.
  • 접근 제어자는 부모 클래스의 메서드와 동일하거나 더 넓은 범위로 지정해야 합니다.

다형성의 구현

메서드 오버라이딩을 통해 다형성을 구현할 수 있습니다. 다형성은 하나의 객체가 여러 가지 타입을 가질 수 있음을 의미합니다. 예를 들어, 부모 클래스인 Animal 클래스에서 상속받은 Dog 클래스와 Cat 클래스가 각자 eat() 메서드를 오버라이딩한 경우를 살펴보겠습니다.

public class Animal {

  public void eat() {
    System.out.println("먹이를 먹습니다.");
  }
}

public class Dog extends Animal {

  @Override
  public void eat() {
    System.out.println("개사료를 먹습니다.");
  }
}

public class Cat extends Animal {

  @Override
  public void eat() {
    System.out.println("고양이사료를 먹습니다.");
  }
}

위의 예제에서는 Animal 클래스에서 상속받은 Dog 클래스와 Cat 클래스가 eat() 메서드를 오버라이딩하고 있습니다. Dog 클래스는 개사료를, Cat 클래스는 고양이사료를 먹는 동작을 구현하도록 재정의하였습니다.

Animal animal1 = new Dog();
Animal animal2 = new Cat();

animal1.eat(); // 개사료를 먹습니다.
animal2.eat(); // 고양이사료를 먹습니다.

위의 예제에서는 다형성을 이용하여 Animal 타입의 변수 animal1과 animal2에 각각 Dog 클래스와 Cat 클래스의 객체를 할당하고 있습니다. 이렇게 하면 animal1과 animal2 변수는 Animal 클래스의 멤버 변수와 메서드에만 접근할 수 있습니다. 하지만 실제로 할당된 객체는 각각 Dog 클래스와 Cat 클래스의 객체이기 때문에 오버라이딩된 eat() 메서드가 호출됩니다. 따라서 다형성을 활용하여 부모 클래스의 타입으로 여러 종류의 서브 클래스를 다룰 수 있습니다.

메서드 오버라이딩을 통해 부모 클래스의 메서드를 그대로 사용하면서, 서브 클래스에서 필요에 맞게 수정하거나 확장할 수 있습니다. 이를 통해 다형성을 구현할 수 있고, 유연하고 확장 가능한 클래스 구조를 만들어낼 수 있습니다. 또한, 다형성을 활용하여 동일한 타입의 변수로 여러 종류의 객체를 다룰 수 있습니다.

저작자표시 비영리 변경금지

티스토리툴바