🌊 ._.sori🪽

원래대로라면 섹션 4-2를 작성해야하지만... 4-1을 정리하고 velog에 있던 글들 Tistory로 다시 옮기면서 강의 내용이 제대로 기억나지 않게 되었다. 그래도 keep going~ 4-2는 8월 중순에 다시 들으면서 정리하기로 하고 섹션 5 강의 부터 정리해볼까 한다. 히히. 취업이 요새 잘 안되는 것 같아 약간의 두려움이 있지만 그래도 모두들 화이팅!

🧸 

🧸 구조파악 레츠꼬우- 🧸

•  singleton
  ㄴ class : SingletonService, SingletonTest, StatefulService, StatefulServiceTest, ConfigurationSingletonTest 
• AppConfig

Q.  스프링을 사용하는 이유는?

A. 싱글톤이 보장되기 때문이다.

✔️  SingletonTest

► pureContainer

순수 자바코드로 생성자를 직접 호출한다.

MemberService memberService1 = appConfig.memberService();

MemberService memberService2 = appConfig.memberService();

AppConfig를 보면 MemberService타입의 bean 이름이 memberService 라는 것을 만든걸 확인할 수 있다.
appConfig.memberService는 MemberService 타입의 객체를 생성하고 반복한다는 뜻이다.
memberService1은 memberService를 가리키는 객체가 된다. (우리가 알기쉽게 이름만 대여해주는 느낌인 것 같다...(?))

결론적으로 memberService1을 통해 MemberServiced 객체에 접근하고 사용한다. 일단 이렇게 이해하긴함🧐

현재 만든 AppConfig는 호출할 때 마다 객체를 생성한다.
만약 사용자가 많은 경우, 많은 객체 생성•소멸로 인해 메모리 낭비가 심해진다.

▸  결과

각 값이 6a472554와 7ff2a664로 다른 것을 확인할 수 있다. 객체가 다르게 생성되었다는 것을 의미한다.

••• 이어서 다른 코드 부분 •••

Assertions.assertThat(memberService1).isNotSameAs(memberService2);

assertThat(A).isNotSameAs(B)

: 대상 A와 대상 B의 주소값이 다른지 확인하는 메서드

Q. assertThat(A).isEqualTo(B)와 assertThat(A).isSameAs(B)와 차이점은 무엇인가?
A. isEqualTo는 대상의 내용을 비교하고 isSameAs는 대상의 주소값을 비교한다.

예시) isEqualTo

String A = "Hi";
String B = "Hi";

assertThat(A).isEqualTo(B);​

예시) isSameAs (==)

String A = "Hi";
String B = A;

assertThat(A).isSameAs(B);

✔️ SingletonService

싱글톤 디자인 패턴을 구현했다.

private static final SingletonService instance = new SingletonService();

private

: 변수를 외부에서 접근할 수 없게 한다.

static

:  instance 변수가 클래스 수준에서 관리되게 하며, 클래스가 메모리에 로드될 때 인스턴스가 생성되고 프로그램 종료될 때까지 유지된다.

final

: 인스턴스가 한 번 생성되면 변경할 수 없다.

Q. 싱글톤 패턴에 static은 왜 쓰는걸까? 

전에 자바완전정복에서 static에 대한 개념을 찾아봤던 것이 기억난다. 그때는 main 메서드에 들어가 있던 것 같았는데, 하여튼 기억을 e되짚어보자면 static을 사용해야 객체의 생성 없이도 호출이 되어 메모리에 올라가 작동할 수 있어서였던 것 같다.(정확하지 않아서 복습이 필요하다) 그런데 싱글톤 패턴에는 왜 사용하는지 잘 이해가 가질 않는다.

A.  static은 인스턴스(메모리 위에 올라간 객체)를 새로 생성하지 않아도 접근 가능하게 하기위해 사용한다. 싱글톤 패턴은 단순히 하나의 인스턴스만 생성하는 것이 아니다. 하나의 인스터스를 생성 후 공유해 사용하도록 한다. 여기서 static은 하나의 인스턴스를 생성되도록 하며, 전역적으로 공유(사용)하도록 하게 해준다. private와 final의 역할은 외부에서 변경할 수 없도록 해준다.

- 싱글톤 패턴과 static의 관련 출처

Q. 객체와 인스턴스의 차이

A. 객체는 선언, 인스턴스는 실체화를 의미한다. 객체는 클래스의 타입으로 선언되었을 때, 인스턴스는 그 객체가 메모리 위에 올려졌을 때를 말한다. 그러니까 특별한 객체를 인스턴스라고 한다. (용어의 의미가 조금 다를 뿐, 객체와 인스턴스는 같다고 보면 되는 것 같다.)

Dog myDog = new Dog(); 
Dog anotherDog = new Dog();

위의 두 코드에서 myDog와 anotherDog는 Dog 클래스의 객체이자 인스턴스임을 나타낸다. 즉, 객체지만 인스턴스가 아닌 경우는 없다고 한다.

- 객체와 인스턴스의 차이점 출처

•••그 다음 코드 •••

public static SingletonService getInstance() {
        return instance;
    }

SingletonService의 인스턴스를 새로 만들지 않고, getInstance( ) 메서드를 통해 인스턴스를 접근한다. 
그러니까 static으로 전역적으로 공유된 것을 사용하게 해주는 메서드가 getInstance( )인 듯 하다.

  private SingletonService() {

    }

생성자

: 인스턴스를 만들 때 호출되는 특별한 메서드

Q. 생성자가 정확하게 무엇인가?

A. 객체가 생성될때 자동으로 호출되는 특수 목적의 멤버함수(메소드)로 객체의 초기화를 위해 사용한다. 무조건 클래스당 하나가 있어야하며, 객체가 생성됐는데 그에 맞는 생성자가 없을 경우 컴파일러가 자동으로 기본생성자를 생성하거나 오류가 발생할 수 있다. 

	public Book() {	}                          // 기본생성자
	
	public Book(String title, int price) {    // 매개변수를 가진 생성자
		this.title = title;
		this.price = price;
	}

 

		Book b1 = new Book();                // 객체생성 - 기본생성자 호출됨
		Book b2 = new Book("국어책", 3000);   // 객체생성 - 매개변수를 가진 생성자 호출됨

 

- 생성자에 대한 설명 출처

Q. 그렇다면 위의 생성자는 기본 생성자인가? 왜 쓰는걸까?

A. 위의 생성자는 기본생성자와 차이가 있다. 일단 기본 생성자는 public을 기반으로 하는데, 위의 코드는 private로 개발자가 정의한 명시적 생성자(매개변수가 없는)다.  private를 사용한 이유는 싱글톤 패턴을 만들기 위해 외부에서 인스턴스를 만들 수 없도록 하기 위함이다.

••• 연결된 테스트 코드 확인하기 •••

✔️  SingletonTest

► singletonServiceTest

SingletonService singletonService1 = SingletonService.getInstance();
SingletonService singletonService2 = SingletonService.getInstance();

SingletonService의 코드를 생각해보면 인스턴스를 외부에서 만들지 못하도록 private 생성자를 만들었다. 그리고 static, final, private로 인스턴스 변경을 불가하게 만들었다. 그런데 전역적으로 공유를 하기 위해 getInstance 메서드를 만들었다.

getInstance( )를 통해 접근하여 singletonService1과 singletonService2의 인스턴스를 반환받는 것이다. 생성자를 직접 호출하지 않고 클래스 내에서 관리하는 유일한 인스턴스를 반환하는 정적 메서드를 사용하는 것이다.

✔️ SingletonTest

► springContainer

싱글톤 패턴을 사용하면 DIP,OCP를 위반할 수 있다. 더구나 private 사용으로 인해 유연성도 떨어진다.

그렇기에 스프링 컨테이너를 사용하여 인스턴스를 싱글톤으로 유지하는 방식을 사용할 것이다.

MemberService memberService1 = ac.getBean("memberService", MemberService.class);
MemberService memberService2 = ac.getBean("memberService", MemberService.class);

AppConfig에 정의되어있는 memberService라는 이름을 가진 빈을 MemberService 타입으로 반환한다. 이때 스프링 컨테이너의 특성에 의해 같은 빈 인스턴스를 할당한다.

같은 결과값이 나온 것을 확인할 수 있다.

✔️  StatefulService

스프링 컨테이너는 무상태로 설계해야한다.

👁️‍🗨️ 문제점

스프링컨테이너 혹은 싱글톤 패턴은 하나의 인스턴스를 가져와 공유하게 된다.

만일 상태를 가지는 필드가 있다면, 처리에 문제가 생기게 된다.

private int price; 

public void order(String name, int price) { 
	...
	this.price = price; 
}

첫번째 주문자가 2만원을 주문했는데 그것을 처리하는 동안 두번째 주문이 10만원 들어오게 되면,
첫번째 주문자의 주문가격이 10만원으로 변경될 수 있다.

💫  해결해보자

public int order(String name, int price) {
        ...
        return price;
    }

1. 무상태로 만들기 위해 원래 있던 this.price = price;를 지워준다.
2. 리턴값을 들어왔던 가격으로 나가도록 return price;로 수정한다.

✔️  StatefulServiceTest

► TestConfig

 	@Bean
        public StatefulService statefulService() {
            return new StatefulService();
        }

@Bean을 써서 간단한 설정 클래스를 만들었다.

	StatefulService statefulService1 = ac.getBean(StatefulService.class);
        StatefulService statefulService2 = ac.getBean(StatefulService.class);

statefulService1과 statefulService2의 인스턴스를 요구한다.
그러면 TestConfig에 있는 StatefulService로 가서 인스턴스를 생성하고 반환한다.

	int userAprice = statefulService1.order("A", 2000);
        int userBprice = statefulService2.order("B", 1000);

StatefulService의 order 메서드를 호출한다. 
순서대로 내부상태필드 price에 각 값을 저장하고 이 값을 반환한다.

🌷

결론적으로 AppConfig에 붙어있는 @Configuration과 @Bean을 통해 각 인스턴스의 싱글톤을 보장해준다.

만일 @Configuration이 없다면 AppConfig의 memberRepository는 다른 인스턴스를 가져 호출될 것이다.

그리고 주의해야할 것은 무상(stateless)를 유지하는 것이다.

컨테이너를 생성했다. 스프링 컨테이너 내에서 빈 이름과 빈 객체를 저장하여 관리해준다. Public과 함께 쓴 것은 타입과 이름이 된다. 예시로 public MemberService memberService( )의 경우 MemberService는 타입이 되고 memberService는 빈의 이름이 된다. return new와  함께 쓰이면 빈 객체과 된다. 예로 return MemberServiceImpl(memberRepository( ))의 경우 MemberServiceImpl이 빈 객체가 되는 것이다. 그렇게 스프링 컨테이너에 저장되어 관리된다. 그리고 이번엔 빈이 제대로 등록되어있는지 확인하는 방법을 배울 것이다.

[ ◀︎ ]

🧸

잘못된 정보가 있다면 댓글로 남겨주세요

🧸 구조파악 레츠꼬우- 🧸

test에 총 3가지의 패키지를 만들었다.

• beanfind
  ㄴ ApplicationContextInfoTest, ApplicationContextBasicFindTest, ApplicationnContextExtendsFindTest
       , ApplicationContextSameBeanFindTest
• beandefinition
  ㄴ BeanDefinitionTest
• xml
  ㄴ XmlAppContext

✔️  beanfind_ApplicationContextInfoTest

►  findAllBean

: 내부에 포함된 Bean을 출력한다.

AnnotationConfigApplicationContext ac 
= new AnnotationConfigApplicationContext(AppConfig.class);

AnnotationConfigApplicationContext

: Bean으로 지정된 객체들을 가지고 있는 context고 컨테이너라고도 부른다.

ApplicationContext는 인터페이스로 다양한 구현체를 가지고 있다. 그 중 하나가 어노테이션을 이용할 수 있도록 해주는 AnnotationConfigApplicationContext이며 현재 강의에서 다루는 것이다. 섹션 4 강의에서 AppConfig에 @Configuration과 @Bean 어노테이션을 정의했다. 이렇게 어노테이션을 정의를 통해 빈을 새롭게 생성하거나 관리하고, 컴포넌트 스캔 혹은 프로파일 관리를 할 수 있게 된다.

ㅤ- ApplicationContext 설명 출처

- AnnotationConfigApplicationContext 출처

-  AnnotationConfigApplication  출처

••• 이어서 다음 코드 •••

String[] beanDefinitionNames = ac.getBeanDefinitionNames();

getBeanDefinitionNames( )

: 팩토리에 등록된 모든 bean을 반환하고 @bean을 제외한 다른 방법으로 등록된 싱글톤 Bean은 무시한다. 또한 계층구조도 무시한다. 

ac는 AppConfig에 등록된 bean에 대한 설정 정보가 담겨있다. 하지만 getBeanDefinitionNames는 내부의 모든 bean을 반환한다고 정의되어있는데, 그 이유를 살펴보면 AppConfig의 설정을 적용하면서 Spring에 기본적으로 필요로하는 내부 빈들도 자동적으로 함께 등록되기 때문이다. 그렇기에 내부 빈들도 모두 보고 싶을 경우 getBeanDefinitionNames()를 사용한다.

- getBeanDefinitionNames 정의 출처

ㅤㅤ••• 그 다음 코드 •••

for (String beanDefinitionName : beanDefinitionNames) {
            Object bean = ac.getBean(beanDefinitionName);
            System.out.println ("name = " + beanDefinitionName + "object = " + bean); }

getBean( );

: 현재 사용 중인 bean을 반환한다.

Object

: 최상위 클래스로 자바 클래스에 따로 extends하지 않으면 java.lang.Object를 상속한다. 필드가 아닌 메서드로 구성되어있으며 모든 타입을 다 받을 수 있다.

beanDefinitionNames는 모든 빈을 반환 받아온 문자열이다. for문을 이용하여 beanDefinitionNames에 들어있는 빈 이름을 beanDefinitionName 변수에 저장한다.  그리고 ac.getBean을 이용하여 빈 객체를 조회하며 이때 bean에 저장되는 타입은 Object로 모든 타입을 다 받을 수 있게 된다. 그렇기 때문에 스프링 내부에 있는 빈까지 모두 출력할 수 있는 것이다.

아래 <결과>를 보면 name은 빈의 이름이 출력되었고 object는 지정된 클래스가 무엇인지 출력되었다. 즉 discountPolicy는 hello.core.discount.RateDiscountPolicy와 연결되어있음을 보여주는 것이다.

<결과>
name = discountPolicy
object = hello.core.discount.RateDiscountPolicy@246f8b8b

요딴식으로 출력된다.🐻

Q.꼭 beanDefinitionName 변수로 받아줘야하는건가? 

A. 꼭 그럴필요는 없다. 가독성을 위해 변수를 사용하는 것 뿐.

String[] beanDefinitionNames = ac.getBeanDefinitionNames();
for (int i = 0; i < beanDefinitionNames.length; i++) {
    String beanName = beanDefinitionNames[i];
    System.out.println("Bean Name " + (i + 1) + ": " + beanName);
}​

이런식으로 그냥 변수없이 받아도 된다고 한다. 그리고 받아온 걸 beanName에 저장하여 출력한다.

Q.ac.getBean에서 ac는 꼭 붙여하는걸까? 

A. getBean은ApplicationContext에서 제공하는 인터페이스 메서드이다.그렇기에 관련 ApplicationContext에서 제공하는 메서드를 쓰려면 내가 지정한 변수(ac)를 꼭 붙여써야 한다.

- getBean 출처

- Object 출처

►  findApplicationBean

: 내가 개발한 bean 출력하기.

for (String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

모든 빈을 getBeanDefinitionNames로 가져왔다. 그리고 for을 통해 모든 빈의 메타정보를 getBeanDefinition으로 beanDefinition에 저장할 것이다.

getBeanDefinition( );

: 특정 bean의 메타정보를 가져온다.

BeanDefinition

: 스프링 프레임워크에서 정의한 인터페이스로, 스프링 컨테이너에서 관리하는 각 bean의 메타정보를 나타내는 역할을 한다.

Q. 위의 코드 중 getBean에서는 Object라는 객체 타입을 적었는데 여기서는 왜 BeanDefinition을 적을걸까?
getBean도 정보를 가져오는 코드인거 아닌가? 현재 사용중인 bean을 반환하는 것이니. 그런데 왜 다르게 쓰는걸까?

A. getBean()과 getBeanDefinition( )은 컨테이너를 가져오는 방식이 다르다. getBean()은 스프링 컨테이너에서 빈의 실제 인스턴스를 가져오고(쉽게 말해서 bean과 연결된 클래스) Object 타입으로 반환한다. 반면에 getBeanDefinition()은 특정 빈의 메타정보를 가져온다. 그리고 가져온 메타정보를 정의해주는 인터페이스가 BeanDefinition이 되기에 빈의 이름이 호출되면 BeanDefinition 객체로 반환하는 것이다. 즉 Object와 BeanDefinition을 써야하는 경우가 완전히 다르며 BeanDefinition은 하나의 구체적인 타입이 아니다.

Q. getBean( ) 메서드는 일반적으로 Object로 받는다고 한다. 그렇다면 왜 일반적으로 Object로 받는가?

A. 빈의 실제 타입이 무엇이든지 상관없이 처리할 수 있게 하기 위해 Object로 받는다. (유연성과 일관성을 갖게 된다)

ㅤㅤ•••그 다음 코드 •••

if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
                Object bean = ac.getBean(beanDefinitionName);
                System.out.println("name = " + beanDefinitionName 
                + "object = " + bean); }

getRole

: 해당 역할을 반환한다. 정수값으로 반환한다.

ROLE_APPLICATION

: 사용자가 정의한(내가 만든) 빈이다. 정수값은 2

• ROLE_SUPPORT : 스프링 내부에서 지원하는 역할을 가진 빈이다. 정수값은 4
• ROLE_INFRASTRUCTURE : 스프링의 내부 구조를 지원하는 빈이다. 정수값은 8

for문으로 모든 빈의 메타정보를 가져왔고(beanDefinition), 그 메타정보를 if문을 통해 사용자가 정의한 빈인지 아닌지 구분할 것이다. beanDefinition에 있는 정보를 getRole을 통해 역할이 무엇인지 확인한다. 그 역할이 ROLE_APPLICATION인지 확인하여 맞으면 괄호 안에 있는 코드가 실행되도록 한다. 여기서BeanDefinition.ROLE_APPLICATION으로 쓴 이유는 ROLE_APPLICATION이 BeanDefinition 클래스 안에 선언되어있기 때문에 이런 형태로 적어야 제대로 작동한다.

beanDefinitionName(모든 빈을 반환되어 저장한 변수)에서 조건에 맞는 빈을 꺼내 Object 타입인 bean에 저장한다.

Q. 무조건 getBean( )과 Object를 통해서만 받아야 결과가 출력되는가?
ㅤ
A. 그렇다. 실제 빈의 인스턴스를 얻어와야만 결과값으로 출력할 수 있다고 한다. getRole( )은 해당 역할을 반환하는 것 뿐, 인스턴스를 반환할 수 없다. 그렇기때문에 실제 인스턴스를 반환해주는 getBean( )을 사용해야만 결과를 볼 수 있다. getBean(타입) 혹은 getBean(빈이름, 타입)을 적으면 조회가 된다.

- getRole 출처

- getRole의 상수 출처

✔️  beanfind_ApplicationContextBasicFindTest

►  findBeanByName

: 빈 이름으로 조회하기.

MemberService memberService = ac.getBean("memberService", MemberService.class);
        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);

assertThat( ).isInstanceOf( )

: 해당 타입의 인스턴스인지를 비교하는 메서드이다.

bean 이름 중에서 memberService이며 해당 타입을 MemberService로 지정한 빈을 MemberService(인터페이스 타입으로)가지며 변수 이름은 memberService으로 받겠다는 것이다. 그리고 그 MemberServiceimpl(구체클래스)이 memberService의 인스턴스인지 비교한다.

좀 더 쉽게 설명해보자면, AppConfig에 인터페이스와 메서드 명을 같이 적었고 return 값으로 구체클래스를 적었다. 여기서 확인하는 것은 AppConfig에 적은 인터페이스와 구체클래스가 맞는지 확인하는 것이고 "memberService"를 적어 이름으로 조회하는 방법이다.

►  findBeanByNameX

: 빈 이름으로 조회하지 않기.

 assertThrows(NoSuchBeanDefinitionException.class,
                () -> ac.getBean("XXXX", MemberService.class));

assertThrows

: JUnit 또는 AssertJ와 같은 테스트 프레임워크에서 예외가 발생하는지를 테스트할 때 사용한다. 발생된 예외 타입과 예상되는 예외 타입이 일치하면 테스트는 성공한다.

NoSuchBeanDefinitionException.class

: 정의를 찾을 수 없는 Bean 인스턴스를 요청했을 때 예외가 발생한다.

() -> 람다식

: (매개변수)가 들어가고 -> 시작부분을 가리킨다.

-> (시작부분)으로 가서 XXXX가 MemberService.class의 해당 빈으로 존재하지 않으면 NoSuchBeanDefinitionException 예외를 발생시킨다.

- assertThrows 출처

- NoSuchBeanDefinitionException 출처

- 람다식 출처

✔️  beanfind_ApplicationContextSameBeanFindTest

    @Configuration
    static class SameBeanConfig {
        @Bean
        public MemberRepository memberRepository1() {
            return new MemoryMemberRepository();
        }
        @Bean
        public MemberRepository memberRepository2() {
            return new MemoryMemberRepository();
        }
  }

AppConfig를 수정하기 싫으니, 이렇게 같은 타입의 같은 구체클래스를 반환하는 두개의 bean을 만들었다.

►  findAllBeanByType

Map<String, MemberRepository> beansOfType =
	ac.getBeansOfType(MemberRepository.class);

getBeansOfType

: 타입을 파라미터로 받는다. Bean 이름을 key로 객체를 value로 하는 Map을 반환한다. 주로 특정 타입에 여러 개의 빈이 있을 경우 오류를 발생시키지 않기 위해 사용한다.

MemberRepository 타입에 있는 빈을 getBeansOfType 메서드를 통해 key와 value를 반환한다. 그러면 String에 bean의 이름이 들어가고 MemberRepository에 실제 bean의 객체가 들어가게 된다. 그렇게 MemberRepository 타입에 bean이 여러 개인 경우 BeansOfType 변수에 모두 담을 수 있게 된다.

ㅤㅤ•••그 다음 코드 •••

       for (String key : beansOfType.keySet()) {
            System.out.println("key = " + key + " value = " +
beansOfType.get(key));
        }

KeySet

: Map의 모든 key를 가져와 Set객체로 반환한다. for-each 루프를 사용하여 순차적으로 접근하고, 각 key를 사용하여 value에 접근할 수 있다.

beansOfType에 있는 모든 key(빈의 이름)를 가져와 반복하여 변수 key에 넣는다. 그리고 get(key)를 통해 그 key(빈의 이름)에 해당하는 값을 beansOfType에서 가져온다. 여기서 beansOfType은 key와 MemberRepository를 저장하고 있는 변수명으로, get(key)는 빈의 이름에 맞는 객체를 가져오라는 의미가 된다.

ㅤ•••그 다음 코드 •••

  System.out.println("beansOfType = " + beansOfType);
        assertThat(beansOfType.size()).isEqualTo(2);

beansOfType은 모든 bean의 이름과 객체를 저장하고 있으니, 그것을 모두 출력한다.  assertThat을 이용하여 beansOfType에 있는 bean의 개수가 2개가 맞는지 확인하는 코드가 된다.

- getBeansOfType 출처

- KeySet 출처

✔️ XML

<bean id="memberService" class="hello.core.member.MemberServiceImpl">
         <constructor-arg name="memberRepository" ref="memberRepository" /> 참조
</bean>
     
                                   실제 구현 객체
<bean id="memberRepository" class="hello.core.member.MemoryMemberRepository" />

GenericXmlApplicatonContext

: 스프링 설정 파일을 읽어와 로딩 시키고, 객체를 생성하며 초기화하는 역할을 한다.

- GenericXmlApplicationContext 출처

.

혼자 천천히 공부하며 작성했습니다.

잘못된 내용이 적혀있을 수 있으니, 감안하고 봐주시면 감사하겠습니다.

🍀 모두들 화이팅하세요 🍀

섹션 3. 예제만들기에서 잠깐 언급했지만 구현체의 의존성을 완전히 배제한 코드가 아니었다. 인터페이스와 연결된 구현체를 변경하려면 하나하나 클래스를 찾아가 수정해야하는 일이 발생할 수 있는 코드였다. 이번 강의에서는 그런 부분을 바꾸며 스프링의 어떤 점이 편리하여 많은 사람들이 선택했지는 알아가는 강의가 될 것이다. 그러니 공부하면서 어떤 식으로 코드를 짜야 의존적이지 않는 코드인지 알아보는 것이 좋을 듯 하다.

[ ◀︎ ]

🧸 

잘못된 정보가 있다면 댓글로 남겨주세요

🧸 구조파악 레츠꼬우- 🧸

• member
  ㄴ class : Member, MemberServiceImpl, MemoryMemberRepository
  ㄴ interface : MemberService, MemberRepository
  ㄴ enum : Grade
• discount
  ㄴ class : FixDiscountPolicy, RateDiscountPolicy
  ㄴ interface : DiscountPolicy
• order
  ㄴ class : Order, OrderServiceimpl
  ㄴ interface : OrderService
• test
  main
  ㄴ MemberApp, OrderApp
  test
  ㄴ RateDiscountPolicyTest, MemberServiceTest
• AppConfig

✔️  discount

    < 조건 >

• 서비스 오픈 직전에 할인 정책을 지금처럼 고정 금액 할인이 아니라 좀 더 합리적인 주문 금액당 할 인하는 정률% 할인으로 변경.
• 기존 정책은 VIP가 10000원을 주문하든 20000원을 주문하든 항상 1000원을 할인.
• 새로 나온 정책은 10%로 지정해두면 고객이 10000원 주문시 1000 원을 할인해주고, 20000원 주문시에 2000원을 할인해주는 거에요!

► RateDiscountPolicy

: 총 주문 금액의 10% 할인 정책

private int discountPercent =10;
.
.
    if (member.getGrade() == Grade.VIP) {
            return price * discountPercent / 100;
        }

정률할인정책인 RateDiscountPolicy는 DiscountPolicy 인터페이스를 상속한다. 그렇게되면 인터페이스인 DiscountPolicy에 속해있는 discount 메서드를 포함시켜 코드를 만들어야한다. 메서드 discount를 제대로 이용하기 위해선 member와 price 값이 들어와야한다. 그리고 들어온 member에 대한 정보를 Member를 통해 getGrade하여 VIP인지 확인한다. 그 후 들어온 price값을 할인률을 계산하여 return한다.

✔️  Test

► RateDiscountTest

: % 할인 관련 테스트 

테스트 만드는 단축기

mac : cmd + shift + T 

    @Test
    @DisplayName("VIP는 10% 할인이 적용되어야한다.")
    void vip_o() {

        Member member = new Member(1L, "memberVIP", Grade.VIP);

        int discount = discountPolicy.discount(member, 10000);
        
        assertThat(discount).isEqualTo(1000);

    }

@Test

: 해당 메소드 위에 선언해야 테스트 대상이 된다.

assertThat(A).isEqualTo(B)

: A와 B의 값이 맞는지 대상 내용 자체를 비교하는 테스트다.

@Test 할 때 쓰는 공식

➰  given (실행단계) : 어떤 조건을 주고
Member member = new Member(1L, "memberVIP", Grade.VIP);
▻ ID는 1L, 이름은 memberVIP, 등급은 VIP인 member가

➰   when (실행단계) : 상황이 어떠할때
int discount = discountPolicy.discount(member, 10000);
▻ 총 금액 만원을 할인 정책에 넣었을 때

➰  then (검증단계) : 이런 결과가 나와야 한다.
assertThat(discount).isEqualTo(1000);
▻ 그 결과가 1000이 되어야한다.

••• 이어서 다른 코드 부분 •••

import static org.assertj.core.api.Assertions.*;

Assertions

: AssertJ에서 제공하는 API로 테스트의 가독성을 높여준다.

Assertions.assertThat(discount).isEqualTo(1000);

간결하게 만들어주는 코드

mac: command + enter

↓

assertThat(discount).isEqualTo(1000);

assertThat(A).isEqualTo(B)

: A의 값이 기댓값 B와 같은지 확인해주는 코드이다.
현재 코드에서는 discount의 값과 1000의 값이 맞는지 확인하는 것이다.

반대로 다른지 확인하는 코드는 assertThat(A).isNotEqualTo(B)이 되겠다.

- 다양한 assertThat()의 정보를 제공, 출처

✔️  AppConfig

OCP와 DIP를 지키기 위해 인터페이스와 연결할 클래스를 만든다.

즉, 환경구성을 수행할 클래스이다. 보통 Ioc컨테이너 혹은 DI컨테이너라고 부른다.

Q. 원래 문제점은?

A.  OrderServiceImpl이 FixDiscountPolicy에 의존하고 있었다.

수정 전 코드

public class OrderServiceImpl implements OrderService {
     private final DiscountPolicy discountPolicy = new RateDiscountPolicy();
 }

할인 정책이 달라지면 OrderServiceImpl 클래스에 가서 RateDiscounPolicy를 다른 할인 정책 클래스로 매번 수정해줘야한다.

그렇기에 아래 코드처럼 의존성 주입으로 수정해준다.

수정 후 코드

public class OrderServiceImpl implements OrderService{

   private final MemberRepository memberRepository;
   private final DiscountPolicy discountPolicy;

   public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy discountPolicy) {
       this.memberRepository = memberRepository;
       this.discountPolicy = discountPolicy;
   }
}

private

: 선언된 클래스 내부에서만 접근할 수 있도록 제안하는 접근제어자

final

: final이 붙은 변수는 상수가 되어, final이 붙은 변수를 변경할 경우 오류가 나타난다.

Q. 왜 각 매개변수들을 private final로 초기화하고 선언하나?

A. private는 내부에서만 접근이 가능하다. 만약 private만 썼다면 내부에서만 접근가능하며, 변수 내용은 변경 가능한 상태였을 것이다. 그런데 final이 붙으면서 변경이 불가능하게 되었다. 정확하게는 단 한 번의 초기화만 가능하게 된 것이다. (한 번 초기화가 되면 변경이 불가능해진다.) 그래서 해당 매개변수는 외부 접근도 불가능하며 메서드 안에서 매개변수를 재할당하는 것도 불가능해진 것이다. 여기서 놓치면 안되는 것은 해당 매개변수가 인터페이스를 가리킨다는 점이다. 그렇다면 아마 final을 통해 하고 싶었던 것은 인터페이스와 연결된 구현체가 변경되는 것을 방지하기 위함일 것이다. 만약 할인정책이 VIP만 10퍼센트 할인으로 지정해놨는데, 다른 개발자가 실수로 모든 고객에게 10퍼센트 할인으로 변경할 경우 큰 문제를 야기하기에 이런 문제를 방지하고자(일관성 유지를 위해) 생성자에 private final로 선언한 것 같다.

••• 이어서 AppConfig 코드 부분 •••

리팩터링 후 코드

@Configuration
public class AppConfig {

    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }
.
.
.

    @Bean
    public DiscountPolicy discountPolicy() {
        return new RateDiscountPolicy();
    }

}

@Configuration

: 설정파일을 만들기 위한 애노테이션 or Bean을 등록하기 위한 애노테이션으로 Bean을 등록할 때 싱글톤이 되도록 보장해준다. 또 스프링컨테이너에서 Bean을 관리할 수 있게 한다.

@Bean

: Spring의 DI Container에 의해 관리되는 POJO(Plain Old Java Object)를 Bean이라고 부른다. @Bean으로 선언된 메서드들은 스프링 컨테이너에게 빈을 생성하고 관리할 수 있도록 지정한다.

AppConfig에 인터페이스에 맞는 구현체를 return해준다. 이렇게 해주면 어떤 클래스에서 다른 클래스를 필요로 할 때 인터페이스만 정의하면 인터페이스와 연결된 구현체를 사용할 수 있게 되는 것이다.

MemberServiceImpl(구현체)은 MemberService(인터페이스)를 상속받고 있다. 그렇기에 인터페이스에 정의한 메서드가 꼭 들어가야한다. 그런데 구현체 속 return 값을 보면 save와 findById로 주고있는데, 회원가입이 된 정보를 저장하기 위해 혹은 저장소에 들어가있는 회원 정보를 찾기 위해 MemberRepository 인터페이스와 연결된 것을 알 수 있다.

정리해보면 MemberService(인터페이스) - MemberServiceImpl(구현체)   ->   MemberRepository(인터페이스) - MemoryMemberRepository(구현체)로 MemberServiceImpl이 save와 findById를 이용하기 위해 MemberRepository 인터페이스와 연결했고 이 인터페이스는 MemberServiceImpl을 상속하고 있기에 구현체와 구현체가 연결된 상황을 막은 것이다.

그래서 AppConfig를 다시 보면 메서드 memberService( )는 MemberService 타입으로 빈을 등록했고 MemberServiceImpl과 인터페이스 구현체를 연결하며, 그 속에서 save와 findById를 수행을 위해 MemberRepository를 의존성으로 받아 회원 데이터를 처리할 수 있도록 했다.

그 아래 DiscountPolicy를 보자. 전의 문제점으로, OrderServiceImpl 클래스에 들어가서 인터페이스의 구현체가 바뀐 코드를 수정하게 했다.(FixDiscountPolicy를 RateDiscountPolicy로) 그런데 AppConfig에서 정의하는 역할만 수행하는 클래스를 만드니 OrderServiceImpl에는 인터페이스만 정의하고 AppConfig에서 인터페이스와 구현체를 연결지어주면 되는 것이다.

- @Configuration 정보 출처

- @Bean에 관련한 어노테이션 출처

✔️  MemberServiceTest

섹션 3에서 만들었던 테스트 코드 수정하기.

     @BeforeEach
     public void beforeEach() {
         AppConfig appConfig = new AppConfig();
         memberService = appConfig.memberService();
     }

@BeforeEach

: 테스트가 복잡한 경우 사용하며 테스트 초기화를 위해 @Test, @RepeatedTest, @ParameterizedTest, @TestFactory, @TestTemplate 가 붙은 메소드 실행 전에 실행된다.

클래스 내부에 사용할 MemberService를 선언하고 테스트에 들어간다. AppConfig에 정의되어있는 memberService 메서드를 사용하기 위해 AppConfig를 정의해줬다. 그리고 memberService(인터페이스)와 연결된 구현체를 제대로 가지고 오기 위해서 초기화를 해준다.

그러면 후에 있는 테스트 코드에서 연결된 구현체에 맞춰 테스트 코드가 작동하게 된다.

- @BeforeEach 출처

✔️  OrderApp

스프링 컨테이너 사용하여 테스트 해보기

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
MemberService memberService = applicationContext.getBean("memberService", MemberService.class);
OrderService orderService = applicationContext.getBean("orderService", OrderService.class);

AnnotationConfigApplicationContext

: java 기반의 설정클래스를 사용하여 Bean 객체를 관리하고 설정하는 역할을 수행한다.

AnnotationConfigApplicationContext에 해당 테스트에 필요한 Bean이 들어있는 설정클래스를 괄호 안에 넣어 매개변수로 넘긴다. 그러면 Bean을 관리해주는 스프링 컨테이너가 되는 것이다.(@Bean이 붙어있는 것들을 관리함) 사용하기 위해선 그 아래 줄에 있는 코드처럼 getBean을 통해 설정클래스에 있는 메서드를 가져오면 된다. (만약 @Bean이 없다면 가져올 수 없다)

조금 더 구체적으로 알아보자. 설정 클래스를 스프링 컨테이너에 넣었어도 테스트를 하기 위해선 설정클래스 속 어떤 메서드를 사용할 것인지 알려줘야한다. 그렇기에 "memberService"와 "orderService"인 메서드 이름을 적어 getBean을 통해 가져온 것이다.

맨 앞에 MemberService와 OrderService가 붙어있다. 그 이유는 현재 테스트 클래스 내에서 메서드를 사용하기 위해 이름을 각각 memberService, orderService를 붙여줬는데 그 이름들의 (가져올) 타입을 앞에 정의한 것이 MemberService와 OrderService가 되는 것이다.

그래서 각 타입의 맞게 정의된 클래스를 가져온 메서드 이름 뒤에 붙여주면 된다. MemberService.class와 OrderService.class와 같이 말이다. 만일  memberService 메서드를 설정클래스 내에 MemberService.class로 지정을 해놨는데 테스트에서 다른 클래스로 바꿀 경우 실제 빈과 기대한 빈의 타입이 아니라는 결과 값이 출력될 것이다. 그리고 .class는 알맞게 적어놨지만 맨 앞에 MemberService와 OrderService를 다른 타입을 적을 경우에도 타입이 다르다는 결과가 출력될 것이다.

- ApplicationContext 출처

[ ▶︎ ]

혼자 천천히 공부하며 작성했습니다.

잘못된 내용이 적혀있을 수 있으니, 감안하고 봐주시면 감사하겠습니다.

🍀 모두들 화이팅하세요 🍀

아주 간단한 예제를 만들어 프로젝트 진행의 기초 틀을 만드는 강의였다. 여기에서 알아둘 것은 인터페이스와 구현체다. 현재 강의 시점에서는 인터페이스를 통해 의존성을 완벽하게 해결하진 못했는데, 그 문제점을 통해 추후 어떤 식으로 코드를 짜야하며 인터페이스와 구현체의 관계를 어떻게 정립해야할지에 대해 설명하는 강의가 이뤄진다. 어쨌든 현재 시점에선 프로젝트의 틀을 어떤식으로 짜야하며 enum, interface, class가 무엇인지 왜 있는지를 중심으로 살펴보면 좋을 것 같다.

🧸

잘못된 정보를 적었다면 댓글로 남겨주세요

🧸 구조파악 레츠꼬우- 🧸

✔️   총 세가지의 package를 만들었다.

• member
  ㄴ class : Member, MemberServiceImpl, MemoryMemberRepository
  ㄴ interface : MemberService, MemberRepository
  ㄴ enum : Grade
• discount
  ㄴ class : FixDiscountPolicy
  ㄴ interface : DiscountPolicy
• order
  ㄴ class : Order, OrderServiceimpl
  ㄴ interface : OrderService

✔️  member

►  Member

회원저장소 관리

GetterSetter(public)

: private 값을 외부로 빼거나 새로운 값을 넣는다.

id, name, grade인 총 3가지 private 정보를 넣었다.

- GetterSetter 출처 

► MemoryMemberRepository

회원정보를 store에 저장하는 회원저장소

 public void save(Member member) {
        store.put(member.getId(), member);
    }

save라는 메서드는 Member 클래스에 정의한 객체를 따르며 Member에 있는 getter를 통해 id 값을 얻고 그 id 값을 store에 put 하겠다는 내용이다. 그렇기에 save 앞에 void를 붙여준 것이다. 반환하는 타입에 void를 붙여 호출한 쪽에 아무것도 반환하지 않을 것이라고 명시한 것이다. (호출 쪽은 넣어달라 했으니 넣으면 끝인 것이다.)

••• 이어서 다른 코드 부분 •••

  public Member findById(Long memberId) {
        return store.get(memberId);
    }

findById

: id를 찾을 때 사용하며 실제 객체가 없는 경우 null을 반환한다.

id는 Member 클래스에 private Long id;라고 선언되어있다. 그렇기에 Map<Long, Member>라고 선언하고 store에서 id를 찾을 때도 Long 타입으로 적은 것이다. 그러면 findById 메서드를 통해 찾은 id는 Member 타입으로 반환된다.

Q. findById와 getById와의 차이점은?

A. 현재 inteliJ에서 getById보다 getReferenceById로 사용하도록 권유하고 있다. 여기서 getReferenceById는 findById와 다르게 실제 객체가 없는 경우 null이 아닌 EntityNotFoundException 예외가 나타나도록 하고 있다.

Q. Member member의 Member와 Long memberId의 Long, 왜 타입이 다른가?

A. 고객이 있다. 고객의 정보는 총 세가지인 id, name, grade가 된다. 이 중에 중복되지 않는 고유한 값은 id 뿐이다. 그렇기에 고객의 정보를 찾고자 할 때 id를 사용하는 것이다. 그러면 Member 객체 속 id 필드만을 이용하여 찾기 때문에 memberId 앞엔 Long 타입으로 적어준 것이다. 그리고 id를 통해 고객의 정보를 찾아오면 그 속에 name과 grade도 포함되어 있게된다. 그렇기에 Member 타입으로 반환할 수 있는 것이다.

- findById와 getById의 차이 출처

► MemberServiceImpl

회원가입과 회원조회 한다. (회원서비스제공)

[테스트 할 때]

// 테스트 MemberServiceTest 
MemberService memberService = new MemberServiceImpl();
...

위의 코드와 함께 회원정보가 들어온다.

MemberServiceImpl 인스턴스를 만들었다. MemberServiceImpl 클래스는 MemberService라는 인터페이스를 상속받고 있다. 그래서 MemberServiceImpl의 인스턴스를 만들 때 MemberService인 인터페이스 타입으로 변수를 선언했다. 그렇게 한 이유는 다형성을 위함으로 인터페이스가 어떤 구현체와 연관되었는지 모르게 하기 위해서다. 

MemberServiceImpl memberServiceImpl = new MemberServiceImpl( );은 코드의 유연성을 떨어뜨린다. 왜냐하면 MemberServiceImpl에 속해있는 메서드만 이용가능하기 때문이다. 그런데 위의 코드처럼 타입을 인터페이스로 변경하게 된다면 인스턴스를 생성할 때 다른 구체 클래스로 변경하기만 하면 같은 이름의 메서드여도 동작 방식이 다른 메서드를 이용할 수 있게된다. 그렇게 되면 코드를 훨씬 유연하게 작성하며 유지보수에도 좋다.

// MemberServiceImpl 클래스

private final MemberRepository memberRepository = new MemoryMemberRepository();

  @Override
    public void join(Member member) {
        memberRepository.save(member);
    }
...

MemoryMemberRepository(회원저장소)에 있는 정보를 원할하게 주고 받기 위해
'private final MemberRepository memberRepository = new MemoryMemberRepository();' 위의 코드를 작성해준다.

아까 test 코드에서 본 것과 같은 이유로 인터페이스를 타입 그리고 인터페이스에 연결할 구현체를 선언했다. 후에 배우겠지만 이렇게 쓰는 방식이 맞는 방식은 아니다. 만일 인터페이스와 연결된 구현체를 변경하고 싶은 경우 선언되어있는 클래스를 하나하나 방문하여 코드를 수정해야하기 때문에(의존성 문제) 이 방식은 선호하지 않는다.

현재 코드에서 final이 붙어있는데 그 이유는 선언된 구현체인 MemoryMemberRepository를 다른 구현 클래스로 변경되는 것을 불가하게 만들기 위함이다. (내부 코드 수정이 불가한 것은 아니다)

memberRepository에 정보를 저장하여 회원가입이 되도록한다.

✔️  discount

     < 조건 >

• 할인 정책은 모든 VIP는 1000원을 할인해주는 고정 금액 할인을 적용해달라. (나중에 변경 될 수 있다.)
• 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수 도 있다. (미확정)

► DiscountPolicy

: 일반(?) 할인 정책

확정된 것이 없기 때문에 언제든지 변경할 수 있도록 인터페이스로 정의만 해준다.

► FixDiscountPolicy 

 : VIP는 1000원 할인 정책

private int discountFixAmount = 1000;

할인할 가격이 변경될 수 있으니 따로 1000원을 선언한다.

if (member.getGrade() == Grade.VIP) {
            return discountFixAmount;

discount 메서드는 Member와 price를 받는다.(Member member, int price) 그렇게 Member 클래스에 있는 getGrade메서드를 사용하여 등급이 VIP이면 discountFixAmount를 리턴하여 가격의 1000원을 할인할 수 있도록 한다.

✔️  order

► Order

: 고객의 주문을 나타내며 최종 금액 계산

public Order(Long memberId, String itemName, int itemPrice ,int discountPrice) {
        this.memberId = memberId;
        this.itemPrice = itemPrice;
        this.itemName = itemName;
        this.discountPrice = discountPrice;
    }

테스트 코드를 짜면 인자를 받게 되는데, 그 인자를 받아 필드를 초기화하는 것이 Order 생성자가 하는 일이다. 

인자에 대해서 쉽게 설명하자면 테스트 코드에 위의 매개변수(memberId, itemName 등) 안에 구체적인 값이 들어가게된다. 그것을 인자라고 하는데

••• 이어서 다른 코드 부분 •••

public Long getmemberId() {
	return memberId;
}

public String getItemName() {
	return itemName;
    }

getter를 이용하여 memberId와 ItemName을 접근할 수 있도록 했다. 그 이유는 Order 클래스에서 변수를 private으로 정의했기 때문에 Order 클래스가 아닌 다른 외부 클래스에서 해당 객체 정보를 가져오고 싶으면 getter를 통해야한다. 

만약 getter를 통해 다른 외부 클래스에서 해당 객체를 가져오고 싶다면, 앞에서 봤듯이 order.getmemberId();를 쓰면 된다.

••• 이어서 다른 코드 부분 •••

public String toString() {
        return "Order{" +
                "memberId=" + memberId +
                ", itemName='" + itemName + '\'' +
                ", itemPrice=" + itemPrice +
                ", discountPrice=" + discountPrice +
                '}';
    }

toString은 객체가 가지고 있는 여러 정보를 문자열로 반환해준다.

Q. 만약 toString을 쓰지 않는다면 어떻게 출력이 될까?

Order order = new Order(1L, "Laptop", 1000, 100);
System.out.println(order);​

A. 예제로 chat-GPT가 만들어줬다. 출력결과는 [ Order@5e2de80c ] 이렇게 나오게 된다.
즉, toString을 쓰지 않는다면 memberId,itemname,itemprice,discountprice가 쭈욱- 출력되어 결과값을 파악하기 어려울 수 있다.

► OrderServiceImpl

: 주문 고객을 확인하여 등급에 맞는 할인정책을 적용 한다.

    private final MemberRepository memberRepository = new MemoryMemberRepository();
    private final DiscountPolicy discountPolicy = new FixDiscountPolicy();

주문 고객 내용을 가져오고, 그에 맞는 할인 정책을 가져오기 위해 코드를 선언했다. 구현체를 다른 구현체로 바꾸는 걸 외부에서 수정할 수 없도록 final로 정의했다.

••• 이어서 다른 코드 부분 •••

 @Override
     public Order createOrder(Long memberId, String itemName, int itemPrice) {
         Member member = memberRepository.findById(memberId);
         int discountPrice = discountPolicy.discount(member, itemPrice);
         return new Order(memberId, itemName, itemPrice, discountPrice);
}

createOrder라는 메서드로 반환타입은 Order가 된다. 이걸 잘 이해하기 위해 테스트 코드를 먼저 살펴보도록 하겠다. 테스트 코드 OrderServiceTest를 보면 Order order = orderService.createOrder(memberId, "itemA", 10000);이란 코드가 있다.

인자가 createOrder로 매개변수에 맞춰 들어오고 memberId는 memberRepository로 들어가 회원 정보를 찾는다.(회원정보 찾는 것을 통해 회원 등급, 회원 이름 등을 알았을 것이다.) 그리고 얻어낸 회원 정보(member)와 상품 가격을 가지고 discountPolicy에 있는 discount 메서드에 전달하면 회원 등급이 VIP인 경우 1000원을 할인하라는 코드에 맞춰 discountFixAmount를 반환 받을 것이다. 그럼 1000원이란 값을 할인한다는 정보가 discountPrice에 저장된다.

이렇게 해서 Order(주문을 받아 최종 계산하는 클래스)에서 요구하는 매개변수에 맞는 정보를 모두 전달할 수 있게 되었다.

다시 테스트 클래스로 가겠다. Assertions.assertThat(order.getDiscountPrice( )).isEqualTo(1000);이 있다. 이 코드는 getDiscountPrice가 1000원이랑 동일한지에 대해 묻는 코드인 것이다. 그럼 아까 위에 있던 테스트 코드에서 Order에 있는 객체 정보들을 order에 넣고 Order 클래스에 있는 getDiscountPrice 메서드를 이용하여 값 private으로 선언된 할인 값을 받아올 수 있게 된 것이다.  그렇게 1000원이 맞는지 확인하는 과정이 된 것이다.

[ ▶︎ ]

혼자 천천히 공부하며 작성했습니다.

잘못된 내용이 적혀있을 수 있으니, 감안하고 봐주시면 감사하겠습니다.

🍀 모두들 화이팅하세요 🍀

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️  전위형, 후위형 증감 연산자_ 86p

• 전위형

: ++가 변수보다 먼저 나오는 것

int a = 3;
int b = ++a;
System.out.println(a);
System.out.println(b);

1) int b = ++a
    : a 앞에 ++가 먼저 있는 전위형으로 a의 값은 1 상승한 4가 된다.
2) int b = ++a
    : a는 4로 변경된 값은 왼쪽에 있는 b에 넣어준다.
3) System.out.println(a);
    : a의 값은 변경되었다. ++가 앞에 있게되면서 a의 값이 변경되고 그 후 b에 넣어주게 된 것이다.
       그러므로 a값은 4가 된다.
4) System.out.println(b);
    : b의 값은 4가 된다.

• 후위형

: ++가 변수보다 뒤에 나오는 것

int c = 3;
int d = c++;
System.out.println(c);
System.out.println(d);

1) int d = c++;
    : c의 값이 먼저 d에 들어간다. 그렇게 d의 값은 3이 넣어진다.
2) int d = c++;
    : 그 후에 c의 값이 1 상승한다. 그렇게 a는 4가 된다.
3) System.out.println(c);
    : c는 1 상승한 값이 4가 된다.
4) System.out.println(d);
    : d는 ++가 나오기 전 a의 값을 담았기에 3이 된다.

✔️  논리연산자와 비트연산자 차이점_ 100p

• 논리연산자

: 쇼트섯킷으로 연산을 수행하는 과정에서 결과가 이미 확정됐을 때 나머지 연산과정을 생략한다.

int a, b, c;

a = 3; b = 3; c = 3;

System.out.println(false && a++ > 6);
System.out.println(true || b++ > 6);
System.out.println(true ^ c++ > 6);

System.out.println(a);
System.out.println(b);
System.out.println(c);

1) System.out.println(false && a++ > 6);
   : 논리연산자는 쇼트 서킷으로 값이 결정나면 뒤의 계산을 안한다고 했다.
     &&(AND)는 두 값이 모두 true여야 true 값이 최종적으로 나오는데,
    이미 false가 있으므로 굳이 뒤의 계산은 하지 않고 넘어간다.

2) System.out.println(false && a++ > 6);
    : 계산을 하지 않으므로, a는 3으로 그대로 남는다.

3) System.out.println(true || b++ > 6);
    : ||(OR)는 둘 중에 하나만 true여도 true값이 최종적으로 나온다.
     위의 식에선 true가 이미 나오므로 굳이 뒤의 계산은 하지 않고 넘어간다. b는 그대로 3인된다.

4) System.out.println(true ^ c++ > 6);
     : ^(XOR)는 true-false(false-true) 값이 나오면 true이고, true-true 혹은 false-false 값이 나오면 false이다.
      앞에 나온 값이 true이므로 뒷 계산을 쭉 해봐야 최종값을 알 수 있다.

5) System.out.println(true ^ c++ > 6);
     : c++는 4가 되고 그 값이 6보다 큰 지를 묻는다. 4 > 6은 틀렸으므로 (true ^ false)가 된다. 최종값은 true가 된다.

6) 그러면 각 값을 살폈을 때, a와 b는 뒤의 계산을 하지 않았으니 초기 설정된 값 3이 출력된다.
     그리고 c는 계산을 끝까지 했기에 증감되어 4가 나온다.

• 비트연산자

int a, b, c;

a = 3; b = 3; c = 3;

System.out.println(false & a++ > 6);
System.out.println(true | b++ > 6);
System.out.println(true ^ c++ > 6);

System.out.println(a);
System.out.println(b);
System.out.println(c);

1) System.out.println(false & a++ > 6);
  : 비트연산자는 논리연사자와 다르게 쇼트서킷이 없다. 해당 값이 false로 나오더라고 a의 값은 1 증가하여 4가 되는 것이다.
2) 그래서 불리언값은 논리연사자와 같지만 각 변수의 값은 다르게 된다. 
3) a,b,c 모두 증가하여 4로 출력된다.

✔️  삼항연산자_ 103p

(참 또는 거짓) ? 참일 때 연산 결과 : 거짓일 때 연산 결과

int a = 2;

int b = (a % 2 == 0) ? 10: 20
System.out.println(b);

1) int b = (a % 2 == 0) ? 10: 20
    : 첫번째로 괄호 안의 계산식으로 봐주면 된다. a는 1로 2로 나눈 나머지값을 묻는데 2로 1을 나눴을 때 나머지 값은 1이된다.
      그러므로 괄호 안의 식은 false가 된다.
2) int b = (a % 2 == 0) ? 10: 20
    : 괄호 식의 값이 true면 10, false면 20의 값이 최종적으로 결정된다.
     1)에서 살펴본 괄호 값의 결과는 false로 b의 값은 20이 된다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️  자료형 선언하기_ 55p

// 자료형 변수 = 값;

int a = 3;
String b = "mybymine";

• 자료형

: 메모리 공간은 목적에 따라 크기와 특징을 나눠준다.

기본자료형 : boolean, byte, short, int, long, chr
참조자료형 : 배열, 클래스, 인터페이스

• 변수

: 메모리 공간에 부여하는 이름

사물함이 있다고 가정했을시, 사물함은 메모리가 된다.
그리고 그 사물함에 부여된 번호나 문자가 변수가 된다.

주의사항
(1) 자료형은 반드시 사용하기 전에 선언한다.
(2) 자료형은 반드시 한 번만 선언한다.

•  값

: 변수에 저장되는 값

✔️  이름 작성시 주의사항_ 59p

1. 특수 문자는 밑줄(_)과 달러($) 표기만 사용가능하다.
2. 아라비아 숫자는 사용가능하나 첫번째 자리는 안된다.
3. 자바에서 사용하는 예약어(public, int, static 등)는 사용불가하다.

•  변수명을 지을 때 권장 사항

: 낙타표기법

int ourClassNum;

•  상수명을 지을 때 권장 사항

: 상수는 변수와 구분짓기위해 모두 대문자로 사용

final int MY_DATA;

Q. 상수와 변수의 차이는 무엇일까?
A. 상수는 변할 수 없는, 고정된 값을 의미하고 변수는 변할 수 있는 값을 말한다.
    그렇기에 변수 앞에 final을 붙이면 상수가 된다.

➰ㅤ final에 대하여...

final은 변수, 메소드, 클래스에 붙일 수 있다.
(1) 변수에 붙으면 변경할 수 없는 값, 상수가 된다.
(2) 메소드에 붙으면 override가 제한되는데, 상속받은 클래스에서 해당 메소드를 수정하지 못하게 한다.
(3) 클래스에 붙으면 해당 클래스는 상속이 불가하다.

〰️  final 메소드 관련 예시 〰️ 

class A {
    final void display() {
        System.out.println("mybymine");
    }
}

class B extends A {
    void display() {
        System.out.println("java velog!");
    }
}​

class A에 final void display가 붙으면서 이 값은 변경할 수 없게 됐다.
그래서 class B에서 A를 상속받아 display( )값을 바꿔 출력하려해도 final이 붙어있기 때문에 override에 실패하게 된다.

ㅤ- final 관련 정보 출처

➰ㅤ그렇다면 override는 무엇인가?  

상위 클래스에 정의된 변수 혹은 메소드를 하위 클래스에서 재정의하는 것이다.
(1) 오버라이딩(overriding)은 상속 관계에서만 가능하고
(2) 오버로딩(overloading)은 동일클래스 또는 상속 관계에서 가능하다.

- override 관련 정보 출처

✔️  자료형의 종류_ 63p

•  메모리의 영역

첫번째 영역 - 클래스 영역, 정적 영역, 상수 영역, 메서드 영역

두번째 영역 - 스택 영역 (변수들이 저장되는 공간)

세번째 영역 - 힙 영역 (객체들이 저장되는 공간)

•  기본자료형과 참조자료형

기본 자료형 - int, float, double, char 등 잘 알고있는 자료형

참조 자료형 - class, interface, enum으로 기본 자료형을 기초로 하여 만들어진 자료형

•  실제 데이터 값

기본 자료형: 스택 메모리(두번째영역)에 실제 변숫값을 저장한다

참조 자료형: 실제 데이터값은 힙 메모리에 저장 -> 스택 메모리에 힙 메모리의 위칫값 저장한다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

: 출처 예스24 홈페이지

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️  클래스 선언부_ 45p

public class Test {

}

• public

: 다른 패키지에서도 사용할 수 있다는 의미를 지닌 접근지정자다.

 몇 개의 클래스가 존재하든 최대 1개의 클래스만 public을 포함할 수 있다.

접근지정자(접근제한자, Access Modifier)란?
public - protected - private - default로 클래스나 인터페이스 혹은 그들이 가지는멤버의 접근에 제한을 거는 것이다.
9장에서 자세히 알아볼 것이다.

• class

: 클래스라는 것을 알려주는 자바 키워드다.

Q. 만약 class가 아닌 interface라면?

public interface Test {

}

• Test

: 클래스명 뒤에는 { 내부구성요소를 포함한 } 중괄호가 오며 클래스명은 반드시 소스파일 이름과 일치해야한다.

내부구성요소?
필드(Field), 메서드(Method), 생성자(Constructor), 이너 클래스(Inner class)이다.
이 4종류를 제외한 것들은 올 수 없다.

✔️  main( ) 메서드_ 45p

‣ 바이트 코드(.class)가 메서드 영역에 로딩되면 자바 가상 머신은 main( )메서드부터 찾는다.
‣ 실행 이후 가장 먼저 실행되는 메서드가 main( )라는 것이다.

public static void main(String[] args) {

}

• static

: 정적 메서드

Q. static을 붙이는걸까?
A. main 메서드는 프로그램이 시작할 때 가장 먼저 호출되는 메서드이다.
    static은 객체의 생성없이 메모리에 할당시켜 메서드를 호출 가능하게 해준다.

    즉, main 메서드는 가장 먼저 실행되기 때문에 객체 생성이 없다.
    그때 static을 붙여주지 않으면 실행할 객체가 없기 때문에 실행이 취소된다.
    하지만 static은 메모리에 항상 상주하도록 설정하기 때문에 객체가 없는 main이 죽지 않게 방지한다.ㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤ

- static 참고한 tistory

• void

: 리턴 타입으로 메서드가 수행한 작업의 결과를 반환하는 데이터 타입을 의미한다.

void는 리턴값이 없음을 나타낸다.
메서드가 어떤 작업을 수행하긴 하지만 그 결과값을 반환하지 않는 경우에 사용된다.

- void 참고한 velog

• Strings[  ] args

: 매서드의 매개변수로, 문자열을 나타낸다.

➰ 이해가 안가서 Chat-GPT씨에게 여쭸다.

java YourProgram arg1 arg2

 

1. 명령프롬프트나 터미널에 위의 코드를 적어준다.
   여기서 YourProgram은 실행할 클래스 이름, arg1과 arg2는 프로그램에게 전달한 명령줄 인수가 된다.
   
   
2. JVM이 실행되고 JVM이 YourProgram을 찾아 main 메서드를 실행한다.
   
   
3. main 메서드의 매개변수 String[ ] args는 ["arg1", "arg2"]와 같은 형태의 배열로 초기화한다.
   여기서 args[0]에는 첫 번째 인수인 "arg1"이 저장되고, args[1]에는 두 번째 인수인 "arg2"가 저장된다.

System.out.println("첫 번째 인수: " + args[0]);
System.out.println("두 번째 인수: " + args[1]);

 

4. 결과:
    첫 번째 인수: arg1
    두 번째 인수: arg2

내가 이해하기론, 인수의 이름(?)은 문자열로 쓰도록 약속했고
그렇기때문에 그 인수를 제대로 받을 수 있게 main 메서드의 매개변수를 String으로 지정한 것 같다.

나중에 다시 알아보고 싶다... 🥲

👁️‍🗨️ 잘못된 내용이나, 저에게 더 알려주고 싶은 내용은 댓글로 남겨주세요. 🐻