1. 절단위 요약

제3장 부자들이 주식을 고르는 방법2

1절 재무제표 모르면 투자하지 마라

• 재무제표 읽고 이해하기 (이것만 해도 됨)
• 재무제표는 재무상태표, 손익계산서, 자본변동표, 현금흐름표 4가지로 구성
• 재무상태표(=자산내역) : 현금, 유가증권, 부동산 등 기업이 가진 자산의 내역
• 부채 : 타인의 자본을 빌린 내역
• 자기자본(내돈) : 자산 - 부채
• 자본은 다시 주주가 출자한 돈(자본금과 자본잉여금)과 기업이 벌어들인 돈(이익잉여금)으로 나뉨
• 손익계산서(=기업용 가계부) : 고객에게 판매한 수입(매출액)부터 시작해서 기업의 경영에 사용된 각종 지출(매출원가 및 판관비)을 제하고 난 이익까지 기록한 내용
• 자본변동표 : 재무상태표의 자본 항목 변화를 좀더 자세히 기록한 장부
• 투자 아이디어를 설명하는 데는 추정 손익계산서 작성으로 충분함

2절 회계가 무엇인지부터 알아야 한다

• 투자 아이디어의 시작은 매출액이다 (매출액 = 판매량 x 판매단가)
• 실제 출고가를 알아야 한다 (소비자가와 혼돈하지말 것)
• 총 시장 규모는 고객의 가처분소득(한 해의 개인 소득에서 세금을 빼고 그 전해의 이전 소득을 합한 것)의 총합을 벗어날 수 없음
• 기업에 투자할 때 시장규모와 생산능력도 반드시 체크
• 필립 피셔 - "넑은 시장, 뛰어난 제품, 훌륭한 경영자를 가진 기업에 투자하라."
• 그의 아들 켄 피셔 - "일시적 결함이 있을 때 투자하라"
• 매출액 증감에 따른 이익의 변환를 계산할 때 공헌이익을 사용하면 좋다
• 신영자산운영은 영억이익률이 낮지만 꼭 필요한 제품을 만드는 회사에 장기 투자해두면 언젠가 반드시 이익률이 개선되는 때가 오는데 이때 영업이익의 극적인 개선에 주가가 급등하면 매도한다
• 자본총계(=주주의 돈)는 주주가 출자한 자본금과 회사가 주주에게 벌어준 이익잉여금으로 나뉨
• 이익잉여금이 늘어나는 회사를 찾아라.
• 손익계산서를 보면 하수, 현금흐름표를 보면 중수, 재무상태표를 보면 고수라는 말이 있다
• 액면가과 유보율로 주식의 가치 보장은 못한다
• 유보율 = 기업의 잉여금 / 자본금
• 복식부기? 기업의 자산과 자본의 변화 과정 및 결과를 거래의 이중성 또는 대칭관계를 전제로 기록하는 것
• 내용연수? 통상적으로 유형자산을 사용할 수 있는 기간을 말함 (ex. 건물 1530년, 자동차 37년)
• 기업의 가치를 평가할 때 매출액 다음로 기본이 되는 숫자는 영업이익이다.
• 투자수익율 = (매각단가+주당배당금) / 매입단가 - 1 (단위: 원)

• 개인사업자 레모네이드 매출액 (매출액 = 판매단가 x 판매개수) 20잔/일 x 1,500원/잔 = 30,000원
  
• 개인사업자 레모네이드 시장규모 (시장규모 = 판매단가 x 연 판매개수) 주말 2일 x 참석가능축제수 4개 x 4계절 x 80잔/일 = 판매일수 32일 x 80잔/일 = 2,560잔 = 2,560잔/연 x 레모네이트 1,500원/잔 = 3,840,000원
  
• 개인사업자 레모네이드 한 잔당 제조단가 = 탄산수 400원/병 + 레몬 200원/반 개 + 얼음 200원/잔 + 기타 부재료(컵,빨대 등등) 100원 = 900원
  
• 개인사업자 레모네이드 매출원가 (매출원가 = 제조단가 x 연 판매개수) = 900원/잔 x 2,560잔/연 = 2,304,000원
  
• 개인사업자 레모네이드 매출총이익 (매출총이익 = 매출액 - 매출원가) = 매출액 3,840,000원 - 매출원가 2,304,000원 = 1,536,000원 매출총이익률 = 매출총이익 / 매출액 = 40%
  
• 개인사업자 레모네이드 공헌이익 (공헌이익 = 매출액 - 변동비) = 매출액 3,840,000원 - 매출원가 2,304,000원 = 1,536,000원 공헌이익률 = 공헌이익 / 매출액 = 40%
  
• 수정된 개인사업자 레모네이드 매출원가 = 900원/잔 x 2,560잔/연 + (쏘카 5,000원 + 동생 일당 5만원) x 판매일수 32일 = 변동비 2,304,000원 + 고정비 1,760,000원 = 4,064,000원
  
• 수정된 개인사업자 레모네이드 매출총이익 (1) 매출액 3,840,000원 - 매출원가 4,064,000원 = -224,000원 (2) 공헌이익 1,536,000원 - 고정비 1,760,000원 = -224,000원 매출총이익률 = 매출총이익 / 매출액 = -6%
  
• 가격 인상을 반영한 개인사업자 레모네이드 공헌이익 매출액 = 2,500원/잔 x 2,560잔/연 = 6,400,000원 변동비 = 900원/잔 x 2,560잔/연 = 2,304,000원 공헌이익 = 매출액 - 변동비 = 4,096,000원 공헌이익율 = 공헌이익 / 매출액 = 64%
  
• 가격 인상을 반영한 개인사업자 레모네이드 매출총이익 (1) 매출액 6,400,000원 - 매출원가 4,064,000원 = 2,336,000원 (2) 공헌이익 4,096,000원 - 고정비 1,760,000원 = 2,336,000원
  
• 개인사업자 레모네이드의 손익계산서 매출액 = 김주린 사업부 매출액 + 김동학 사업부 매출액 = 2,500원 x 2,560잔/연 + 2,500원 x 2,560잔/연 = 6,400,00원 + 6,400,00원 = 12,800,000원 매출원가 = 김주린 사업부 변동비 + 김동학 사업부 변동비 + 고정비 = 900원 x 2,560잔/연 + 900원 x 2,560잔/연 + 55,000원 x 32일 = 2,304,000원 + 2,304,000원 + 1,760,000원 = 6,368,000원 매출총이익 = 매출액 - 매출원가 = 6,432,000원 판매비와 관리비 = 김동학 사업부 매출액 6,400,000원 x 판매수수율 30% = 1,920,000원 영업이익 = 매출총이익 - 판관비 = 4,512,000원

• 주식회사 레몬카페 창업비용 보증금 5,000만 원 인테리어 비용 1,500만 원 커피머신, 냉장고 등 집기 구매 2,00만 원 초기 운전자금 등 잡비 및 예비비 1,500만 원
  
• 주식회사 레몬카페 자산총계 현금 10,000만 원
  
• 주식회사 레몬카페 재무상태표
• 자산총계 10,000만 원* 현금 10,000만 원
• 부채총계 2,500만 원* 아빠론 2,5000만 원
• 자본총계 7,500만 원* 자본금 7,500만 원 이익잉여금 0만 원
  
• 주식회사 레몬카페 주식사무 (7,500만 원 자본금) 액면가 5,000원/주 발행주식수 15,000주 자본금 = 액면가 5,000/주 x 발행주식수 15,000주 = 7,500만 원
  
• 주식회사 레몬카페 주주명부 김주린 10,000주 = 납입금 5,000만원 / 액면가 5,000원/주 (지분율 약 66,7%) 김개미 5,000주 = 납입금 2,500만원 / 액면가 5,000원/주 (지분율 약 33.3%)
  
• 주식회사 레몬카페 재무상태표
• 자산총계 11,800만 원* 현금 3,300만 원 보증금 5,000만 원 커피 머신, 냉장고 등 집기 2,000만 원 인테리어 1,500만 원
• 부채총계 4,300만 원* 미지급금 1,800만 원 아빠론 2,5000만 원
• 자본총계 7,500만 원* 자본금 7,500만 원 이익잉여금 0만 원
  
• 할부금융이 종료된 이후를 가정한 주식회사 레몬카페 재무상태표
• 자산총계 10,000만 원* 현금 1,500만 원 보증금 5,000만 원 커피 머신, 냉장고 등 집기 2,000만 원 인테리어 1,500만 원
• 부채총계 2,500만 원* 아빠론 2,5000만 원
• 자본총계 7,500만 원* 자본금 7,500만 원 이익잉여금 0만 원
  
• 주식회사 레몬카페 한 달 치 손익계산서
• 매출액 1,000만 원*
• 매출원가 440만 원* 원재료 구입대금 400만 원 카드 수수료 40만 원
• 매출총이익 560만 원*
• 판관비 375만 원* 아르바이트생 급여 75만 원 임차료 50만 원 관리비 50만 원
• 영업이익 185만 원*
• 영업외손익 -20만 원* 아빠론 이자비용 -20만 원
• 법인세차감전이익 165만 원*
  
• 수정된 주식회사 레몬카페 한 달 치 손익계산서
• 매출액 1,000만 원*
• 매출원가 298만 원* 원재료 구입대금 200만 원 카드 수수료 40만 원 집기 및 인테리어 감가상각비 58만 원 (집기 2,000만 원 + 인테리어 1,500만 원) / 내용연수 5년 / 12개 월 = 약 58만 원
• 매출총이익 702만 원*
• 판관비 375만 원* 아르바이트생 급여 75만 원 임차료 50만 원 관리비 50만 원
• 영업이익 327만 원*
• 영업외손익 -20만 원* 아빠론 이자비용 -20만 원
• 법인세차감전이익 307만 원*
• 법인세 34만 원* (법인세차감전이익 307만 원 x 과세표준 2억 원 이하 법인세율(주민세 포함) 11% = 약 34만 원)
• 순이익 273만 원*
  
• 주식회사 레몬카페 회전율 지표 매출채권 회전율 = 매출액 12,000만 원(1,000만 원/월 x 12개월) / 매출채권 100만 원 = 120회 재고자산 회전율 = 매출원가 3,576만 원(298만 원/월 x 12개월) / 재고자산 200만 원 = 약 18회 매출채권회전일수 = 365일 / 120회 = 약 3일 재고자산회전일수 = 365일 / 18회 = 약 20일
  
• 한 달 후 주식회사 레몬카페 재무상태표
• 자산총계 11,907만 원* 현금 3,165만 원 매출채권 100만 원 재고자산 200만 원 보증금 5,000만 원 커피 머신, 냉장고 등 집기 1,967만 원 인테리어 1,475만 원
• 부채총계 4,134만 원* 미지급금 1,600만 원 미지급비용(법인세) 34만 원 아빠론 2,500만 원
• 자본총계 7,773만 원* 자본금 7,500만 원 이익잉여금 273만 원
  
• 주식회사 레몬카페 손익계산서
• 매출액 72,000만 원*
• 매출원가 20,064만 원* 원재료 14,400만 원 카드수수료 2,880만 원 감가상각비 2,784만 원
• 매출총이익 51,936만 원*
• 판관비 31,920만 원* 급여 17,520만 원 임차료 12,000만 원 관리비 2,400만 원
• 영업이익 20,016만 원*
• 영업외손익 0만 원*
• 법인세차감전이익 20,016만 원*
• 법인세 2,202만 원*
• 순이익 17,814만 원*
  
• 표준화된 이익 기준 주식회사 레몬카페 손익계산서
• 매출액 72,000만 원*
• 매출원가 20,064만 원* 원재료 14,400만 원 카드수수료 2,880만 원 감가상각비 2,784만 원
• 매출총이익 51,936만 원*
• 판관비 38,520만 원* 급여 20,520만 원 임차료 12,000만 원 관리비 2,400만 원 광고비 3,600만 원
• 영업이익 13,416만 원*
• 영업외손익 0만 원*
• 법인세차감전이익 13,416만 원*
• 법인세 1,476만 원*
• 순이익 11,940만 원*
  
• 주식회사 레몬카페 재무상태표
• 자산총계 53,561만 원* 현금 21,214만 원 매출채권 0만 원 재고자산 1,200만 원 보증금 20,000만 원 유형자산(집기, 인테리어 등) 11,147만 원
• 부채총계 0만 원*
• 자본총계 53,561만 원* 자본금 11,250만 원 주식발행초과금 3,750만 원 이익잉여금 38,561만 원
  
• 주식회사 레몬카페 유상증자 관련 주식사무 액면가 5,000원/주 발행가 10,000원/주 기존 발행주식수 15,000주 신규 발행주식수 7,500주 자본금 = 기본 자본금 7,500만 원 + 액면가 5,000원/주 x 신규 발행주식수 7,500주 = 11,250만 원 주식발행초과금 = (발행가 10,000원 - 액면가 5,000원) x 신규 발행주식수 7,500주 = 3,750만 원
  
• 주식회사 레몬카페 유상증자 후 주주명부 김주린 10,000주 = 기존 보유주식수 10,000주 (지분율 약 44.4%) 김개미 12,500주 = 기존 보유주식수 5,000주 + 납입금 7,500만 원 / 발행가 10,000원/주 (지분율 약 55.6%)
  
• 주식회사 레몬카페 배당금 지급 후 매각 전 최종 재무상태표
• 자산총계 3.2억* 현금 0.0억 매출채권 0.0억 재고자산 0.1억 보증금 2.0억 유형자산(집기, 인테리어 등) 1.1억
• 부채총계 0.0억*
• 자본총계 3.2억* 자본금 1.1억 주식발행초과금 0.4억 이익잉여금 1.7억

2. 장별 소요시간

3. 눈 근육 연습표

조급하면 망하는 법. 비싼 교훈이였다..

제가 주식을 망한 타임라인 입니다

• 2021년에 카카오게임즈로 반짝 수익 발생 (1천만원)
• 2022년 초반에 엔씨소프트와 LG생활건강 진입 (둘다 고점에서 살짝 내려온 상태..)
• NC는 그때 당시 하반기에 기대작이 나온다고 해서 ... , 생건은 중국 경제 부활을 꿈꾸며... 투자를 했죠
• 그러나 두 종목 다 10% 20% 50%로 수직 낙하하더군요.
• 물타기를 수차례 시도 했지만 소생 불가로 -50%이상 손절매했습니다 (이때까지 손절을 해본 적이 없네요, 첫 손절매..)
• 2023년부터는 원금만 복구하자는 마음으로 테마주에 손을 대기 시작합니다
• 상장주, 시즌주, 바이오주 등등 이리갔다 저리갔다 용을 써봤지만 계속 마이너스만 나더라구요
• 그래도 신용은 안 쓴게 불행 중 다행이라 위안을 삼고 있습니다
• 지난 10월, 마지막 심정으로 두산로보틱스에 (6만원)에 입성(상장된 첫날..) 했습니다
• 그러나 반토막이 되었고 물타기 한번 했습니다 (이때 정말 아찔하더라구요..)
• 최근에 30퍼 반등해서 지금은 조용히 회사만 다니고 있습니다…

아래는 두산로보틱스 내역...

손에 마이너스가 달렸는나 😭😭

솔루션 찾기 (ver. 2023/11/09)

저랑 비슷한 사람의 사연을 유튜브에서 발견하였다 그 영상을 보고 전문가가 제공하는 솔루션을 실행하기로 했다

링크: 오늘부터 '이런 주식' 팔고 현금 모으면서 준비하세요 (구해줘월부 주식상담) https://www.youtube.com/watch?v=GSwlgAUfSGo&ab_channel=%EC%9B%94%EA%B8%89%EC%9F%81%EC%9D%B4%EB%B6%80%EC%9E%90%EB%93%A4TV

위 영상에서 제공하는 전문가의 조언

• 1년 공부하면 벌 수 있다.

• 손절하고 그 주식은 돌아보지 말자 (마음 회복부터 하자!)

• 유튜브에서 한두 마디 한 것으로 의사결정이 된 것이면 누구나 다 부자 된다, 그것은 기준이 아니다.

• 습관 만들기 : 금액 말고 퍼센트로 말 할 수 있게 되자.

• 주식초보 공부법 :

  1) 일단 손절하라. 마음을 비우자.

  2) 실생활에서 내가 관심 있는 제품이나 서비스를 찾아라.

  3) 그리고 모의투자 또는 소액투자를 해보자. 하지만 반드시 실패할 것이다.

  4) 이렇게 찾은 회사의 주식이 왜 안 오를까 의문점이 생길 것이고 투자 아이디어에 대해 고민하게 될 것이다.

  5) 이때, 김현준 대표의 (주식 관련) 추천 도서 목록에서 제일 위에 있는 쉬운 책 2권 정도를 읽어보자.

  6) 그러면 투자 아이디어와 본질 가치를 이해하게 될 것이다.

  7) 내가 찾은 회사들의 진짜 투자 아이디어와 본질 가치를 다시 분석해보자.

  8) 내가 논리적으로 분석하였고 이 회사는 돈이 될 거라 판단된다면 주식을 다시 사보자.

  9) 하지만 또 실패할 것이다, 투자 아이디어를 재무제표로 바꿀 때이다.

  10) 다시, 김현준 대표의 추천 도서 중 재무제표 관련 책들을 읽는다.

  11) 좋은 투자 아이디어, 그리고 그 아이디어를 숫자(재무제표 분석)로 바꿔서 회사를 판단해 보고 좋으면 주식을 사보자.

  12) 하지만, 또 잃을 것이다. 아마 내가 비싸게 샀을 것이다. 저점 매수를 노려야 한다.

  13) 피터 린치, 필립 피셔, 워런 버핏, 모니시 파브라이, 이런 투자 거장들의 이야기책을 많이 읽어보자. (심신 수련을 해보자.)

  14) 책을 읽다 보면 다시 주식시장에 저점이 올 것이고 1년 정도 걸릴 것으로 보인다.

  15) 기회가 왔을때! 그동안 갈고닦은 기량으로 신중히 도전해 보자.

3가지로 요약하기

1) 관심분야 중 그 회사의 투자 아이디어와 본질 가치를 파악하자.

• 책: <부의 추월차선>, <가치투자의 비밀>, <경제적 해자>, <부자는 이런 주식을 삽니다>

2) 그리고 재무제표 공부하여, 발굴한 회사를 밸류에이션해보자.

• 책: <슈퍼 스톡스>, <어닝스 최고의 주식투자 아이디어>, <워렌 버핏처럼 사업보고서 읽는 법>

3) 투자 거장들의 책을 보면서 저점을 기다리자. 그리고 확신이 들면 도전해 보자.

11월 TODO LIST

1) <부의 추월차선>, <부자는 이런 주식을 삽니다> 2권 완독하고 요약하기 2) 위 책에서 작게 실행 할 수 있는 것들 찾아서 실행하기 2) <역행자> 읽기, 성공 7단계 요약 및 실행해 보기 3) 두산로보틱스 투자 아이디어와 본질 가치 파악해 보기

혹시 저처럼 고민하시는 분들을 위해 추천하는 영상들

1) 시골의사 박경철 https://youtu.be/vgQh-Hq7nBA?si=-hCCF48TGT9cR6jY

2) 방법을 알려줘도 99%는 안해요. 이번에도 안 하면 분명 후회합니다 (추천도서 너나위) [역행자 풀버전] https://www.youtube.com/watch?v=SREWb1tKkpo&list=PLE__UZ8Mop0tPzv4vGOBXaTQbgvq9_W4Y&index=3&t=48s&ab_channel=%EC%9B%94%EA%B8%89%EC%9F%81%EC%9D%B4%EB%B6%80%EC%9E%90%EB%93%A4TV

3) '이 비밀'을 알게 된 이후 돈을 버는 게 쉽게 느껴집니다 (추천도서 너나위) [레버리지 풀버전] https://www.youtube.com/watch?v=RAvrDyG9lmA&ab_channel=%EC%9B%94%EA%B8%89%EC%9F%81%EC%9D%B4%EB%B6%80%EC%9E%90%EB%93%A4TV

1. 독서 근육 (눈근육&머리근육의 시너지)의 능력

1) 눈 근육, 머리 근육 '정확하게' 목표설정

- 책 한쪽 : 20~30줄로 구성됨
- 책 한줄을 읽는데 1~2초 소요 (숙달된 사람은 1초 안 걸림)
- 한쪽 1분, 10분 읽으면 10쪽, 45분 읽으면 45쪽
- 목표: 휴일 하루에 책 1권!(45분 읽고 15분 쉬는 것 반복)

2) 눈 근육 연습 한달

- 눈 근육 연습은 10분 단위로!
- 내용이 파악 안되도 일단 좌->우로 줄을 읽어 내려간다
- 10분 독서 연습을 하면 한달이면 마스터 가능 (초기에는 스톱워치 꼭 사용)    
- 2쪽을 2분 이내에 읽도록 눈 근육 운동
- 2쪽, 다음에는 4쪽, 8쪽 점점 분량을 늘려서 연습
- 10분동안 쉬지 않고 눈을 좌우로 움직이며, 10쪽을 읽음
- 의미가 없어 보여도 한 달동안 연습하시면 책에 최적화된 눈운동이 체화됨
- 한 달만 꼭 참고 연습해보시기를 권함
- 고개를 움직이는 것이 아님, 눈만 좌우로 움직이는 것

3) 눈 근육, 머리 근육이 같이 움직이는 연습 한달

- 눈 연습 한달 이후 시작한다.
- 읽다가 뜻이 파악이 안되는 경우, 위로, 거꾸로 다시 돌아가서 읽음 (눈의 움직임이 자유자재로 된다는 뜻)
- 윗줄로 갔다가 그 다음 읽을 첫글자로 바로 가지 못하는 경우가 많음
- 왼손으로 읽는 부분 행의 처음을 짚어주면서 읽기
- 읽는 속도를 늘리는 연습 계속할 것
- 2쪽, 4쪽, 8쪽 단위로 분량을 늘려 가면서 연습
- 뜻이 파악되었다는 것이 무엇을 의미하는가
- 질적인 부분이라 지표 없음, 전체적인 맥락을 파악하면서 읽기
- 10분 읽고 (대략 10쪽) 쉬면서 읽은 것을 생각해보자 (약 1분 정도 생각)
- 10분씩 반복하여 45분 동안 독서 (하루에 책 한권 목표)

2. 메모하고 요약하는 능력

1) 읽고 자기 식으로 이해하기

- 목차를 확인한 뒤, 관심 가는 부분부터 읽기 (자기 생각 위주 독서법, 목차순 읽니는 필자 생각 위주 독서법)
- 10분에서 20분 정도 보기
- 본격적으로 읽기 (내게 궁금증을 유발하는 것들 위주로 읽기)
- 내용을 문달별로 읽어갈 때도 무조건 다 알아내려고 하는 것은 금물
- 눈에 들어오는 것, 마음에 와 닿는 것을 위주로 읽고, 나머지는 스킵해도 무방 (NEWS처럼 알고 싶은 것만 읽듯, 책도 편하게 읽기)
- 자기의 궁금증을 위주로 자기식으로 책을 읽고 내용을 자기식으로 파악하는 것이 아주 중요

2) 책에 표시하고 메모하기 (단, 내 지식으로 만들고 싶은 것만)

- 키워드 위주로 메모
- 표시는 동그라미, 밑줄 (표나 그림은 사진 캡처)
- 주의! 너무 많이 표시하지 않도록 억제하며 메모하기 (포스트잇 사용)
- 예외도 있음. 궁금한게 많은 쪽은 맑이 표시될 수 있음

3) 키워드로 요약하고 자기 식의 이야기로 재배열하기

- 절 단위로 키워드 요약
- 책 한권 요약 시 A4 3장을 넘지 않도록 조절
- 10줄 이내로 1개의 절을 키워드로 요약
- 머리에 남은 것을 중심으로 노트북에 타이핑 (주의! 책을 보면서 베껴 쓰면 안됨)    
- 기억이 나지 않으면 책에 메모, 표시된 부분을 다시 보고 키워드 요약
- 키워드를 참고하여 이야기 만들기
- 1개 절이 25쪽일 경우 읽는 데 2시간이 걸렸다면 요약 정리하는데 10~~15분이면 가능
- <90년생이 온다> 책 같은 경우, 20~30시간이면 읽고 정리하기 가능
- 좀 더 빨리하고 싶으면 읽지 않아도 될 절은 뺌
- 마지막으로, 전체 요약을 보면서 책의 목차와 상관 없이 목차를 재편해 보자

3. 읽은 책의 내용을 외우는 능력

1) 읽을 때 메모하기

- 2. 메모하고 요약하는 능력 참고
- 한 챕터를 읽고 기억나는 내용, 키워드를 쪽 입력하기
- 주의! 책을 보면서 문장 베끼지 않기, 키워드 위주로 정리 (기억에 의존!!)
- 50쪽(50분) 읽고 5분 정리 하기
- 요약문은 A4용지 3쪽을 넘기지 않기
- 보통, 완전히 자기화 할 수 있는 분량은 A4 3쪽 정도임
- 처음 시작할 때는 요약문 2쪽을 목표로 함 (한 챕터에 A4 1/3쪽 정도로 요약)

2) 자기 서사 재구성법. 2쪽 개조식 독서노트

- 자기 생각대로 과감하게 순서 변경, 내용 지우기
- 요약문을 자기 서사대로 바꾸는 '편집' 작업 수행 (저자, 내용구성, 특장점, 책의 내용)
- 이 단계가 자기화 과정의 핵심에 해당됨 (자기 언어로 재구성)

3) 2번 연습하고 외워서 말하기

- A4 2장짜리 요약문으로 '발표 연습' 
- 15분 정도 발표 연습 2번 반복 (머리 속에 각인하기 위함, 말을 체계적으로 하기 위한 수단)
- 발표 연습하면서 (조금씩 보는걸 줄이며) 정리한 내용을 발표 연습
- 책 한권 쭉 요약해서 말하는 것이 목표
- 세 번째는 요약문을 보지 않고 발표하기 (모두 말할거라는 강박은 안됨)

출처 :

1. 이 방법이면 1시간에 50쪽, 6시간이면 책 한 권 뚝딱 읽기 가능 https://www.youtube.com/watch?v=KnJYmBeYa2k&ab_channel=%EA%B9%80%EA%B5%90%EC%88%98%EC%9D%98%EC%84%B8%EA%B0%80%EC%A7%80

2. 책 요약하는 법 https://www.youtube.com/watch?v=xN1kG-eb-q8&ab_channel=%EA%B9%80%EA%B5%90%EC%88%98%EC%9D%98%EC%84%B8%EA%B0%80%EC%A7%80

3. 책 한 권 통째로 외워서 말하는 법 https://www.youtube.com/watch?v=TIqNO6bJ23o&ab_channel=%EA%B9%80%EA%B5%90%EC%88%98%EC%9D%98%EC%84%B8%EA%B0%80%EC%A7%80

• 수열(sequence, 수 또는 다른 대상의 순서 있는 나열) An에 대해 특정 구간의 합을 말함

• int[] a = new Int[100000]; 10만 개의 요소가 적재된 a 배열를 이용하여 특정 구간의 합을 구할 때 단순히 for문으로 sum += a[i] 을 사용할 경우 시간복잡도가 높아짐

• 누적합 배열(prefix array)을 생성하고 해당 배열의 구간시작인덱스와 구간끝인덱스를 사용하여 구간의 합을 구하면 됨

• 식 : f(a, b) = f(b) - f(a-1), (a<=b) f(b) : 1부터 b까지의 합 (누적합 배열의 b인덱스에 b까지의 누적 합이 들어있음) f(a-1) : 1부터 a-1까지의 합 (누적합 배열의 a-1인덱스에 a-1까지의 누적합이 들어있음)

  자세한 설명은 아래 링크 참조 누적 합 설명 블로그 by nahwasa

연습 문제

• 백준 11659번 - JAVA 풀이 구간 합 구하기 4

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

public class PrefixSumEx1 {

    public static void main(String[] args) throws IOException {
        // BufferedReader, StringTokenizer 대용량 입출력 시 사용함 (성능에 좋음)
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        // 누적합 배열을 생성한다
        // index를 1부터 시작한 이유: 시작Index, 끝Index 처리가 쉬워진다
        // 구간 입력 예시가 [1, 3], [5, 5] 이런식으로 되어 있음
        int[] prefixSum = new int[n + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= n; i++) {
            prefixSum[i] = prefixSum[i - 1] + Integer.parseInt(st.nextToken());
        }

        // 누적합 배열의 끝index 값에서 시작index-1 값을 빼면
        // 구간의 시작부터 끝까지의 합이 나옴
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int s = Integer.parseInt(st.nextToken());
            int e = Integer.parseInt(st.nextToken());
            System.out.println(prefixSum[e] - prefixSum[s - 1]);
        }
    }
}

• 기존의 클래스로 새로운 클래스를 작성하는 것 (코드의 재사용)
• 두 클래스를 부모와 자식으로 관계를 맺어주는 것
• 자손은 조상(부모의 부모까지)의 모든 멤버를 상속 받음 (생성자, 초기화블럭은 제외)
• 자손의 멤버 개수는 조상보다 적을 수 없음 (같거나 많다)
• 키워드 extends

class 자식클래스 extends 부모클래스 {
    // ...
}

class Parent {    // 멤버 1개
    int age;
}

class Child extends Parent {    // 부모로 받은 멤버 1개
}

• 자손의 변경은 조상에 영향을 미치지 않음

class Parent {    // 멤버 1개
    int age;
}

class Child extends Parent {    // 멤버 2개 (자신 멤버 1개, 상속 받은 멤버 1개)
    void play() {    // 자식에게 새로운 멤버가 추가 되었지만 부모는 영향 받지 않음
        System.out.println("놀자~");
    }
}

• 상속을 받고 안 받고의 차이점

class Point {
    int x;
    int y;
}

class Point3D {    // Point 클래스와 관계가 없고 영향을 안 받음
    int x;
    int y;
    int z;
}

class Point3D extends Point {    // Point 클래스에 영향을 받음
                                // 부모 멤버 개수가 줄거나 늘면 영향을 받음
    int z;
}

포함 관계

• 포함(composite)이란? 클래스의 멤버로 참조변수를 선언하는 것을 말함
• 작은 단위의 클래스를 만들고, 이들을 조합해서 클래스를 만든다
• 클래스의 관계는 크게 상속과 포함으로 구분됨

class Point {
    int x;
    int y;
}

class Circle {
    int x;
    int y;
    int r;
}
class Circle2 {    // Circle클래스가 Point클래스를 포함(composite)하고 있음
    Point c = new Point();     
    int r;
}

class Ex {
    public static void main(String[] args) {
        Circle c = new Circle();    // c.x
        Circle c2 = new Circle2();    // c.c.x
    }
}

클래스 간의 관계 결정하기

• 상속 관계 : ~은 ~이다 (is -a)
• 포함 관계 : ~은 ~을 가지고 있다 (has -a) (90%)

원은 점이다 - Circle is a Point 원은 점을 가지고 있다. - Circle has a Point

class MyPoint {
    int x;
    int y;
}

class Circle {
    MyPoint p = new MyPoint();
    int r;
}

class Circle2 extends MyPoint {    // 상속
    int r;
}

class InheritanceTest {
    public static void main(String[] args) {
        Circle c = new Circle();    // 참조변수 c에 주소값이 저장되어 있음
        c.p.x = 1;    // 참조변수  c.p에 주소값이 저장되어 있음
        c.p.y = 1;
        c.r = 2;

        Circle2 c2 = new Circle2();
        c.x = 1;
        c.y = 2;
        c.r = 3;
    }
}

단일 상속(Single Inheritance)

• Java는 단일상속만을 허용함 (C++은 다중상속 허용)

class Tv {
    void power { // A로직 실행}
}
class DVD {
    void power { // B로직 실행}
}

class TvDVD extends Tv, DVD {    // 에러. 자바는 조상을 하나만 허용함
    // 이유: power() 메소드를 호출 시 두 부모의 power() 메소드가 충돌이 발생
}

• 다중 상속처럼 사용하기 : 비중이 높은 클래스 하나만 상속 관계로, 나머지는 포함관계로 한다

class Tv {
    boolean power;
    int channel;

    void power() { power = !power;}
    void channelUp() { ++channel; }
    void channelDown() { --chanel; }
}

class DVD {
    boolean power;

    void power() { power = !power; }
    void play() { /* 내용 생략 */ }
    void stop() { /* 내용 생략 */ }
    void rew() { /* 내용 생략 */ }
    void ff() { /* 내용 생략 */ }
}

class TvDVD extends Tv {    // 비중이 높은 놈을 상속 받음
    DVD dvd = new DVD();    // 포함관계로 사용

    void play() {    // dvd의 객체를 사용하여 dvd의 메소드를 호출
        dvd.play();
    }
    void stop() {
        dvd.stop();
    }
    void rew() {
        dvd.rew();
    }
    void ff() {
        dvd.ff();
    }
}

Object 클래스 (모든 클래스의 조상)

• 부모가 없는 클래스는 자동적으로 Object클래스를 상속 받게 된다
• 모든 클래스는 Object클래스에 정의된 11개의 메서드를 상속받는다 toString(), equals(Object ojb), hashCode(), ... 등등

class Tv { }
// Tv클래스에 부모를 선언하지 않으면 컴파일러가 자동으로 추가
// class Tv extends Object {}

class SmartTv extends Tv {}
// 부모가 있는 경우는 Object 클래스를 추가하지 않음
// 상속 계층도 : SmartTv => Tv => Object (하위 => 상위 순)
// 고로, SmartTv도 Object클래스를 상속 받는다

메서드 오버라이딩 (Overriding)

• 상속 받은 조상의 메서드를 자신에 맞게 변경하는 것

class Point extends Object {
    int x;
    int y;
    String getLocation() {
        return "x:" + x + ", y:" + y;
    }

    public String toString() {    // Object클래스의 toString()을 오버라이딩 함
        return "x:" + x + ", y:" + y;
    }
}

class Point3D extends Point {
    int z;

    String getLocation() {    // 조상의 getLocation()을 오버라이딩
        // 내용만 변경가능 (선언부는 변경 불가)
        return "x:" + x + ", y:" + y + ", z:" + z;
    }
}

public class OverrideTest {
    public static void main(String[] args) {
        Point3D p3 = new Point3D();
        p3.x = 3;
        p3.y = 4;
        p3.z = 5;
        System.out.println(p.getLocation());    // x:3, y:4, z:5

        Point p = new Point();
        p.x = 1;
        p.y = 2;
        System.out.println(p.toString);    // x:1, y:2
        System.out.println(p);    // x:1, y:2
    }
}

오버라이딩(Overring)의 조건

• 선언부가 조상 클래스의 메서드와 일치해야 함 (반환 타입, 메서드 이름, 매개변수 목록)
• 접근 제어자를 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없음 public, protected, (default), private
• 예외(Exception)는 조상 클래스의 메서드보다 많이 선언할 수 없음

class Parent {
    void parentMethod() throws IOException, SQLException {    // 조상 메서드의 Exception 2개
        // ...
    }
}

class Child extends Parent {
    void parentMethod() throws IOException {    // 자식은 조상보다 작거나 같아야 함
        // ...
    }
}

오버로딩 vs 오버라이딩 (둘은 관계가 없다)

• 오버로딩(overloading) : 기존에 없는 새로운 메서드를 정의하는 것(new)
• 오버라이딩(overriding) : 상속 받은 메서드의 내용을 변경하는 것 (change, modify)

class Parent {
    void parentMethod() {}
}

class Child extends Parent {
    void parentMethod() {}    // 오버라이딩
    void parentMethod(int i) {}    // 오버로딩

    void childMethod() {}    // 메소드 정의
    void childMethod(int i) {}    // 오버로딩
    void childMethod() {}    // 중복 정의
}

참조변수 super

• super란? 객체 자신을 가리키는 참조변수
• 인스턴스 메서드(생성자)내에만 존재 (static 메서드에서는 사용불가)
• 조상의 멤버를 자신의 멤버와 구별할 때 사용

class Ex {
    public static void main(String[] args) {
        Child c = new Child();
        c.method();
    }
}

class Parent { int x = 10; /* super.x */ }

class Child extends Parent {
    int x = 20;    // this.x

    void method() {
        System.out.println("x=" + x);    // x=20
        System.out.println("this.x=" + this.x);    // this.x=20
        System.out.println("super.x=" + super.x);    // super.x=10;
    }
}

class Ex2 {
    public static void main(String[] args) {
        Child2 c = new Child2();
        c.method();
    }
}

class Parent2 { int x = 10; /* super.x */ }

class Child2 extends Parent2 {
    void method() {
        System.out.println("x=" + x);    // x=10
        System.out.println("this.x=" + this.x);    // this.x=10
        System.out.println("super.x=" + super.x);    // super.x=10;
    }
}

super() 조상의 생성자

• 조상의 생성자를 호출할 때 사용
• 조상의 멤버는 조상의 생성자를 호출해서 초기화
• 상속 시 조상의 생성자와 초기화 블럭은 상속불가, 그래서 super로 호출해야 함
• super()와 super는 다름

class Point {
    int x, y;

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

class Point3D extends Point {
    int z;
    Point3D(int x, int y, int z) {
        this.x = x;    // 조상의 멤버를 초기화
        this.y = y;    // 조상의 멤버를 초기화
        // 위 방법으로 사용할 수 있지만 조상의 멤버는 조상 생성자가 초기화 하는 것이 좋음

        super(x, y);    // 조상클래스의 생성자 Point(int x, int y)를 호출
        this.z = z;    // 자신의 멤버를 초기화
    }
}

• 모든 생성자의 첫 줄에는 반드시 다른 생성자를 호출해야 한다
• 그렇지 않으면 컴파일러가 생성자의 첫 줄에 super()를 삽입한다

class Point extends Object {
    int x;
    int y;

    Point() {
        this(0,0);    // ok
    }

    Point(int x, int y) {
        // 첫 줄에 생성자가 없어서 컴파일러가 자동으로 super() 추가함
        // super(); <= Object() 기본 생성자를 호출하게 됨

        this.x = x;
        this.y = y;
    }
}

제어자 (modifier)

• 클래스와 클래스의 멤버(멤버 변수, 메서드)에 부가적인 의미 부여
• 접근 제어자 : public, protected, (defalut), private
• 그 외 : static, final, abstract, native, transient, synchronized, volatile, strictfp
• 하나의 대상에 여러 제어자를 같이 사용 가능 (단, 접근 제어자는 하나만 사용함)

public class ModifierTest {
    public static final int WIDTH = 200;

    public static void main(String[] args) {
        System.out.println("WIDTH="+WIDTH);
    }
}

static - 클래스의, 공통적인

class StaticTest {
    static int width = 200; // 클래스 변수 (static 변수)
    static int height = 120; // 클래스 변수 (static 변수)

    static {    // 클래스변수 초기화 블럭
        // static 변수의 복잡한 초기화 수행
    }

    static int max(int a, int b) {    // 클래스 메서드 (static메서드)
        return a > b ? a : b;    // 클래스 메서드 안에서 iv사용 못함
                                // instance메서드 사용 못함
    }
    // static 변수, 메서드는 객체 생성 없이 사용해야 함
}

final - 마지막의, 변경될 수 없는

final class FinalTest {    // 조상이 될 수 없는 클래스 (String클래스, Math클래스 등등)
                        // 자식을 가질 수 없으며, 상속계층도에서 최하위에 위치함
    final int MAX_SIZE = 10;    // 값을 변경할 수 없는 멤버변수(상수)

    final void getMaxSize() {    // 오버라이딩할 수 없는 메서드 (변경불가)
        final int LV = MAX_SIZE;    // 값을 변경할 수 없는 지역변수(상수)
        return MAX_SIZE;
    }
}

abstact - 추상의, 미완성의 (추상화)

abstract class AbstractTest {    // 추상클래스(추상 메서드를 포함한 클래스)
    abstract void move();        // 추상 메서드(구현부가 없는 메서드)
    // 미완성 클래스 - 미완성 설계도 - 제품 생성 불가
}

AbstractTest a = new AbstractTest();    // 에러. 추상클래스의 인스턴스 생성불가
// 추상(미완성)클래스를 상속 받아서 구상(완전한)클래스를 만든 후에 객체생성이 가능함

접근 제어자(access modifier)

• private : 같은 클래스 내에서만 접근 가능
• (default) : 같은 패키지 내에서만 접근 가능
• protected : 같은 패키지 내에서, 그리고 다른 패키지의 자손클래스에서 접근 가능
• public : 모든 곳에서 접근 가능

public (전체) > protected (같은 패키지+자손) > (default) (같은 패키지) > private(같은 클래스)

[public | (default)] class AccessModifierTest {    // 클래스는 public, (default)만 가능
    // 멤버(iv, cv, im)는 4개 모두 가능
    [public | protected | (default) | private] int iv;
    [public | protected | (default) | private] static int cv;
    [public | protected | (default) | private] void method() {}
}

package pkg1;
public class MyParent {
    private int prv;
    (default) int dft;
    protected int prt;
    public int pub;

    public void printMembers() {
        System.out.println(prv);    // ok.
        System.out.println(dft);    // ok.
        System.out.println(prt);    // ok.
        System.out.println(pub);    // ok.
    }
}

class MyParentTest {    // 접근 제어자  (default)
    public static void main(String[] args) {
        MyParent p = new MyParent();
        System.out.println(p.prv);    // 에러. 같은 클래스가 아니라서 사용불가
        System.out.println(p.dft);    // ok. 같은패키지안에 있어서 사용가능
        System.out.println(p.prt);    // ok. 같은패키지(+자손)안에 있어서 사용가능
        System.out.println(p.pub);    // ok. 모든 곳에서 접근가능
    }
}

package pkg2;
import pkg1.MyParent;

class MyChild extends MyParent {
    public void printMembers() {
        System.out.println(prv);    // 에러. 같은 클래스가 아니라서 사용불가
        System.out.println(dft);    // 에러. 같은 패키지가 아니라서 사용불가
        System.out.println(prt);    // ok. 자손클래스에서 접근해서 사용가능
        System.out.println(pub);    // ok. 모든 곳에서 사용가능
    }
}

public class MyParentTest2 {
    public static void main(String[] args) {
        MyParent p = new MyParent();
        System.out.println(p.prv);    // 에러. 같은 클래스가 아니라서 사용불가
        System.out.println(p.dft);    // 에러. 같은 패키지가 아니라서 사용불가
        System.out.println(p.prt);    // 에러. 같은패키지+자손클래스가 아니라서 사용불가
        System.out.println(p.pub);    // ok. 모든 곳에서 사용가능
    }
}

출처 : 남궁성의 정석코딩

• 한 클래스 안에 같은 이름의 메서드 여러개 정의하는 것

void println() {}
void println(blooean x) {}
void println(char x) {}
void println(char[] x) {}
void println(double x) {}
void println(float x) {}
void println(int x) {}
void println(long x) {}
void println(Object x) {}
void println(String x) {}

메서드 오버로딩 성립 조건

• 메서드 이름 같아야 함
• 매개변수 타입 또는 개수가 달라야 함
• 반환 타입은 영향 없음

long add(int a, long b) { return a+b; }
long add(long a, int b) { return a+b; } // 매개변수 타입이 다름으로 overloading이 맞음
// add(3, 3) 호출 시 어느 메서드를 호출해야 하는지 모름. Ambiguous method call. both 에러 발생

주변지식 : 연산자 오버로딩

java에서 +기호는 부호, 덧셈, 문자열 결합 등으로 사용됨, 하나의 연산자로 여러 역할을 수행함

생성자 (constructor) - iv 초기화 메서드

• 인스턴스 생성될 때 마다 호출되는 '인스턴스 초기화 메서드'
• 인스턴스 생성 시 수행할 (iv 초기화) 작업에서 사용함

Time t = new Time();    // 객체 생성 & 생성자 호출
t.hour = 12;            // iv 초기화
t.minute = 34;            // iv 초기화
t.secound = 56;         // iv 초기화

Time t = new Time(12, 34, 56);    // 생성자 호출
// Time(12, 34, 56)과 같은 생성자를 클래스에 추가해야 사용 가능

생성자 (constructor) 생성 규칙

• 생성자 이름이 클래스 이름과 같아야 함
• 리턴값 없음 (void 안 붙임)
• 모든 클래스는 반드시 생성자(1개 이상)를 가져야 함

class Card {

    Card() {    // 기본 생성자 (매개변수 없는 생성자)
        ... // 인스턴스 초기화 작업
    }

    Card(String kind, int number) {    // 매개변수 있는 생성자
        // 인스턴스 초기화 작업
        // 주로, 인스턴스 변수의 초기화 코드를 적음
    }
}

기본 생성자 (default constructor)

• 매개변수가 없는 생성자
• 생성자가 하나도 없을 때 컴파일러가 자동으로 추가함

클래스이름 () {}    // 기본 생성자 형태
Point() {}    // Point 클래스의 기본 생성자

class Data_1 {
    int val;

    // 생성자를 선언하지 않으면 컴파일러가 자동으로 생성자를 추가함
    // 기본 생성자로 생성됨 : Data_1() {}
}

class Data_2 {
    int val;

    Data_2(int x) {    // 매개변수가 있는 생성자
        val = x;
    }
}

class Ex {
    public static void main(String[] args) {
        Data_1 d1 = new Data_1(); // 컴파일러가 기본 생성자를 자동으로 생성해서 ok
        Data_2 d2 = new Data_2(); // 에러. Data_2클래스에 기본 생성자가 없어서 compile error 발생
    }
}

매개변수가 있는 생성자 (constructor)

• 매개변수 있는 생성자 호출 시 코드 간결화 가능

class Car {
    String color;
    String gearType;
    int door;

    Car() {}    // 기본 생성자
    Car(String c, String g, int d) {    // 매개변수가 있는 생성자
        color = c;
        gearType = g;
        door = d;
    }
}

class Ex {
    public static void main(String[] args) {
        Car c = new Car();
        c.color = "white";
        c.gearType = "auto";
        c.door = 4;
        // 여러 줄로 iv를 초기화 하고 있음

        Car c2 = new Car("black", "manual", 2);    // 생성자 호출 시 초기화값을 넣으면 코드가 간결해진다
    }
}

Car c2 = new Car("black", "manual", 2);

1) 참조변수 c2 선언 2) new 키워드로 객체 생성 3) Car("black", "manual", 2) 생성자를 호출하여 객체 초기화

생성자 this()

• 생성자에서 다른 생성자 호출할 때 사용됨 (같은 클래스 안에서 호출 시)
• 다른 생성자 호출 시 this 선언은 반드시 첫 줄에서만 사용 가능

class Car {
    String color;
    String gearType;
    int door;

    Car() {
        this("white", "auto", 4);    // Car(String color, String gearType, int door) 생성자를 호출함        
        // Car(color, "auto", 4); 이런 형태로 호출 시 method error 발생. this를 사용해야 함
    }

    Car(String color) {
        this(color, "auto", 4);    // 각각의 생성자에서 객체 초기화 로직을 구현하지 않아도 됨 (코드가 간결함)
    }

    Car(String color, String gearType, int door) {
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }
}

참조변수 this

• 인스턴스 자신을 가리키는 참조변수 (인스턴스의 주소가 저장됨)
• 인스턴스 메서드(생성자 포함)에서 사용 가능 (모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재함)
• 지역변수(lv)와 인스턴스 변수(iv)를 구별할 때 사용
• this와 this()는 다름
• this()는 같은 클래스의 다른 생성자를 호출할 때 사용함

Car(String c, String g, int d) {    
    color = c;    // color -> iv,    c -> lv
    gearType = g;    // 같은 클래스 안이라서 this를 생략가능
    door = d;
}

Car(String color, String gearType, int door) {    
    this.color = color; // iv(this.color)에 lv(color)값을 저장
    color = color; // lv에 lv를 저장
}

class MyMath {
    long a, b;    // this.a, this.b (진짜 이름)

    MyMath(int a, int b) {    // 생성자
        this.a = a;    // lv와 iv를 구별하기 위해 this. 사용, 생략불가
        this.b = b;
    }

    long add() {    // 인스턴스 메서드
        return a + b;    // return this.a + this.b; (this 생략가능)
    }

    static long add(long a, long b) {    // 클래스 메서드 (static 메서드)
        return a + b;    // 여기서는 lv임, static 메서드에서는 iv 사용 불가
                        // this도 사용불가, 이유 : static 호출 시점에 iv존재 여부가 불투명함 (메모리에 존재여부 확인불가)
    }
}

변수의 초기화

• 지역변수(lv)는 수동 초기화(우리가 직접 초기화) 해야함 (사용하기전 꼭!!!)
• 멤버변수(iv, cv)는 자동 초기화됨

```java class InitTest { int x; // 인스턴스 변수 int y = x; // 인스턴스 변수

void method1() {
    int i;    // 지역변수
    int j = i;    // 에러. lv를 초기화하지 않고 사용해서 안됨