원 투 쓰리 포 버블버블

Enum을 비교할 때에는 ==과 equals()중 어떤 것을 써야 할까?

Bubbles — Tue, 6 Feb 2024 10:23:09 +0900

회사에서 MergeRequest를 올리고 코드 리뷰를 팀원께 요청드렸었는데, 아래와 같이 Dto에 있던 enumType비교 시 ==기호를 사용한 것에 대해 코드 리뷰가 달렸었다.

if (someDto.type == someEnumType.Atype) {
	// do something
}

Enum 비교에 있어서 equals( )와 ==의 차이에 대해 공부해보는것도 좋을 것 같다고 공부할만한 토픽을 하나 주셔서, 겸사겸사 공부한 것을 정리하려 포스팅한다.

equals( )와 == 연산의 차이는 CS 스터디때도, 멘토링 공부하면서도 알고 있던 부분이라고 생각했고, 다시 내가 공부했던 내용을 찾아보면 아래와 같다.

equals()는 참조 변수의 값이 같은지 비교하는 메소드로, 재정의 되어있지 않다면 객체의 주소값을 비교하여 동일 객체인지 비교후 boolean 값을 리턴하는 메소드이다.
hashCode()도 오버라이딩 해줘야 제대로 중복 객체가 Hash 자료구조에 들어오는 것을 방지할 수 있음
== 연산자는 primitive type일 경우 값을, 그 외에는 주소값을 비교하는 연산자이다.

그래서 equals()의 경우, String 클래스에는 따로 내용물만 비교할 수 있도록 overriding 되어 있다.

하지만 Oracle Docs의 Enum class를 보면 equals() 메소드는 final로 선언이 되어있다.

즉, Enum에서의 equals 오버라이딩을 더는 허용하지 않는다는 뜻이고, equals 호출 시 Object의 equlals 호출하여 사용한다. Object의 equals는 아래와 같이 되어 있다.

public boolean equals(Object obj) {
	return (this == obj);
}

Oracle 공식 문서에도 아래처럼 나와 있다.

https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.9
[ ... 중략 ]
Because there is only one instance of each enum constant, it is permitted to use the == operator in place of the equals method when comparing two object references if it is known that at least one of them refers to an enum constant.
The equals method in Enum is a final method that merely invokes super.equals on its argument and returns the result, thus performing an identity comparison.

enum 상수는 1개만 존재하기 때문에, 2개의 객체를 비교할 때 ==을 사용해도 된다.
Enum에서의 equals 메소드는 단지 super.equals를 호출하여 동일성 비교를 수행하는 메소드이다.

출처 : https://docs.oracle.com/javase/8/docs/api/java/lang/Enum.html

이를 보고, 나는 Enum 타입의 경우, == 연산과 equals의 차이가 없으며 NPE 발생 여부만 다르다고 판단하고, 추가적으로 == 과 equals 메소드를 가지고 실험도 해봤다.

public class Main {
    public static void main(String[] args) {
        Test test = new Test(Types.RED);
        Test test2 = new Test(Types.RED);
        Test test3 = new Test();

        // 같은 enum 넣은 경우 equals든, ==이든 동일하게 true
        System.out.println(test.types.equals(test2.types)); 
        System.out.println(test.types == test2.types);
        
        // 그냥 enum 상수 자체와 비교해도 둘다 true
        System.out.println(test.types.equals(Types.RED));
        System.out.println(test.types == Types.RED);
        
        // test3의 types는 null, equals든, ==이든 동일하게 false
        System.out.println(test.types.equals(test3.types));
        System.out.println(test.types == test3.types);
        
        // false
        System.out.println(new Test().types == Types.RED);
        // NPE 발생
        System.out.println(new Test().types.equals(Types.RED));
    }

    static class Test {
        Types types = null;
        Test (Types types) {
            this.types = types;
        }
        Test() { }
    }
}

주목할 것은 이 부분이다.

Null 이 들어있을 때 두 연산자는 어떤 결과를 뱉는가?

// false
System.out.println(new Test().types == Types.RED);
// NPE 발생
System.out.println(new Test().types.equals(Types.RED));

Null값이 들어왔을 때, == 연산자는 단지 false를 반환하고, equals 메소드는 NPE를 발생 시킨다.

기초적인 것이지만 늘 헷갈리는 부분인만큼 이번 기회에 다시 정리해두었다.

팀원 분 덕분에 좋은 공부를 할 수 있었다 :DD

Factory Pattern

Bubbles — Wed, 17 Jan 2024 11:10:53 +0900

인터페이스를 사용한다고 해도 구상 클래스의 인스턴스를 만들어야 하지 않나?

Duck duck = new MallardDuck();
// Duck이라는 인터페이스를 써서 유연하게 만들려고 해도, 그럼에도 구상 클래스의 인스턴스를 만들어야 한다.

Duck duck;
if (picnic) {
	duck = new MallardDuck();
} else if (hunting) {
	duck = new DecoyDuck();
} else if (inBathTub) {
	duck = new RubberDuck();
}

이 코드를 보면 구상 클래스의 인스턴스가 여러 개 있고, 그 인스턴스의 형식은 실행 시 조건에 따라 결정된다.
변경하거나 확장할 때, 코드를 다시 확인하고 새롭게 추가하거나 기존 코드 제거

=> 관리와 갱신이 어렵다.
=> 인터페이스에 맞춰서 코딩하면 시스템에서 일어날 수 있는 여러 변화에 대응 가능 (인터페이스만 구현하면 사용 가능, 다형성)
=> 구상 클래스를 많이 사용하면 새로운 구상 클래스 추가될 때마다 코드 고쳐야 함
=> 새로운 구상 형식을 써서 확장할 때에는 어떻게 해서든 다시 열 수 있게 만들어야 한다...!

Pizza orderPizza(String type) {
		Pizza pizza;
		
// 이 부분이 피자가 바뀔 때마다 코드를 계속 추가하고 삭제해야 하는 것이 문제이다.
// ( 인스턴스를 만드는 구상 클래스 선택하는 부분 )
// 이 부분을 따로 빼두자(팩토리)
		if (type.equals("cheese")) {
				pizza = new CheezePizza();
		} else if (type.equals("pepperoni") {
				pizza = new PepperoniPizza();
		} else if (type.equals("clam")) {
				pizza = new ClamPizza();
		} else if (type.equals("veggie")) {
				pizza = new VeggiePizza();
		} 

// 이 아래부분은 바뀌지 않음 

		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
}

인스턴스를 만드는 구상 클래스를 선택하는 부분 -> 이 부분을 따로 빼내자(피자 종류에 따라 계속 바뀌는 부분이므로)

public class SimplePizzaFactory {

		public Pizza createPizza(String type) {
				if (type.equals("cheese")) {
								pizza = new CheezePizza();
				} else if (type.equals("pepperoni") {
								pizza = new PepperoniPizza();
				} else if (type.equals("clam")) {
								pizza = new ClamPizza();
				} else if (type.equals("veggie")) {
								pizza = new VeggiePizza();
				} 
				return pizza;
		}
}

피자 객체 생성 작업을 팩토리 클래스로 캡슐화 해놓으면 구현을 변경할 때 여기저기 고칠 필요 없이 팩토리 클래스 하나만 고치면 된다.
피자 객체를 받아서 주문하는 클래스 말고도, 피자를 설명하는 클래스, 가격을 알려주는 클래스 등 다른 방식으로 피자를 처리하는 클래스에도 이 팩토리를 사용할 수 있다.

간단한 팩토리?

디자인 패턴이라기보다는, 프로그래밍에서 자주 쓰이는 관용구에 가까움
PizzaStore(팩토리 사용하는 클라이언트)
SimplePizzaFactory (객체를 생성하는 팩토리, 구상 Pizza 클래스를 직접 참조)
Pizza (팩토리에서 만드는 피자)
- CheesePizza, VeggiePizza, ClamPizza, PepperoniPizza 등등
- 팩토리에서 생산하는 제품에 해당하는 구상 클래스
- Pizza 인터페이스를 구현하며, 각각은 구상 클래스이다.

public abstract class PizzaStore {
	public Pizza orderPizza(String type) {
    	Pizza pizza;
        pizza = createPizza(type);
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
    
    abstract Pizza createPizza(String type);
}

createPizza : PizzaStore 상속받은 NYStylePizzaStore, ChicagoStylePizzaStore 2가지
- ex ) NYStylePizzaStore의 createPizza(type)
  - NYStyleCheesePizza()
  - NYStylePepperoniPizza()
orderPizza : 그냥 구현하지 않고 가져다 사용, 만약 못 고치도록 막고 싶다면 final 붙이면 된다

팩토리 메서드

객체를 생성할 때 필요한 인터페이스를 만든다.
어떤 클래스의 인스턴스를 만들 지는 서브 클래스에서 결정한다.
즉, 클래스 인스턴스 만드는 일을 서브 클래스에게 맡기게 된다.

Creator

추상 클래스, 팩토리 메소드 용 인터페이스를 제공한다.
인터페이스만 제공, 실제 팩토리 메소드를 구현하고 객체 인스턴스 만드는 일은 서브 클래스에서만 할 수 있음
PizzaStore 추상클래스 상속받는 NyPizzaStore, ChicagoPizzStore
- PizzaStore의 orderPizza : pizza = createPizzas(type) 이렇게 호출
- 사용하는 쪽에서 어느 PizzaStore의 orderPizza호출하냐 따라 NyPizza가 만들어질수도, ChicagoPizza가 만들어질수도 있다!
- 즉, 서브 클래스에서 어떤 객체가 생성될지 결정되는 것 !

간단한 팩토리와 팩토리 메서드 비교

추상 팩토리

구상 클래스에 의존하지 않고도 서로 연관되거나 의존적인 객체로 이루어진 제품군을 생산하는 인터페이스를 제공하고, 구상 클래스는 서브클래스에서 만들어진다.

위의 시나리오에서 원재료들을 생산하는 팩토리도 만들자!

public interface PizzaIngredientFactory {
    public Dough createDough();
    public Sauce creaetSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
}

각 스타일의 피자별로 implements PizzaIngredientFactory 해서 사용
각각 createXXX 메소드를 지점별로 알맞게 만든다.
- ex ) 냉동 조개를 쓸 수도 있고, 생 조개 쓸 수도 있고..!
기존 PizzaClass에서도 prepare()을 추상 메소드로 만든다.

EX) CheesePizza

public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;
    
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
    	this.ingredientFactory = ingredientFactory;
    }
    
    void prepare() {
    	dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        // 등등 재료가 필요할 때마다 팩토리에 있는 메소드 호출하여 만든다
    }
}

EX) NYPizzaStore

public class NYPizzaStore extends PizzaStore {
	protected Pizza createPizza(String item){
    	Pizza pizza = null;
        PizzaIntgredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        
        // .. 중략, item별로 치즈 피자 만들기 등등 수행 
    }
}

팩토리 메소드 패턴(PizzaStore)과 추상 팩토리 패턴(PizzaIngredientFactory) 비교

팩토리 메소드 패턴	추상 팩토리 패턴
어플리케이션을 특정 구현으로부터 분리하기 위해 사용
클래스를 사용해서 만든다. - 상속을 통해 객체를 만든다. - 클래스를 확장, 팩토리 메소드 오버라이드 PizzaStore ~ createPizza() 라는 팩토리 메소드 override NYPizzaStore, ChicagoPizzaStore (상속)	객체 구성을 통해 객체를 만든다. - 필드로 클래스 인스턴스 참조 - 제품군을 만드는 추상 형식 제공 - 제품이 생산되는 방법은 이 형식의 서브 클래스에서 정의 PizzaIngredientFactory - createDough, createCheese 등 추상 형식을 제공 - 구체적으로 어떤 dough, cheese인지는 Ny, Chic(하위)에서 NyPizzaStore의 createPizza() PizzaIngredientFactory ingredientFactory = new NyPizzaIngredientFactory 넣어주기
클라이언트 코드와 인스턴스를 만들어야 할 구상 클래스를 분리	새로운 제품을 추가 시 인터페이스 변경이 일어난다. ex) 현재는 dough, cheese인데 ham 이런거 추가한다면?
클라이언트는 자신이 사용할 추상 형식만 알고 있으면 OK 서브 클래스에서 구상 형식을 처리 해준다.	팩토리를 사용하려면, 팩토리 인스턴스를 만들고, 추상 형식을 써서 만든 코드에 전달
어떤 구상 클래스가 필요할지 미리 알 수 없을 때에도 유용	클라이언트에서 서로 연관된 일련의 제품을 만들 때 즉, 제품 군을 만들 때 활용

Decorator Pattern

Bubbles — Thu, 11 Jan 2024 17:39:40 +0900

Decorator Pattern

객체에 추가 요소를 동적으로 더할 수 있는 디자인 패턴
서브 클래스 만들 때보다 훨씬 유연하게 기능을 확장할 수 있음
데코레이터의 슈퍼 클래스는 자신이 장식하고 있는 객체의 슈퍼 클래스와 동일 ~ 원래 객체에 들어갈 자리에 데코레이터 넣어도 상관 X
힌 객체를 여러 개의 데코레이터로 감쌀 수 있음
객체는 언제든지 감쌀 수 있음, 실행중에 필요한 데코레이터를 마음대로 적용 가능

- 객체 구성(인스턴스 변수로 다른 객체 저장하는 방식) 사용 ~ 첨가물을 다양하게 추가해도 유연성을 잃지 않도록

예시 ) 커피 주문

public abstract class Beverage {
	String description = "제목 없음";
    
    public String getDescription() {
    	return description;
    }
    
    public abstract double cost();
}

// 데코레이터
public abstract class CondimentDecorator extends Beverage {
	Beverage beverage;
    public abstract Stromg getDescription;
}

// 음료 
public class Espresso extends Beverage {
	public Espresso() {
    	description = "에스프레소";
    }
    public double cost() {
    	return 1.9;
    }
}

// 첨가물
public class Mocha extends CondimentalDecorator {
	public Mocha(Beverage beverage) {
    	this.beverage = beverage;
    }
    
    public String getDescription() {
    	return beverage.getDescription() + ", 모카";
    }
    
    public double cost() {
    	return beverage.cost() + .20;
    }
}


Beverage beverage = new DarkRoast();
beverage = new Mocha(beverage);
beverage = new Whip(beverage);

또 다른 예시 - Java IO

InputStream : 추상 구성 요소
- FileInputStream (바이트까지는 데코레이터에 감싸이는 구상 구성 요소)
- StringBufferInputStream
- ByteArrayInputStream
- FileInputStream (추상 데코레이터)
  - BufferedInputStream (구상 데코레이터들)
  - DataInputStream

기타 주의점

데코레이터를 끼워 넣어도 클라이언트가 데코레이터를 사용하고 있음을 모른다는 것이 장점이다.
- 따라서 특정 형식에 의존하는 코드에 데코레이터 그냥 적용하면 이 장점을 살릴 수 없음
구성 요소 인스턴스를 꽤 많은 데코레이터로 감싸야 하는 경우가 있음
잡다한 클래스가 너무 많아질 수도 있음

Observer Pattern

Bubbles — Thu, 4 Jan 2024 18:07:55 +0900

Observer Pattern이란 무엇인가?

한 객체의 상태가 바뀌면, 그 객체에 의존하는 모든 객체들에 연락이 가고 자동으로 내용이 갱신되는 방식
주제에서 중요한 데이터 관리 → 주제 데이터 바뀌면 옵저버에게 바뀐 값 / 바뀌었다는 소식이 전해진다.
옵저버 객체들은 주제를 구독하고 있으며(주제 객체에 등록되어 있음), 주제 데이터가 바뀌면 갱신 내용을 전달받는다.
Subject : Observer = 1 : N 관계

public interface Subject {
	public void registerObserver(Observer o);
	public void removeObserver(Observer o);
	public void notifyObservers(); // 모든 옵저버들에게 변경내용을 알리려 호출하는 메소드
}

public interface Observer {
	public void update(float temp, float humidity, float pressure);
} // 기상 정보가 변경되었을 때 옵저버에게 전달되는 상태값들

여기까지는 Subject가 Observer들에게 Push 하는 방식
반대로 Observer들이 Pull 해오는 방식도 있다.

// Subject : 알림 보내기 
public void notifyObservers() {
	for (Observer observer : observers) {
		observer.update();
	} // update 메소드 인자 없이 호출하도록 
}


// Observer : 알림 받기 
public interface Observer {
	public void update();
}

// CurrentConditionsDisplay 클래스라면 업데이트를 아래처럼 구현하면 된다. 
public void update() {
	this.temperature = weatherData.getTemperature();
	this.humidity = weather.getHumidity();
	display();
} // 원하는 데이터만 (온도, 습도) 받아올 수 있다!

활용 방안

애플리케이션에서 달라지는 부분을 찾아내고 달라지는 않는 부분과 분리
- 옵저버 패턴에서 변하는 것은 주제의 상태와 옵저버의 개수, 형식
- 옵저버 패턴에서는 주제를 바꾸지 않고도 주제의 상태에 의존하는 객체를 바꿀 수 있음
- 나중에 바뀔것을 대비해두면 편하게 작업할 수 있다
구현보다 인터페이스에 맞춰서 프로그래밍하자
- 주제는 Subject interfcae, 옵저버는 Observer interface
- Observer 인터페이스를 구현하는 객체들의 등록과 탈퇴를 관리하고, 그런 객체들에 연락 돌림

상속보다는 구성을 활용하자

[ 이모저모 ] ERD 설계(1) - 회원 도메인

Bubbles — Wed, 13 Dec 2023 02:31:58 +0900

최근 새롭게 프로젝트를 시작했다.

지그재그 서비스를 클론코딩한 프로젝트이고, 개인 프로젝트로 백엔드 API 쪽을 구현해보기로 했다.

이번 포스팅에서는 ERD 설계 관련해서 고민하고, 피드백을 받아 수정한 것들에 대해 정리하려 한다.

먼저 구현할 기능들을 User Story 형태로 정리해보면 다음과 같다.

회원은 카카오, 네이버 로그인을 통해 서비스에 회원 가입 및 로그인할 수 있다.
회원은 언제든 서비스 탈퇴가 가능하다.
회원은 4가지의 등급별로 매달 등급 쿠폰을 발급받을 수 있다.
회원은 만료된 쿠폰, 소지하고 있는 쿠폰, 발급 가능한 쿠폰 목록을 확인할 수 있다.
회원은 구매 확정한 주문에 포함한 상품들에 대해 확정 후 30일 이내로 리뷰를 작성할 수 있다.
회원은 작성한 리뷰를 수정할 수 있다.
회원은 작성 가능한 리뷰, 작성한 리뷰, 작성 만료된 리뷰 목록을 확인할 수 있다.
회원은 구매 확정한 주문에 대한 적립금을 받을 수 있으며, 적립금의 사용 기한은 1년이다.
회원은 적립금에 대한 적립, 사용, 만료 내역을 조회할 수 있다.
회원은 상품을 찜하거나 삭제할 수 있다. (위시리스트)
회원은 장바구니에 상품을 저장할 수 있다.
회원은 장바구니에서 선택한 상품들에 대해 주문을 진행할 수 있다.
회원은 주문 시 장바구니와 쿠폰, 프로모션 등을 적용할 수 있다.
회원은 하나의 주문을 일괄로 취소할 수 있다. (부분취소 불가)
회원, 비회원은 판매량에 따른 쇼핑몰 랭킹을 매일 확인할 수 있다.
회원, 비회원은 프로모션 중인 쇼핑몰 목록을 확인할 수 있다.
회원, 비회원은 하나의 쇼핑몰의 모든 상품 목록을 확인할 수 있다.
회원, 비회원은 쇼핑몰 또는 상품 이름, 태그로 검색이 가능하다.

크게 도메인은 회원, 스토어, 주문 3가지 정도로 구분할 수 있다.

회원 도메인 : 회원, 리뷰, 위시, 즐겨찾기 관련 테이블

스토어 도메인 : 프로모션, 쇼핑몰, 상품 관련 테이블

주문 도메인 : 장바구니, 주문 관련 테이블

설계한 전체 ERD는 아래와 같다.

개발하면서 조금씩 바뀔수도 있겠지만, 일단은 아래처럼 확정하였다.

회원 도메인에서 고민했던 것들은 2가지 정도였다.

1. 적립금 관련해서 이력들을 다 보여줘야 하는데, 적립금 총액을 회원 테이블에 가지고 있어야 하는가?

2. 찜과 장바구니, 2가지를 합칠 수 있을까?

✅ 회원 테이블에 적립금 총액 Column을 만들자.

처음에는 적립금 총액(reserve_sum) 칼럼을 회원 테이블에 만들어두지 않았다.
정규화를 생각해서 분리해두고, 그때 그때 계산해야지라는 ... 생각을 했었다.
하지만, 아래와 같은 질문을 생각해보자.

한 회원이 매일매일 만 건 씩 주문하면 어떻게 될까요?
유효기간이 1년이면, 몇 건이 저장될까요?
그렇다면 데이터를 계산할 때 연산이 얼마가 들까요?

위 상황을 가정하면 360만건이다. 아주 극단적인 예시지만, 유저 여럿이 있다고 생각해보면 충분히 가능한 데이터 양이다.
그럼 이 상황에서 특정 회원의 사용 가능한 적립금 총액을 계산하려면 어떻게 할까?

GROUP BY 연산

우선 데이터베이스 자체에 Native Query 날려서 status 별로 분리한 후 계산하여 가져오는 방식
데이터 자체가 몇 백만건이므로 굉장히 느릴 것
데이터베이스 자체에 부하를 주는 것이므로 ! 다른 기능들도 영향을 받을 수 있다.

Application 단에서 연산하기

userIdx로 가져온 360만건의 데이터를 그냥 어플리케이션 단으로 올려준다.
데이터베이스 자체에서 연산하진 않으므로 데이터베이스 쪽은 괜찮을지도 모른다.
하지만 이 방식 또한 JVM 메모리를 생각해보면 불가능하다는 것을 알 수 있다.
- JVM의 Heap 사이즈는 전체 메모리의 1/64가 기본이고, 메모리의 1/4까지 늘어날 수 있다.
  - Initial heap size of 1/64 of physical memory
  - Maximum heap size of 1/4 of physical memory (oracle docs)
- 주로 운영환경에서는, JVM의 메모리 최소 최대 크기를 동일하게 맞춰둔다.
  - 유동적으로 조절하게 되면, 나중에 JVM이 추가 메모리 요청했을 때 Native 영역에서 못 준다고 하면?
    - 바로 Out Of Memory 에러 내면서 프로그램이 죽는다.
  - 이 사이즈만큼 메모리 확보해두고, 이 안에서 최대한 버티면서 GC로 메모리를 확보한다.
위 2가지를 생각해보면, 제한된 Heap 내에서 GC로 최대한 버티면서 사용하는 것이 메모리 전략이다.
- 그런데, 데이터 360만건을 메모리에서 처리한다?
- 이 데이터 자체가 커서 메모리를 많이 잡아먹으므로, GC가 빈번하게 일어난다.
  - (360만건의 데이터들은 우리가 계산해야 할, reachable 객체이므로 GC 대상이 아니다. 따라서 다른 곳에서 메모리를 확보해야 한다.)
- 최악의 경우, GC를 계속해도 메모리 확보가 되지 못해서 Out Of Memory 낼 위험도 있다.

그렇다면, 적립금 계산이 바뀔 때에도, 회원 정보가 바뀔 때에도
같은 회원 테이블에 접근해야 하지 않나요?

이 경우에는 어플리케이션 단에서 좀 완화할 수 있는 방법이 있을 것 같다.

트랜잭션 전파 - REQUIRES_NEW 를 사용 : 적립금 / 회원 정보 이 2가지 관심사를 분리할 수 있다.
메서드 단에서 로직 분리 처리 등등...!

✅ 찜과 장바구니는 분리하자.

처음에 찜과 장바구니는 모두 쇼핑몰 + 상품 식별자로 굉장히 단순하게 생각하고 찜이냐 장바구니냐를 구분했었다.

하지만 도메인 측면에서도 찜은 사용자와 더 가깝고, 장바구니는 주문 도메인과 더 가깝다.

또한 장바구니는 상품 옵션과 수량이라는 정보까지 가지고 있어야 하는데에 반해, 찜은 그냥 해당 상품 자체에 누른다. (지그재그 기준)

그렇기 때문에 2가지 테이블은 분리해야 한다.

어찌보면 당연한건데 처음에 둘이 비슷해서 그냥 합쳐두는게 편하지 않나? 라고 단순하게 생각했었다...;;

프로그래머스 - 단속카메라, 백준 13549, 5427

Bubbles — Fri, 10 Nov 2023 02:28:18 +0900

프로그래머스 : 단속카메라

https://school.programmers.co.kr/learn/courses/30/lessons/42884

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

그리디 알고리즘 문제

진입 / 진출 지점에서 만난 것도 만난 것으로 인정하므로 구간 끝에 카메라를 설치한다고 생각하면 된다.

여기서 진입 지점으로 정렬할지 진출 지점으로 정렬할지 헷갈렸는데 진출 시점으로 정렬해야 한다. 첫 구간이 아주 길다면 내부 구간이 다 무시되기 때문이다.

그림 설명

전체코드

참고로 pivot은 이 구간의 최솟값이 -30000이라 -30001로 초기화하였다.

import java.util.*;
class Solution {
    public int solution(int[][] routes) {
        PriorityQueue<Route> queue = new PriorityQueue<>((o1, o2) -> o1.end - o2.end);
        
        for (int[] route : routes) {
            queue.add(new Route(route[0], route[1]));
        }
        
        int answer = 0;
        int pivot = -30001;
        while (!queue.isEmpty()) {
            Route route = queue.poll();
            if (route.start > pivot) {
                pivot = route.end;
                answer++;
            }
        }
        return answer;
    }
    
    class Route {
        int start;
        int end;
        Route(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }
}

백준 13549 : 숨바꼭질 3

https://www.acmicpc.net/problem/13549

13549번: 숨바꼭질 3

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때

www.acmicpc.net

BFS 알고리즘 문제

수빈 위치와 동생 위치가 같다면 바로 0 출력해주고 끝난다.

방문 배열에 방문 처리 하고, 최단 시간 찾는 것이므로 BFS로 풀면 된다.

순간이동 한 경우 / 걸은 경우 시간은 다르게 표현해줘야 하며, 배열의 인덱스를 넘어가지 않도록 if 조건 분기만 잘 나누어주면 어렵지 않게 풀 수 있다

전체코드

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class p13549 {
    public static void main(String[] args) {
        int[] arr = new int[100001];
        boolean[] visited = new boolean[100001];
        Scanner sc = new Scanner(System.in);
        Queue<Integer> queue = new LinkedList<>();

        int n = sc.nextInt();
        int k = sc.nextInt();
        queue.add(n);
        visited[n] = true;
        arr[n] = 1;
        if (n == k) {
            System.out.println(0);
            return;
        }

        while (!queue.isEmpty()) {
            int poll = queue.poll();
            if (poll == k) {
                System.out.println(arr[poll] -1);
                break;
            }

            if (poll <= 50000 && !visited[poll*2]) {
                arr[poll*2] = arr[poll];
                visited[poll*2] = true;
                queue.add(poll*2);
            }
            if (poll > 0 && !visited[poll-1]) {
                arr[poll-1] = arr[poll] + 1;
                visited[poll-1] = true;
                queue.add(poll-1);
            }
            if (poll < 100000 && !visited[poll+1]) {
                arr[poll+1] = arr[poll] + 1;
                visited[poll+1] = true;
                queue.add(poll+1);
            }

        }
    }
}

백준 5427 : 불

https://www.acmicpc.net/problem/5427

5427번: 불

상근이는 빈 공간과 벽으로 이루어진 건물에 갇혀있다. 건물의 일부에는 불이 났고, 상근이는 출구를 향해 뛰고 있다. 매 초마다, 불은 동서남북 방향으로 인접한 빈 공간으로 퍼져나간다. 벽에

www.acmicpc.net

백준 4179번 - 불! 과 느낌표 하나 차이로 다른 문제가 있어서 풀어봤다.

동일하게 BFS 문제이다.

불이 아예 없는 경우(fires.isEmpty())인 경우 불 BFS 돌리지 않도록 하기

불이 있어도 불 자체가 벽으로 둘러쌓여서 못 퍼지는 경우 있을 수도 있다. 이 경우 visitied 값이 0이라 탈출 못한걸로 판정나는 실수가 있었는데, 그래서 마지막 정답 비교조건에서 불길이 아예 닿지 않았거나, 나의 도착시간이 불보다 빠른 경우에 정답을 갱신하도록 만들었다.

이 2가지 예외처리만 잘 해준다면 이전에 풀었던 문제와 유사한 문제였다.

전체코드

import java.io.*;
import java.util.*;
public class p5427 {
    private static char[][] map;
    private static int[][] visited;
    private static int[] dirX = { 0, 0, 1, -1 }; // 동서남북
    private static int[] dirY = { 1, -1, 0, 0 };
    private static int row, col;
    private static Pos me;
    private static List<Pos> fires;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            col = Integer.parseInt(st.nextToken());
            row = Integer.parseInt(st.nextToken());

            map = new char[row][col];
            visited = new int[row][col];
            fires = new ArrayList<>();

            for (int j = 0; j < row; j++) {
                String line = br.readLine();
                for (int k = 0; k < col; k++) {
                    map[j][k] = line.charAt(k);
                    if (map[j][k] == '@') {
                        me = new Pos(j, k);
                    }
                    else if (map[j][k] == '*') {
                        fires.add(new Pos(j, k));
                    }
                }
            }

            int answer = BFS();
            if (answer == Integer.MAX_VALUE) {
                System.out.println("IMPOSSIBLE");
            } else {
                System.out.println(answer);
            }
        }

    }


    private static int BFS() {
        int answer = Integer.MAX_VALUE;
        Map<Pos, Integer> time = new HashMap<>();
        Queue<Pos> queue = new LinkedList<>();

        queue.add(me);
        visited[me.x][me.y] = 1;
        while (!queue.isEmpty()) {
            Pos poll = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nextX = poll.x + dirX[i];
                int nextY = poll.y + dirY[i];

                if (nextX < 0|| nextX >= row || nextY < 0 || nextY >= col) {
                    time.put(new Pos(poll.x, poll.y), visited[poll.x][poll.y]);
                    continue;
                }

                if (map[nextX][nextY] != '.') {
                    continue;
                }

                if (visited[nextX][nextY] != 0) {
                    continue;
                }

                queue.add(new Pos(nextX, nextY));
                visited[nextX][nextY] = visited[poll.x][poll.y] + 1;
            }
        }

        if (fires.isEmpty()) {
            for (Integer i : time.values()) {
                answer = Math.min(answer, i);
            }
            return answer;
        }

        // 불 퍼트리기
        queue = new LinkedList<>();
        visited = new int[row][col];
        queue.addAll(fires);
        for (Pos p : fires) {
            visited[p.x][p.y] = 1;
        }


        while (!queue.isEmpty()) {
            Pos poll = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nextX = poll.x + dirX[i];
                int nextY = poll.y + dirY[i];

                if (nextX < 0 || nextX >= row || nextY < 0 || nextY >= col) {
                    continue;
                }

                if (map[nextX][nextY] == '#') {
                    continue;
                }

                if (visited[nextX][nextY] != 0) {
                    continue;
                }

                queue.add(new Pos(nextX, nextY));
                visited[nextX][nextY] = visited[poll.x][poll.y] + 1;
            }
        }

        for (Pos pos : time.keySet()) {
            if (visited[pos.x][pos.y] == 0 || time.get(pos) < visited[pos.x][pos.y]) {
                answer = Math.min(answer, time.get(pos));
            }
        }


        return answer;
    }

    private static class Pos {
        int x;
        int y;

        public Pos (int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

CS - Java & Spring 정리

Bubbles — Thu, 9 Nov 2023 02:30:25 +0900

Java 문법 & 특징

자바는 인터프리터 언어인가요? 컴파일 언어인가요?

자바는 2가지 방식을 모두 혼합하여 사용합니다. 자바 컴파일러가 .java 파일을 컴파일을 통해 .class파일을 만들고, JVM의 실행 엔진의 인터프리터가 각 운영체제에 맞게 이진 코드로 변환 후 실행합니다.

자바 프로그램의 수행 과정에 대해 말씀해주세요.

자바 소스 코드를 프로그래머가 작성(.java) → 자바 컴파일러가 바이트 코드로 변환 (.class) → JVM 클래스로더로 전달, 클래스 로더가 JVM의 Runtime Data Area(JVM이 OS로부터 할당받는 메모리영역)에 올린다. → 실행 엔진이 바이트 코드들을 명령어 단위로 하나씩 가져와서 실행합니다.

Java의 String 클래스에서 equals()와 == 차이가 무엇인가요?

equals()는 참조 변수의 값이 같은지 비교하는 메소드로, 재정의 되어있지 않다면 객체의 주소값을 비교하여 동일 객체인지 비교후 boolean 값을 리턴하는 메소드입니다.
== 연산자는 primitive type일 경우 값을, 그 외에는 주소값을 비교하는 연산자입니다.
String 클래스에 equals를 사용할 경우에는 주소값이 아닌 데이터 값을 비교하여 동일 여부를 판정합니다.
==을 사용하는 경우, 같은 문자열을 가지고 있어도 객체끼리 주소가 다르기 때문에 다르다고 판정합니다.
만약 String a = "hello" String b = "hello" 이런식으로 문자열로 생성할 경우 a를 생성할 때 String constant pool에 먼저 hello를 저장해둬서, b를 생성할 때 기존에 있는 hello를 참조하는 방식으로 생성하므로 이 경우엔 == 연산의 결과가 true이다.

equals() 함수만 오버라이딩하고 hashCode()는 오버라이딩 하지 않으면 어떤 문제가 발생할까요?

equals()는 객체의 주소값을 비교하여 동일 객체인지 비교후 boolean 값을 리턴하는 메소드입니다.
hashCode()는 객체의 주소값을 이용하여 해싱 기법을 적용한 결과값을 리턴하는 메소드입니다.
자바의 해시 컬렉션은 동일 객체인지 판정할 때 hashCode() 값이 같은지 먼저 확인하고 같다면 equals()함수를 호출하여 같은지 총 2번의 확인 작업을 거칩니다. equals()만 오버라이딩할 경우, hashCode() 값이 달라 다른 객체로 판단되어 동일하다고 의도했던 두 객체가 모두 추가되는 등 원치 않은 방향으로 동작할 수 있습니다.

Java는 매개변수를 call by value로 전달하나요 call by reference로 전달하나요?

Call by value는 메소드의 매개변수로 값을 넘길때 원래 값은 놔두고, 새롭게 값을 복제하여 넘기는 방식입니다.
Call by reference는 매개변수로 넘어온 값의 참조 자체를 넘기는 방식입니다.
자바의 참조형때문에 call by reference라고 생각하기 쉽지만, 주소 값을 전달하는 방식입니다.
참조 자체를 넘긴다면 new로 할당을 했을 때 methodA의 원래 값도 new로 할당한 값으로 변화해야 하지만, 자바는 그렇지 않기 때문입니다. (포인터처럼 메모리에 직접 new 할당하면 해당 객체 쓰는 메소드들 다 영향 받음)

Overloading과 Overriding의 차이점이 무엇인가요?

오버로딩은 하나의 메소드 명에, 반환타입과 파라미터의 개수나 타입 등을 다르게 해서 함수를 중복 정의 하는 것이다.
오버라이딩은 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재 정의하는 것이다. 부모 클래스의 메소드를 호출해도 실제 타입이 자식 클래스이면 자식 클래스의 메소드가 호출된다.

인터페이스와 추상 클래스의 차이점이 무엇인가요?

추상 클래스는 abstract로 선언되어 있거나 추상 메소드가 하나 이상 포함된 클래스를 의미합니다.

인터페이스는 추상 메소드와 public 정적 상수들만 가지는 구조를 의미합니다.

추상클래스는 다중 상속이 불가능하고 인터페이스는 다중 상속(구현)이 가능합니다.

다수의 인터페이스를 구현하는 것은 가능한데, 여러 개의 클래스를 상속은 불가능한 이유가 무엇일까요?

다이아몬드 문제
- 하나의 클래스가 같은 메소드 이름을 가진 복수의 상위 클래스를 상속받는다면, 해당 클래스는 어느 메소드를 상속받은 것인지 모호해진다.
- EX) 물고기 클래스와 사람 클래스 2가지를 상속받은 인어 클래스의 swim 메소드는 물고기처럼 수영할까 사람처럼 수영할까?
인터페이스의 경우 구현해야할 행위 자체만을 나타낸 추상 메서드로 이루어져 있으므로, 중간에 구현체가 끼지 않아 다중 구현이 허용된다.

Java의 Thread는 어째서 사용하고, Runnable 인터페이스를 구현하는 방식과 Thread 클래스를 상속받는 방식 중, 어떤 방식으로 구현하는 것이 좋을까요?

프로세스 내에서 동시에 여러 작업을 수행하기 위해 스레드를 사용합니다.
자바 언어에서는 다중 상속이 지원되지 않으므로, 다른 클래스를 상속받을 가능성을 생각하여 Runnable 인터페이스를 구현하는 방식으로 사용하는 것이 좀 더 권장됩니다.

Arrays.asList() 함수로 생성한 리스트는 어떤 특징을 가지나요?

remove, add 메소드를 제공하지 않아 엘리먼트를 추가하거나 삭제하는 등의 작업이 불가합니다.(실행 시 unsupportedOperationException 발생)

사이즈를 변경할 수 없고 값만 꺼낼 수 있습니다.

함수형 인터페이스는 왜 필요할까요?

람다식은 익명 함수(객체)여서 함수를 부를 이름이 없으므로 람다식으로 만든 객체에 접근하기 위해 1개의 추상 메소드만를 가지고 있는 함수형 인터페이스를 사용합니다.

stream을 사용함으로서 얻는 장점이 무엇인가요?

Java 8의 stream은 함수형 프로그램의 특징들을 대입하여, 기존의 Collection을 다루는 방법보다 간결하고 가독성이 좋도록 개선되었습니다. Lambda 구문을 사용하여 for문, if문 등을 사용하지 않아 더욱 직관적인 코드 작성에 편리하다.

원본 데이터를 바꾸지는 않으며, 재사용 불가하므로 stream 연산 결과를 컬렉션으로 반환하여 사용해야 합니다.

Error와 Checked Exception, Unchecked Exception의 차이가 무엇인가요?

먼저 프로그램 외부에서 발생하여 프로그램이 멈추는 것은 Error입니다.

프로그램 내부에서 발생하고, 스레드에만 영향을 주어 프로그램 자체는 계속 실행 가능한 것은 Exception입니다.

Exception에는 checked, unchecked 2가지 종류가 있습니다.

Runtime Exception 이라고도 하는 Unchecked Exception은 컴파일 시 체크하지 않으며 예외처리를 강제하지 않는, 실행 중 발생가능한 예외를 의미합니다. ArrayIndexOutOfBounds, NullPointerException 등이 있습니다.

Checked Exception은 Exception 클래스의 하위 클래스 중 Runtime Exception을 제외한 나머지로, 컴파일러가 예외처리를 확인하여 반드시 예외처리가 되어야 하는 예외를 의미합니다. IOException 등이 있습니다.

Java의 Access Modifier 에 대해서 설명해주세요.

접근 제어자는 변수, 메소드의 접근 범위를 설정해주기 위해 사용하는 예약어입니다.

public, protected(동일패키지, 외부라도 상속받았다면 ok), default(동일패키지), private(해당 클래스 내)이 있습니다.

Junit에 대해 설명해주세요.

Junit은 자바 언어의 단위 테스트 프레임워크입니다. 단위 테스트는 프로그램의 개별 코드 조각들이 의도대로 작동하는지 검증하는 테스트입니다. 단위 테스트를 작성하고 실행하기 위한 도구로 사용됩니다.

Object 클래스에 대해 설명해주세요.

자바 모든 클래스의 최상위 클래스로 모든 클래스가 상속하게 되는 기본 클래스입니다. 아무런 클래스도 상속하지 않는 클래스더라도 Java 컴파일러가 자동으로 extends Object 코드를 넣어줍니다. Object 클래스에는 equals, hashCode, toString 등 객체들이 공통적으로 가지는 메소드들이 정의되어 있습니다.

객체 지향 프로그래밍에서의 메소드 호출과 관련된 2가지 다른 바인딩 방식에 대해 설명해주세요.

정적 바인딩

컴파일 시 변수 / 참조 타입을 기반으로 어떤 메소드 호출되어 실행해야 하는지 결정. 오버로딩된 메소드들의 호출에서 주로 발생합니다.

동적 바인딩

실행 시간에 메소드 호출과 실제 실행될 메소드를 결정하는 것으로, 객체 실제 타입을 확인하고 해당 객체에 맞는 메소드를 호출합니다.

직렬화에 대해 설명해주세요.

사용하고 있는 데이터를 파일 저장 혹은 데이터 통신에서 파싱할 수 있는 유의미한 데이터를 만들기 위해 사용하는 기술로, 자바 시스템 내부에서 사용되는 객체 또는 데이터를 외부의 자바 시스템에서도 사용할 수 있도록 바이트(byte) 형태로 데이터 변환하는 기술입니다.

컬렉션 클래스에서 Generic을 사용하는 이유가 무엇인가요?

컬렉션 클래스에 저장되는 인스턴스 타입을 제한하여 런타임에 발생할 수 있는 잠재적인 모든 예외를 컴파일 타임에 잡아 낼 수 있어서 사용합니다.

JVM 관련 질문

Major GC와 Minor GC 차이점이 무엇인가요?

Minor GC
- Young 영역에서 일어나는 Garbage Collection으로, 속도가 빠르고 Eden, Survivor영역에 속한 젊은 객체들에 대한 Garbage Collection을 의미합니다.
Major GC
- Old 영역에서 일어나는 Garbage Collection으로, Minor GC에 비해 속도가 느리고 Old 영역에 속한 오래된 객체들에 대한 Garbage Collection을 의미합니다.

자바의 메모리 영역은 어떻게 구성되어 있나요?

메소드(Method) 영역 : 전역변수와 static 변수를 저장, 프로그램의 시작부터 종료까지 남아있습니다.
스택(Stack) 영역 : 지역변수와 매개변수 데이터 값이 저장, 메소드 호출 시 메모리에 할당되고 종료되면 메모리가 해제된다.
힙(Heap) 영역 : 객체, 배열 등이 저장, 가비지 컬렉터에 의해 관리되어 진다.

Reflection이란 무엇인가요?

실행 시간에 JVM의 메모리 영역에 저장된 클래스 정보들을 읽어서 활용하는 기술로 라이브러리나 프레임워크에서 활용하는 기술입니다.

Spring 관련 질문

Spring과 Spring Boot의 차이점이 무엇인가요?

Spring은 프레임워크로, 개발자가 직접 설정파일 작성을 통해 컨테이너 구성, 빈 객체 등록, 의존성 설정 등을 수동으로 해줘야 했습니다.
Spring Boot는 Spring에서 제공하는 여러 기능들을 자동으로 설정하여 Spring을 쉽게 사용하도록 만든 도구입니다. 프로젝트의 설정, 라이브러리 의존성 관리 등 다양한 기능들을 제공하여 편리하다는 장점이 있습니다.
Spring Boot는 내장 톰캣 서버를 사용하여 따로 톰캣을 설치할 필요가 없고, starter를 통해 dependency를 자동화하며(버전관리 자동화), jar file을 이용해 자바 옵션만으로 손쉽게 배포가 가능하다는 차이가 있습니다.

DTO를 사용하는 이유가 무엇인가요?

양방향 참조 시의 순환 참조를 예방하고, entity 내부를 캡슐화하며 계층 간 역할을 분리하기 위해서입니다.

Bean Scope 종류는 어떤 것이 있나요?

Bean Scope란 문자 그대로 빈이 존재할 수 있는 범위를 의미하며, 스프링 빈은 기본적으로 싱글톤 스코프로 관리되어 스프링 컨테이너의 시작과 함께 생성, 컨테이너 종료될 때까지 유지됩니다.
싱글톤 스코프 외에 스프링 컨테이너가 빈 생성에서 의존관계 주입까지만 관여하는 프로토타입 스코프, 웹 어플리케이션 환경에서 사용하는 웹 스코프인 request, session, application 스코프가 있습니다.

Spring Bean 라이프사이클에 대해 간단히 설명해주세요.

스프링 컨테이너가 생성되고, 컨테이너에 의해 빈이 생성됩니다. 빈이 생성되면 의존관계가 주입되고, 초기화 콜백을 통해 의존관계 주입 완료를 알립니다. 그 후 빈을 사용하고, 빈 스코프에 따라 소멸 시 소멸전 콜백이 일어나고 (싱글톤이라면 스프링 컨테이너 종료 전 등) 스프링이 종료됩니다.

Spring이 Request를 처리하는 과정에 대해 설명해주세요.

Client 요청을 Dispatcher Servlet이 받음
Handler Mapping이 요청 정보를 통해 요청을 위임할 Controller 찾는다.
요청을 Controller로 위임할 Handler Adpater를 찾아 전달, 해당 Controller로 요청을 위임
요청에 맞게 비즈니스 로직을 처리 후 Controller 가 반환값을 반환
Handler Adapter가 반환값을 반환
최종적으로 Dispatcher Servlet이 클라이언트에게 서버의 응답 반환

Spring에서 멤버 변수를 주입받는 방법 3가지에 대해 각각 설명해주세요.

생성자 주입, 필드 주입, 수정자 주입 총 3가지가 있습니다.

필드 주입, 수정자 주입은 빈을 모두 생성한 이후 해당하는 필드나 setter 메소드를 찾아서 주입하는 방식이고, 생성자 주입은 빈을 생성하는 시점에 주입을 같이 하는 방식입니다.
생성자 주입이 권장되는데, 모든 빈을 생성하지 않아도 되어 단위 테스트가 다른 방식보다 편하고, 필드에 final 키워드를 선언하여 변경불가능하게 사용할 수 있습니다.

Spring의 IOC와 DI의 정의에 대해 간단히 설명해주세요

IOC(제어의 역전) : 프로그램의 제어 흐름을 직접 제어하는 것이 아니라 외부에서 관리하는 것
DI(의존성 주입) : 필요한 객체를 직접 생성하는 것이 아닌 외부로부터 객체를 받아서 사용하는 것

Spring Filter와 Interceptor와 사용하는 예시를 설명해주세요.

Filter

요청과 응답을 정제하는 역할로, 스프링 컨테이너가 아닌 톰캣과 같은 웹 컨테이너에 의해 관리되며 스프링 범위 밖에서 처리됩니다.
Dispatcher Servlet에 요청이 전달되기 전/후에 사용합니다.
보안, 인증 / 인가 작업, 요청에 대한 일괄적인 로깅 또는 검사, 이미지/데이터 압축 및 문자열 인코딩, Spring과 분리되어야 하는 기능

Interceptor

Dispatcher Servlet이 Controller를 호출하기 전 / 후에 인터셉터가 끼어들어 요청과 응답을 참조하거나 가공할 수 있으며, Spring Context 내에서 동작합니다.
세부적인 보안 및 인증/인가 작업, API 호출에 대한 로깅 또는 검사, Controller 데이터 가공

Controller로 들어오는 입력값을 검증하는 방법은 어떤 것들이 있나요?

DTO 를 검사할때는 validation 패키지의 @NotNull, @NotEmpty, @Min, @Max 등을 활용할 수 있습니다.

Controller단에서는 BindingResult 객체를 활용하여 서비스 단에서 직접 클라이언트에게 예외가 발생하였음을 알리거나, @ControllerAdvice를 이용한 전역 에러 핸들링을 활용하는 방법도 존재합니다.

@Pathvariable, @RequestParam, @RequestBody, @ModelAttribute 의 차이가 무엇인가요?

@PathVariable : 값을 하나만 받아올 수 있으며 보통 id 값을 전송할때 주로 사용
@RequestParam : param 형식으로 간단한 데이터를 전송할때 주로 사용
@RequestBody : Json 형식으로 데이터를 전송할때 주로 사용
@ModelAttribute : 폼 / MultipartFile 형식에 주로 사용

Spring에서 Dependency Injection을 IoC Container가 하는 일을 중심으로 설명해주세요

IoC Container는 Inversion of Control의 약자로, 개발자가 Spring Bean의 관리를 하지 않고 Framework가 주도적으로 관리하도록 역전시킨것이다. 따라서 IoC Container가 Spring Bean의 의존성 주입을 관리하게 되고, 개발자가 @AutoWired 등의 방법으로 설계해놓은 것을 실행한다.

Spring Bean은 언제 어떻게 생성되게 될까요?

Spring Application의 메인 메소드에서 static 메소드인 run() 메소드를 찾아 실행시킨다. run 메소드는 application context를 생성하고, @ComponentScan 때문에 @Component, @Bean 등 Bean으로 만드는 어노테이션을 찾아 Spring Bean으로 생성한 뒤, IoC 에 저장한다.

한 클래스에 대해서 Bean 생성을 여러개 하고 싶으면 어떻게 하면 될까요?

@Scope 어노테이션을 통해 Bean Scope를 session, prototype등 세션이나 요청마다 생성하는 스코프로 변경해줍니다.

Spring에서 테스트 시, @Mock 과 같은 가짜 객체를 만들어서 테스트하는 이유가 무엇인가요?

테스트는 통합 테스트 외 단위 테스트를 실행할 때, Spring 컨테이너를 띄우지 않고 테스트 하고자 하는 영역 외 나머지들은 가짜 객체로 생성하여 테스트하려는 부분만 집중적으로 보기 위해서입니다.

백준 11501, 2169, 프로그래머스 체육복

Bubbles — Tue, 7 Nov 2023 18:21:13 +0900

백준 11501 : 주식

https://www.acmicpc.net/problem/11501

11501번: 주식

입력의 첫 줄에는 테스트케이스 수를 나타내는 자연수 T가 주어진다. 각 테스트케이스 별로 첫 줄에는 날의 수를 나타내는 자연수 N(2 ≤ N ≤ 1,000,000)이 주어지고, 둘째 줄에는 날 별 주가를 나타

www.acmicpc.net

메인 로직

각 날짜의 주식가격을 배열에 쭉 저장해둔다.
그리디 유형의 문제긴 하지만, 무조건 높을때 다 팔고 끝나는것이 아니라 마지막날에도 이전보다 올랐다면 팔 수 있다.
뒤에서부터 차례로 돌면서 현재 내가 가진 최댓값보다 높은 가격이 나왔다 = 그날 기점으로 가격이 떨어졌다 이것이므로 최댓값을 갱신해준다.
그 외에는 최댓값보다 낮은 날이므로 무조건 사뒀다가 파는게 이득이라 answer에 더해준다.

메인 로직을 코드화하면 아래와 같다.

int temp = price[days-1];
for (int d = days-2; d >= 0; d--) {
	if (temp < price[d]) {
		temp = price[d]; // 최댓값 갱신해준다. 
	} else {
		answer += (temp - price[d]); // 더 낮은값일때는 계속 사놓는 것이 이득
	}
}

전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class p11501 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        for (int i = 0; i < n; i++) {
            int days = Integer.parseInt(br.readLine());
            int[] price = new int[days];
            int answer = 0;
            StringTokenizer st = new StringTokenizer(br.readLine());

            for (int d = 0; d < days; d++) {
                price[d] = Integer.parseInt(st.nextToken());
            }

            int temp = price[days-1];
            for (int d = days-2; d >= 0; d--) {
                if (temp < price[d]) {
                    temp = price[d];
                } else {
                    answer += (temp - price[d]);
                }
            }

            System.out.println(answer);

        }

    }
}

백준 2169 : 로봇 조종하기

https://www.acmicpc.net/problem/2169

2169번: 로봇 조종하기

첫째 줄에 N, M(1≤N, M≤1,000)이 주어진다. 다음 N개의 줄에는 M개의 수로 배열이 주어진다. 배열의 각 수는 절댓값이 100을 넘지 않는 정수이다. 이 값은 그 지역의 가치를 나타낸다.

www.acmicpc.net

문제 유형 찾기 : DP

문제 조건을 보면 이러한 말들이 있다.
- 한 번 탐사한 지역(배열에서 하나의 칸)은 탐사하지 않기로 한다.
- 탐사한 지역들의 가치의 합이 최대가 되도록 하는 프로그램을 작성하시오.
처음에는 2차원 배열, 3방향으로 움직일 수 있다는 조건을 보고 BFS를 생각했는데, BFS는 최단거리 찾는것이므로 가치의 합이 최대가 되는 것이라면..하고 DFS를 생각했었다.
하지만 제한시간이 1초이고 n,m이 1000까지 갈 수 있으므로 동적계획법으로 푸는 건가? 라는 생각을 했다. (위의 조건을 보고 / 그리고 실제로 DP문제였다. )

메인 로직

이동 가능한 방향은 좌, 우, 하 이렇게 3가지이고, DP[ i ][ j ]에서 위, 오른쪽, 왼쪽을 다 비교해보고 Max를 찾아야 한다.
위로 돌아가는 것은 불가능하므로, 무조건 DP 2차원 배열의 맨 윗줄은 map에서 가져와야 한다.

DP[0][0] = map[0][0];
for (int j = 1; j < col; j++) {
	DP[0][j] = DP[0][j-1] + map[0][j];
}

각 칸 별로 왼쪽에서 탐색해서 오는 경우와 오른쪽에서 탐색해서 오는 경우 중 더 큰 걸 찾아야 한다.

// 왼쪽에서 출발
left[0] = DP[i-1][0] + map[i][0];
for (int j = 1; j < col; j++) {
	left[j] = Math.max(DP[i-1][j], left[j-1]) + map[i][j];
}

// 오른쪽에서 출발
right[col-1] = DP[i-1][col-1] + map[i][col-1];
for (int j = col-2; j >= 0; j--) {
	right[j] = Math.max(DP[i-1][j], right[j+1]) + map[i][j];
}

왼쪽 오른쪽 다 탐색 후 MAX로 갱신해준다.

for (int j = 0; j < col; j++) {
	DP[i][j] = Math.max(left[j], right[j]);
}

전체코드

import java.util.*;
import java.io.*;
public class p2169 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int row = Integer.parseInt(st.nextToken());
        int col = Integer.parseInt(st.nextToken());

        int[][] map = new int[row][col];
        int[][] DP = new int[row][col];

        for (int i = 0; i < row; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < col; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        DP[0][0] = map[0][0];
        for (int j = 1; j < col; j++) {
            DP[0][j] = DP[0][j-1] + map[0][j];
        }

        for (int i = 1; i < row; i++) {
            int[] left = new int[col];
            int[] right = new int[col];

            // 왼쪽에서 출발
            left[0] = DP[i-1][0] + map[i][0];
            for (int j = 1; j < col; j++) {
                left[j] = Math.max(DP[i-1][j], left[j-1]) + map[i][j];
            }

            // 오른쪽에서 출발
            right[col-1] = DP[i-1][col-1] + map[i][col-1];
            for (int j = col-2; j >= 0; j--) {
                right[j] = Math.max(DP[i-1][j], right[j+1]) + map[i][j];
            }
            for (int j = 0; j < col; j++) {
                DP[i][j] = Math.max(left[j], right[j]);
            }
        }

        System.out.println(DP[row-1][col-1]);
    }


}

⛹ ‍♀️ 프로그래머스 : 체육복

https://school.programmers.co.kr/learn/courses/30/lessons/42862

프로그래머스

programmers.co.kr

⛹ ‍♀️ 메인로직

먼저 모든 학생들이 참석할 수 있다고 가정하고 answer을 초기화 시킨 다음, 참석 불가능한 애들만 빼주면 된다.
set에다가 여벌을 가지고 온 학생들 번호를 넣는다.
문제 조건에 따르면, 여벌 가지고 온 애들이 도난당한 경우 여벌을 빌려줄 수 없다. 그러므로 먼저 이 경우를 반복문을 돌린다.
- reserve 배열 탐색하면서 set과 동일한 애가 있는 경우가 위의 예시이므로, set에서 제거해준 후 list에 넣지 않는다.
list는 중복을 제거한, 진짜 잃어버린 애들을 담는 리스트이며, 번호 순대로 정렬해준다.(체격 순으로 번호가 매겨지니까)
그 후 set에서 자기 앞뒤 사이즈의 여벌이 있는지 확인하고, 없다면 answer--해준다.

⛹ ‍♀️ 전체코드

import java.util.*;
class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        int answer = n;
        Set<Integer> set = new HashSet<>();
        List<Integer> list = new ArrayList<>();
        for (int i : reserve) {
            set.add(i);
        }
        for (int i : lost) {
            if (set.contains(i)) {
                set.remove(i);
            } else {
                list.add(i);
            }
        }
        Collections.sort(list);
        
        for (int i : list) {
            if (set.contains(i-1)) {
                set.remove(i-1);
            } else if (set.contains(i+1)) {
                set.remove(i+1);
            } else {
                answer--;
            }
        }
        return answer;
    }
}

CS - 운영체제 정리

Bubbles — Thu, 2 Nov 2023 02:06:52 +0900

기본 개념

운영체제가 무엇인가요?
하드웨어 자원을 관리하고, 응용프로그램과 하드웨어 사이를 중재하는 인터페이스입니다.

커널이 무엇인가요?
메모리에 상주하는 운영체제의 핵심 부분으로, OS 전체를 메모리에 올려두는 것은 메모리 낭비가 심하므로 핵심 부분인 커널만 메모리에 올려놓고 사용합니다.

시스템 콜이 무엇이고 왜 존재하는지 설명해주세요.
OS가 커널에 접근하기 위한 인터페이스로, 유저 프로그램이 OS의 서비스 받기 위해 커널함수를 호출할 때 사용합니다.
자원에 대한 직접 접근을 차단함으로써 자원을 보호한 채 사용자에게 서비스를 제공하기 위해 존재합니다.

인터럽트란 무엇이고 어떤 종류가 있나요 ?
CPU가 프로그램을 실행하고 있을 때 하드웨어 장치 이벤트나 예외 상항등이 발생했을 때 마이크로 프로세서에게 알려 처리할 수 있도록 합니다.

하드웨어 인터럽트
- CPU가 아닌 다른 하드웨어 장치가 CPU에게 어떤 사실을 알려주거나 CPU 서비스를 요청해야 하는 경우 발생
소프트웨어 인터럽트
- 소프트웨어가 발생시키는 인터럽트로 예외 상황, system call 등의 상황에서 발생

IO interrupt가 발생하면 내부적으로 어떤 일이 일어나나요?

I/O 가 필요한 경우, 실행을 멈추고 System Call을 한다.
해당 프로세스는 Waiting 상태로 이동하고 I/O 를 진행시키며 다른 프로세스에 CPU를 할당해 실행시킨다.
I/O 가 끝나면 다시 Ready 상태로 이동해서 CPU 할당을 기다린다.

동시성 제어

동시성과 병렬성의 차이가 무엇인가요?

동시성 : 메모리에 여러 프로세스를 적재, 번갈아 수행하여 동시에 실행되는것처럼 보이게 하는 것 / 싱글 코어에서 멀티스레드 동작시키는 방식
병렬성 : 멀티 프로세싱에서 나온 개념, 실제로 동시에 여러 프로세스를 병렬적으로 수행하는 것 / CPU가 멀티 코어여야 한다.

Blocking - Non-blocking과 Synchronous - Asynchronous 차이에 대해 각각 설명해주세요.

Blocking VS Non-Blocking
- 호출된 함수가 끝날 때까지 제어권을 계속 가지고서 호출한 함수에게 바로 돌려주지 않으면 Blocking
- 호출된 함수가 끝나지 않아도 바로 제어권을 건네주어 호출한 함수가 다른 일을 진행할 수 있도록 해주면 Non-blocking
Synchronous VS Asynchronous
- 호출된 함수의 수행 결과와 종료를 기다리고, 순서대로 응답을 받을 수 있으면 Synchronous
- 호출된 함수의 수행 결과와 종료를 기다리지 않고 순서대로 응답이 온다는 보장이 없으면 Asynchronous

교착상태, 데드락, 경쟁상태

경쟁상태가 발생하는 원인과 해결책에 대해 설명해주세요.
경쟁 상태는 공유 메모리를 사용하기 때문에 발생합니다.
경쟁 상태를 해소하기 위해서는 공유 메모리를 쓰는 프로세스/스레드 간 동기화를 통해 순차적 실행을 보장하여 임계구역의 상호 배제를 이뤄지도록 합니다. 세마포어와 뮤텍스 등이 있습니다.

임계 영역이 무엇이고, 임계영역에 문제가 발생하지 않도록 만족해야하는 조건이 있나요?
여러 프로세스가 동시에 공유하면 안되는 자원에 접근하고 실행하는 프로그램의 부분을 의미합니다. 상호배제와 비어있는 임계영역에 어떤 프로세스가 진행할지 결정하고, 기아 상태를 방지하기 위해 한번 임계구역에 들어간 프로그램은 다음 진입에 제한을 둡니다.

데드락(교착상태)란 무엇인가요?
2개 이상의 프로세스나 스레드가 서로 자원을 얻지 못해서 다음 작업을 수행하지 못하고 자원을 무한정 기다리는 상태를 의미합니다.

데드락의 발생 조건에는 어떤 것들이 있나요?

상호배제 : 한 자원에 여러 프로세스가 동시에 접근할 수 없음
점유대기 : 하나의 자원을 소유한 상태에서 다른 자원을 기다림
비선점 : 프로세스가 어떤 자원의 사용을 끝낼 때까지 프로세스 자원 뺏을 수 없음
순환대기 : 각 프로세스가 순환적으로 다음 프로세스가 요구하는 자원을 갖고 있음

뮤텍스와 세마포어의 차이에 대해 설명해주세요.
뮤텍스는 오직 하나의 스레드 || 프로세스만 접근할 수 있으며, 락을 획득한 스레드 || 프로세스가 락을 해제해야 합니다.
세마포어는 세마포어 변수만큼의 스레드 || 프로세스가 접근할 수 있으며 현재 수행중이 아닌 프로세스가 세마포어를 해제할 수 있습니다.

UNIX, Windows 등 대부분의 범용 OS가 채택하고 있는 데드락에 대한 조치 방식은 무엇인가요?

Deadlock이 일어나지 않는다고 생각하고 아무런 조치를 취하지 않습니다.
사실 Deadlock은 매우 드물게 발생하므로 deadlock에 대한 조치 자체가 더 큰 overhead를 불러올 수 있기 때문에 시스템이 비정상적으로 작동하는 것을 사용자가 느끼고 직접 process를 kill하는 방식으로 해결합니다.

프로세스 & 스레드

프로세스와 스레드의 차이가 무엇인가요?
프로세스는 실행 중인 프로그램으로, 각 프로세스는 메모리 영역을 독립적으로 사용합니다.
스레드는 프로세스 내에서 프로세스 자원을 이용하여 실행되는 작업으로 Stack과 program counter만 따로 할당 받고, 그 이외의 메모리 영역을 공유합니다.

프로세스 생성 과정에 대해 설명해보세요.

프로세스 생성 시 PCB가 생성되고, 부모 프로세스의 내용을 복사해 주소공간을 할당한다. 그 후 자식 프로세스의 실제 데이터를 로딩한다. 그 후 프로세스를 ready queue에 넣고 CPU 할당을 기다린다.

Context switching이 무엇인가요?

멀티 프로세스 환경에서 CPU는 여러 프로세스를 돌아가면서 작업을 처리하므로, 현재 프로세스를 중단하고 다음 프로세스가 실행되어야 하는 경우가 발생합니다.
현재까지 수행한 context를 저장해두고 다음 프로세스의 context로 교체하는 것을 의미합니다.

PCB에 대해 설명해주세요
프로세스 생성시 만들어지는 정보로 context switching 발생 시 프로세스의 상태를 기록해두었다가 복구할 때 사용합니다.

프로세스 status 중 suspended에 대해 설명해주세요

사용자가 정지시키거나, 메모리에 너무 많은 프로세스가 올라가 있어 디스크로 swap out 된 상태를 의미합니다.
Suspended Ready는 Ready 상태였던 프로세스가 swap out 당한 상태를 의미합니다.
Suspended Block은 Blocked 상태의 프로세스 swap out된 것으로 blocked 된 조건이 충족되면 Suspended Ready로 바뀝니다.

* swap out : 시스템 성능이 저하되는 경우 일부 프로세스로부터 메모리를 통째로 빼앗아 디스크의 swap 영역에 저장.

Running : CPU 받아 명령을 수행중인 상태
Ready : CPU 제외한 메모리 등 모든 조건이 준비된 상태(메인 메모리로 로드된) - CPU만 받으면 당장 수행 가능한 상태
Blocked : CPU 받더라도 당장 실행 불가 -> I/O event 기다리거나 디스크에서 file 읽어와야 하는 등 저장매체에 액세스해서 이벤트 발생 대기중인 상태
new : 프로세스를 위한 자료구조들은 생성, 아직 메모리 획득 승인은 못 받은 상태
terminated : 프로세스는 종료되었는데 프로세스와 관련된 자료구조 정리 완전히 못한 상태
Suspended : 사용자가 정지시키거나 메모리에 너무 많은 프로세스가 올라가있어 디스크로 swap out된 상태

멀티 스레드 방식이 멀티 프로세스 방식에 비해 가지는 장점에 대해 설명해주세요.

멀티 프로세스 방식만으로도 하나 이상의 작업을 수행할 수 있지만, 멀티 프로세스보다 메모리 등 자원을 적게 사용하고, 자원을 어느정도 공유하기 때문에 스레드 간 데이터 주고 받는 통신 비용이 적게 든다는 장점을 가집니다.

스레드가 독립적으로 할당하는 자원 2가지가 무엇이고, 왜 공유하지 않고 독립적으로 할당할까요?

Program Counter
- 스레드의 명령어가 어디까지 수행되었는지 저장하는 부분으로 스레드가 CPU 할당받았다가 스케줄러에 의해 선점당하여 연속적으로 수행되지 못합니다. 따라서 각 스레드별로 수행된 부분을 기록할 필요가 있습니다.

Stack
- 스택 영역에 함수 호출 시 전달되는 인자, 되돌아갈 주소 등을 저장하므로 함수에 따른 독립적인 실행 흐름을 갖기 위해 스택을 각각 할당해줄 필요가 있습니다.

크롬 브라우저에서 한 탭에 오류가 생기더라도, 다른 탭에 영향을 끼치지 않는데, 각각의 크롬 탭은 프로세스일까요? 스레드일까요?

한 탭에 오류가 생기더라도 다른 탭에 영향을 끼치지 않으므로 크롬 탭은 프로세스입니다.

메모리

메모리 단편화란 무엇이고, 어째서 발생하나요?
RAM에서 메모리의 공간이 작은 조각으로 나뉘어져 사용 가능한 메모리가 충분히 존재하지만 할당(사용)이 불가능한 상태를 보고 메모리 단편화가 발생했다고 합니다.

내부 단편화(Internal Fragmentation) : 메모리를 할당할 때 프로세스가 필요한 양보다 더 큰 메모리가 할당되어서 프로세스에서 사용하는 메모리 공간이 낭비 되는 상황
외부 단편화(External Fragmentation) : 메모리가 할당되고 해제되는 작업이 반복될 때 작은 메모리가 중간중간 존재하게 된다. 이 때 중간에 생긴 사용하지 않는 메모리들로 인해, 합쳐진 총 메모리 공간은 충분하지만 실제로 할당할 수 없는 상황

가상 메모리가 필요한 이유와 역할, 구현 방식에 대해 설명해주세요.
메모리 크기보다 큰 사용자 프로그램을 실행가능하게 하기 위해 필요합니다.
가상 메모리 기법을 사용하여 프로그램의 필요한 부분만 메모리에 적재하고, 필요하지 않은 메모리 공간은 디스크에 저장하게 됩니다.
프로세스가 생성될 때 개별적인 주소 공간이 만들어지며, 이를 물리적 주소로 바꾸어 처리합니다.

컴퓨터의 설계에 있어 캐시의 이점이 무엇인가요?
데이터를 미리 복사해놓음으로써 접근 시간이나 다시 계산하는 시간을 줄여주고, 이로 인해 속도가 빠른 장치와 느린 장치 사이 속도차이에 따른 병목현상을 완화할 수 있습니다.

프로그램이 운영체제로부터 할당받는 메모리 공간의 구조에 대해 설명해주세요.
코드 영역, 데이터 영역, 스택 영역, 힙 영역으로 구성됩니다.

Code : 프로그램의 코드 / 명령어들이 기계어로 저장된 영역
Data : 코드에서 선언된 전역 / 정적 변수가 저장되는 영역 -> 실행 시 할당되고 종료 시 소멸
Stack : 컴파일 타임에 크기 결정, 지역변수, 매개변수, 리턴 값 등 저장
Heap : 런타임에 크기가 결정, 사용자에 의해 메모리 공간이 동적으로 할당되고 해제되는 영역, 참조형 등 저장

프로세스 스케줄링 알고리즘을 몇가지 예시를 들어 설명해주세요.

비선점형
- FCFS : 도착 순서대로 실행, 단순하지만 긴 프로세스 실행 시 다른 프로그램이 오래 기다림
- SJF : 점유시간 가장 짧은 프로세스를 우선 처리, 기아 문제 (오래 걸리는 프로세스 CPU 할당을 못받음)
선점형
- SRTF : 점유시간 가장 짧은 프로세스에 넘겨줌
- RR : 시간 할당량을 각 프로세스마다 할당한 후 끝나면 CPU를 다른 프로세스에 할당

TLB란 무엇인가요?
고속 캐시의 일종으로, 주소로 접근되는 일반 메모리와는 다르게 키 값으로 찾고자 하는 워드를 동시에 접근하는 메모리입니다.
페이지 테이블을 메모리에 두고 페이지 참조를 줄여서 접근 속도를 향상시키기 위해 사용하며, TLB miss시 페이지테이블을 참조합니다.

세그먼테이션이란 무엇인가요?
고정된 크기로 분할하는 고정 분할방식이 아닌, 크기가 동적으로 변할 수 있는 세그먼트로 나누는 기법입니다.
외부 단편화가 발생할 수 있습니다.

스레싱에 대해 설명해주세요.
페이지 부재율이 증가하여 swapping이 자주 일어나게 되고, 이로 인해 CPU 이용율이 급격히 떨어지는 현상을 의미합니다.
CPU 이용율이 낮으면 OS가 메모리에 올라간 프로세스의 수를 늘리고, 실행에 필요한 최소한의 프레임도 할당받지 못하게 되어 CPU 이용율이 지속적으로 떨어지는 악순환을 일으킵니다.

동시에 메모리에 올라가있는 프로세스의 개수를 조절하는 방식

working set : 지역성 원리 이용하여 지역성 집합이 메모리에 동시에 올라갈 수 있도록 보장. 대신 충분한 페이지를 할당하지 않으면 작업집합에 있는 페이지를 물리 메모리에 유지하기 힘듦.
page fault frequency : 프로세스 페이지 부재율을 주기적으로 조사, 이 값에 근거하여 각 프로세스에 할당할 메모리 양을 동적으로 예측하고 조절하는 방식

page fault 과정에 대해 설명해주세요

CPU가 프로그램을 실행하면서 필요한 페이지가 물리 메모리에 없는 경우가 생기는데 이를 page fault라고 합니다.
page fault가 발생하면 디스크로부터 해당 페이지를 가져오고, 메모리 상 페이지와 스와핑, 페이지 테이블 갱신 후 프로그램을 다시 실행합니다.

파일 시스템

USB에서 많이 쓰는 FAT 파일 시스템의 단점을 아시나요?
파일 할당 여부를 체크하는 file allocation table에 대한 용량을 소비하며, 할당 여부만 확인 가능하여 기능이나 보안부분이 다소 떨어집니다. 대신 USB처럼 많은 기능, 보안 수준이 필요없는 장치에 사용됩니다.

I-node 파일 시스템에 대해 간단히 설명해주세요
파일과 관련된 정보들을 테이블 형태로 저장하며, 각 파일마다 inode 번호를 할당하여 파일을 구분하고 찾습니다.
실제 데이터 블록은 inode가 가리키는 위치에 저장됩니다.

Java와 객체지향

Bubbles — Sat, 28 Oct 2023 19:56:21 +0900

클래스와 객체 : 정말 붕어빵틀과 붕어빵인가?

클래스 : 분류에 대한 개념이지 실체가 아니다. 같은 특성을 지닌 여러 객체를 총칭하는 집합의 개념이다.
객체 : 실체이고, 세상에 존재하는 유일무이한 사물이다.

클래스 - 객체의 관계는 분류와 사물의 관계로 봐야 한다.

EX ) 펭귄(클래스) - 뽀로로(객체), 쥐(클래스) - 미키마우스(객체) 이런 느낌이다.

객체 지향의 4대 특성

추상화 : 모델링

구체적인 것을 분해해서 관심영역(만들려고 하는 어플리케이션이 어디에 사용되는지)에 대한 특성만을 가지고 재조합하는 것이다.
실제 사물을 정확히 복제하는 것이 아닌, (ex. 사람의 모든 특성을 다 나열할 수는 없다) 목적에 맞게 관심이 있는 특성만을 추출해서 표현하고, 실제 사물을 단순하게 묘사하는 것이다.

EX) 병원에서 사람이라는 클래스가 있다면, 사람이라는 클래스의 직업이나 연봉과 같은 특성들은 필요가 없으므로 제거하고, 나이, 몸무게, 혈액형 등 필요한 특성들만 필드로 선언해두는 것

♻️ 상속 : 재사용과 확장

하위 클래스는 상위 클래스이다.

상속을 단순히 할아버지 - 아버지 관계처럼 부모 - 자식 개념으로 생가하면 아버지는 할아버지다 라는 어색한 문장이 된다.
하지만 포유류 (상위) - 고래 (하위) 라고 생각해보면 고래는 포유류이므로 이 문장이 어색하지 않다.
부모 - 자식이 아닌 상위 - 하위 클래스 뉘앙스로 기억하자.

상속을 is A 관계가 아닌, is a kind of로 생각하자.

ex ) 펭귄은 동물의 한 분류이다.

정리하자면, 상속은 상위 클래스의 특성을 재사용, 확장하는 것이고 is a kind of 관계를 만족해야 한다.

자바는 왜 다중 상속을 지원하지 않는가?

다이아몬드 상속 문제라고 많이 소개되는데, 굉장히 책에 쉬운 예시가 있다.

인어공주는 물고기와 사람 클래스를 상속 받았다면, 인어공주는 수영할 때 물고기처럼 수영할까? 아니면 사람처럼 수영할까?
어느 쪽의 메소드를 수행해야 할 것인지 모호하다.

인터페이스는 ?

구현 클래스 is able to 인터페이스(구현 클래스는 인터페이스 할 수 있어야 한다.)

무엇을 할 수 있는 ~ 이라는 표현 형태로 만들자.

ex ) 헤엄을 칠 수 있는 ~

고래도 헤엄을 칠 수 있고 펭귄도 헤엄을 칠 수 있다.

고래 클래스와 펭귄 클래스가 헤엄이라는 메소드를 구현한다.

상위 클래스는 물려줄 특성이 풍성할수록 좋고, 인터페이스는 구현을 강제할 메소드가 적을 수록 좋다.

‍ ‍ ‍ 다형성 : 사용편의성

오버로딩 : 같은 메서드 이름, 다른 인자 목록으로 다수의 메서드를 중복정의
- 만약 이러한 특성이 지원되지 않는다면, 덧셈 함수를 만들 때를 생각해보자
  - 오버로딩이 지원될 경우
    - 정수 + 정수, 정수 + 소수, 소수 + 소수 3가지 모두 같은 함수 이름 add 사용이 가능
    - add(int a, int b) , add (int a, double b) , add (double a, double b) 이런식으로 작성해둠
    - 사용하는 측에서 그냥 add만 쓰면 매개변수 따라 적합한 함수 매핑되어 수행
  - 오버로딩이 지원되지 않는다면?
    - addIntToInt, addDoubleToInt, addDoubleToDouble .... 다 이름이 다르게 생성해야 한다.
    - 또한 사용할 때도, 정수끼리 덧셈이라면 addIntoInt 부르고, 실수끼리 덧셈이라면 addDoubleToDouble부르고...
    - 사용 편의성이 현저히 떨어진다!
오버라이딩 : 같은 메서드 이름, 같은 인자 목록으로 상위의 메서드를 재정의
- 상위 클래스의 객체 참조변수를 사용하더라도 하위 클래스에서 오버라이딩한 메서드가 호출된다
- 형변환이나 instanceof 연산자로 일일이 하위 클래스 무엇인지 신경쓰지 않아도 된다. (알아서 하위 클래스가 오버라이딩한 메서드를 자동으로 호출해주므로)

// Penguin extends Animal
// Animal의 showName -> Penguin에서 오버라이딩

Animal pingu = new Penguin();
pingu.showName(); // Penguin의 메소드가 호출된다!

캡슐화 : 정보 은닉

접근 제어자
- public
- protected
- default
- private

package one;
class A {
    public int pub;
    protected int pro;
    int def;
    private int pri;

    static public int pubStatic;
    static protected int proStatic;
    static int defStatic;
    static private int priStatic;
    
    void runSomething() {
    
    }
    
    static void runStatic() {
    
    }
}

runSomething( )

상속 받았다면 객체를 생성하지 않아도 자식 클래스에서 부모의 인스턴스 변수(객체 변수) 접근 가능
상속을 받지 않았다면 new ClassA() 로 객체 생성 후 접근 가능
정적 변수들은 classA.pub 이런식으로 접근 가능

runStatic( )

class A의 인스턴스 변수들은 모두 객체를 생성한 후 접근이 가능
정적 변수들은 classA.pub 이런식으로 접근 가능

각 접근 제어자, 패키지 별 접근 가능성 여부

// 동일 패키지 (package one)
class AA extends A
class B

// 다른 패키지 (package two)
class AB extends A
class C

class AA extends A

runSomething()
- 상속 받았으므로 객체를 생성하지 않아도 public, protected, default 접근 가능
- classA.pubStatic, classA.proStatic, classA.defStatic 접근 가능
runStatic()
- Static 메소드이므로 new ClassAA() 후 public, protected, default 접근 가능
- classA.pubStatic, classA.proStatic, classA.defStatic 접근 가능

class B

runSomething()
- 상속 받지 않았으므로 new ClassA() 한 후 public, protected, default 접근 가능
  - protected는 동일 패키지라면 상속 여부 상관없이 접근이 가능하고, 다른 패키지라면 상속받은 애만 접근 가능
- classA.pubStatic, classA.proStatic, classA.defStatic 접근 가능
runStatic()
- Static 메소드이므로 new ClassA() 후 public, protected, default 접근 가능
- classA.pubStatic, classA.proStatic, classA.defStatic 접근 가능

package two

class AB extends A

runSomething()
- 상속 받았으므로 객체 생성하지 않아도 public, protected 접근 가능
- classA.pubStatic, classA.proStatic 접근 가능
runStatic()
- Static 메소드이므로 new ClassAB() 후 public, protected 접근 가능(상속받았으므로 얘도 가지고 있다)
- classA.pubStatic, classA.proStatic 접근 가능

class C

runSomething()
- 상속 받지 않았으므로 new ClassA() 한 후 public만 접근 가능
- classA.pubStatic만 접근 가능
runStatic()
- Static 메소드이므로 new ClassA() 후 public만 접근 가능
- classA.pubStatic만 접근 가능

스프링 입문을 위한 자바 객체지향의 원리와 이해를 학습하고 정리한 내용입니다.