이해가 안되는 프로세스들은 컨트롤러 로그 하나하나 디버깅해가면서 어떤 데이터 넘겨받는지도 확인을 했었고, 하면서 이렇게 혼자 파악하는게 맞는건가? 의문을 가지기도 했어요.

초기에 입사했을 당시에 회사가 많이 바빠서 저희팀 리더님이 혼자서 프로젝트를 5개씩 가지고 있었던 시기여서 그때 당시에는 그분의 시간을 뺏으면 안되겠다는 생각이 들어서 최대한 막힐때까지 다 찾아봤던거 같아요. 그러다가 도저히 혼자서 해결이 안된다 싶은 부분들은 바로 윗 선임님에게 물어봐서 해결했어요. 그때 당시에 저랑 18개월정도 차이가 나시는 분이었으니, 제가 막히는 부분들은 어느정도 해소가 되기도 했어요. 여기서 막히면 파트 리더님에게 물어봤죠. 본인들이 많이 바빠서 옆에서 도와주지 못하는 부분에 대해서 미안해하시기도 하셨고요.

저는 비전공자 출신의 국비지원 학원 출신인데, 당시에 강사님이 30년 이상 현직개발자 생활을 하셨던 베테랑이셨는데, 안되면 로그찍어서 확인을 하나하나 해보라고 강조를 많이 하셨어요. 그리고 개발자들이 쓸데없는 질문하면 겉으로 티는 안내도 싫어한다는 얘기를 많이 하셨어요. 그때 그 교육이 강하게 뇌리에 박혀버린건지, 질문을 하기 전에 이게 정말 내가 내놓을 수 있는 결과의 최선이었나? 내가 빠트린부분은 없었나를 한 번 더 생각하게 되다보니, 이게 또 질문을 위한 검토과정을 다시 한 번 거치게 되니까 진도가 느려지는 경향이 있었어요. 지금은 익숙해져서 어디까지가 내가 혼자할 수 있는 부분이고, 어디부터 내가 막히는지 이런 것들을 빠르게 파악할 수 있게 되기도 했고요. 그리고 또 질문을 하다보면 정리를 해놓지 않고 궁금하다가 바로 물어보면 이게 서로의 시간이 뺏기는 경향이 발생한다는 것도 느껴서, 어느시점부터는 애초에 궁금한 부분에 대해서 간단한 이미지로 문서화를 통해서 질문을 받는 상대방 입장에서 최대한 빠르게 파악하실 수 있도록 신경을 쓰게 되는 것 같아요. 정말 도움을 받으면서 그 사람 시간까지 많이 뺏고 싶지 않달까 제 성격 문제인거 같기도 해요.

그래서 "어떻게 질문을 잘 할 수 있을까"는 늘 고민을 하게 되는 부분이에요. 이렇게 하게된 이유가 항상 업무를 구두로 넘겨받아서 이게 내가 파악한 부분이랑 일치하는건지 확인하는데 시간이 너무 많이 걸리더라고요. 그래서 업무를 받아도 일단 받아서 내용을 파악한 다음에 "업무 내용을 이렇게 이해했는데 이게 맞나요?"를 자주 하는 것 같아요. 상대방 피곤하게 하는게 아닌가 싶기도 한대, 곧이곧대로 제 선에 파악 끝내고 개발해서 결과물 나왔을때 의도와 다른 결과물이면 다시 작업해야되잖아요. 다시 하면 저야 좋죠, 일하면서 새로 공부하는거니까 근데 회사 입장에선 손해죠, 다른일 시킬거 못 시키니까.

그래서 질문이 정말 중요한거 같아요. 그리고 제발 좀 문서화 좀... 10번 물어볼거 혼자 파악하고 한두번 확인만 하면 되잖아요...

처음에는 바로 만들 수 있을줄 알고 바로 코드에 손을 댔었고, 그렇게 실패를 겪고나서는 어떻게하면 로직을 완성 시킬 수 있을까 방법적인 부분들을 순차적으로 정리해서 나열해봤다.

그 와중에 기능이나 특징으로 인해서 구현할 수 없었던 부분들은 새로 만들거나 계획을 수정을 해서 시도를 다시 해봤고,

그렇게도 잘 되지 않아서 list set dict 이와 관련된 함수들 append() strip() replace() len() 등을 다시 학습하고 시도하고 콘솔찍어서 어떻게 출력되는지 확인해보고 다시 학습하고 시도하고를 반복해서

4시간 만에 만들 수 있었다. 누군가에게는 시간낭비일지도 모른다고 생각하지만, 어쨌든 이러한 로직을 만드는 것에 대해서 생각해보고 실행시켜나가는 과정에서 사고의 흐름을 좀 더 명확하게 그리고 단순화시켜서 현실에 대입해볼 수 있었던 것 같다.

그동안 수업 일정과 프로젝트 시도 및 학습, 복습 등으로 인해서 따라하기 바빴던 점도 사실이지만, 이제는 논리적으로 사고하는 습관들에 대해서 신경을 써보려고 한다.

#단어 찾기 로직 만들어서 구현하기 :: 총 4시간 걸렸음

file = open('raiseup.txt', "r")
text = file.read()
wordList = text.split()
print("=============================================")
print(text)
print("=============================================")
print("wordList: \n",wordList)
print("wordList: ",type(wordList))      #wordList:  <class 'list'>
print(len(wordList))
print("=============================================")
print()

'''
해당 문서에 포함된 있는 문자 갯수 세기 로직

list에서 공백과 불필요한 문자 제거
두 개의 동일한 리스트 만들고,
하나는 중복 제거(set)하고 다시 list에 담아서 as A
남은 하나는 비교군으로 as B 사용해서

A에 포함되어 있는 단어가 B에 몇개 있는지 카운팅(count)해서
dict에 key:value로 담기
'''

#wList : 리스트
wList = []
i = 0
#반복문 돌려서 wList 리스트 채우기
while i < len(wordList):
    #word = wordList[i].replace(',','').replace(';','').replace('-','').strip()
    word = wordList[i].strip(','';''-''')   #불필요한 문자 제거
    wList.append(word)
    i += 1
print("type(word): ", type(word))
#wList: 불필요한 문자 정리가 끝난 리스트
print("type(wList): ", type(wList))
print("len(wList): ", len(wList))
print("wList: ", wList)
print("=============================================")
print()

#wwList: 중복제거가 끝난 집합 자료형을 다시 리스트로 변환
wwList = set(wList)     #중복제거
wwList = list(wwList)   #리스트에 담기
print("type(wwList): ", type(wwList))
print("len(wwList): ", len(wwList))
print("wwList: ", wwList)
print("=============================================")
print()

#listDict: 이제 문자 카운팅해서 listDict에 key:value 로 넣기
listDict = {}
i = 0
while i < len(wwList):
    count = wList.count(wwList[i])
    listDict[wwList[i]] = count
    i += 1
print(" '' 제거 전 len(listDict): ", len(listDict))
#'' 인 key 제거, 총 65개 -> 64개로 바뀜
del listDict['']
print(" '' 제거 후 len(listDict): ", len(listDict))
print("type(listDict): ", type(listDict))
print("listDict: ", listDict)
print("=============================================")
print()

for key in listDict.keys():
    print(key, ": ", listDict[key])

데이터베이스 내에서 변별 가능한 객체
정보가 저장될 수 있는 사람, 장소, 사건 그리고 개념 등 보이지 않는 개념도 포함한다.

2. 특징

• 반드시 해당 업무에서 필요하고 관리하고자 하는 정보여야 한다

• 유일한 식별자(Unique Identifier)(인스턴스를 구별하는 식별자)에 의해 식별 가능해야 한다.
• 두 개 이상의 (영속적으로 존재하는)인스턴스의 집합
• 업무 프로세스(Business Process)에 의해 이용되어야 한다
• 반드시 속성(Attributes)이 있어야 한다.

• 예외 관계엔터티(Associative Entity)의 경우, 주식별자 속성만 가지고 있어도 엔터티로 인정한다.

• 다른 엔터티와 최소 1개 이상의 관계가 있어야 한다.

• 예외, 통계성(Read Only)/코드성/시스템처리시 내부 필요(ex.트랜잭션 로그 테이블 등)에 의한 엔터티는 관계 생략 가능

3. 분류

• 유무형에 따른 분류

• 유형엔터티(Tangible Entity) : 물리적 형태 : 사원, 물품, 강사
  • 개념엔터티(Conceptual Entity) : 개념적 정보 : 조직, 보험상품
  • 사건엔터티(Event Entity) : 업무수행시 발생 : 주문, 청구, 미납

• 발생시점에 따른 분류

- 기본/키엔터티(Fundamental Entity, Key Entity) : 
    그 업무에 원래 존재하는 정보
    타 엔터티의 부모 역할
    주식별자를 상속받지 않고 자신의 고유한 주식별자를 가짐
    ex) 사원, 부서 등
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- 중심엔터티(Main Entity) : 
    기본 엔터티로부터 발생
    다른 엔터티와의 관계로 많은 행위 엔터티 생성
    ex) 계약, 사고, 예금원장, 청구, 주문, 매출 등
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- 행위엔터티(Active Entity) : 
    2개 이상의 부모 엔터티로부터 발생
    자주 바뀌거나 데이터량이 증가
    분석초기 단계에서는 잘 나타나지 않으며,
    상세 설계단계나 프로세스와 상관모델링을 진행하면서 도출될 수 있다.
    ex) 주문목록, 사원변경이력

4. 엔터티의 명명

• 현업업무에서 사용하는 용어 사용
• 가능하면 약어를 사용하지 않는다
• 단수명사를 사용
• 고유한 이름 사용
• 생성의미대로 이름을 부여한다

2. 항(operand) : 연산에 사용하는 값

    ex) 단항 연산자: 항이 한 개 -> n++
        이항 연산자: 항이 두 개 -> n1 + n2
        삼항 연산자: 항이 세 개 -> (n1 > n2) ? 1 : 0

3. 연산자 종류

- 대입연산자 = : 오른쪽 변수 값이나 식의 연산 결과값을 왼쪽 변수에 대입
       ex) int i = 10;

- 부호연산자 +, - : 변수나 상수값을 양수, 음수로 만든다. 
    ex) +10, -10

- 산술연산자 +, -, *, /, % : 덧셈, 뺄셈, 곱셈, 나눗셈, 나머지

- 증가/감소연산자 ++, -- : 연산자 앞이나 뒤에 사용하여 값을 1만큼 늘리거나 1만큼 줄인다.
    ex) n = ++num; : 먼저 num값이 1 증가한 후 n에 대입
        n = num++; : num값을 n에 대입한 후 num값이 1 증가

- 관계연산자 : 왼쪽항과 오른쪽항을 비교해서 참과 거짓을 반환한다.
    > : 왼쪽 항이 크면 참, else 거짓, (great than)
    < : 왼쪽 항이 작으면 참, else 거짓, (less than)
    >= : 왼쪽 항이 크거나 같으면 참, else 거짓, (great than or equal)
    <= : 왼쪽 항이 작거나 같으면 참, else 거짓, (less than or equal)
    == : 두 개의 항의 값이 같으면 참, else 거짓, 상등연산자, equalilty
    != : 두 개의 항이 다르면 참, else 거짓

- 논리연산자 
    && : 두 항 모두 참인 경우만 참, else 거짓
    || : 두 항 중 하나만 참이어도 참, 두 항 모두 거짓이면 거짓
    !  : 참인 경우 거짓으로, 거짓인 경우 참으로 바꾼다

- 복합대입연산자 
    += : 두 항의 값을 더해서 왼쪽 항에 대입
    -= : 왼쪽항에서 오른쪽 항을 빼서 그 값을 왼쪽 항에 대입
    *= : 두 항의 값을 곱해서 왼쪽 항에 대입
    /= : 왼쪽 항을 오른쪽 항으로 나누어 그 몫을 왼쪽 항에 대입
    %= : 왼쪽 항을 오른쪽 항으로 나눈 나머지를 왼쪽 항에 대입

- 조건연산자 (조건식 ? 결과1: 결과2) : 조건식이 참이면 결과1, 거짓이면 결과2

4. 연산자 우선순위

- 단항 연산자가 가장 높고 이항, 삼항 연산자 순서이다.
- 대입 연산자의 우선순위가 가장 낮다.
- 산술, 관계, 논리, 대입 연산자 순서로 우선순위를 가지며 ()의 우선순위가 가장 높다.
- 연산의 진행 방향은 단항과 대입 연산자("<--")를 제외하고는 ("-->") 방향이다.

1. 생성자(constructor)란?

• new 키워드를 사용해서 어떤 클래스에 대한 오브젝트(인스턴스)를 생성할 때, 자동적으로 호출되어 실행되는 특수한 메소드이다.
• 생성자가 하는 일은 클래스를 처음 만들때 멤버변수나 상수를 초기화하는 것이다.
• 생성자는 오브젝트 생성시 한 번만 수행된다.
• 기본적으로 메소드기 때문에 메소드의 특징을 그대로 가지고 있지만 반환값이 없다.

2. 생성자(Constructor) 작성 규칙

• 생성자의 이름은 함수지만 클래스의 이름과 동일하게 붙인다.
• 생성자의 리턴형은 지정하지 않는다.(void 라고 쓰지도 않는다)
• 오버로드된 형태로 여러 개의 생성자를 작성할 수 있다.
• 클래스 작성시 생성자를 정의하지 않으면 디폴트 생성자(default constructor)가 제공된다.
• 왜냐면 기본적으로 생성자 하나를 컴파일 과정에서 자바의 컴파일러가 만들어주기 때문이다.
• 디폴트 생성자는 매개변수가 없고 구현 코드도 없다.

3. 생성자 오버로드란(overload)?

• 서로 다른 시그니처를 갖는 여러 함수를 같은 이름으로 정의하는 것이다.

  ex)

  • 오브젝트(인스턴스) 생성 문장 -> 호출되는 생성자 Member m = new Mebmer(); -> Member() Member m1 = new Member(10); -> Member(int a) Member m2 = new Member(10, “abc”); -> Member(int a, String s)

4. 함수 시그니처(Method Signature)란?

• 두 함수의 이름, 매개변수의 개수, 그 타입이 모두 같다면 이 두 함수의 시그니처는 같다고 할 수 있다.

• 두 함수는 시그니처가 같다.

    ex)
            int sum ( int a , int b , double c);
            int sum ( int i    , int m    , double x);

5. 추가사항

자바 컴파일러는 생성자가 하나도 없는 경우에만 디폴트 생성자를 제공한다.
따라서 프로그래머가 생성자를 직접 추가하면 디폴트 생성자는 만들어지지 않기 때문에,
디폴트 생성자를 만들지 않은 상태에서 오브젝트를 디폴트 생성자로 생성하려고 한다면,
당연하게도 오류가 발생한다. 
그렇기 때문에 디폴트 생성자를 사용하고자 한다면 꼭 디폴트 생성자도 선언을 해주어야 한다.

  ex) public String rMethod(String str){
          return str;
      }

2. void 예약어 : return이 없는 함수. 함수의 끝에 따로 return을 해줄 필요가 없다.

  ex) public void addM(int x, int y){
          int xx = x;
          int yy = y;
          int zz = xx + yy;
          System.out.println(zz);
      }

- 1,2 를 통해서 두 예약어는 동시에 사용될 필요가 없다는 사실을 알 수 있다.
- void 예약어를 사용하지 않을 경우 반드시 return값(선언했던 데이터타입)을 반환해야 한다.

3. public 예약어 : 선언된 멤버변수, 함수, 생성자는 외부 클래스 어디에서나 접근할 수 있다.

4. private 예약어 : 같은 클래스 내부에서만 사용할 수 있다.

• 외부 클래스에서 직접 접근할 수 없다.
• 이를 객체 지향에서는 '정보은닉'이라고 한다.

5. protected 예약어: public과 private의 중간 정도의 역할을 한다.

• 해당 클래스를 상속받은 자식클래스에게 public처럼 동작
• 그외 클래스에겐 private처럼 동작

- 3,4,5 를 접근제어자(access modifier)라고 하는데, 
클래스 내부의 변수나 함수 그리고 생성자에 대한 접근 권한을 지정할 수 있다.
아무것도 쓰지 않는 경우 : 기본값으로 동일 패키지 내에서만 public처럼 동작한다.

• final 예약어를 사용해서 선언한다.

  ex) public final static int MAX_VALUE = 100;
                            -> 숫자 상수 MAX_VALUE
    public final static String MEMBER_BOARD = "M"; 
                                -> 문자 상수 MEMBER_BOARD

• 상수의 이름은 모두 대문자로 하며, 1개 이상의 단어로 이루어진 경우 "_"로 구분한다.

  ex) MAX_VALUE, MEMBER_BOARD

• 상수를 선언하고 초기화했을 경우, 그 값을 변경하면 안된다.

  ex) final int MAX_VALUE = 100;
     MAX_VALUE = 0; -> 위에 선언 후 초기화를 했기 때문에 사용할 수 없다.

• 상수를 선언만 했을 경우 사용하기 전에 초기화를 꼭 해주어야 한다.

2. 리터럴(Literal) : 프로그램에서 사용하는 모든 숫자, 문자, 논리값을 뜻한다. 기본자료형을 참고.

• 예를 들어 'A', 65, 3.14 와 같은 문자와 숫자를 리터럴 혹은 리터럴 상수라고 한다.

• 리터럴은 프로그램이 시작할 때 시스템에 같이 로딩되어 특정 메모리 공간인 상수풀(constant pool)에 놓인다.

  ex) int i = 10; 

  숫자 10이 메모리 공간 어딘가에 존재해야 변수 i에 그 값을 초기화 할 수 있기 때문에 일단 숫자값이 어딘가 메모리(상수풀)에 놓여있고, 이 값이 변수 i에 초기화될 수 있는 것이다.

• 참고로 문자열 리터럴의 경우 객체화된 문자열과 비교해서 생각을 해야한다.

2. 멤버변수(Member variable) : 클래스 영역에 선언된 변수를 의미한다.

- 멤버변수는 프로그램의 어디에서나 접근할 수 있어서, 어느 위치에서든 호출이 가능하다.

- 선언할 때는 초기화를 하지 않는다.

- 해당 클래스에 public키워드가 붙으면 패키지 밖에서도 호출할 수 있게 되는데,
 이때 멤버변수를 전역변수(Global variable)라고도 할 수 있다.

- 이렇게 클래스에 선언된 멤버변수를 인스턴스변수(Instance variable)이라고도 부른다.
 인스턴스 변수는 객체가 생성될 때마다 새로운 주소를 가진 변수가 생성된다.
 이러한 인스턴스 변수는 객체가 생성되서 Heap 영역에 할당될때마다 Stack에 생성된다.
 그렇기 때문에 뒤에 설명할 클래스변수와 비교하여 공유되지 않는다.

- 이번에는 멤버변수에 static 키워드가 붙은 경우 클래스변수(Class variable)라고 한다.
 프로그램이 실행되면 메모리에 할당되는데 프로그램이 종료되어야지만 메모리에서 사라진다.
 클래스변수는 모든 인스턴스가 하나의 저장공간을 공유하게 된다.
 이때 저장되는 공간은 Static 영역이라고 한다.
 클래스의 객체가 여러번 생성되어도 static 키워드가 붙은 클래스변수는 처음에 딱 한 번만 생성된다.
 그렇기 때문에 동일한 클래스의 모든 객체들이 공유한다.
 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야하는 속성의 경우 선언하기 때문에 
 객체지향적인 자바에서 주로 쓰이진 않는 것 같다.

3. 지역변수(Local variable): 함수(method) 블럭{} 안에 있는 변수

- 변수가 선언된 블록 내에서만 유효하고, 블록이 종료되면 메모리에서 사라져 사용할 수 없게 된다.

- 지역변수들은 해당 블록을 벗어나면 소멸하게 되기 때문에, 특정 구역 내에서만 사용이 가능하다.

- 메소드에 선언된 변수가 있다면 그 지역변수는 메소드가 호출될 때마다 매번 새롭게 할당된다.

- 지역변수는 멤버변수와 다르게 선언과 동시에 초기화를 해야한다.

- 그 메모리 제거를 가비지컬렉션(Garbage Collection)에서 관여한다.

4. 다음은 멤버변수 vs 지역변수, 클래스변수 vs 인스턴스변수 그리고 전역변수를 시각화하였다.

public class Test {        //public키워드가 붙어있는 클래스다.
    int var1;             //멤버변수,전역변수
     static int var2;     //멤버변수(클래스 안에 있음),전역변수
                        //클래스변수(static키워드가 붙어 있음)

    public void fun() {    
        int var3;         //지역변수(함수 안에 있음)
    }
}

*변수가 선언되고 메모리를 할당받는 순서와 그 위치를 보다 정확히 알면 변수에 대해서 더 많이 이해할 수 있겠다고 생각한다.

1. 형변환(type conversion) : 데이터 타입을 변경하는 것이다.

2. 형변환을 이유 :

예를 들어 byte형(1byte 자료형)과 int형(4byte 자료형)의 연산을 한다고 생각해보자.
데이터 타입이 달라서 그 크기가 다르기 때문에 하나의 자료형으로 통일한 후 연산을 해야한다.
이때 형변환이 이루어진다.

3. 형변환의 종류

- 묵시적 형변환 : 크기가 작은 자료형에서 큰 자료형으로 형변환, 업캐스팅이라고도 한다.
                 묵시적 형변환의 경우 데이터의 손실이 없으므로 자동으로 형변환된다.

                ex) byte b = 10;
                    int i = b;

                      -> int형 변수 i에 그것보다 작은 타입의 변수 b를 초기화해서
                    자동적으로 묵시적 형변환이 이루어졌다.

- 명시적 형변환 : 크기가 큰 자료형에서 작은 자료형으로 형변환
                 명시적 형변환의 경우 작은 데이터 타입에 큰 데이터가 들어가서
                강제적으로 형을 바꾸기 위한 명시적 형변환을 해주어야한다.

                ex) int i = 10;
                      byte b = (byte)i;

                    -> byte형 변수 b에 그것보다 큰 타입의 변수 i를 초기화해서
                    강제적으로 명시적 형변환을 해주었다.

4. 참고

- boolean을 제외한 나머지 기초자료형은 서로 형변환이 가능하다.
- 기초자료형과 참조자료형은 서로 형변환을 할 수 없다.
- 형변환은 데이터타입이 다른 경우 그 데이터타입을 똑같이 만들어주기 위해서 사용된다.
- 자바에서 부모와 자식간의 관계에도 형변환이 가능하다.(이를 업캐스팅, 다운캐스팅이라고 한다.)

최근에 회원가입 페이지를 만들어서 그 회원정보를 DB에 저장하는 방법들과 그 동작 순서와 원리들을 MVC 패턴을 통해서 학습하고 있다.

- HTML 문서로 회원가입 페이지를 만들고(member.html)
- jsp(memberInsert.jsp)를 이용해서 html문서에서 입력한 회원정보 데이터를 DB Column에 맞게끔 다듬어서
- VO 클래스에 옮겨담는 과정을 거친 후(MemberVO.java)
- Service인터페이스(MemberService.java -> MemberServiceIm.java 로 구현된)의 함수를 사용해서
- DAO 인터페이스까지 연결해 준 후 DAO인터페이스의 함수를(MemberDAO.java -> MemberDAOImpl.java로 구현된) 통해서
- DBMS로 가기 위한 연결정보(Connection.java 에 코드로 입력해둔 URL,IP,PORT,SID 정보)를 가져와서 MS의 DB에 도달했다.
- 그 후 INSERT와 관련된 쿼리문을 작성해야 되는데, 
- 식별과 관리가 편하도록 미리 만들어둔 QuerySql클래스(MemberQuerySql.java)의 함수를 사용해서
- DAOImp 내에서 이러한 쿼리들을 문자열 형태로 반환 받아서 
- PreparedStatement 클래스(PreparedStatement.java)를 사용해서 INSERT 쿼리문을 입력,
- DB 안의 TableSpace 내에 있는 해당 Table의 칼럼 인덱스에 매칭되는 회원정보를 저장해주었다.

이때 DBMS 에 접근하여 쿼리문을 작성하고 데이터를 저장할 수 있었던 것은 ojbdc6.jar 에 내장되어 있던 Connection, PreparedStatement를 사용할 수 있었기 때문이다. 이런점들이 객체 지향의 장점이 아닐까 생각했다.

그 후 저장했던 데이터의 정보 전체를 가져와서 확인 및 수정 하기 위해서 
새로운 jsp 파일(memberSelectAll.jsp)을 만들었고, 
정확한 데이터 정보와 형식을 가져올 수 있도록 코딩하는 작업을 거쳤다.

그 코딩 중 가장 많이 생겼던 실수가 "오타"였는데, 오타로 인해서 생긴 문제점은 정말 찾아내기가 어려웠다.
가장 좋은 방법은 실수와 오타가 없게끔 하는 것이겠지만, 이건 주의를 기울여서 조심을 해야되는 부분이었다.

처음에는 오타라는 생각을 하지 못했고, 어떤 부분들이 빠져있는지 알 수 없어서, 
클래스와 함수, 쿼리문 등을 좀 더 자세하게 들여다보면서 이어지는 연결점들을 통해서 문제점을 찾아보려고 했다.
하나하나 코드를 다 읽어가면서 문제점을 찾으려고 하다보니 코딩을 작성했던 시간만큼 많은 시간이 소요되었지만, 
그만큼 다시 한번 리뷰할 수 있는 계기가 되었기 때문에 학습하는 입장에서는 의미있었다고 생각한다.
하지만 실제로 현장에 가서 문제가 생길때마다 이렇게 많은 시간들을 소요하면서 원인을 찾아내지 못하게 된다면, 
좀 아찔하지 않을까.

이러한 경험을 통해서 console에 log를 찍어두고 하나하나 살펴보는 과정들이 
얼마나 중요한 일인지 깨닫게 되는 계기가 되었다. 
또한 그 log들을 통해서 내가 원하는 데이터가 제대로 전달되었는지 확인하는 과정이 필요하다.
실제로, 발생하는 오류가 어디에서 발생했는지 찾는 것이 너무 어려워서, 
함수 시작점과 끝점에 로그를 하나하나 다 새겨보았더니, 어떤 문제가 있었는지까지는 바로 알 수 없었지만,
적어도 어느 지점쯤에서 문제가 발생했는지 정도까지는 빠르게 찾아낼 수 있었다.

잘 만들어서 문제없이 서비스를 제공하는 것도 굉장한 일이겠지만, 
반대로 문제 없이 제공되고 있던 서비스들이 성장을 이어나가고 그러한 과정에서 
기존에는 없었던 문제점들이 생긴다면(아직은 어떤 문제점들이 생길지까지는 모르겠다)
최대한 신속하게 문제점을 발견하는 것도 중요하고, 
그걸 해결해나가는 과정 또한 정말 중요하겠다는 생각을 하게 되었다.

그래서일까 선생님께 항상 하시던 말씀이 
"지금 당장 문제가 없는 코드보다 문제가 있는 학생의 코드에서 더 많은 것을 배울 수 있다"
라고 하셨나보다.

문제가 생겼을 때, 어떤 문제점들이 생겼는지를 고민해보고 이를 해결하는 과정들은 학생 혹은 개발자에게 꼭 과정인 것 같다.
서비스를 만드는 과정 자체도 중요하고 어렵겠지만, 
문제점을 찾아서 하나하나 해결해가면서 이를 풀어가는 과정들이 병행된다면 
그 코드들에 대한 좀 더 정확한 이해를 통해서 더 개선되고 나은 서비스를 제공할 수 있게되지 않을까?
물론 아직은 당연하게도 혼자서 코드를 치고 서비스를 내놓을 수 있을만큼의 학습과 숙련도가 이루어지진 않았다.
(22년7월28일이 첫 수업이었으니, 몇일이 지나면 2달이 꽉 채워진다. 시간 정말 빠르게 지나간다.)

그래도 주어진 문제들이 있고, 혹은 해야될 과제가 있다면, 
이를 해결하거나 완수해나가는 과정들과 이를 통해 학습하고 성장하는 과정들이 너무나도 재밌어서 다행이다.

학원에 처음 갔을때 담당 과장님께서 "7개월을 7년 같이 보내자" 이런 말씀을 하시기도 하셨고,
선생님께서는 "오늘의 내가 어제의 나보다 성장했다는걸 느낄 수 있다면 된다"라고도 하셨는데,

개발자로서 살아가면서 이 두 가지는 항상 마음에 품고 실천하려고 한다.

1. 클래스(Class) : 객체(object)의 속성(변수)과 기능(함수)을 코드로 구현한 것이다.

객체를 클래스로 구현하는 것을 '클래스를 정의한다' 라고도 한다.
클래스는 단독으로 사용할 수도 있고, 객체를 생성해서 그 객체를 이용할 수도 있다.

예시로, 자동차 객체를 생각해보면, 

첫째, 자동차를 표현할 클래스의 이름을 Car라고 하겠다.
둘째, 자동차 객체가 가지는 일반적인 속성은 엔진배기량, 소비연료, 차량형태 등이 있는데
이런 클래스 속성(혹은 특성)은 클래스 내부에 변수(variable)로 선언한다.
셋째, 자동차 객체의 일반적인 기능들은 전진, 후진, 중립, 브레이크, 신호깜박이 등이
있는데 이런 클래스 기능을 클래스 내부에 함수(method)로 선언한다.

다음은 예시로 든 자동차 객체를 클래스로 구현(클래스를 정의)한 코드이다.

package classstudy;

public class Car{
    int displacement;    //배기량 변수
    String fuel;        //연료 변수
    String appearance;    //외형 변수

    public static void String Drive(){        //전진 함수
        System.out.println("앞으로 전진합니다.");
    }
    public static void String Reverse(){    //후진 함수
        System.out.println("뒤로 후진합니다.");
    }
    public static void String Break(){        //브레이크 함수
        System.out.println("멈춥니다.");
    }
}

2. 클래스의 종류

클래스는 두 종류가 있다.
1. 사용자정의 클래스
2. 빌트인(Built-in) 클래스 
    -> java.lang.String 클래스와 같이 rt.jar에 내장된 클래스들
        ex)
            Integer 빌트인클래스 숫자다루는클래스
            Byte     빌트인클래스 숫자다루는클래스
            Short    빌트인클래스 숫자다루는클래스
            Long     빌트인클래스 숫자다루는클래스
            Float     빌트인클래스 숫자다루는클래스
            Double     빌트인클래스 숫자다루는클래스
            Character 빌트인클래스 문자다루는클래스
            Boolean 빌트인클래스 논리다루는클래스
            String     빌트인클래스 문자열다루는클래스
            System     빌트인클래스 시스템과통신할때다루는클래스

3. 클래스 규칙

클래스는 첫 글자가 항상 대문자로 시작해야 한다.
Java파일명은 반드시 클래스 이름과 일치해야 한다.
하나의 자바 파일에 여러 개의 클래스가 있을 수도 있지만, public 클래스는 단 하나이다.

1.객체(Object)

사람, 자동차, 학생, 밥, 버스 등 눈에 보이는 사물은 모두 객체라고 할 수 있다. 물론 주문, 생산, 관리, 판매 등의 눈에 보이지 않는 것도 객체가 될 수 있다. 즉, 객체는 어떠한 대상이라고 할 수 있다. 객체는 속성과 동작으로 구성되어 있다. 예를 들어, 자동차를 떠올리면 우리가 생각할 수 있는 어떤 정의 혹은 이미지를 속성이라고 할 수 있고, 그 자동차가 가진 역할 혹은 기능이 동작이라고 할 수 있다.

2. 객체 지향 프로그래밍(Object Oriented Programming)

객체를 사용하는 하는 프로그래밍이다. 객체를 클래스를 통해서 정의하고 객체(클래스) 간의 협력을 프로그래밍하는 것이다. 클래스는 객체의 속성과 기능을 코드로 구현한 것이다. 이러한 객체의 속성을 변수(Variable), 동작을 함수(Method)라고 한다. 자바(Java)는 객체 지향 프로그램이다.

3. 객체 지향 프로그래밍에 대해서 좀 더 자세하게 예시를 들어보겠다.

예를 들어, 자동차를 생각해보자.

자동차의 구성요소들은 정말 다양한다.

자동차의 뼈대가 되는 바디와 샤시가 있고, 또 그 바디에는 트렁크, 범퍼, 도어, 보닛 등이 들어간다. 
샤시는 바디를 제외한 나머지 부분으로서, 자동차를 동작하기 위해 필요한 장치들을 말한다.
브레이크, 엔진, 조향장치 등이 해당한다.

운전자는 이러한 구성요소와 동작방식들을 알 필요가 없다.
드라이브, 리버스, 중립, 파킹 그리고 엑셀과 브레이크 핸들조작 정도의 방법만 알면 충분히 운전을 할 수 있다.

이를 가능하도록 하기 위해서 자동차 안에는 수많은 구성요소들이 포함되어서 도움을 준다.
자동차, 트렁크, 범퍼, 도어, 보닛, 브레이크, 엔진, 조향장치 등을 객체라고 한다면,
그 객체를 속성(변수)과 동작(함수)으로 다시 분리할 수 있다.
각각의 이름을 변수로 하고 그 기능과 동작들을 함수로 구현하는 것이다.
그렇게 각각의 객체들이 협력하여 하나의 자동차를 만들어 내는 방식을 객체 지향 프로그래밍에 비유할 수 있다.

자동차라는 객체가 다른 객체들을 이용해서 자신의 기능을 완벽하게 구현하면
운전자는 자동차를 운전하는 방법만 배워오면 쉽게 운전할 수 있게 된다.

이렇게 객체를 속성(변수)과 동작(함수)으로 나눠서 이러한 동작들을 객체끼리 
가져다가 쓰는 방식을 객체 지향 프로그래밍이라고 한다.

1. 변수(variable) : 데이터를 담는 공간(주소값)

변수는 값을 넣을 수 있는 빈통과 같다.

2. 선언 : 클래스, 함수 또는 변수와 같은 것이 존재한다고 말한다.

그 클래스나 함수 또는 변수가 단지 존재한다고 말하는 행위를 선언이라고 한다.

3. 변수 초기화 : 변수라는 통에 데이터 값을 담는 행위

ex) byte b = 1 ; 

    byte  :  byte 자료형(변수가 가진 공간의 특성을 의미)
    b       :  변수 이름
    =       :  대입연산자, 이를 통해 우항의 것을 좌항으로 넣는다.
    1       :  숫자
    ;       :  세미콜론, 종결연산자, 문장 종결행위

byte 자료형 변수b를 선언한다. 그리고 숫자 1을 변수b에 초기화한다.
이때 숫자 1을 변수 b에 담는 행위를 초기화라고 한다. 정확히는 
위 문장을 JVM(JavaVirtualMachine)이 읽으면서 해당 값을 초기화한다.

 변수는 컴퓨터 내부의 메모리 공간에 저장된다. 메모리는 프로그램이 실행되는 작업 공간이다.
byte b; 라는 문장을 선언하면, 메모리에 2byte 크기의 공간이 b라는 이름으로 할당된다.
byte라는 자료형을 가진 변수 이름이 b가 되는 것이다. 그리고 이 메모리를 변수 b로 사용하겠다는 의미이다. 
또한 변수 b에 초기화된 값이 있다면 변수를 연산에 사용하거나 값을 출력할 일이 있을 때 
이 공간에 있는 값을 가져와야 한다. 이때 사용하는 것이 변수 이름이다.

 즉, 변수를 선언한다는 것은 선언한 변수 이름으로 어떤 *위치에 있는 메모리를 
얼마만큼의 크기로 사용하겠다는 의미이다.

자바에서 클래스명, 메서드명, 변수명 등 이름을 짓는데 각각의 지켜야 할 규칙이 있다. 
편의성을 위해서 함께 소개하기로 하겠다.

 - 클래스명의 첫 글자는 대문자로 한다.
 - 메서드명, 변수명의 첫 글자는 소문자로 한다. 
 - 변수 이름은 영문자(대문자, 소문자)나 숫자를 사용할 수 있고, 특수 문자 중 "$, _"만 사용할 수 있다. 
 - 변수 이름은 숫자로 시작할 수 없다.
 - 자바에서 이미 사용중인 예약어(keyword)는 변수 이름으로 사용할 수 없다.
 - 1개 이상의 단어로 이루어진 경우 단어의 첫 글자는 대문자로 한다. ex) countOfWords
 - 상수의 이름은 모두 대문자로 하며, 1개 이상의 단어로 이루어진 경우 "_"로 구분한다.
   ex)COUNT_OF_WORDS

1. 기본자료형(Primitive type)

자바 라이브러리에서 기본으로 제공하며. 얼마만큼의 메모리를 어떻게 사용할 것인지가 이미 정해져 있다. 기본자료형은 각 자료형이 사용할 공간의 크기(바이트 수)가 정해져 있어서 범위를 초과하는 값을 사용할 수 없다

  1. 정수형 : 양수, 음수, 0을 나타내는데 사용하는 자료형

    - byte형  : 부호1bit, 지수부7bit  8bit(1byte)를 사용한다.
    - short형 : 부호1bit, 지수부15bit 16bit(2byte)를 사용한다.
    - int형   : 부호1bit, 지수부31bit 32bit(4byte)를 사용한다.
    - long형  : 부호1bit, 지수부63bit 64bit(8byte)를 사용한다.

  2. 실수형 : 소수점을 나타내는데 사용하는 자료형

    - *부동소수점 방식을 통해서 실수를 표현한다. 정수와 조금 다른방식으로 표현한다. 
     float형  : 부호1bit, 지수부8bit,  가수부23bit로 32bit(4byte)를 사용한다.
     double형 : 부호1bit, 지수부11bit, 가수부52bit로 64bit(8byte)를 사용한다.

    *지수와 가수를 구분해서 표현하는 방식이다.

  3. 문자형 : 문자를 나타낸다. 문자열(String)과 구분해서 사용해야한다.

    - 컴퓨터는 0과1로만 표현할 수 있다. 
     문자 역시 컴퓨터 내부에서 표현할 때 0과1의 조합으로 나타내야 한다. 
     그래서 어떤 문자를 컴퓨터 내부에서 표현하려면 특정 정수 값으로 정하자고 약속을 한다. 
     예를 들어 '알파벳 대문자 A를 65로 표현하기로 약속'하는데, 그와 같은 형태로 다른
     문자들도 약속을 한다. 이런 코드 값을 모아 둔 것을 '문자 세트'라고 한다.

      문자를 정해진 코드값으로 변환하는 것을 '문자인코딩(encoding)'이라고 한다.
     반대로 코드값을 문자로 다시 변환하는 것을 '문자디코딩(decoding)'이라고 한다.
     가장 기본이 되는 문자 인코딩은 **아스키(ASCII)코드이다.

     ** 영문자, 숫자, 특수 문자 등을 나타내는 문자 세트이다.

  4. 논리형 boolean : 어떤 변수의 참, 거짓의 값을 나타내는데 사용한다.

    - 정수형 상수의 기본형은 int , 실수형 상수의 기본형은 double 으로 인식을 한다.
     그래서 long과 float를 사용할 경우 각각 L과 F를 뒤에 붙여서 인식을 시켜줘야 한다.

2. 참조자료형(Reference type)

참조자료형은 클래스형이다. 자바에서 제공하는 것도 있고 개발자가 직접 만들어서 사용하는 클래스도 있다.

3. 바이트 크기와 범위 및 디폴트값(default value)

*그렇게 이해를 하고 있는데 아니라면 꼭 좀 알려주시면 도움이 될 것 같습니다.

1. 컴파일(compile)

• 컴파일 : 프로그램이 프로그래밍 언어 문법에 잘 맞는지 확인하고,
            컴퓨터가 이해할 수 있는 언어로 번역하는 작업이다.

• 컴파일러 : 위와 같은 작업을 하는 프로그램을 컴파일러라고 한다.

2. 패키지(package)

• 패키지도 자바의 키워드이다.
• 클래스의 최대 단위는 패키지다.
• 패키지는 수많은 클래스 파일의 묶음이다.
• 자바의 클래스는 패키지 단위로 관리를 한다.
• 패키지의 형태는 디렉토리 모양과 동일하게 생겼다.
• .(dot)연산자는 패키지의 구분자이다.
• 패키지는 영문자 소문자로 작성한다.
• 패키지는 유니크해야 한다.

                package a.b.c.com;
                public class HelloPackage{
                    System.out.println("Hello Package");
                }

자바 소스 코드에서 클래스의 패키지 선언은 위와 같이 맨 위에서 한다. 클래스의 이름은 "HelloPackage"이지만, 클래스의 전체 이름은 "a.b.c.com.HelloPackage" 이다. 이를 "NameSpace"라고 한다. 클래스의 이름이 같아도 패키지 이름이 다르면 클래스의 전체 이름이 다르므로 다른 클래스가 된다.

3. 패키지 컴파일(package compile)

일반적으로 컴파일은 해당 통합 개발 환경(IDE: Integrated Development Environment)에서 자동적으로 처리해주기 때문에 직접 컴파일을 확인하기 위해서 MS DOS console을 이용한다.

1. 해당 자바소스 파일이 있는 폴더를 찾아간다. 해당 파일이 C드라이브에 있다고 가정하겠다.

2.    C:\> javac -d . HelloPackage.java
   
        - HelloPackage.java : 자바소스 파일
        - javac    : 컴파일 명령어
        - -d     : 디렉토리를 만들어서 그 위치에 클래스 파일을 만든다.
        -  .     : dot 연산자, 현재 디렉토리부터 패키지를 만들기 시작한다.

3. 컴파일이 성공적으로 수행되었다면 다음의 경로로 클래스 파일이 생성되었을 것이다.

             C:\a\b\c\com\HelloPackage.class

4. 자바 명령어를 사용해서 클래스파일을 실행시켜보자.

             C:\>java a.b.c.com.HelloPackage 
             Hello Package

위와 같이 "Hello Package"가 출력되었다면 패키지 컴파일을 성공적으로 수행한 것이다. 클래스의 전체 이름 "a.b.c.com.HelloPackage"을 "NameSpace"라고 했다. 자바를 통해 클래스를 실행하려면 NameSpace를 입력해줘야 한다.

1. 식별자(identifier): 임의로 만들어서 사용할 수 있는 이름

    ex) 클래스이름 / 함수이름 / 변수이름

    - 식별자는 사용하는 규칙이 있다.

    - 클래스이름은 대문자로 시작하고 함수 및 변수는 소문자로 시작한다.
    - 두 단어를 조합하여 이름을 정할 때는 조합하는 문자의 첫글자를 대문자로 한다.
    - 첫 글자는 문자로 시작해야 된다.
    - 문자 사이에 공백을 가질 수 없다.
    - 대소문자를 구별한다.
    - 예약어는 식별자로 사용할 수 없다.
    - 한글도 식별자로 사용할 수 있지만 권장하지는 않는다.

2. 예약어(keyword): 자바에서 미리 예약되어 있는 명령어

        abstract    continue        for            new            switchassert
        package        synchronized    boolean        do            if        
        private        this            break        double        implements
        protected    throw            byte        else        import    
        public        throws            case        instanceof    return    
        transient    catch            extends        int            short    
        try            char            final        interface    static    
        void        class            finally        long        strictfp    
        volatile    float            native        super        while

3. 자원(resource): rt.jar 안에 있는 다양한 API들

    ex) java.lang. / java.util. / java.io. / java.sql. 등

rt.jar 파일을 살펴보면 위와 같이 다양한 클래스들을 확인할 수 있다. 이러한 클래스 하나하나를 통해서 자바를 보다 쉽고 편리하게 사용할 수 있다.

사용법들은 Java API 를 살펴보면 된다.

1. JDK, JRE 구성요소

• JDK : Java Development Kit : 개발용

  • javac.exe
  • java.exe

• JRE : Java Runtime Environment : 배포용

  • java.exe
    

2. 역할

• javac.exe : 자바소스코드(자바 규칙에 맞게 작성된 코드)를 JVM(JavaVirtualMachine)이 읽을 수 있게 규칙을 검사하는 엔진(컴파일러), 검사가 완료되면 클래스코드(byte code)를 생성한다.

• java.exe : 실행엔진 : 컴파일된 클래스 코드를 실행해주는 엔진

• compile : 소스코드를 컴퓨터가 알 수 있게 해주는 행위

  
  

3. Hello Java 콘솔에 출력하기

c:\Exam>javac Hello.java        :컴파일이 성공적으로 수행됬으면 Hello.class(생성)
c:\Exam>java Hello                :class파일을 실행할때 확장자를 작성하지 않아도 된다.
Hello Java                        :출력결과

과정 : Hello.java(실행) -> javac.exe(컴파일) -> Hello.class(생성) -> java.exe(실행)
    -> console 결과 : Hello Java 출력

1. 내 컴퓨터 정보체크 : 내가 사용하는 도구 정보 확인

운영체제 : 윈도우10 / 64bit (윈도우 - 설정 - 시스템 - 정보 등)

2. jdk 다운로드 : oracle.com

계정만들기 유/무료버전 구분하기(2022.08.01 기준 1.8 _202 ver.까지 무료)

3. 환경변수 설정

(윈도우 - 설정 - 시스템 - 정보 - 고급 시스템 설정 - 시스템 속성 팝업 - 고급탭(환경변수(N)))

새 시스템변수 팝업

변수이름 : JAVA_HOME 변수값 : C:\Program Files\Java\jdk1.8.0_202

시스템 변수(S) 에서 변수 - path 선택 - 편집 버튼

환경변수 편집 팝업

새로만들기 버튼 - %JAVA_HOME%\bin 가장 위로 이동