티끌모아 태산

Spring Boot

goldpig — Mon, 3 Jun 2024 16:58:36 +0900

스프링 부트란

https://start.spring.io/

보통 스프링부트 프로젝트를 만들 때, 위 사이트에서 설정을 하고 다운받아 IDE에서 Open을 통해 실행하게 된다. 스프링부트란 자바 웹 프로그램을 더욱 쉽고 빠르게 만들기 위한 도구이다. 새로운 기술이라기 보다는 스프링 프레임워크를 개선한 것이다.

개발 환경 설정 간소화: 외부라이브러리를 최적화해 제공하기 때문에 사용자가 직접 연동할 필요가 없다. (스프링은 버전에 따라 동작하는 외부 라이브러리를 일일 찾아 연동해야 한다.)
웹 애플리케이션 서버 내장: 스프링 부트는 웹 애플리케이션 서버(WAS: Web Application Server)인 톰캣을 가지고 있다. 따라서 웹 서비스를 jar 파일로 간편하게 배포할 수 있다.

스프링 부트 개발 환경 설정

JDK(Java Development Kit, 자바 개발 도구) 설치하기
IDE(이클립스 or 인텔리제이) 설치하기. IDE는 개발 생산성을 높여주는 도구 역할
스프링 부트 프로젝트 만들기 (스프링 부트 3 버전은 JDK 17이상만 지원한다.)

H2 Database: 자료를 저장하기 위한 데이터베이스
Mustache: 화면을 만들기 위해 필요한 도구
Spring Data JPA: 데이터베이스를 좀 더 편리하게 다루게 해주는 도구

트러블 슈팅

A problem occurred configuring root project 'toy'.
> Could not resolve all artifacts for configuration ':classpath'.
   > Could not resolve org.springframework.boot:spring-boot-gradle-plugin:3.3.0.
     Required by:
         project : > org.springframework.boot:org.springframework.boot.gradle.plugin:3.3.0
      > No matching variant of org.springframework.boot:spring-boot-gradle-plugin:3.3.0 was found. The consumer was configured to find a library for use during runtime, compatible with Java 11, packaged as a jar, and its dependencies declared externally, as well as attribute 'org.gradle.plugin.api-version' with value '8.7' but:
          - Variant 'apiElements' declares a library, packaged as a jar, and its dependencies declared externally:
              - Incompatible because this component declares a component for use during compile-time, compatible with Java 17 and the consumer needed a component for use during runtime, compatible with Java 11
              - Other compatible attribute:
                  - Doesn't say anything about org.gradle.plugin.api-version (required '8.7')
          - Variant 'javadocElements' declares a component for use during runtime, and its dependencies declared externally:
              - Incompatible because this component declares documentation and the consumer needed a library
              - Other compatible attributes:
                  - Doesn't say anything about its elements (required them packaged as a jar)
                  - Doesn't say anything about its target Java version (required compatibility with Java 11)
                  - Doesn't say anything about org.gradle.plugin.api-version (required '8.7')
          - Variant 'mavenOptionalApiElements' declares a library, packaged as a jar, and its dependencies declared externally:
              - Incompatible because this component declares a component for use during compile-time, compatible with Java 17 and the consumer needed a component for use during runtime, compatible with Java 11
              - Other compatible attribute:
                  - Doesn't say anything about org.gradle.plugin.api-version (required '8.7')
          - Variant 'mavenOptionalRuntimeElements' declares a library for use during runtime, packaged as a jar, and its dependencies declared externally:
              - Incompatible because this component declares a component, compatible with Java 17 and the consumer needed a component, compatible with Java 11
              - Other compatible attribute:
                  - Doesn't say anything about org.gradle.plugin.api-version (required '8.7')
          - Variant 'modernGradleRuntimeElements' declares a library for use during runtime, packaged as a jar, and its dependencies declared externally, as well as attribute 'org.gradle.plugin.api-version' with value '8.7':
              - Incompatible because this component declares a component, compatible with Java 17 and the consumer needed a component, compatible with Java 11
          - Variant 'runtimeElements' declares a library for use during runtime, packaged as a jar, and its dependencies declared externally, as well as attribute 'org.gradle.plugin.api-version' with value '7.5':
              - Incompatible because this component declares a component, compatible with Java 17 and the consumer needed a component, compatible with Java 11
          - Variant 'sourcesElements' declares a component for use during runtime, and its dependencies declared externally:
              - Incompatible because this component declares documentation and the consumer needed a library
              - Other compatible attributes:
                  - Doesn't say anything about its elements (required them packaged as a jar)
                  - Doesn't say anything about its target Java version (required compatibility with Java 11)
                  - Doesn't say anything about org.gradle.plugin.api-version (required '8.7')

* Try:
> Review the variant matching algorithm at https://docs.gradle.org/8.7/userguide/variant_attributes.html#sec:abm_algorithm.
> No matching variant errors are explained in more detail at https://docs.gradle.org/8.7/userguide/variant_model.html#sub:variant-no-match.
> Run with --stacktrace option to get the stack trace.
> Run with --info or --debug option to get more log output.
> Run with --scan to get full insights.
> Get more help at https://help.gradle.org.
BUILD FAILED in 99ms

스프링 부트 프로젝트를 다운받아 빌드하는 과정에서 오류가 발생했다.

오류 원인

스프링 부트 버전 3이상부터는 JDK가 17이상이어야 한다. 처음 인텔리제이스에는 아래와 같이 버전이 잘못 초기화 되어있는 것을 확인할 수 있다.

해결 방안

이와 같이 Grade JVM을 수정한 후 빌드를 실행하면 성공적으로 빌드가 됨을 확인할 수 있다.

CI/CD를 왜 배우는 걸까?

goldpig — Sun, 2 Jun 2024 23:38:05 +0900

✅CI/CD란?

CI/CD란 Continuous Integration, Continuous Deployment라는 의미를 갖고 있다. 쉽게 말해 CI/CD는 테스트(Test), 통합(Merge), 배포 (Deploy)의 과정을 자동화하는 걸 의미한다.

CI/CD를 왜 배울까?

예를들어, 서버를 AWS EC2에 배포하고 운영하다보면 코드 수정 혹은 새로운 기능을 추가하는 일이 많아진다. 그러면 새로운 기능에 대한 코드를 작성한 후 Commit을 한다. 그런 뒤 브런치에 Merge를 하고 배포를 한다. 배포를 할 때, 직접 수동으로 컴퓨터 서버 (ex. AWS EC2)에 접속해서 새로운 코드를 다운받아 실행시켜야한다.

이 과정을 새로운 기능 추가 또는 코드의 수정이 일어날 때마다 반복하기란 너무 귀찮은 일이다. 그래서 이런 반복적인 과정을 자동화 시키기 위해서 CI/CD를 배우는 것이다.

CI/CD 과정은 일반적으로 다음과 같은 과정으로 일어난다.

출처 : https://www.performetriks.com/post/load-test-in-a-cicd-environment

특정 기능을 개발하고 완료해서 Commit을 찍으면 빌드가 되게 셋팅된다. 빌드가 완료되면 작성한 테스트 코드를 실행시킨다. ( 테스트 코드를 작성하지 않은 서비스에서는 이 과정을 생략하기도 한다. ) 그런 뒤 테스트가 통과되면 서버 컴퓨터에 최신 코드가 배포된다.

✅CI/CD를 구축할 때 사용할 Github Actions

CI/CD를 구축할 때 사용하는 툴은 여러가지가 있다.

Github Actions - 별도의 서버 구축 필요 없음
Jenkins - 별도의 서버 구축 필요
Circle CI
Travis CI
등등

이 중에서 현업에서 많이 사용하면서, 무료로 사용할 수 있고, 빌드용 서버가 따로 필요없는 Github Actions를 활용해서 CI/CD를 구축할 수 있다. 실제 현업에서는 Github Actions 뿐만 아니라 Jenkins도 많이 활용한다. 둘 중 무엇을 사용해도 CI/CD 구성을 전부 할 수 있다. 그러므로 Github Actions를 사용할 지, Jenkins를 사용할 지는 장단점을 비교해서 상황에 맞게 선택하면 된다. 개인적으로 추천하는 툴은 Github Actions이다.

Jenkins의 단점은 별도의 서버를 구축해야 한다는 점이다. 하지만 Github Actions는 빌드용 서버 구축 없이 Github에 내장되어 있는 Github Actions 기능을 사용할 수 있다.
Github Actions는 비용적인 측면도 유리하고 셋팅하는 데 시간도 적게 걸린다.

Github Actions를 활용한 전체적인 CI/CD 흐름

Github Actions를 로직을 실행시킬 수 있는 일종의 컴퓨터라고 생각하면 된다. 그렇기 때문에 CI/CD과정에서 Github Actions는 "빌드, 테스트, 배포"에 대한 로직을 실행시키는 역할을 하게 된다. CI/CD의 구성은 다양하지만 일반적으로 아래의 흐름을 같는다.

코드 작성 후 Commit
Github에 push
Push를 감지해서 Github Actions에 작성한 로직이 실행된다.
1. 빌드(Buid)
2. 테스트(Test)
3. 서버로 배포(Deploy)
서버에서 배포된 최신 코드로 서버를 재실행

백엔드 CI/CD에 필요한 AWS 지식

goldpig — Sun, 2 Jun 2024 23:05:26 +0900

✅배포란(Deployment)?

배포란 내가 만든 서비스를 다른 사용자들이 인터넷을 통해서 사용할 수 있게 만드는 것을 의미한다. 쉽게 말해 우리가 만든 웹 페이지나 서버를 다른 사람들이 사용하려면 인터넷 상에 배포가 돼있어야한다.

보통 자신의 컴퓨터에서 개발을 할 때는 'localhost' 라는 주소로 테스트도하고 개발을 한다. 하지만 이 localhost는 다른 컴퓨터에서 접근이 불가능한 주소다. 그렇기 때문에 배포를 하게되면 고유의 IP주소나 도메인 주소를 부여받게되고, 다른 컴퓨터에서 그 주소로 접속할 수 있게 된다.

따라서 어떤 서비스를 완성했으면, 그것을 다른 사용자들이 사용할 수 있도록 배포를 해줘야한다.

✅EC2(Elastic Compute Cloud)란 무엇인가?

EC2란 쉽게 말해 컴퓨터를 빌려서 원격으로 접속해 사용하는 서비스다. 쉽게 말해 하나의 컴퓨터를 의미한다. 그렇다면 EC2를 왜 배울까? 배포를 하기 위해서는 컴퓨터가 필요한데, 내 컴퓨터를 활용할 수 있다. 하지만 내 컴퓨터로 서버를 배포하게 되면 24시간 동안 컴퓨터를 켜놔야한다. 또한 인터넷을 통해 내 컴퓨터에 접근할 수 있게 만들다보니 보안상의 위험이 있다.

이러한 문제점을 해결하기 위해서 내 컴퓨터를 사용하지 않고, AWS EC2라는 컴퓨터를 빌려서 해결할 수 있다. 이 외에도 AWS EC2는 여러가지 부가 기능(로깅, 오토스케일링, 로드밸런싱 등)을 많을 갖고 있다. 실제 현업에서도 서버를 배포할 때 AWS EC2를 많이 활용한다.

백엔드 서버를 배포해야 할 때면 EC2에 서버를 배포해서 사용한다.
프론트엔드 웹 페이지를 배포할 때는 AWS EC2를 활용할 수 있지만 vercel, netlify 또는 AWS S3를 사용해서 주로 배포한다.

IP와 Port의 개념

IP란 host에 대한 식별자로, 네트워크 상에서 특정 컴퓨터를 가리키는 주소다. Port란 한 컴퓨터 내에서 실행되고 있는 특정 프로그램의 주소를 의미한다. 예를 들어, 외부에서 특정 컴퓨터 내부에 있는 Spring Boot라는 서버에 통신을 하고 싶다고 가정하자. 하지만 외부에서 IP주소만 알아서는 실행되고 있는 여러 프로그램 중 어떤 프로그램과 통신을 해야 할 지 알 수가 없다. 그래서 특정 서버와 통신을 할 때는 IP 주소와 서버가 실행되고 있는 포트 번호까지 알고 있어야 한다.

22번 (SSH, Secure Shell Protocol): 원격 접속을 위한 포트 번호. EC2 인스턴스에 연결할 때, 22번 포트를 사용한다.
80번 (HTTP): HTTP로 통신을 할 때 사용한다.
442 (HTTPS): HTTPS로 통신을 할 때 사용한다.

위 포트 번호는 일반적으로 정해져 있는 규약이지 반드시 지켜야하는 것은 아니다. 예를 들어, 특정 서버와 HTTP 통신을 할 때 80번 포트를 쓰지 않고 3000번 포트나 8080번 포트를 써도 상관 없다.

⭐다형성과 설계

goldpig — Sun, 2 Jun 2024 15:45:47 +0900

객체 지향 프로그래밍

객체지향 프로그래밍은 컴퓨터 프로그램을 객체들의 모임으로 보는 것이다. 각각의 객체는 메시지를 주고받고, 데이터를 처리할 수 있다. (협력) 그리고 프로그램을 유연하고 변경 용이하게 만든다. 즉, 레고 블록 조립하듯이 개발을 할 수 있다.

다형성(Polymorphism)

객체 지향 프로그래밍의 가장 핵심적인 특징은 다형성이다. 다형은 역할과 구현을 분리시킨다. 아래 그림과 자동차의 역할과 자동차의 구현을 분리시킨다. 다형성의 본질은 클라이언트를 변경하지 않고, 서버의 구현 기능을 유연하게 변경할 수 있다는 것이다.

역할과 구현을 분리

클라이언트(운전자)는 역할(인터페이스)만 알면 된다. 즉, 인터페이스를 구현하는 K3, 아반떼, 테슬라 모델3의 세부적인 내부 구조를 몰라도 된다.
클라이언트는 구현 대상의 내부 구조가 변경되어도 영향을 받지 않는다. K3, 아반떼 등의 내부 구조가 바뀌어도 영향X
클라이언트는 구현 대상 자체를 변경해도 영향을 받지 않는다. 즉, 자동차가 K3이든, 아반떼로 바뀌든 운전자에게는 영향을 주지 않는다.

객체 지향 프로그래밍의 핵심은 다형성이다. 디자인 패턴 대부분은 다형성을 활용하는 것이다. 스프링의 핵심인 제어의 역전(IoC), 의존관계 주입(DI)도 결국 다형성을 활용하는 것이다. 그리고 프레임워크인 스프링을 활용하면 레고 블럭 조립하듯이 구현을 편리하게 변경할 수 있다.

역할과 구현 예제

다형성을 활용하면 역할과 구현을 분리해서, 클라이언트 코드의 변경 없이 구현 객체를 변경할 수 있다. 다음 관계에서 Driver가 클라이언트이다.

운전자(Driver)는 Car의 역할에만 의존한다. 구현인 K3, Model3 자동차에 의존하지 않는다.
Driver 클래스는 Car car 멤버변수를 갖는다. 따라서 Car 인터페이스를 참조한다.
인터페이스를 구현한 K3Car, Model3Car에 의존하지 않고, Car 인터페이스에만 의존한다.
의존은 클래스 의존 관계를 뜻한다. 즉 클래스 상에서 어떤 클래스를 알고 있는가를 뜻한다. Driver 클래스 코드를 보면 Car 인터페이스만 사용하는 것을 알 수 있다.
Car는 자동차의 역할이고 인터페이스다. K3Car, Model3Car 클래스가 인터페이스를 구현한다.

public class Driver {
    private Car car; // 멤버변수

    public void setCar(Car car) {
        System.out.println("자동차를 설정합니다. " + car);
        this.car = car;
    }

    public void drive(){
        System.out.println("자동차를 운전합니다.");
        car.startEngine();
        car.pressAccelerator();
        car.offEngine();
    }
}

Driver는 멤버 변수로 Car car를 갖는다. setCar(Car car)를 통해 멤버 변수에 자동차를 설정한다. 외부에서 누군가 이 메서드를 호출해주어야 Driver는 새로운 자동차를 참조하거나 변경할 수 있다.
drive() 메서드는 Car 인터페이스가 제공하는 기능들을 통해 자동차를 운전한다.

driver.setCar(k3Car)를 호출해서 Driver의 Car car 필드가 K3Car의 인스턴스를 참조하도록 한다.
driver.drive()를 호출하면 x001을 참조한다. car 필드가 Car 타입이므로 Car 타입을 찾아서 실행하지만 메서드 오버라이딩에 의해 K3Car의 기능이 호출된다.

Model3Car를 생성한다.
driver.setCar(model3Car)를 호출해서 Driver의 Car car 필드가 Model3Car의 인스턴스를 참조하도록 변경한다.
driver.drive()를 호출하면 x002을 참조한다. car 필드가 Car 타입이므로 Car 타입을 찾아서 실행하지만 메서드 오버라이딩에 의해 Model3Car의 기능이 호출된다.

⭐OCP(Open-Closed Principle) 원칙

좋은 객체 지향 설계 원칙 중 하나는 OCP 원칙이다.

Open for extension: 새로운 기능의 추가나 변경 사항이 생겼을 때, 기존 코드는 확장할 수 있어야 한다.
Closed for modification: 기존의 코드는 수정되지 않아야 한다.

위 말이 좀 헷갈릴 수 있는데, 기존 코드 확장은 인터페이스나 인터페이스를 구현하는 코드를 추가하거나 변경하는 것이고 기존 코드를 수정하지 않아야 한다는 것은 클라이언트 코드를 변경하지 않는다는 뜻이다. 다시 말해, 클라이언트 코드를 변경하지 않고 서버의 구현 기능을 유연하게 변경하는 것이다.

클라이언트인 Driver는 인터페이스인 Car에만 의존하고 인터페이스를 구현하는 K3Car, Model3Car, NewCar에 대해서는 알지 못한다. 그렇기 때문에 새로운 차량을 추가해도 Driver의 코드는 전혀 변경하지 않는다. 차량의 종류는 계속 늘어나도 이는 마찬가지다. 즉, 기능을 확장해도 main() 일부를 제외한 프로그램의 핵심 부분의 코드는 전혀 수정하지 않아도 된다.

확장에 열려있다는 뜻: Car 인터페이스를 사용해서 새로운 차량을 자유롭게 추가하거나 변경할 수 있다. 그리고 Car 인터페이스를 사용하는 클라이언트 코드인 Driver도 Car 인터페이스를 통해 새롭게 추가된 차량을 자유롭게 호출할 수 있다.
코드 수정은 닫혀 있다는 뜻: 새로운 차를 추가하게 되면 기능이 추가되기 때문에 기존 코드의 수정을 불가피하다. 하지만 클라이언트 코드의 수정은 일어나지 않는다.
변하지 않는 부분: 클라이언트 코드는 변하지 않는다.
변하는 부분: main()과 같이 새로운 차를 생성하고 Driver에게 필요한 차를 전달해주는 역할은 당연히 코드 수정이 필요하다. main()은 전체 프로그램을 설정하고 조율하는 역할을 한다. 이런 부분은 OCP를 지켜도 변경이 필요하다.

결국, Car를 사용하는 클라이언트 코드인 Driver 코드의 변경 없이 새로운 차량을 확장할 수 있다. 다형성을 활용하고 역할과 구현을 잘 분리한 덕분에 새로운 차량을 추가해도 대부분의 핵심 코드들을 그대로 유지할 수 있게 된다.

전략 패턴(Strategy Pattern)

디자인 패턴 중 가장 중요한 패턴은 전략 패턴이다. 전략 패턴은 알고리즘을 클라이언트 코드의 변경 없이 쉽게 교체할 수 있다. 위 코드처럼 Car인 인터페이스가 바로 전략을 정의하는 인터페이스가 되고, 각각의 차량이 전략의 구체적인 구현이 된다. 그리고 전략을 클라이언트 코드(Driver)의 변경 없이 손쉽게 교체할 수 있다.

다형성2

goldpig — Sat, 1 Jun 2024 17:30:30 +0900

다형성을 왜 사용하는지 그리고 장점은 무엇인지 알아보자.

위와 같은 객체들이 있고, sound() 함수를 정의했다고 하자. 이때, 개, 고양이, 소 말고 다른 동물을 추가하면 어떻게 될까? 새로운 클래스를 만들고 sound() 함수를 정의해야한다. 하지만 그렇게 될경우 중복되는 부분이 존재하게 된다. 그러면 중복되는 부분을 어떻게 제거할 수 있을까? 메서드 또는 배열? 안된다. 개, 고양이, 소 모두의 타입이 서로 다르기 때문에 중복되는 부분을 제거할 수 없다.

그렇다면 Dog, Cat, Caw가 모두 같은 타입을 사용할 수 있다면 메서드와 배열을 활용해서 코드의 중복을 제거할 수 있다는 것이다. ❗다형성의 핵심인 다형적 참조와 메서드 오버라이딩을 활용하면 Dog, Cat, Caw가 모두 같은 타입을 사용하고, 각자 자신의 메서드도 호출할 수 있다.

다형성 활용1

다형성을 활용하기 위해 Animal(동물) 부모 클래스를 만들고 sound() 메서드를 정의한다. 그리고 이 메서드는 자식 클래스에서 오버라이딩 된다.

        Dog dog = new Dog();
        Cat cat = new Cat();
        Caw caw = new Caw();

        soundAnimal(dog);
        soundAnimal(cat);
        soundAnimal(caw);
        }
    private static void soundAnimal(Animal animal){
        System.out.println("동물소리 테스트 시작");
        animal.sound();
        System.out.println("동물소리 테스트 종류");
    }

예를들어, soundAnimal(dog)를 호출하면 soundAnimal (Animal animal)에 Dog 인스턴스가 전달된다.
Animal animal = dog로 이해하면 되고, 부모는 자식을 담을 수 있다. Animal은 dog의 부모다.
그러면 메서드 안에서 animal.sound() 메서드가 호출 된다.
animal 변수의 타입은 Animal 이므로 Dog 인스턴스에 있는 Animal 클래스 부분을 찾아서 sound() 메서드를 실행한다. 그런데 하위 클래스인 Dog에서 sound() 메서드를 오버라이딩 했다. 따라서 오버라이딩한 메서드가 우선권을 갖는다.

⭐핵심은 Animal animal 코드이다. 다형적 참조로 인해 animal 변수는 자식인 Dog, Cat, Caw의 인스턴스를 참조할 수 있다. (부모는 자식을 담을 수 있다.) 또한 메서드 오버라이딩으로 인해 animal.sound()를 호출해도 Dog.sound, Cat.sound, Caw.sound()와 같이 각 인스턴스의 메서드를 호출할 수 있다.

추상 클래스1

클래스를 설계도에 비유한다면, 추상 클래스는 미완성 설계도에 비유할 수 있다. 따라서 실체인 인스턴스가 존재하지 않는다. 추상클래스는 상속을 통해 자식 클래스에 의해서만 완성될 수 있다.

상속을 목적으로 사용
부모 클래스 역할을 담당

abstract class AbstractAnimal {...}

추상 클래스를 생성할 때, 추상이라는 의미의 abstract 키워드를 붙여 준다.
추상 클래스는 new AbstractAnimal()와 같이 직접 인스턴스를 생성하지 못한다.

// 추상클래스 생성 불가
AbstractAnimal animal = new AbstractAnimal();

추상 메서드 -> 미완성 메서드

메서드는 선언부와 구현부(몸통)로 구성되어 있다. 이때, 선언부만 작성하고 구현부는 작성되지 않은 채로 남겨둔 것이 추상메서드이다. 이는 부모 클래스를 상속 받는 자식 클래스가 반드시 오버라이딩 해야하는 메서드이다.

public abstract void sound();

추상 메서드는 선언할 때, abstract 키워드를 붙여주면 된다.
❗추상 메서드가 하나라도 있는 클래스는 추상 클래스로 선언해야 한다. -> 그렇지 않으면 컴파일 오류 발생한다.
❗추상 메서드는 상속 받는 자식 클래스가 반드시 오버라이딩 해서 사용해야 한다.

추상클래스는 왜 사용할까?

추상 클래스 덕분에 실수로 부모(Animal) 인스턴스를 생성할 문제를 근본적으로 방지해준다.
추상 메서드 덕분에 새로운 동물의 자식 클래스를 만들 때, 실수로 sound()를 오버라이딩 하지 않을 문제를 근본적으로 방지해준다.

추상 클래스2

순수 추상 클래스: 모든 메서드가 추상 메서드인 추상 클래스

AbstractAnimal의 모든 기능을 자식 클래스에서 오버라이딩 해야한다. 대상 타입을 찾을 때는 호출자의 타입을 기준으로 선택한다. 처음 호출자의 타입으로 선택 후 오버라이딩을 호출한다.

모든 메서드가 추상 메서드인 순수 추상 클래스는 코드를 실행할 바디 부분이 없다.

public abstract class AbstractAnimal {
    public abstract void sound();
    public abstract void move();
}

인스턴스를 생성할 수 없다.
상속시 자식은 모든 메서드를 오버라딩 해야 한다.
주로 다형성을 위해 사용한다.

상속하는 클래스는 모든 메서드를 구현해야 한다. 이러한 특징은 상속받는 자식 클래스 입장에서 어떤 규격을 지켜서 구현해야 하는 것처럼 느껴진다. 이것은 일반적으로 인터페이스와 같이 느껴진다. 이런 순수 추상 클래스 개념은 프로그래밍에서 매우 자주사용되고, 이를 편리하게 사용할 수 있도록 인터페이스라는 개념을 제공한다.

인터페이스

자바는 순수 추상클래스를 더 편리하게 사용할 수 있는 인터페이스 개념을 제공한다. interface 키워드 사용

// 순수 추상 클래스
public interface interfaceAnimal {
    void sound(); // public abstract 생략
    void move(); // public abstract 생략
}

인터페이스는 순수 추상 클래스와 같다. 여기에 약간의 편의 기능이 추가된 것 뿐이다.

인터페이스의 메서드는 모두 public, abstract 이다.
메서드에 public abstract 를 생략할 수 있다. 참고로 생략을 권장한다.
인터페이스는 다중 구현(다중 상속)을 지원한다.

public interface InterfaceAnimal {
    public static final double MY_PI = 3.14;
   }
   
public interface InterfaceAnimal {
    double MY_PI = 3.14; // public static final  생략가능
   }

인터페이스에서 멤버 변수는 public, static, final 이 모두 포함되어 있다고 간주하고 생략 가능하다. final은 변수의 값을 한번 설정하면 바꿀 수 없다는 뜻이다.

인터페이스는 class 대신에 interface 키워드를 사용한다. 그리고 인터페이스를 상속받을 때는 extends 대신에 implements라는 구현 키워드를 사용한다.

클래스, 추상 클래스, 인터페이스는 모두 똑같다.

클래스, 추상 클래스, 인터페이스는 프로그램 코드, 메모리 구조상 모두 똑같다. .class로 다 이뤄진다. 인터페이스를 작성할 때도 .java에 인터페이스를 정의한다. 그렇기 때문에 인터페이스는 추상 클래스와 비슷하다고 생각하면 된다.

상속 vs 구현

부모 클래스의 기능을 자식 클래스가 상속 받을 때, 클래스는 상속 받는다고 표현하지만 부모 인터페이스의 기능을 자식이 상속 받을 때는 인터페이스를 구현한다고 표현한다. 상속은 부모의 기능을 물려받는 것이 목적이다. 하지만 인터페이스는 모든 메서드가 추상 메서드 이기때문에 물려받을 기능이 없고 오히려 인터페이스에 정의한 모든 메서드를 자식이 오버라이딩해서 기능을 구현해야 한다. 따라서 인터페이스는 상속 대신 구현이라고 표현한다.

인터페이스를 사용해야하는 이유 -> 좋은 프로그램은 제약이 있는 프로그램

⭐제약: 인터페이스를 만드는 이유는 인터페이스를 구현하는 곳에서 인터페이스의 메서드를 반드시 구현하라는 규약(제약)을 주는 것이다.
다중 구현: 자바에서 클래스 상속은 부모를 하나만 지정할 수 있다. 반면에 인터페이스는 부모를 여러명 두는 다중 상속이 가능하다.

인터페이스 - 다중 구현

자바는 다중 상속을 지원하지 않는다. AirplaneCar입장에서 move()를 호출할 때, 어떤 부모의 move()를 사용해야할지 애매한 문제가 발생하는데 이를 '다이아몬드' 문제라고한다. 그리고 다중 상속을 사용하면 클래스 계층 구조가 매우 복잡해 질 수 있다. 그렇기 때문에 자바는 클래스의 다중 상속을 허용하지 않는다. 대신 인터페이스의 다중 구현을 허용하여 이러한 문제점을 예방한다.

인터페이스 자신은 구현을 갖지 않는다. 대신 인터페이스를 구현하는 곳에서 해당 기능을 모두 구현해야 한다. 여기서 interfaceA, interfaceB는 같은 이름의 methodCommon()를 제공하지만 이것의 기능은 Child가 구현한다. 그리고 오버라이딩에 의해 Child에 있는 methodCommon()이 호출된다. 결과적으로 어떤 부모의 methodCommon()을 선택하는 것이 아니라 그냥 인터페이스를 구현한 Child에 있는 methodCommon()이 사용된다. 이러한 이유로 다이아몬드 문제가 발생하지 않는다.

        interfaceA a = new Child(); // 부모는 자식을 담을 수 있다.
        a.methodA();
        a.methodCommon();
    
        interfaceB b = new Child();
        b.methodB();
        b.methodCommon();

a.method()Common()을 호출하면 먼저 x001 Child 인스턴스를 찾는다.
변수 a가 InterfaceA 타입이므로 해당 타입에서 methodCommon()을 찾는다.
methodCommon()은 하위 타입인 Child에서 오버라이딩 되어 있다. 따라서 Child의 methodCommon()이 호출된다.

b.method()Common()을 호출하면 먼저 x002 Child 인스턴스를 찾는다.
변수 b가 InterfaceB 타입이므로 해당 타입에서 methodCommon()을 찾는다.
methodCommon()은 하위 타입인 Child에서 오버라이딩 되어 있다. 따라서 Child의 methodCommon()이 호출된다.

클래스와 인터페이스 활용

클래스 상속과 인터페이스 구현을 함께 사용해보자

AbstractAnimal은 추상 클래스다. -> 상속 목적
Fly는 인터페이스이다. -> 구현 목적
- Bird, Chicken은 날 수 있는 동물이다. fly() 메서드를 구현해야한다.

public class Bird extends AbstractAnimal implements Fly

extends를 통한 상속은 하나만 할 수 있고, implements를 통한 인터페이스는 다중 구현할 수 있기 때문에 둘이 함께 나온 경우 extends가 먼저 나와야 한다.

animal.sound()를 호출하면 참조 대상인 x001 Bird 인스턴스를 찾는다.
호출한 animal 변수는 AbstractAnimal 타입이다. 따라서 AbstractAnimal.sound()를 찾는다. 해당 메서드는 오버라이딩 되었기 때문에 Bird.sound()가 호출된다.

메서드 안에서 fly.fly()를 호출하면 참조 대상인 x001 Bird 인스턴스를 찾는다.
호출한 fly 변수는 Fly 타입이다. 따라서 Fly.fly()를 찾는다. 해당 메서드는 Bird.fly()에 오버라이딩 되어 있다.
Bird.fly()가 호출된다.

10. 다형성(1)

goldpig — Fri, 31 May 2024 23:53:55 +0900

좋은 개발자가 되기 위해서는 다형성에 대한 이해가 필수다. 다형성(Polymorphism)은 말 그대로 "다양한 형태", "여러 형태"를 뜻한다. 보통 하나의 객체는 하나의 타입으로 고정된다. 그런데 다형성을 사용하게 되면 하나의 객체가 여러 타입으로 사용될 수 있다.

다형성을 이해하기 위해서는 다형적 참조와 메서드 오버라이딩이라는 핵심 이론을 알아야 한다.

다형적 참조

다형적 참조의 핵심은 부모는 자식을 품을 수 있다는 것이다.

ex1) 부모 타입의 변수가 부모 인스턴스 참조

Parent -> Parent: parent.ParentMethod()

부모 타입의 변수가 부모 인스턴스를 참조한다.
Parent parent = new Parent();
Parent 인스턴스를 만들었다. 부모 타입인 Parent를 생성했기 때문에 메모리 상에 Parent만 생성된다. (자식은 생성되지 않는다.)
생성된 참조값을 Parent 타입의 변수인 parent에 담아 둔다.
parent.parentMethod()를 호출하면 인스터스의 Parent 클래스에 있는 parentMethod()가 호출된다.

ex2) 자식 타입의 변수가 자식 인스턴스 참조

Child -> Child: child.childMethod()

자식 타입의 변수가 자식 인스턴스를 참조한다.
Child child = new Child();
Child 인스턴스를 만들었다. 이 경우 자식 타입인 Child를 생성했기 때문에 메모리 상에 Child와 Parent가 모두 생성된다.
생성된 참조값을 Child 타입의 뱐수인 child에 담아 둔다.
child.childMethod()를 호출하면 인스턴스의 Child 클래스에 있는 childMethod()가 호출된다.

⭐ex3) 다형적 참조: 부모 타입의 변수가 자식 인스턴스 참조

Parent -> Child: poly.parentMethod()

부모 타입의 변수가 자식 인스턴스를 참조한다.
Parent poly = new Child();
Child 인스턴스를 만들었다. 이 경우 자식 타입인 Child를 생성했기 때문에 메모리 상에 Child와 Parent가 모두 생성된다.
생성된 참조값을 Parent 타입인 poly에 담아 둔다.

⭐부모는 자식을 담을 수 있다.

부모 타입은 자식 타입을 담을 수 있다. 반대로 자식 타입은 부모 타입을 담을 수 없다.
Parent poly = new Child() 는 가능하다. 반대로 Child child1 = new Parent()는 컴파일 오류! 이처럼 Parent 타입은 자신은 물론이고, 자식 타입까지 참조할 수 있다.
Parent poly = new Parent(), Parent poly = new Child(), Parent poly = new Grandsom() (Child 하위에 손자가 있다면 가능)

따라서 자바에서 부모 타입은 자신은 물론이고, 자신을 기준으로 모든 자식 타입을 참조할 수 있다. 이것이 바로 다양한 형태를 참조할 수 있다고 해서 다형적 참조라고 한다.

다형적 참조와 인스턴스 실행

다형적 참조의 한계

Parent -> Child: poly.childMethod()

Parent poly = new Child() 처럼 자식 인스턴스를 참조하고 있는 상황에서 poly가 자식 타입인 Child에 있는 childMethod()를 호출하면 어떻게 될까? 부모 타입의 참조변수로 자식 인스턴스를 참조할 수 있다. 하지만 자식의 기능은 호출할 수 없다.

poly.childMethod()를 실행하면 참조값을 통해 인스턴스를 찾는다.
인스턴스 안에서 실행할 타입을 찾아야 한다. 이때, 호출자 타입을 기준으로 선택한다. 그러므로 Parent 클래스부터 시작해서 필요한 기능을 찾는다.
상속 관계는 부모 방향으로 찾아 올라갈 수 있지만 자식 방향으로 찾아 내려갈 수 는 없다.
Parent는 부모 타입이고 상위에 부모가 없다. 그러므로 childMethod()를 찾을 수 없으므로 컴파일 오류가 발생한다.

그렇다면 어떻게 childMethod를 호출할 수 있을까? 정답은 캐스팅! 캐스팅이란 특정 타입으로 변경하는 것이다.

다형성과 캐스팅

다운캐스팅

Child child = (Child) poly // Parent poly

(타입) 처럼 괄호와 그 사이에 타입을 지정하면 참조 대상을 특정 타입으로 변경할 수 있다. 위에서 말했듯이 부모는 자식을 담을 수 있지만 자식은 부모를 담을 수 없다. 이때, 다운캐스팅이라는 기능을 활용해서 부모 타입을 잠깐 자식 타입으로 변경하면 된다.

poly는 Parent 타입니다. 이 타입을 (Child)를 사용해서 일시적으로 자식 타입인 Child 타입으로 변경한다. 그리고 나서 Child child에 대입한다.

구체적인 실행 순서는 다음과 같다.

Child child = (Child) poly // 다운캐스팅을 통해 부모타입을 자식 타입으로 변환한 다음에 대입 시도
Child child = (Child) x001 // 이때, poly 자체를 변경하는 것이 아니라 참조값을 꺼내서 읽은 다음 자식 타입으로 지정
Child child = x001 // 최종결과

❗캐스팅을 한다고해서 Parent poly의 타입이 변하는 것은 아니다. 해당 참조값을 꺼내고 꺼낸 참조값이 Child 타입이 되는 것이다. 따라서 poly의 타입은 Parent로 기존과 동일하다.

캐스팅의 종류

업캐스팅: 자식을 부모 타입으로 변경
다운캐스팅: 부모를 자식 타입으로 변경

        // 다운캐스팅(부모 타입 -> 자식 타입)
        Child child = (Child)poly; // x001
        child.childMethod();

        //일시적 다운캐스팅 -> 해당 메서드를 호출하는 순간만 다운캐스팅
        ((Child) poly).childMethod();

이때도 poly가 Child 타입으로 바뀌는 것은 아니다.

((Child) poly).childMethod(); // 다운캐스팅을 통해 부모타입을 자식 타입으로 변환 후 기능 호출
((Child) x001).childMethod(); // 참조값을 읽은 다음 자식 타입으로 다운캐스팅

이렇게 일시적 다운 캐스팅을 사용하면 별도의 변수 없이 인스턴스의 자식 타입의 기능을 사용할 수 있다. 반대로 업캐스팅은 현재 타입을 부모 타입으로 변경하는 것이다.

     Parent parent1 = (Parent) child; // 업캐스팅은 생략 가능, 생략 권장
     Parent parent2 = child; // 업캐스팅 생략, 자바가 알아서 해준다.

     parent1.parentMethod();
     parent2.parentMethod();

항상 부모는 자식을 담을 수 있다. 사실 이때, 자식도 부모로 타입 변환이 필요한데 이는 자바에서 자동으로 변환해 준다. 따라서 (Parent) 부분이 생략이 가능하다.

업캐스팅은 생략할 수 있다. 다운캐스팅은 생략할 수 없다. 참고로 업캐스팅은 매우 자주 사용하기 때문에 생략을 권장한다. 다시말하지만 부모는 자식을 담을 수 있다. 하지만 반대는 안된다. (꼭 필요하다면 다운캐스팅을 해야한다.)

그렇다면 다운캐스팅은 왜 개발자가 직접 명시적으로 캐스팅을 해야할까?

다운캐스팅과 주의점

        Parent parent1 = new Child();
        Child child1 = (Child) parent1;
        child1.childMethod(); // 문제 없음

        Parent parent2 = new Parent();
        Child child2 = (Child) parent2; // 런타임 오류 - ClassCastException
        child2.childMethod(); // 실행 불가

다운캐스팅은 잘못하면 심각한 런타임 오류가 발생할 수 있다. *런타임 오류는 말 그대로 프로그램이 실행되고 있는 시점에서 발생하는 오류다. 런타임 오류는 매우 안좋은 오류다 왜냐하면 보통 고객이 해당 프로그램일 실행하는 도중에 발생하기 때문이다.

다운 캐스팅이 가능한 경우

parent1의 경우 다운캐스팅을 해도 문제가 되지 않는다. 하지만 아래 경우는 다운캐스팅이 불가능 하다.

parent2를 Child 타입으로 다운캐스팅한다. 하지만 parent2는 Parent로 생성되었다. 따라서 메모리 상에 Child 자체가 존재하지 않는다. 즉, Child 자체를 사용할 수 없다. 자바에서는 사용할 수 없는 타입으로 다운캐스팅을 하는 경우에 ClassCastException 이라는 예외를 발생시킨다.

업캐스팅이 안전하고 다운캐스팅이 위험한 이유

업캐스팅은 다운캐스팅과 다르게 이런 문제가 발생하지 않는다. 왜냐하면 객체를 생성하면 해당 타입의 상위 부모 타입은 모두 생성된다. 따라서 위로만 타입을 변경하는 업캐스팅은 메모리 상에 인스턴스가 모두 존재하기 때문에 안전하다. 반면에 다운 캐스팅은 존재하지 않는 하위 타입으로 캐스팅하는 문제가 발생할 수 있다. 왜냐하면 객체를 생성하면 부모 타입은 모두 함께 생성되지만 자식 타입은 생성되지 않는다. 그렇기 때문에 이런 문제를 인지하고 사용해야 한다는 의미로 명시적으로 캐스팅 해줘야 한다.

클래스 A, B, C는 상속 관계다. 그러므로 new C()로 인스턴스를 생성하면 메모리 상에 즉, 인스턴스 내부에 자신과 부모인 A,B,C가 모두 생성된다.

하지만 new B()를 하게 되면 인스턴스 내부에 자기 자신인 B와 부모인 A만 생성된다. 즉 C는 B 인스턴스 내부에 존재하지 않기 때문에 C로 다운 캐스팅을 하게 되면 오류가 발생한다. 왜냐하면 C 자체는 존재하지 않기 때문이다.

A a = new B() : A로 업케스팅
B b = new B() : 자신과 같은 타입
C c = new B() : 하위 타입은 대입할 수 없음, 컴파일 오류
C c = (C) new B() : 하위 타입으로 강제 다운캐스팅, 하지만 B 인스턴스에 C와 관련된 부분이 없으므로 잘못된 캐스팅, ClassCastException 런타임 오류 발생

컴파일 오류 vs 런타임 오류

컴파일 오류는 변수명 오타, 잘못된 클래스 이름 사용 등 자바 프로그램을 실행하기 전에 발생하는 오류다. 이런 오류는 IDE에서 즉시 확인할 수 있기 때문에 안전하고 좋은 오류다. 반면에 런타임 오류는 프로그램이 실행되는 도중에 발생하는 오류로 좋은 않은 오류다. 왜냐하면 고객이 사용하는 도중에 오류가 발생하기 때문이다.

instanceof

다형성에서 참조형 변수가 참조하는 대상이 다양하기 때문에 어떤 인스턴스를 참조하고 있는지 확인할 필요가 있다. 이때, instanceof 키워드를 사용한다.

Parent parent1 = new Parent();
Parent parent2 = new Child();

여기서 Parent는 자신과 같은 Parent의 인스턴스도 참조할 수 있고, 자식 타입인 Child의 인스턴스도 참조할 수 있다. 이때, parent1, parent2 변수가 참조하는 인스턴스의 타입을 확인하고 싶다면 instanceof 키워드를 사용할 수 있다.

	Parent parent1 = new Parent();
        System.out.println("parent1 호출");
        call(parent1);
        Parent parent2 = new Child();
        System.out.println("parent2 호출");
        call(parent2);
    }

    	private static void call(Parent parent){

        parent.parentMethod();
        // parent가 Child 인스턴스 인 경우 childMethod() 실행
        if (parent instanceof Child){
            System.out.println("Child 인스턴스 맞음");
            ((Child) parent).childMethod();
        }

    }

자바 16 - Pattern Matching for instanceof

자바 16부터는 instanceof를 사용하면서 동시에 변수를 선언할 수 있다.

private static void call(Parent parent){

        parent.parentMethod();
        // Child 인스턴스 인 경우 childMethod() 실행
        if (parent instanceof Child child){
            System.out.println("Child 인스턴스 맞음");
            // 생략 가능
            //Child child = (Child) parent;
            child.childMethod();
        }

    }

다형성과 메서드 오버라이딩

메서드 오버라이딩의 핵심은 "오버라이딩 된 메서드가 항상 우선권을 가진다." 메서드 오버라이딩의 진짜 힘은 다형성과 함께 사용할 때다.

        // 부모 변수가 자식 인스턴스를 참조(다형적 참조)
        Parent poly = new Child();
        System.out.println("Parent -> Child");
        System.out.println("value = " + poly.value); // 변수는 오버라이딩 x
        poly.method(); // 메서드는 오버라이딩!

poly 변수는 Parent 타입이다. 따라서 poly.value, poly.method()를 호출하면 인스턴스의 Parent 타입에서 기능을 찾아 실행한다.
poly.value: Parent 타입에 있는 value 값을 읽는다. 즉, 변수(필드)는 오버라이딩 x
⭐poly.method(): Parent 타입에 있는 method()가 아니라 하위 타입으로 오버라이딩 된 Child.method()를 호출한다. 따라서 오버라이딩 된 메서드가 항상 우선권을 갖는다.

만약, 자식에서도 오버라이딩 하고 손자에서도 같은 메서드를 오버라이딩을 하는 경우 손자의 오버라이딩 메서드가 우선권을 갖는다. 즉, 더 하위 자식의 오버라이딩 된 메서드가 우선권을 갖는 것이다.

다형적 참조: 하나의 변수 타입으로 다양한 자식 인스턴스를 참조할 수 있다.
메서드 오버라이딩: 기존 기능을 하위 타입에서 새로운 기능으로 재정의

9. 상속

goldpig — Thu, 30 May 2024 20:18:00 +0900

상속이란 기존 클래스를 재사용하여 새로운 클래스를 작성는 것이다. 상속은 코드의 재사용성을 높이고 코드의 중복을 제거하여 프로그램의 생산성과 유지보수에 크게 기여한다.

상속을 사용하려면 extends 키워드를 사용하고 extends 대상은 하나만 선택할 수 있다.
부모 클래스 (슈퍼 클래스): 상속을 통해 자신의 필드와 메서드를 자손 클래스에 제공하는 클래스.
자손 클래스 (자식 클래스): 부모 클래스로부터 필드와 메서드를 상속받는 클래스

Car는 부모클래스이고 ElectricCar와 GasCar는 자손클래스이다.

상속은 부모의 기능을 자식이 물려받는 것이다. 따라서 자식은 부모의 기능을 물려 받아서 사용하고 있다. 하지만 부모 클래스는 자식 클래스에 접근할 수 없다.

자바는 다중 상속을 지원하지 않는다. 따라서 extends 대상은 하나만 선택할 수 있다. 즉, 부모는 여러개의 자식을 가질 수 있지만 자식은 하나의 부모만 선택할 수 있다.
생성자와 초기화 블럭은 상속되지 않는다. 오직 부모 클래스의 필드와 메서드만 상속된다.
자손 클래스의 멤버 개수는 조상 클래스보다 항상 같거나 많다.

⭐상속과 메모리 구조

ElectricCar electricCar = new ElectricCar();

new ElectricCar()를 호출하면 ElectricCar 뿐만 아니라 상속 관계에 있는 Car까지 포함해서 인스턴스가 생성된다. 참조값은 x001로 하나이지만 실제로 그 안에는 Car, ElectricCar 라는 두 가지 클래스 정보가 공존한다.

상속 관계의 객체를 생성하면 그 내부에는 부모와 자식이 모두 생성된다.
상속 관계의 객체를 호출할 때, 호출자의 타입을 기준으로 대상 타입을 찾는다.
현재 타입에서 기능을 찾지 못했다면 상위 부모 타입으로 기능을 찾아서 호출한다. 최상위 클래스에서 기능을 찾지 못하면 컴파일 오류가 발생한다.

상속과 메서드 오버라이딩

오버라이딩: 부모 클래스로부터 물려받은 메서드의 내용(기능)을 자식 클래스에서 재정하는 것이다.
조건: 1. 메서드의 이름이 같아야 한다 2. 매개변수가 같아야 한다 3. 반환 타입이 같아야 한다.
@Override 애노테이션 활용한다. 필수는 아니지만 코드의 명확성을 위해 붙여주는 것이 좋다.

오버로딩은 메서드의 이름은 같지만 매개변수가 다른 메서드를 여러 개 정의하는 것이다. (기존에 없는 새로운 메서드를 정의하는 것이다.) 반면 오버라이딩은 상속받은 메서드의 내용을 변경하는 것이다.

접근 제어자의 종류

private: 모든 외부 호출을 막는다.
default: 같은 패키지 안에서 호출을 허용한다.
protected: 같은 패키지 안에서 호출을 허용한다. 하지만 상속관계일 경우 패키지가 달라도 호출을 허용한다.
public: 모든 외부 호출을 허용한다.

super - 부모 참조

super는 자손 클래스에서 부모 클래스의 멤버를 참조하는데 사용되는 참조 변수이다. 즉, super 키워드를 통해 부모를 참조할 수 있다.

조상 클래스의 멤버와 자손 클래스의 멤버가 중복 정의되어 서로 구별해야하는 경우에만 super를 사용하는 것이 좋다.

super() - 조상 클래스의 생성자

상속 관계의 인스턴스를 생성하면 결국 메모리 내부에는 자식과 부모 클래스가 모두 만들어진다. Child를 만들면 부모인 Parent까지 함께 만들어지는 것이다. 따라서 각각의 생성자도 모두 호출되어야 한다.

상속 관계를 사용하면 자식 클래스의 생성자에서 부모 클래스의 생성자를 반드시 호출해야한다. (규칙)

public class ClassB extends ClassA {
    public ClassB(int a){
        super(); // 부모 클래스의 기본 생성자 생략 가능
        System.out.println("ClassB 생성자 a=" + a);
    }

부모 생성자를 호출할 때는 super()를 사용하면 된다.
this()는 같은 클래스의 다른 생성자를 호출할 때 사용하지만, super()는 조상 클래스의 생성자를 호출할 때 사용한다.

Object클래스를 제외한 모든 클래스의 생성자 첫 줄에 생성자 this(), 또는 super()를 호출해야한다. 그렇지 않으면 컴파일러가 자동적으로 'super();'를 생성자의 첫 줄에 삽입한다. 하지만 만약 생성자가 정의되어 있으면, 기본생성자를 자동으로 생성해주지 않는다.

public class ClassC extends ClassB{
    public ClassC(){
        super(10,20); // 수퍼를 직접 정의해야한다.
        System.out.println("ClassC 생성자");
    }
}

클래스와 메서드에 사용되는 final

클래스에 final: 상속 끝 즉, final로 선언된 클래스는 확장 될 수 없다. 따라서 다른 클래스가 final로 선언된 클래스를 상속받을 수 없다.
메서드에 final: 오버라이딩 끝 즉, final로 선언된 메서드는 오버라이드 될 수 없다. 상속받은 서브 클래스에서 이 메서드를 변경할 수 없다.

H-index

goldpig — Thu, 30 May 2024 13:08:10 +0900

문제 설명

H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과에 따르면, H-Index는 다음과 같이 구합니다.

어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.

어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.

제한사항

과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
논문별 인용 횟수는 0회 이상 10,000회 이하입니다.

입출력 예

입출력 예 설명

이 과학자가 발표한 논문의 수는 5편이고, 그중 3편의 논문은 3회 이상 인용되었습니다. 그리고 나머지 2편의 논문은 3회 이하 인용되었기 때문에 이 과학자의 H-Index는 3입니다.

핵심 아이디어

H-Index란 문제에 명시되어 있는 것처럼 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 과학자의 H-Index이다. 각 논문의 인용된 횟수를 차례대로 보기 위해 내림차순으로 정렬한다.

index	0 (1)	1 (2)	2 (3)	3 (4)	4 (5)
citations	6	5	3	1	0

여기서 각 index는 i번 이상 이용된 논문의 개수를 나타낸다. citations의 값이 index보다 크다면 계속해서 개수를 세어준다. 하지만 만약 citations의 값이 index보다 작거나 같아진다면 더 이상 i번 이상 인용된 논문이 없다는 뜻이므로 i의 값을 리턴해준다.

❗ 주의할 점은 만약 [5,5,5] 처럼 인용횟수가 모두 같은 요소가 여러개 있거나 혹은 [100] 처럼 논문이 1개 밖에 없다면 citations의 길이를 리턴해주면 된다.

코드 구현

def solution(citations):
    #answer = 0
    citations.sort(reverse=True)
    for i in range(len(citations)):
        # i번 이상 인용된 논문이 더 이상 없다면
        if i >= citations[i]:
            return i
        
    return len(citations) # 인용횟수가 모두 같을 때 ex [5,5,5]

n^2 배열 자르기

goldpig — Thu, 30 May 2024 12:31:27 +0900

문제 설명

정수 n, left, right가 주어집니다. 다음 과정을 거쳐서 1차원 배열을 만들고자 합니다.

n행 n열 크기의 비어있는 2차원 배열을 만듭니다.
i = 1, 2, 3, ..., n에 대해서, 다음 과정을 반복합니다.
- 1행 1열부터 i행 i열까지의 영역 내의 모든 빈 칸을 숫자 i로 채웁니다.
1행, 2행, ..., n행을 잘라내어 모두 이어붙인 새로운 1차원 배열을 만듭니다.
새로운 1차원 배열을 arr이라 할 때, arr[left], arr[left+1], ..., arr[right]만 남기고 나머지는 지웁니다.

정수 n, left, right가 매개변수로 주어집니다. 주어진 과정대로 만들어진 1차원 배열을 return 하도록 solution 함수를 완성해주세요.

❗제한사항

1 ≤ n ≤ 107
0 ≤ left ≤ right < n2
right - left < 105

핵심 아이디어

예시에서 1,2,3이 들어있는 곳의 규칙을 살펴보면, (0,0)은 1이고 인덱스에 1이 하나라도 들어가면 2 그리고 인덱스에 2가 하나라도 들어가면 3이 된다.

2차원 배열을 1차원 배열로 만들어서 살펴보면 다음과 같다.

인덱스 8을 살펴보면, 8 (8 // 3, 8 % 3) 즉 (몫, 나머지)로 확인할 수 있다. 그리고 몫과 나머지 중 큰 값을 구하고 거기 1을 더하면 원하는 값을 얻을 수 있다.

코드 구현

def solution(n, left, right):
    answer = []
    for i in range(left, right+1):
        a = i // n # 몫
        b = i % n # 나머지
        # 둘 중 더 큰값을 구하고 1을 더하면 원하는 값을 구할 수 있다.
        answer.append(max(a,b)+1)
    return answer

할인 행사

goldpig — Wed, 29 May 2024 14:24:41 +0900

문제 설명

XYZ 마트는 일정한 금액을 지불하면 10일 동안 회원 자격을 부여합니다. XYZ 마트에서는 회원을 대상으로 매일 한 가지 제품을 할인하는 행사를 합니다. 할인하는 제품은 하루에 하나씩만 구매할 수 있습니다. 알뜰한 정현이는 자신이 원하는 제품과 수량이 할인하는 날짜와 10일 연속으로 일치할 경우에 맞춰서 회원가입을 하려 합니다.

예를 들어, 정현이가 원하는 제품이 바나나 3개, 사과 2개, 쌀 2개, 돼지고기 2개, 냄비 1개이며, XYZ 마트에서 14일간 회원을 대상으로 할인하는 제품이 날짜 순서대로 치킨, 사과, 사과, 바나나, 쌀, 사과, 돼지고기, 바나나, 돼지고기, 쌀, 냄비, 바나나, 사과, 바나나인 경우에 대해 알아봅시다. 첫째 날부터 열흘 간에는 냄비가 할인하지 않기 때문에 첫째 날에는 회원가입을 하지 않습니다. 둘째 날부터 열흘 간에는 바나나를 원하는 만큼 할인구매할 수 없기 때문에 둘째 날에도 회원가입을 하지 않습니다. 셋째 날, 넷째 날, 다섯째 날부터 각각 열흘은 원하는 제품과 수량이 일치하기 때문에 셋 중 하루에 회원가입을 하려 합니다.

정현이가 원하는 제품을 나타내는 문자열 배열 want와 정현이가 원하는 제품의 수량을 나타내는 정수 배열 number, XYZ 마트에서 할인하는 제품을 나타내는 문자열 배열 discount가 주어졌을 때, 회원등록시 정현이가 원하는 제품을 모두 할인 받을 수 있는 회원등록 날짜의 총 일수를 return 하는 solution 함수를 완성하시오. 가능한 날이 없으면 0을 return 합니다.

❗제한사항

1 ≤ want의 길이 = number의 길이 ≤ 10
- 1 ≤ number의 원소 ≤ 10
- number[i]는 want[i]의 수량을 의미하며, number의 원소의 합은 10입니다.
10 ≤ discount의 길이 ≤ 100,000
want와 discount의 원소들은 알파벳 소문자로 이루어진 문자열입니다.
- 1 ≤ want의 원소의 길이, discount의 원소의 길이 ≤ 12

핵심 아이디어

Counter
zip()

*zip() 함수는 파이썬 내장 함수로, 여러 개의 반복 가능한 객체를 인자로 받아서 동일한 인덱스의 요소를 튜플 형태로 묶여주는 역할을 한다.

코드 구현

from collections import Counter
def solution(want, number, discount):
    answer = 0
    dic = {}
    for w,n in zip(want, number):
        dic[w] = n
    # print(dic), {'banana': 3, 'apple': 2, 'rice': 2, 'pork': 2, 'pot': 1}
    
    # discount에서 총 10개의 상품을 꺼내는 반복문 실행
    # 이 범위는 슬라이딩 윈도우 방식으로 10개의 연속된 상품을 검사하기 위해 설정됨 
    for i in range(len(discount) - 9):
        c = Counter(discount[i:i+10])
        '''
        print(c)
        Counter({'apple': 3, 'banana': 2, 'rice': 2, 'pork': 2, 'chicken': 1})
        Counter({'apple': 3, 'banana': 2, 'rice': 2, 'pork': 2, 'pot': 1})
        Counter({'banana': 3, 'apple': 2, 'rice': 2, 'pork': 2, 'pot': 1})
        Counter({'banana': 3, 'rice': 2, 'apple': 2, 'pork': 2, 'pot': 1})
        Counter({'banana': 3, 'rice': 2, 'apple': 2, 'pork': 2, 'pot': 1})
        '''
        if c == dic:
            answer += 1
    return answer