Java 와 spring 관련 면접 깔끔 정리

1.객체지향이란 무엇인가?
 - 객체지향은 프로그래밍에서 필요한 데이터를 추상화시켜서 상태와 행위를 가진 객체를 만들고, 해당 객체들간의 유기적인 상호작용을 기반으로 로직을 구성하는 프로그래밍을 말한다.

2. 객체지향 프로그래밍의 주요 키워드 
 - 하나, 추상화 : 복잡한 현실 세계를 단순화하여 필요한 부분만 추출하는 것. 객체의 공통된 특징을 추상화하여 클래스로 정의한다.
 - 둘, 캡슐화 : 데이터와 그를 다루는 메서드를 하나로 묶어 외부에서 직접 접근하지 못하도록 보호하는 것. 정보 은닉을 통해 객체의 내부 구현을 감춘다.
 - 셋, 상속 : 이미 정의된 클래스의 특징과 동작을 그대로 물려받아 새로운 클래스를 생성하는 것. 코드의 재사용성을 높이고, 계층적인 구조를 형성한다.
 - 넷, 다형성 : 같은 이름의 메서드를 다양한 방식으로 동작하도록 하는 것.
    - 오버라이딩 :  부모 클래스의 메서드를 자식 클래스에서 오버라이딩하여 다양한 형태로 사용할 수 있다.
    - 오버로딩 : 같은 이름의 함수를 여러개 정의하고 매개변수의 타입과 개수를 다르게 해서 매개변수에 따라서 다르게 호출 할 수 있다.

3.객체지향 프로그래밍의 장점은 무엇인가?
 - 객체지향 프로그래밍의 장점은 크게 3가지로 말씀드릴 수 있습니다. 
   - 하나, 코드 재사용이 편리하다  : 다른사람이 생성한 클래스를 가져와서 사용 가능함.
   - 둘, 유지보수가 쉽다.  : 객체지향 프로그래밍은 변화가 있는 부분만 간단하게 수정이 가능한 구조이지만, 만약 절차지향 프로그래밍으로 구현했다면, 모든소스를 일일이 찾아다니며 변화가 있는 부분을 수정해야하는 경우가 발생할 수 있다.
   - 셋, 클래스단위로 모듈화를 잘 구성할 수 있다. : 클래스 단위로  잘 모듈화가 되어 있기때문에 대형프로젝트에서 클래스 단위로 모듈화 시켜서 개발가능하다.    

4.객체 지향적 설계 원칙 SOLID
 - 하나, SRP(Single Responsibility Principle) : 단일책임원칙클래스는 단 하나의 책임을 가지고 있고, 클래스를 변경하는 이유는 단 하나의 이유이어야 한다.
 - 둘, OCP(Open-Closed Principle) : 개방-폐쇄의 원칙은 확장에는 열려 있어야 하고, 변경에는 닫혀 있어야 한다.
 - 셋, LSP (Liskov Substitution Principle) : 리스코프 치환 원칙은 상위타입의 객체를 하위 타입의 객체로 치환해도 상위 타입을 사용하는 프로그램은 정상적으로 동작해야 한다. 
 - 넷, ISP (Interface Segregation Principle) : 인터페이스 분리 원칙은 인터페이스는 그 인터페이스를 사용하는 클라이언트를 기준으로 분리해야한다.
 - 다섯, DIP(Dependency Inversion Principle) : 의존 역전 원칙은 고수준 모듈은 저수준 모듈의 구현에 의존해서는 안된다.

5. 제네릭에 대해서 설명하시오.
 - 제네릭은 자바에서 컴파일 시 타입을 체크하여 타입 안정성을 보장하는 기능이다. 
제네릭을 사용하면 클래스나 메서드를 선언할 때 타입 파라미터를 사용하여 다양한 타입을 지원할 수 있다. 
이를 통해 코드의 재사용성과 가독성을 높일 수 있다. 
제네릭은 컬렉션 프레임워크에서 많이 사용되며, 타입 안정성을 유지하면서 다양한 타입의 객체를 저장하고 처리할 수 있다. 
예를 들어, ArrayList<String>은 문자열만 저장할 수 있는 리스트를 의미한다. 제네릭은 컴파일 시에 타입 체크를 하기 때문에 런타임 오류를 줄일 수 있고, 타입 변환을 자동으로 처리해주어 편리하다.

6.컬렉션 클래스에서 제네릭을 사용하는 이유는? 
 - 컬렉션 클래스에 저장되는 인스턴스 타입을 제한해서 런타임에 발생할 수 있는 잠재적인 모든 예외를 컴파일 타임에 잡아 낼수 있기때문에 사용한다.

좀 더 자세하게 알아보면 아래와 같다.

하나. 타입 안정성: 제네릭을 사용하면 컴파일 시에 타입 체크를 할 수 있어서 잘못된 타입의 객체를 저장하려고 할 때 컴파일 오류를 발생시킬 수 있다. 이를 통해 런타임 시에 발생할 수 있는 타입 관련 오류를 사전에 방지할 수 있다.

둘. 코드 재사용성: 제네릭을 사용하면 다양한 타입의 객체를 저장하고 처리할 수 있는 컬렉션 클래스를 만들 수 있다. 이를 통해 코드의 재사용성을 높일 수 있다.

셋. 가독성: 제네릭을 사용하면 코드의 가독성을 높일 수 있다. 타입 파라미터를 사용하여 어떤 타입의 객체를 다루는지 명확하게 표현할 수 있기 때문이다.

넷. 타입 변환의 번거로움 제거: 제네릭을 사용하면 타입 변환을 자동으로 처리해주기 때문에 번거로운 타입 변환 코드를 줄일 수 있다.

다섯, 컴파일 시간 오류 검출: 제네릭을 사용하면 컴파일 시에 타입 체크를 하기 때문에 런타임 오류를 줄일 수 있다. 이를 통해 안정성을 높일 수 있다.

7.데드락(Dead Lock) 이 어떤것이고, 해결방법을 정리해보시오.

데드락(Deadlock)은 멀티스레드 환경에서 두 개 이상의 스레드가 서로 상대방의 작업이 끝나기를 기다리며 무한히 대기하는 상태를 말한다. 이는 다음과 같은 네 가지 조건이 동시에 충족될 때 발생한다:

하나. 상호 배제(Mutual Exclusion): 자원은 한 번에 하나의 스레드만이 사용할 수 있다.
둘. 점유와 대기(Hold and Wait): 스레드가 이미 자원을 가지고 있으면서 다른 스레드가 필요로 하는 자원을 기다리는 상태이다.
셋. 비선점(No Preemption): 다른 스레드가 이미 점유한 자원을 강제로 빼앗을 수 없다.
넷. 순환 대기(Circular Wait): 스레드 간에 자원을 기다리는 순환 형태가 형성되어야 한다.

데드락을 해결하기 위한 방법은 다음과 같다:

하나. 상호 배제 조건 제거: 자원의 공유를 허용하거나, 여러 스레드가 동시에 자원을 사용할 수 있도록 변경한다.
둘. 점유와 대기 조건 제거: 스레드가 자원을 요청할 때 해당 자원을 사용할 수 없을 경우, 자원을 모두 반납하고 다시 요청하는 방식으로 변경한다.
셋. 비선점 조건 제거: 자원을 점유한 스레드가 다른 스레드의 자원 요청을 기다리는 대신, 자원을 강제로 빼앗아 사용할 수 있도록 변경한다.
넷, 순환 대기 조건 제거: 자원에 고유한 번호를 할당하고, 스레드가 자원을 요청할 때 번호 순서대로 요청하도록 변경한다.

데드락을 완전히 예방하는 것은 어렵지만, 위의 방법들을 조합하여 데드락을 최소화하고 해결할 수 있다.

8.JVM이 하는 역할에 대해서 설명하세요~

JVM(Java Virtual Machine)은 자바 프로그램을 실행하기 위한 가상 머신이다. JVM의 주요 역할은 다음과 같다:

하나. 자바 코드 실행: JVM은 자바 바이트코드를 실행하여 자바 프로그램을 실행한다. 자바 코드는 컴파일러에 의해 자바 바이트코드로 변환되고, JVM은 이를 해석하거나 JIT(Just-In-Time) 컴파일러를 통해 기계어로 변환하여 실행한다.

둘. 메모리 관리: JVM은 자바 프로그램이 사용하는 메모리를 관리한다. 이는 자동으로 메모리를 할당하고 해제하는 가비지 컬렉션(Garbage Collection)을 통해 이루어진다. 가비지 컬렉션은 더 이상 사용되지 않는 객체를 자동으로 제거하여 메모리를 최적화한다.

셋. 자원 관리: JVM은 자바 프로그램이 사용하는 자원(파일, 네트워크 연결 등)을 관리한다. 자원의 올바른 사용과 해제를 보장하여 프로그램의 안정성과 성능을 유지한다.

넷. 보안 관리: JVM은 자바 프로그램의 보안을 관리한다. 클래스 로딩 시에 보안 검사를 수행하고, 실행 중인 코드의 권한을 제어하여 악의적인 동작을 방지한다.

다섯. 다중 스레드 관리: JVM은 다중 스레드를 지원하고, 스레드의 생성, 스케줄링, 동기화 등을 관리한다. 이를 통해 자바 프로그램은 동시에 여러 작업을 수행할 수 있다.

JVM은 플랫폼에 독립적이며, 자바 프로그램의 이식성과 보안성을 높이는 역할을 한다.

9.Spring의 AOP(Aspect-Oriented Programming)에 대해서 설명하시오~ 
AOP(Aspect-Oriented Programming)은 관점 지향 프로그래밍의 약자로, 애플리케이션의 핵심 로직과는 별개로 공통적으로 발생하는 부가 기능을 모듈화하는 프로그래밍 패러다임이다. 
Spring 프레임워크에서는 AOP를 지원하여 다음과 같은 특징을 가진다:

하나. 핵심 로직과 부가 기능의 분리: AOP는 핵심 로직과 공통 기능을 분리하여 개발할 수 있게 해준다. 
핵심 로직은 비즈니스 로직에 집중하고, 공통 기능은 별도의 모듈로 작성하여 재사용할 수 있다.

둘. 횡단 관심사(Cross-cutting Concerns) 처리: AOP는 횡단 관심사를 처리하기 위해 사용된다. 횡단 관심사는 여러 모듈에서 공통으로 발생하는 로깅, 트랜잭션 관리, 보안 등의 기능을 말한다. 
AOP를 사용하면 이러한 횡단 관심사를 한 곳에서 관리할 수 있다.

셋, 애스펙트(Aspect)와 포인트컷(Pointcut): AOP에서는 애스펙트와 포인트컷이라는 개념을 사용한다. 
애스펙트는 횡단 관심사를 모듈화한 것으로, 공통 기능을 정의하고 어디에 적용할지를 결정한다. 
포인트컷은 애스펙트가 적용될 대상을 지정하는 것으로, 특정 메서드 실행 시점이나 클래스에 적용할 수 있다.

넷, 어드바이스(Advice): 어드바이스는 애스펙트가 핵심 로직에 적용할 공통 기능을 정의한 것이다. 
어드바이스는 핵심 로직 실행 전, 후, 예외 발생 시 등 다양한 시점에 적용될 수 있다.

Spring AOP는 프록시 기반으로 동작하며, 런타임 시에 프록시 객체를 생성하여 핵심 로직과 공통 기능을 결합한다. 
이를 통해 AOP를 사용하면 코드의 중복을 줄이고 유지보수성을 향상시킬 수 있다.

10.Spring의 DI(Dependency Injection)에 대해서 설명하시오~
DI(Dependency Injection)는 의존성 주입의 약자로, 객체 간의 의존 관계를 외부에서 설정하여 객체를 생성하고 조립하는 방식이다. 

주입방법은 필드주입, setter 주입, 생성자 주입 3가지가 존재한다.
개발코드에서는 객체를 생성하는 것이 아니라, 데이터 주입만 담당하는 별도의 공간에서 객체를 생성하고 데이터간의 의존성을 주입해 개발코드에서 가져다 쓰면서 의존성을 줄이게된다.

Spring 프레임워크에서는 DI를 지원하여 다음과 같은 특징을 가진다:

하나. 객체 간의 결합도 감소: DI를 사용하면 객체 간의 결합도를 낮출 수 있다. 
객체가 직접 의존하는 객체를 생성하거나 참조하지 않고, 외부에서 의존 객체를 주입받아 사용한다. 
이를 통해 객체 간의 의존성이 줄어들어 유연하고 확장 가능한 코드를 작성할 수 있다.

둘. 객체의 생성과 조립을 외부에서 관리: DI를 사용하면 객체의 생성과 조립을 외부에서 관리할 수 있다. 
Spring 컨테이너는 객체의 라이프사이클을 관리하고, 필요한 의존 객체를 주입하여 객체를 생성하고 조립한다. 
이를 통해 개발자는 객체 생성과 조립에 대한 부분을 신경쓰지 않고 비즈니스 로직에 집중할 수 있다.

셋. 객체의 재사용성과 테스트 용이성: DI를 사용하면 의존 객체를 외부에서 주입받기 때문에 의존 객체를 쉽게 교체하거나 모의 객체(Mock Object)를 주입하여 테스트할 수 있다. 
또한, 의존 객체를 별도로 관리하기 때문에 객체의 재사용성이 높아진다.

넷. 컴포넌트 간의 관계 설정: DI를 사용하면 컴포넌트 간의 관계를 설정할 수 있다. 
Spring에서는 XML 또는 어노테이션을 사용하여 의존성을 설정하고, 컨테이너가 이를 해석하여 객체를 생성하고 조립한다.

Spring의 DI는 IoC(Inversion of Control)의 개념과 밀접하게 연관되어 있다. 
IoC는 제어의 역전을 의미하며, 객체의 생성과 관리를 개발자가 아닌 프레임워크 또는 컨테이너가 담당한다는 것을 의미한다. 
DI는 IoC의 구현 방식 중 하나로, 객체의 의존성을 외부에서 주입받는 것을 통해 IoC를 실현한다.

10. IoC에 대해서 설명하시오~
IoC(Inversion of Control)는 제어의 역전을 의미한다. 
기존의 프로그램에서는 개발자가 객체를 생성하고 조립하는 제어 흐름을 가지고 있었다. 
하지만 IoC는 이 제어 흐름을 프레임워크 또는 컨테이너에게 위임하여 개발자는 객체의 생성과 조립에 대한 부분을 신경쓰지 않고 비즈니스 로직에 집중할 수 있다.

Spring에서의 IoC는 다음과 같은 특징을 가진다:

하나. 객체의 생성과 조립을 컨테이너가 담당: Spring 컨테이너는 객체의 생성과 조립을 담당한다. 개발자는 객체를 생성하고 조립하는 코드를 작성하지 않고, 컨테이너에게 필요한 객체를 요청하여 사용한다.

둘. 객체의 라이프사이클 관리: Spring 컨테이너는 객체의 라이프사이클을 관리한다. 객체의 생성, 초기화, 소멸 등의 작업을 컨테이너가 담당하여 개발자는 이에 대한 부분을 신경쓰지 않아도 된다.

셋, 의존성 주입(Dependency Injection): Spring의 IoC는 의존성 주입(DI)을 통해 객체 간의 의존 관계를 설정한다. 개발자는 객체가 필요로 하는 의존 객체를 직접 생성하거나 참조하지 않고, 컨테이너에게 의존 객체를 주입받아 사용한다.

넷. 컴포넌트의 관리: Spring에서는 컴포넌트를 관리하기 위해 XML 또는 어노테이션을 사용한다. 컴포넌트의 의존성, 라이프사이클 등을 설정하여 컨테이너가 이를 해석하고 객체를 생성하고 조립한다.

IoC는 객체 지향 프로그래밍의 장점을 극대화하고, 유연하고 확장 가능한 코드를 작성할 수 있도록 도와준다. 
개발자는 객체의 생성과 조립에 대한 부분을 신경쓰지 않고 비즈니스 로직에 집중할 수 있으며, 객체 간의 결합도를 낮추어 유지보수와 테스트를 용이하게 한다.

11. Bean에 대해서 설명하시오~
Spring에서의 Bean은 Spring 컨테이너가 관리하는 객체를 의미한다. 
Bean은 다음과 같은 특징을 가진다:

하나. 객체의 인스턴스: Bean은 일반적으로 클래스의 인스턴스를 의미한다.
Spring 컨테이너는 Bean을 생성하고 초기화하여 개발자가 필요로 하는 객체를 제공한다.

둘. 컨테이너에 등록: Bean은 Spring 컨테이너에 등록되어야 한다.
컨테이너는 등록된 Bean을 관리하고 필요한 시점에 Bean을 생성하고 제공한다.

셋. 스코프: Bean은 스코프(scope)를 가지고 있다.
스코프는 Bean의 생명주기와 관련된 개념으로, 싱글톤, 프로토타입 등 다양한 스코프가 존재한다.

넷. 의존성 주입: Bean은 의존성 주입(Dependency Injection)을 통해 다른 Bean과의 의존 관계를 설정할 수 있다.
이를 통해 객체 간의 결합도를 낮추고 유연한 코드를 작성할 수 있다.

다섯. 설정 방법: Bean은 XML, 어노테이션, 자바 설정 클래스 등 다양한 방법으로 설정할 수 있다.
XML을 사용하는 경우 <bean> 요소를 사용하여 Bean을 정의하고, 어노테이션을 사용하는 경우 @Component, @Service, @Repository 등의 어노테이션을 사용하여 Bean을 등록할 수 있다.

Spring의 Bean은 IoC 컨테이너에 의해 생성되고 관리되므로 개발자는 Bean의 생성과 조립에 대한 부분을 신경쓰지 않고 비즈니스 로직에 집중할 수 있다. 
또한, Bean은 의존성 주입을 통해 유연하고 확장 가능한 코드를 작성할 수 있도록 도와준다.

12. Spring 필터와 인터셉터의 차이점를 설명하시오
Spring에서의 필터(Filter)와 인터셉터(Interceptor)는 모두 요청과 응답을 가로채어 처리하는 역할을 한다. 하지만 그들 사이에는 몇 가지 차이점이 있다:
추가적으로 필터는 dispatcherServlet 으로 요청이 가기전에 실행되며, 인터셋터는 Controller로 요청이 가기전에 실행된다.

하나. 위치: 필터는 Servlet 컨테이너에서 동작하며, 인터셉터는 Spring MVC에서 동작한다. 따라서 필터는 웹 애플리케이션의 모든 요청에 대해 동작하고, 인터셉터는 Spring MVC에서만 동작한다.

둘. 용도: 필터는 주로 요청과 응답의 헤더, 파라미터, 쿠키 등을 변경하거나 검증하는 데 사용된다. 반면에 인터셉터는 주로 요청 전후에 특정 작업을 수행하거나, 컨트롤러의 메소드 호출 전후에 추가적인 로직을 수행하는 데 사용된다.

셋. 설정 방법: 필터는 web.xml 파일에 등록하여 설정한다. 인터셉터는 Spring의 설정 파일에 등록하여 설정한다. 필터는 Servlet 컨테이너에 의해 관리되고, 인터셉터는 Spring 컨테이너에 의해 관리된다.

넷. 적용 범위: 필터는 모든 요청에 대해 동작하므로, 모든 URL 패턴에 대해 적용된다. 인터셉터는 특정 URL 패턴에 대해서만 적용할 수 있다.

다섯. 실행 순서: 필터는 Servlet 컨테이너에서 동작하므로, 필터 체인에 등록된 순서대로 실행된다. 인터셉터는 Spring MVC에서 동작하므로, 인터셉터 체인에 등록된 순서대로 실행된다.

요약하자면, 필터는 Servlet 컨테이너에서 동작하며 모든 요청에 대해 적용되고, 주로 요청과 응답의 변경이나 검증에 사용된다. 인터셉터는 Spring MVC에서 동작하며 특정 URL 패턴에 대해 적용되고, 주로 요청 전후에 추가적인 로직을 수행하는 데 사용된다.

13.Spring Entity에 대해서 설명하시오.
Spring에서의 Entity는 데이터베이스 테이블과 매핑되는 클래스를 말한다. 
이 클래스는 주로 JPA(Java Persistence API)를 사용하여 데이터베이스와 상호작용한다. 
Entity 클래스는 다음과 같은 특징을 가진다:

하나. 어노테이션: Entity 클래스는 @Entity 어노테이션을 사용하여 선언된다.
이 어노테이션은 해당 클래스가 데이터베이스 테이블과 매핑된다는 것을 나타낸다.

둘. 필드: Entity 클래스는 데이터베이스 테이블의 컬럼과 매핑되는 필드를 가진다.
이 필드들은 주로 private으로 선언되고, 각 필드에는 @Column 어노테이션을 사용하여 컬럼의 속성을 지정할 수 있다.

셋. 식별자: Entity 클래스는 주로 하나 이상의 식별자 필드를 가진다.
이 식별자는 @Id 어노테이션을 사용하여 지정되며, 주로 데이터베이스 테이블의 기본 키와 매핑된다.

넷. 관계: Entity 클래스는 다른 Entity 클래스와의 관계를 맺을 수 있다.
이 관계는 @OneToOne, @OneToMany, @ManyToOne, @ManyToMany 등의 어노테이션을 사용하여 지정된다.

다섯. Getter와 Setter: Entity 클래스는 필드에 접근하기 위해 Getter와 Setter 메소드를 가진다.
이 메소드들은 주로 public으로 선언되고, 필드에 접근하여 값을 가져오거나 설정할 수 있다.

Setter를 무분별하게 사용하면 안되는 이유는 Entity를 작성할때 Setter 를 무분별하게 사용하면 해당 값을 변경할 수 있으므로 객체의 일관성을 보장할 수 없다.

여섯. 데이터베이스와의 상호작용: Entity 클래스는 JPA를 사용하여 데이터베이스와 상호작용한다.
JPA는 Entity 클래스를 사용하여 데이터베이스 테이블에 데이터를 저장하거나 조회하는 등의 작업을 수행한다.

요약하자면, Spring의 Entity는 데이터베이스 테이블과 매핑되는 클래스로, @Entity 어노테이션을 사용하여 선언된다. 
이 클래스는 필드, 식별자, 관계 등을 가지며, JPA를 사용하여 데이터베이스와 상호작용한다.

14. Spring DTO와 VO의 차이점을 설명하시오~
Spring에서의 DTO(Data Transfer Object)와 VO(Value Object)는 데이터 전달을 위한 객체를 말한다. 
이 둘의 차이점은 다음과 같다:

하나. 목적: DTO는 서로 다른 계층 간 데이터 전달을 위해 사용되는 객체이다.
주로 비즈니스 로직과 Presentation 계층 사이에서 데이터를 전달하는 데 사용된다.
반면에 VO는 도메인 모델의 일부로 사용되는 객체로, 주로 도메인 객체의 상태를 나타내는 데 사용된다.

둘. 가변성: DTO는 주로 가변적인 객체로, 데이터 전달을 위해 필요한 필드들을 가지고 있다.
이 필드들은 주로 Getter와 Setter 메소드를 통해 접근된다.
반면에 VO는 불변적인 객체로, 한 번 생성되면 그 상태가 변경되지 않는다.

셋. 의존성: DTO는 주로 여러 도메인 객체의 데이터를 한 번에 전달하기 위해 사용되므로, 여러 도메인 객체에 대한 의존성을 가질 수 있다.
반면에 VO는 주로 한 개의 도메인 객체의 상태를 나타내므로, 해당 도메인 객체에 대한 의존성을 가진다.

넷. 네이밍: DTO는 데이터 전달을 위한 객체이므로, 주로 비즈니스 로직과 Presentation 계층에서 사용되는 데이터를 담는 객체를 의미하는 이름을 사용한다.
반면에 VO는 도메인 객체의 상태를 나타내는 객체이므로, 해당 도메인 객체의 이름을 사용하여 VO라는 접두어를 붙인다.

요약하자면, Spring에서의 DTO는 서로 다른 계층 간 데이터 전달을 위해 사용되는 가변적인 객체이고, 
VO는 도메인 객체의 상태를 나타내는 불변적인 객체이다. 
DTO는 주로 비즈니스 로직과 Presentation 계층에서 사용되며, VO는 도메인 모델의 일부로 사용된다.

15. 객체(Object) 에 대해서 설명하시오~
객체지향프로그래밍에서 Object는 모든 클래스의 기반이 되는 개념이다. 
객체는 속성과 동작을 가지며, 이를 클래스로 정의한다. 
Object는 클래스의 인스턴스를 생성하고, 이를 통해 데이터와 기능을 사용할 수 있다. 
객체는 다른 객체와 상호작용하며, 데이터를 주고받고 메소드를 호출하여 원하는 동작을 수행한다. 
객체는 상속, 다형성, 캡슐화 등의 개념을 활용하여 유연하고 재사용 가능한 코드를 작성할 수 있다. 
객체지향프로그래밍은 현실 세계의 개념과 구조를 모델링하여 프로그램을 작성하는 방법으로, Object를 중심으로 한다.

16. 클래스에 대해서 설명하시오~
클래스란 객체를 만들어 내기 위한 설계도 혹은 툴 
즉, 연관되어 있는 변수와 메소드의 집합

17. 인스턴스에 대해서 설명하시오~
소프트웨어에서 객체를 실체화하면 그것을 인스턴스라고 부른다.
즉, 객체지향프로그래밍의 관점에서 객체가 메모리에 할당되어 실제 사용될때 그것을 인스턴스라고 한다.

클래스, 객체와인스턴스, 그리고 인스턴스화에 대해서 Java 예제프로그램을 사용해서 설명하자면 아래와 같다.

클래스는 객체를 만들기 위한 설계도이다. 
클래스는 속성(변수)과 동작(메소드)을 정의한다. 
예를 들어, "사람" 클래스는 이름, 나이, 성별 등의 속성과 걷기, 말하기 등의 동작을 가질 수 있다.

객체는 클래스의 인스턴스이다. 
객체는 클래스를 기반으로 생성되며, 클래스에 정의된 속성과 동작을 가지게 된다. 
예를 들어, "사람" 클래스의 객체는 실제로 존재하는 개별 사람을 나타낼 수 있다.

인스턴스화는 클래스를 기반으로 객체를 생성하는 과정이다. 
Java에서는 "new" 키워드를 사용하여 클래스의 인스턴스를 생성한다. 
예를 들어, 다음과 같은 Java 코드를 통해 "사람" 클래스의 객체를 인스턴스화할 수 있다.

public class Person {
    String name;
    int age;
    
    public void walk() {
        System.out.println(name + " is walking.");
    }
    
    public void talk() {
        System.out.println(name + " is talking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "John";
        person1.age = 25;
        
        person1.walk(); // 출력: John is walking.
        person1.talk(); // 출력: John is talking.
    }
}

위의 예제에서 "Person" 클래스는 사람을 나타내는 설계도이다.
"Main" 클래스에서 "Person" 클래스의 객체를 인스턴스화하여 사용한다.
"person1" 객체는 "Person" 클래스의 인스턴스로, "name"과 "age" 속성을 가지며 "walk()"와 "talk()" 메소드를 호출할 수 있다.

18. String, StringBuffer, StringBuilder 차이점을 설명하시오~

String은 불변(immutable)한 문자열을 나타내는 클래스로, 한 번 생성된 문자열은 수정할 수 없다. 따라서 문자열을 변경할 때마다 새로운 객체를 생성하므로 메모리 낭비가 발생할 수 있다.

StringBuffer와 StringBuilder는 가변(mutable)한 문자열을 나타내는 클래스로, 문자열을 변경할 수 있다. 두 클래스의 가장 큰 차이점은 동기화(synchronization)의 유무이다. StringBuffer는 동기화가 되어 있어 멀티스레드 환경에서 안전하게 사용할 수 있지만, StringBuilder는 동기화가 되어 있지 않아 단일 스레드 환경에서 더 빠르게 동작한다.

따라서, 문자열을 자주 변경해야 하는 경우에는 StringBuffer나 StringBuilder를 사용하는 것이 좋고, 문자열 변경이 없거나 변경이 적은 경우에는 String을 사용하는 것이 좋다.

19.프로세스, 스레드, 멀티프로세스, 멀티쓰레드에 대해서 설명하시오~

프로세스는 실행 중인 프로그램을 의미하며, 독립된 메모리 공간을 할당받아 실행되는 단위이다. 각각의 프로세스는 자신만의 주소 공간, 파일, 자원 등을 가지고 있으며, 다른 프로세스와는 독립적으로 실행된다.
참고로, 하나의 프로세스는 코드영역(code), 데이터영역(data), 스택영역(stack), 힙영역(Heap) 4가지로 이루어져 있다.

스레드는 프로세스 내에서 실행되는 작은 실행 단위로, 프로세스의 자원을 공유하면서 동시에 실행된다. 스레드는 프로세스 내에서 독립적으로 실행되는 여러 개의 흐름이다. 스레드는 프로세스 내에서 생성되고 제거되며, 각각의 스레드는 독립적으로 실행되는 코드를 가지고 있다.

멀티프로세스는 여러 개의 프로세스가 동시에 실행되는 것을 의미한다. 각각의 프로세스는 독립적으로 실행되기 때문에 안정성이 높지만, 프로세스 간의 통신이 복잡하고 오버헤드가 크다는 단점이 있다.

멀티스레드는 하나의 프로세스 내에서 여러 개의 스레드가 동시에 실행되는 것을 의미한다. 스레드는 프로세스의 자원을 공유하기 때문에 통신이 간단하고 오버헤드가 적다는 장점이 있다. 하지만 스레드 간의 동기화와 관련된 문제들을 고려해야 하며, 안정성에 주의해야 한다.

20. MVC에 대해서 설명하시오~
Spring MVC는 Spring 프레임워크에서 제공하는 웹 애플리케이션 개발을 위한 모듈이다.

MVC는 Model-View-Controller의 약자로, 애플리케이션을 세 가지 역할로 구분한다.

- Model: 데이터와 비즈니스 로직을 담당한다. 데이터베이스와의 상호작용, 데이터 처리 등을 수행한다.
- View: 사용자에게 보여지는 화면을 담당한다. HTML, CSS, JavaScript 등을 사용하여 UI를 구성한다.
- Controller: 사용자의 요청을 처리하고, Model과 View를 연결하는 역할을 담당한다. 요청을 받아 해당하는 비즈니스 로직을 실행하고, 결과를 View에 전달한다.

Spring MVC는 이러한 역할을 구분하여 개발을 할 수 있도록 지원한다. 
요청은 DispatcherServlet이 받아서 Controller에게 전달하고, Controller는 요청을 처리한 후 결과를 Model에 담아 View에 전달한다. 
View는 Model의 데이터를 사용하여 사용자에게 보여지는 화면을 생성한다.

이렇게 구성된 Spring MVC는 애플리케이션의 유연성과 확장성을 높여주며, 개발자들이 각각의 역할에 집중하여 개발을 할 수 있도록 도와준다.

21. Spring 에서 DTO를 사용하는 이유를 설명하시오~
DTO는 Data Transfer Object의 약자로, 데이터 전송을 위한 객체이다. 
Spring에서 DTO를 사용하는 이유는 다음과 같다.

하나. 데이터 전송의 효율성: DTO는 데이터 전송을 위한 최소한의 필드만을 가지고 있는 객체이다. 
따라서 네트워크 통신이나 데이터베이스 조회 등에서 필요한 데이터만을 전송하므로 효율적인 데이터 전송이 가능하다.

둘. 불변성: DTO는 주로 읽기 전용으로 사용되며, 필드 값이 변경되지 않는 불변 객체로 설계된다. 
이는 데이터의 안정성과 일관성을 보장하며, 다중 스레드 환경에서 안전하게 사용할 수 있다.

셋. 계층 간 데이터 교환: DTO는 계층 간 데이터 교환을 위한 중간 객체로 사용된다. 
예를 들어, Controller에서 Service로 데이터를 전달하거나, Service에서 Repository로 데이터를 전달할 때 DTO를 사용하여 데이터를 전송한다. 
이를 통해 계층 간의 의존성을 낮추고, 유연한 아키텍처를 구성할 수 있다.

넷. 데이터 변환: DTO는 데이터의 변환을 위해 사용된다. 
예를 들어, 데이터베이스의 엔티티 객체를 DTO로 변환하여 API 응답에 필요한 필드만을 전송하거나, 반대로 DTO를 엔티티로 변환하여 데이터베이스에 저장하는 등의 작업을 수행할 수 있다.

다섯. 클라이언트와의 인터페이스: DTO는 클라이언트와의 인터페이스 역할을 수행한다. 
클라이언트는 DTO를 통해 필요한 데이터를 전달하고, 서버는 DTO를 통해 클라이언트에게 데이터를 전송한다. 이를 통해 클라이언트와 서버 간의 데이터 형식을 표준화하고, 개발자들 간의 협업을 용이하게 한다.

이러한 이유로 Spring에서는 DTO를 사용하여 데이터 전송과 변환을 효율적으로 처리하고, 계층 간의 데이터 교환을 원활하게 할 수 있다.

22. JPA에서 Entity를 설계할때 주의점에 대해서 설명하시오~

JPA에서 Entity를 설계할 때 주의해야 할 점은 다음과 같다.

1. 식별자: Entity는 식별자를 가져야 한다. 주로 `@Id` 어노테이션을 사용하여 식별자를 지정한다. 식별자는 유일하고 변경되지 않는 값이어야 한다.

2. 연관관계: Entity 간의 연관관계를 정의해야 한다. `@ManyToOne`, `@OneToMany`, `@OneToOne`, `@ManyToMany` 등의 어노테이션을 사용하여 연관관계를 매핑한다. 연관관계는 양방향으로 설정할 수 있으며, 외래 키를 사용하여 관계를 유지한다.

3. 영속성 전이: 연관된 Entity의 상태를 함께 관리하기 위해 영속성 전이를 설정할 수 있다. 
`CascadeType.ALL`, `CascadeType.PERSIST`, `CascadeType.MERGE` 등의 옵션을 사용하여 연관된 Entity의 상태를 자동으로 처리할 수 있다.

4. 지연 로딩: 연관된 Entity를 필요할 때만 로딩하도록 지연 로딩을 설정할 수 있다. `@ManyToOne`, `@OneToOne` 등의 관계에서 `fetch = FetchType.LAZY` 옵션을 사용하여 지연 로딩을 설정할 수 있다. 이를 통해 성능을 최적화할 수 있다.

5. 상속: Entity 간의 상속 관계를 매핑할 수 있다. `@Inheritance`, `@DiscriminatorColumn`, `@DiscriminatorValue` 등의 어노테이션을 사용하여 상속 관계를 정의할 수 있다.

6. equals()와 hashCode(): Entity는 equals()와 hashCode() 메서드를 오버라이딩해야 한다. 이는 Entity의 동등성 비교를 위해 필요하다. 주로 식별자를 기준으로 equals()와 hashCode()를 구현한다.

7. 데이터 유효성 검사: Entity에는 데이터 유효성 검사를 위한 제약 조건을 설정할 수 있다. `@NotNull`, `@Size`, `@Pattern` 등의 어노테이션을 사용하여 필드의 유효성을 검사할 수 있다.

8. 테이블 매핑: Entity와 데이터베이스 테이블 간의 매핑을 설정해야 한다. `@Table`, `@Column`, `@JoinColumn` 등의 어노테이션을 사용하여 Entity와 테이블 간의 매핑을 정의한다.

이러한 주의점을 기억하면 JPA에서 Entity를 올바르게 설계할 수 있다.

23. N+1 문제에 대해 짧게 설명하시오
Lazy 로딩에 의해서 한번에 모든 정보를 안가져와서 발생하는 문제인데 Fetch조인을 사용해서 해결할 수 있다.
SQL 1번으로 100명의 회원을 조회하였는데,한번 SQL을 실행해서 조회된 결과 수만큼 N번 SQL을 추가로 실행한다고 해서 N+1 문제라 한다.
각 회원마다 주문한 상품을 추가로 조회하기 위해 100번의 SQL을 추가로 실행하는 상황을 말한다.
JPA에서 N+1 문제는 연관된 Entity를 조회할 때 발생하는 성능 문제이다. 
이를 해결하기 위해 다음과 같은 방법을 사용할 수 있다.

하나. FetchType.LAZY 사용: 연관된 Entity를 지연 로딩으로 설정하여 필요한 시점에만 조회하도록 한다. 이를 통해 초기 조회 시에는 N+1 문제가 발생하지 않는다.

둘. FetchType.EAGER 사용: 연관된 Entity를 즉시 로딩으로 설정하여 한 번의 쿼리로 모든 연관 데이터를 조회한다. 하지만 모든 연관 데이터를 항상 필요로 하는 경우에만 사용해야 한다.

셋. @BatchSize 사용: 연관된 Entity를 일괄적으로 조회하기 위해 `@BatchSize` 어노테이션을 사용한다. 이를 통해 한 번의 쿼리로 여러 개의 연관 데이터를 조회할 수 있다.

넷. 페치 조인 사용: 연관된 Entity를 함께 조회하기 위해 페치 조인을 사용한다. `JOIN FETCH`를 사용하여 연관된 데이터를 한 번에 조회할 수 있다.

다섯. DTO 사용: 필요한 데이터만을 조회하기 위해 DTO(Data Transfer Object)를 사용한다. 필요한 필드만을 포함한 DTO를 생성하여 성능을 최적화할 수 있다.

여섯. 쿼리 최적화: 쿼리를 최적화하여 N+1 문제를 해결할 수 있다. `JOIN`이나 `LEFT JOIN`을 사용하여 필요한 데이터를 한 번에 조회하도록 한다.

이러한 방법을 사용하여 N+1 문제를 해결할 수 있다. 각 상황에 맞게 적절한 방법을 선택하여 성능을 향상시키도록 한다.

24. 생성자 인젝션을 사용하는 이유를 설명하시오~

생성자 인젝션을 사용하는 이유는 다음과 같다:
하나. 의존성을 명시적으로 표현: 생성자 인젝션은 필요한 의존성을 생성자 매개변수로 전달하는 방식이다. 이를 통해 클래스의 의존성을 명시적으로 표현할 수 있어 코드의 가독성을 높일 수 있다.

둘. 의존성 주입의 불변성: 생성자 인젝션은 한 번 생성되면 변경되지 않는 불변성을 가진다. 이는 클래스의 의존성이 변하지 않는다는 것을 의미하며, 객체의 일관성과 안정성을 보장할 수 있다.

셋. 테스트 용이성: 생성자 인젝션은 의존성을 외부에서 주입받기 때문에 테스트하기 쉽다. 의존성을 모의 객체(Mock Object)로 대체하여 테스트할 수 있으며, 의존성 주입을 통해 테스트의 격리성과 재현성을 확보할 수 있다.

넷. 순환 의존성 방지: 생성자 인젝션은 순환 의존성을 방지할 수 있다. 순환 의존성은 A 객체가 B 객체를 의존하고, B 객체가 다시 A 객체를 의존하는 상황을 말한다. 생성자 인젝션을 사용하면 의존성 주입 시점에 순환 의존성을 감지하여 예외를 발생시키므로, 이를 방지할 수 있다.

다섯. DI 프레임워크 호환성: 생성자 인젝션은 대부분의 DI(Dependency Injection) 프레임워크와 호환된다. DI 프레임워크는 생성자 인젝션을 통해 의존성을 주입하므로, 생성자 인젝션을 사용하면 DI 프레임워크를 쉽게 적용할 수 있다.

이러한 이유로 생성자 인젝션은 필드 인젝션보다 선호되는 방식이다. 생성자 인젝션을 사용하여 의존성을 명시적으로 표현하고, 코드의 가독성과 유지보수성을 높이며, 테스트 용이성과 순환 의존성 방지를 확보할 수 있다.