HyunHa.log https://velog.io/ Thu, 14 Jul 2022 11:40:48 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed HyunHa.log https://velog.velcdn.com/images/hyun_ha/profile/7e9e2fb3-a026-4b14-98c0-2138599ee95f/image.jpg https://velog.io/ Copyright (C) 2019. HyunHa.log. All rights reserved. <![CDATA[[Project] Happyever - 국내여행 플래너]]> https://velog.io/@hyun_ha/Project-Happyever-%EA%B5%AD%EB%82%B4%EC%97%AC%ED%96%89-%ED%94%8C%EB%9E%98%EB%84%88 https://velog.io/@hyun_ha/Project-Happyever-%EA%B5%AD%EB%82%B4%EC%97%AC%ED%96%89-%ED%94%8C%EB%9E%98%EB%84%88 Thu, 14 Jul 2022 11:40:48 GMT ✈️ Happyever

MVC 패턴을 활용한 JSP 팀 프로젝트 - 국내여행 플래너

https://github.com/Hyun-HaHa/Happyever


📆 개발 기간

  • 2022-05-17 ~ 2022-07-01

🙍‍♀️🙍‍♂️팀원 소개 & 역할

  • 총 7명 (멀티 포지션)
    • 정유섭 (조장) - 게시판, 일정 만들기 조현하 - 메인페이지, 로그인 & 로그아웃, header 문기연 - 메인페이지, 비밀번호 찾기, footer 문승우 - 일정 만들기 김태경 - 일정 만들기 박종휘 - 마이페이지 유승재 - 회원가입

📖 프로젝트 소개

한국관광공사에서 제공하는 Tour3.0 API와 지도 API 등을 이용해 직관적인 UI로 누구나 쉽게 사용할 수 있는 여행 플래너

이제 코로나19로 인한 제한이 풀어지면서 여행을 마음껏 다닐 수 있는 희망이 다가오고 있습니다. 또한 지자체는 물론 정부 차원에서도 국내 여행을 다방면에서 지원하고 있습니다. 따라서 저희는 이러한 흐름에 편승하여 국내 여행 플래너를 만들어 보았습니다.


  • 국내 관광지 추천관광지 및 검색 기능
  • 나만의 여행 플래너 작성 ( 원하는 도시와 일정 관리 가능 )
  • 여행 리뷰 공유 게시판 (테마 별로 검색 기능)
  • 회원가입, 로그인 (이메일로 비밀번호찾기 기능)
  • 한국관광공사 API, Kakao Map API

⚙ 개발 환경

  • JAVA 1.8.0 (eclipse)
  • Apache Tomcat 8.5
  • MyBatis 3.5.10
  • ORACLE 11g DB
  • HTML5, CSS3, JavaScript, JSP, Jquery

🔨 설계

  • 화면 구현 사이트맵

  • ERD



🔍 화면 & 기능 소개

메인페이지

  • Bootstrap 프레임워크를 이용한 반응형 페이지 구현
  • 3장의 배너 사진을 캐러셀(이미지 슬라이드)로 구현
  • 키를 입력할 때마다 검색 결과가 동적으로 변하는 검색기능 구현
  • 클릭한 여행지에 맞춰서 일정 만들기 페이지로 이동
  • 비로그인 시 사용기능 제한



로그인 & 비밀번호 찾기

  • 정규표현식을 사용하여 이메일 형식 체크
  • 사용자 정보가 틀렸을 때 alert으로 안내문구 출력
  • <로그인>
    • header에 로그인 버튼 클릭 시 모달창 화면으로 구현
    • 로그인 성공시 session에 회원정보 저장과 header에 사용자 이름이 표시된다.
  • <비밀번호 찾기>
    • 이메일과 이름으로 회원가입 여부 판단 후, 이메일로 임시 비밀번호 전송



회원가입 & 마이페이지

  • <회원가입>
    • 정규 표현식을 사용하여 유효성 검사
  • <마이페이지>
    • 회원 정보 수정, 탈퇴하기 기능



여행 일정 만들기

  • 클릭한 지역명을 인자값으로 받아서 화면 이동
  • 지도 API와 한국관광공사 API를 이용하여 사용자에게 추천 장소와 위치를 제공
  • API를 통해 JSON 형식으로 받아온 데이터를 MVC2패턴 방법으로 데이터 처리
  • 여행 날짜를 입력 시 좌측영역에 DAY 생성
  • DAY마다 사용자가 원하는 여행지 추가 기능



여행 리뷰 공유 게시판

  • 여행 키워드 클릭 시, 검색시 동적으로 변하는 검색기능 구현



감사합니다. 😊

]]> <![CDATA[[WEB] JSP & Servlet / MVC 패턴]]> https://velog.io/@hyun_ha/WEB-JSP-Servlet-MVC-%ED%8C%A8%ED%84%B4 https://velog.io/@hyun_ha/WEB-JSP-Servlet-MVC-%ED%8C%A8%ED%84%B4 Sun, 03 Jul 2022 15:19:13 GMT

📝JSP & Servlet

  • 동적 웹 페이지를 생성하는 공통점이 있다.
  • 역할의 차이점이 있다.



서블릿(Servlet)

  • 클라이언트의 요청을 처리하고, 그 결과를 반환하는 Servlet 클래스의 구현 규칙을 지킨 자바 웹 프로그래밍 기술이다.
  • JAVA 코드 안에 HTML태그가 삽입된 자바 언어이다.

JSP

  • 서블릿(Servlet)의 단점을 보완한 서블릿 기반의 스크립트 기술이다.

  • HTML 코드에 JAVA코드를 넣어 동적 웹페이지를 생성하는 웹어플리케이션 도구이다.

  • JSP가 실행되면 자바 서블릿(Servlet)으로 변환되면, 웹 어플리케이션 서버에서 동작되면서 필요한 기능을 수행하고 그렇게 생성된 데이터를 웹페이지와 함께 클라이언트로 응답한다.

스크립트 태그

<%!     %>        : 자바 변수나 메소드를 정의하는데 사용되는 태그

<%     %>        : 자바 변수 선언 및 자바 로직 코드를 작성하는데 사용되는 태그

<%=  %>        : 변수, 계산식, 메소드 호출 결과를 나타내는 태그

<%@  %>        : 페이지 속성 지정

<%-- --%>    : 주석처리



📙 JSP와 Servlet의 정리

JSP Servlet
형태 JAVA in HTML HTML in JAVA
형태 예시 <% for(int i = 0; i <= 3; i++){ %> PrintWriter out = response.getWriter();
out.println("<HTML>");
특징 presentation(View)에 좋다. data processing(Controller)에 좋다.

  • Servlet : 코드가 수정되면 다시 컴파일하고 배포해야 한다.
  • JSP : 코드가 수정되도 재배포 할 필요가 없지만, 다양한 코드가 JSP에 노출되어 있기 때문에 유지보수가 힘들다.




📝 MVC 패턴

  • JSP와 Servlet을 모두 이용하는 모델이다.
  • 유지보수에 용이하다.

M : Model

  • 사용자가 원하는 데이터나 정보를 제공한다.
  • 애플리케이션의 정보, 데이터를 나타낸다. 이러한 Data, 정보들의 가공을 책임지는 역할을 한다.
  • Java Beans로 DTO와 DAO를 통해 DataBase에 접근한다.

V : View

  • 데이터 및 객체의 입력, 즉 보여주는 출력을 담당한다.
  • 데이터를 기반으로 사용자들이 볼 수 있는 화면이다.
  • HTML이 중심이 되는 JSP를 사용한다.

C : Controller

  • 사용자의 요청을 처리하고, 그 요청에 따른 전체적인 흐름을 제어한다.
  • 데이터와 사용자의 인터페이스 요소들을 잇는 다리역할을 한다.
  • Java 코드가 중심이 되는 Servlet을 사용한다.



DTO & DAO


DTO(Data Transfer Object) / Vo (Value Object) / Bean

  • 양쪽으로 전송되어 오고가는 데이터들을 담은 객체, jsp에서는 Bean이라고 부른다.
  • 여러 데이터들을 포장해서 만든 데이터 포장객체
  • 사용자가 입력한 값을 객체 형태로 받을 수 있게 클래스 구성
    • 폼에서 입력된 데이터들은 하나의 DTO 객체로 변환 가능하다.
  • 하나의 데이터베이스 레코드를 저장하여 레코드와 같은 구조를 가짐
    • 레코드가 50개면 DTO객체도 50개, 한 개의 레코드는 빈즈 클래스 객체 하나로 매핑
  • 데이터가 포함된 객체를 한 시스템에서 다른 시스템으로 전달하는 작업을 처리하는 객체

DAO(Data Access Object)

  • DB를 사용해 데이터를 조회하거나 조작하는 기능을 전담하도록 만든 즉 데이터 접근을 목적으로 하는 객체
  • 데이터에 접근, 데이터를 관리하기 위한 객체 데이터들을 관리(CRUD)하는 여러 메소드들이 정의되어 있다.
    • 커넥션 같은 것을 하나만 두고 여러 사용자가 DAO의 인터페이스를 사용하여 필요한 자료에 접근하도록 하는 것
  • SQL을 직접 실행하는 기능을 가짐
    • Insert, Delete, Update, Select 등 레코드 처리를 주 목적으로 한다.
    • 데이터베이스 서버로부터 레코드를 select한 후, DTO 객체로 변경해 가져온다.
    • DTO 객체를 데이터베이스 서버에 저장한다.



MVC1 & MVC2


MVC1 패턴

  • view와 Controller를 JSP가 담당하는 형태를 가진다. 즉, JSP 하나로 유저의 요청을 받고 응답을 처리하므로 구현 난이도는 쉽다.

  • 단순한 프로젝트에는 괜찮겠지만, 내용이 복잡하고 거대해질수록 이 패턴은 힘을 잃는다. 즉 유지보수에 있어서 문제가 발생한다.


MVC2 패턴

  • MVC1 패턴과는 다르게 Controller, View가 분리되어 있다. 그러므로 개발자는 M, V, C 중에서 수정해야 할 부분이 있다면, 그것만 꺼내어 수정하면 된다.
  • 유지보수에 있어서 큰 이점을 가진다.






참고 사이트 : https://bangu4.tistory.com/35
]]> <![CDATA[[HTML] HTML 기본 태그]]> https://velog.io/@hyun_ha/HTML-HTML-%EA%B8%B0%EB%B3%B8-%ED%83%9C%EA%B7%B8 https://velog.io/@hyun_ha/HTML-HTML-%EA%B8%B0%EB%B3%B8-%ED%83%9C%EA%B7%B8 Sun, 22 May 2022 08:27:23 GMT

📝 HTML이란?

HT - HyperText : 문서와 문서가 링크로 연결되어 있다. M - Markup : 태그로 이루어져 있다. L - Language : 언어 -> 즉 웹사이트의 틀을 만들어 주는 마크업 언어이다. 마크업 언어는 마크업 태그들로 이루어져 있다.

HTML 태그는 다음과 같이 표현한다.

<태그 이름>내용</태그 이름>



기본 태그

📌<!DOCTYPE html> 선언하기📌

html 태그를 사용하기 전에 선언한다. 웹 브라우저에게 HTML 버전을 알려주는 역할을 한다.

1. <html> </html> 태그

<html>과 </html> 사이에 html 문서를 작성한다.

2. <head> </head> 태그

<head>과 </head> 사이에 문서 제목, 스타일, 스크립트 등등 문서에 대한 정보를 제공한다.

3. <meta charset="UTF-8">

인코딩 설정 <meta charset="인코딩 형식">로 시작하며 charset속성의 값으로 인코딩 형식을 지정해서 웹 페이지에 표시되는 문자의 인코딩을 설정한다.

4. <title> </title> 태그

<title>과 </title> 사이에는 문서의 제목을 쓴다.

브라우저의 탭이나 방문 기록에 나와 있는 바로 그 제목이 이 곳에 들어간다.

5. <body> </body> 태그

<body>과 </body> 사이에는 화면에 표시되는 문서의 내용을 쓴다.



HTML 태그

1. 시멘틱(semantic) 태그

  • 의미론적 태그로 문서의 정보를 보다 잘 표현하기 위해서는 의미에 맞는 태그를 잘 사용해야 한다.

  • 사용이유

      1. SEO(Search Engine Optimization)

    • 검색을 최적화하기 위해서 제목, 부제목, ... 시멘틱 태그를 잘 활용하면 특정 키워드로 검색했을때 내가 만든 웹사이트가 검색창에 노출될 수 있다.

      1. 유지보수

    • 단순히, div 태그로만 모든 구조를 짜는 것보다 더 한눈에 알아 볼 수 있기 때문에, 유지보수에 더 편해진다.


웹 사이트 구조 예시)

  1. 헤더 영역

  1. 본문 영역

  1. 푸터 영역


주요 태그

태그 설명
<header> 화면의 상단에 위치하는 사이트나 문서의 전체적인 정보를 정의
<nav> 사이트의 내비게이션(메뉴) 항목을 정의
<article> 문서의 내용을 표시하는 태그로, 독립적인 콘텐츠를 표시
<main> 문서에서 가장 중심이 되는 콘텐츠를 표시
웹 문서마다 한 번만 사용할 수 잇다.
<aside> 광고와 같이 페이지 내용과는 관계가 적은 사이드바 콘텐츠를 표시
<details> 기본적으로 표시되지 않는 정보들을 정의
<figure> 삽화나 다이어그램과 같은 부가적인 요소를 정의
<mark> 참조나 하이라이트 표시를 필요로하는 문자를 정의
<footer> 화면의 하단에 위치하는 사이트나 문서의 전체적인 정보를 정의
<section> 문서의 내용을 표시하는 태그로, 주로 문서의 영역적인 의미로 사용

2. <div> 태그

  • html 문서에서 영역 또는 구역을 정의한다.
  • 서로 중첩되어 사용할 수 있으며, 다른 태그를 포함할 수 있다.
  • 고유한 id값을 부여하여 처리한다.

3. <head> 태그 안에 쓰는 태그

태그 설명
<title> </title> html 문서 제목
<style> </style> <style>과 </style> 태그 사이에 스타일시트 코드를 기술한다.
웹 페이지를 위한 스타일 정보를 정의하며
웹 브라우저에서 HTML 태그를 표현하는 방법을 기술한다.
<meta> html 문서에 대한 메타데이터(데이터를 설명하는 데이터)를 정의하며
주로 페이지 설명, 키워드, 인코딩, 뷰포트, 검색 로봇 차단 등을 설정할 때 사용한다.
<link> 웹 페이지와 외부 자원간의 관계를 정의하며,
주로 CSS파일 링크에 사용한다.
<script> </script> <script>와 </script> 태그 사이에 자바스크립트 코드를 기술한다.
<base> 웹 페이지상의 모든 링크를 위한 기본 주소 또는 기본 대상을 지정한다.

4. 텍스트(text) 태그

1. <h1> ~ <h6> 태그

  • 머리말(제목 또는 주제) 태그
  • 글자 크기 순서
    • <h1> > <h2> > <h3> > <h4> > <h5> > <h5> > <h6>

2. <p> 태그

  • 문단과 문단 사이를 구분할 때 사용한다.

3. <b> & <strong> 태그

  • 글꼴을 진하게 표시한다.

4. <I> & <em>

  • 글꼴을 기울임으로 표시한다.

5. <br> 태그

  • 줄 바꿈 태그

6. <blockquote> 태그

  • 인용문을 삽입할 때 사용한다.

<body>
    <h1>h1</h1>
    <h2>h2</h2>
    <h3>h3</h3>
    <h4>h4</h4>
    <h5>h5</h5>
    <h6>h6</h6>

    <p>
        Hello world!
    </p>

    <p>
        b와 strong태그는 <b>글꼴</b>을 <strong>진하게</strong>표시한다.<br>
        I와 em 태그는 <i>글꼴</i>을 <em>기울임</em>으로 표시한다.
    </p>
        <blockquote>blockquote태그는 인용문을 삽입할 때 사용한다.</blockquote>
</body>

5. 목록 태그

  • <ul>태그 : 순서가 없는 목록 태그
  • <ol>태그 : 순서가 있는 목록 태그
  • <li>태그 : 목록의 내용인 아이템

<body>
    <h2>순서가 없는 목록 태그</h2>
    <ul>
        <li>HTML</li>
        <li>CSS</li>
        <li>JavaScript</li>
    </ul>

    <h2>순서가 있는 목록 태그</h2>
    <ol>
        <li>HTML</li>
        <li>CSS</li>
        <li>JavaScript</li>
    </ol>
</body>

6. <a> 태그

  • 하이퍼링크(또는 링크)를 사용해서 이동할 페이지 또는 이동할 위치를 지정할 때 사용한다.

  • 필수 속성 : href="이동할 페이지 또는 위치"

<a href="이동할 페이지 또는 위치">내용</a>
  • 새 창에서 페이지를 열리게 할려면 target속성과 _blank 속성값을 사용하면 된다.
    <a href="이동할 페이지 또는 위치" target="_blank">내용</a>

7. 테이블 태그

<table> 태그는 표를 작성하는 태그이다.

  • <table> : 표 영역만 설정하는 태그
  • <thead> : 테이블의 head 부분을 의미
  • <tbody> : 테이블의 본문을 의미
  • <tfoot> : 테이블의 가장 아래쪽을 의미
    • thead, tbody, tfoot 각각의 위치가 바껴도 head, body, foot에 맞춰 테이블이 그려진다.
  • <th> : 테이블의 제목을 정의하는 태그
  • <tr> : 표의 행을 정의하는 태그
  • <td> : 표의 열을 정의하는 태그
  • <rowspan> : 행을 합치는 태그
    • 테이블의 셀을 세로로 합친다.
  • <colspan> : 열을 합치는 태그
    • 테이블의 셀을 가로로 합친다.

<body>
    <h2>회원 정보 & 회비</h2>

    <table border="2">    <!-- border 속성은 테이블의 테두리선의 두께를 나타낸다. -->
        <thead>
            <tr>
                <th>이름</th>
                <th>성별</th>
                <th>주소</th>
                <th>나이</th>
                <th>회비</th>
            </tr>
        </thead>

        <tbody>
            <tr>
                <td>철수</td>
                <td>남</td>
                <td rowspan="3">역삼동</td>
                <td>23</td>
                <td>1000원</td>
            </tr>
            <tr>
                <td>영희</td>
                <td>여</td>
                <td>24</td>
                <td>2000원</td>
            </tr>
            <tr>
                <td>미영</td>
                <td>남</td>
                <td>25</td>
                <td>3000원</td>
            </tr>
        </tbody>    

        <tfoot>    
            <tr>
                <td colspan="4">합계</td>
                <td>6000원</td>
            </tr>
        </tfoot>
    </table>
</body>

8. 이미지 태그

<img>태그는 웹 페이지에 이미지를 삽입할 때 사용한다.

  • <img>태그의 주요 속성
속성 설명
src 표시할 이미지 파일의 경로를 포함한 이름을 입력한다.
필수 속성
alt 이미지가 표시되지 못할 경우 대신 표시할 메시지 지정
title 이미지 위에 마우스 커서가 위치했을 때 보여지는 메시지 지정
width 이미지의 가로길이
height 이미지의 세로길이 
<body>
    <img src="이미지 파일 경로" alt="대체용 메시지"
         title="이미지 메시지" width="가로길이" height="세로길이">
</body>

9. <form> 태그

  • <form> 태그는 폼을 만드는 가장 기본적인 태그로, 서버 전송 태그이다.
  • 모든 폼 태그는 <form>과 </form> 사이에 위치한다.

<form>태그의 속성

속성 설명
accept-charset 폼의 캐릭터 셋을 지정한다.
ex) <form accept-charset="utf-8">
action 폼에 입력된 값을 처리(제출)할 페이지의 url을 지정한다.
autocomplete 폼에 입력 값을 자동 완성할지를 지정한다.
enctype 폼에 입력된 값을 처리 페이지로 넘길 때 인코딩 방식을 지정한다.
method 폼에 입력된 값을 처리 페이지로 넘길 때 HTTP 방식을 지정한다.
name 폼의 이름을 지정한다.
novaildate 폼에 입력된 값을 처리 페이지로 넘길 때 입증된 데이터가 아니라는 것을 지정한다.
target action속성에 있는 처리 페이지의 타깃을 지정한다.
(현재 창에 표시할지, 새 창에 표시할지 등을 지정)



<legend> & <fieldset> 태그

  • <fieldset> : 웹 폼 태그를 그룹화한다.
  • <legend> : <fieldset> 태그로 묶인 그룹의 제목을 구성한다.

<body>
    <h2>폼</h2>
    <form action="http://localhost/regist.jsp">
        <fieldset>
            <legend>성별</legend>
                남자 <br>
                여자 
        </fieldset>
    </form>
</body>

<label> 태그

  • 입력 요소 앞이나 뒤에서 표시되는 제목을 구성

<body>
    <h2>폼</h2>
    <form action="http://localhost/regist.jsp">
        <fieldset>
            <legend>성별</legend>
            <label>
                남자 <input type="radio" name="gender" value="남자" checked> 
            </label>
            <label>    
                여자 <input type="radio" name="gender" value="여자"> 
            </label>    
        </fieldset>
    </form>
</body>



10. <form>태그의 종류 - input 태그

<input> 태그는 입력형식을 구현한 태그로 웹 폼을 지원하기 위한 다양한 속성이 있다.

  • <input> 태그의 속성
속성 설명
type 텍스트, 패스워트, 체크 박스 등의 웹 폼 태그를 만들 때 사용
accept 파일 선택기인 <input type="file">에서만 사용하는 속성으로,
서버가 받아들일 수 있는 파일의 타입을 지정
autocomplete 웹 폼태그에서 자동 완성 기능을 사용할 수 있도록 지정
autofocus 웹 페이지가 화면에 표시될 때 자동으로 특정 웹 폼 태그에 포커스를 지정
checked 체크박스 또는 라디오 버튼에서 선택 항목을 미리 지정할 때 사용
disabled 웹 폼 태그를 사용할 수 없도록 지정
list 데이터 리스트에서 선택한 항목을 표시
max 숫자 입력이나 날짜 입력 등에서 최댓값을 지정
maxlength 입력할 문자의 수를 제한하기 위해서 사용
min 숫자 입력이나 날짜 입력 등에서 최솟값을 지정
multiple 1개 이상의 값을 입력 받을 때 사용 (주로 여러 파일을 선택할 때 사용)
name 웹 프로그램과 연계되는 속성으로 한 페이지 안에서 고유한 값을 명시
pattern 정규표현식을 지정
placeholder 직접 입력하는 웹 폼 태그에 입력 힌트 값을 지정
required 반드시 입력해야 하는 필수 항목을 지정
size 텍스트 필드 등의 너비 지정
step 입력되는 숫자 간격을 지정
value 웹 폼 태그의 기본 값을 지정



type의 속성 값

  1. text, password
    • 텍스트와 비밀번호 입력 양식을 생성한다.

<body>
    <p>아이디 : <input type="text" name="id"></p>
    <p>패스워드 : <input type="password" name="pwd"></p>
</body>

  1. checkbox & radio

    • checkbox는 체크박스를 만들 때 사용한다.

    • 여러 항목 중 복수로 선택 가능한다.

    • radio는 라디오 버튼을 만들 때 사용한다.

    • 여러 항목 중 한 가지만 선택 가능

<body>
    <p>
        <h1>색상(단일선택)</h1>
        붉은색 : <input type="radio" name="color">
        검은색 : <input type="radio" name="color">
        파란색 : <input type="radio" name="color">
        보라색 : <input type="radio" name="color" checked>
    </p>
    <hr/>

    <p>
        <h1>사이즈(다중선택)</h1>
        95 : <input type="checkbox" name="size">
        100 : <input type="checkbox" name="size">
        105 : <input type="checkbox" name="size">
    </p>
</body>

  1. file

    • 파일을 선택하고 업로드할 수 있는 필드를 제공한다.

    • 한번에 하나의 파일만 첨부 가능하다.

    • 파일 업로드하려는 폼은 <form>태그의 method속성이 "posi"이고, enctype이 "multipart/form-data" 가 명시되어야 한다.

<body>
    <form action="http://localhost/upload.jsp" enctype="multipart/form-data"
             method="post">
         <input type="file">
     </form>
</body>

  1. submit
    • submit 버튼을 만들 때 사용한다.

<body>
    <input type="submit">
    <hr>
    <input type="submit" value="회원가입">
</body>

  1. reset

    • 입력한 내용을 모두 초기화하는 리셋 버튼을 만들 때 사용한다.

  2. button

    • 일반적인 버튼을 만들 때 사용한다.
    • 순수html (껍데기 라고 생각하면 된다.)

  1. 그 밖의 속성값들

    • email : 이메일 필드

    • url : URL을 입력받을 수 있는 필드

    • tel : 전화번호 필드

    • number : 숫자 필드 [▲/▼을 눌러 숫자를 증감할 수 있다.]

    • range : 슬라이드 막대를 사용해 숫자를 선택하는 필드

    • date : 날짜 선택 필드

    • time : 시간 선택 필드

    • week : 특정 연도의 주 선택 필드

    • search : 검색 필드

    • color : 색상 선택 필드

    • hidden : 화면에는 표시되지 않는 필드



11. <form>태그의 종류 - <select> 태그

  • 드롭다운 리스트를 만들 때 사용한다.
  • <select> 태그는 단지 드롭 다운 리스트의 영역을 만든다.
  • <option> 태그를 사용해서 각 목록을 만든다. 

<body>
    <fieldset>
        <legend>이동통신사 선택하기</legend>
        <label for="teleccom">이동 통신사 선택</label>
        <select name="telecom" id="telecom">
            <option value="SKT">SKTelecom</option>
            <option value="KT">KT</option>
            <option value="LG">LG U+</option>
        </select>
    </fieldset>
</body>



12. <form>태그의 종류 - <textarea> 태그

  • 여러 줄을 입력할 수 있는 필드를 제공한다.

<body>
    <p>자기소개</p>
        <p>
            <textarea rows="5" cols="40">자기 소개를 입력하세요</textarea>
        </p>
</body>







참고자료 : <쉽게 배우는 HTML5 & CSS3 그리고 jQuery>
]]> <![CDATA[[DBMS] DBMS & SQL 개념 ]]> https://velog.io/@hyun_ha/SQL-DBMS-SQL-%EA%B0%9C%EB%85%90 https://velog.io/@hyun_ha/SQL-DBMS-SQL-%EA%B0%9C%EB%85%90 Fri, 20 May 2022 23:28:32 GMT

📝 데이터베이스

  • 데이터(data)와 베이스(base)의 합성어이며 DBMS는 Database Management System의 약자로 '데이터베이스 관리 시스템'을 의미한다.

기본 개념

자료 (Data)

  • 현실 세계에서 관찰이나 측정을 통해 수집한 단순한 사실이나 값

정보 (Information)

  • 의사 결정에 도움을 줄 수 있는 유용한 형태
  • 자료를 가공(처리)해서 얻을 수 있는 결과를 의미

데이터 베이스

  • 어느 한 조직체의 여러 응용 시스템들이 공동으로 사용할 수 있도록 통합하여 저장한 운영데이터의 집합.
  • 공동의 목적을 지원하기 위한 서로 관련된 자료들의 모임
  • 주제와 관련된 의미 있는 데이터들의 모음

DBMS (DataBase Management System)

  • 사용자에게 데이터베이스를 생성하고 유지할 수 있게 하는 프로그램 집합
  • DBMS는 데이터베이스 언어를 가지고 있으며 이를 통해 데이터의 삽입/삭제/수정을 할 수 있다.
  • DBMS 종류 :
    • MySql, MongoDB, Oracle, MSSql, MariaDB, Tibero, Postgresql, sqlite, h2



DBMS 기능

  • 데이터의 무결성 유지
    • DB의 데이터는 실세계를 적용하는 규칙을 항상 만족해야 한다.
    • 서로 다른 부분에 있는 두 개의 데이터가 서로 모순되지 않아야 한다. 즉, 데이터의 일관성 유지

DBMS의 3가지 특성

  1. 데이터의 논리적 독립성

    • 한 속성에 가해진 변경이 동일한 테이블에서 다른 속성에 영향을 주지 않는 것을 의미한다.
    • 응용프로그램에 영향을 주지 않고 데이터 구조를 변경할 수 있게 하는 것

  2. 참조 무결성과 데이터 무결성

    • 응용프로그램 개발시 무결성 제약 조건을 신경쓰지 않아도 된다.

  3. 비정규 질의

    • 사용자는 작업을 실행하는 방법을 명시하지 않고도, 데이터베이스에게 어떤 데이터를 조회할 것인지를 명령할 수 있다.



데이터베이스 모델의 종류

  • 계층형 데이터 모델
    • 나뭇가지 형태의 트리(tree)구조를 활용하여 데이터 관련성을 계층별로 나누어 부모 자식 같은 관계를 정의하고 데이터를 관리한다.
    • 일대다 구조의 데이터를 표현하기에는 알맞지만 자식 개체가 여러 부모를 가진 관계는 표현할 수 없다.


  • 망형 데이터 모델 (네트워크 데이터 모델)
    • 그래프(graph) 구조를 기반으로 한다.
    • 개체 간 관계를 그래프 구조로 연결하므로 자식 개체가 여러 부모 개채를 가질 수 있다.


  • 객체 지향 데이터 모델
    • 객체 지향 프로그래밍에서 사용하는 객체 개념을 기반으로 한다.
    • 데이터를 독립된 객체로 구성하고 관리하여 상속, 오버라이드 등 객체 지향 프로그래밍에서 사용하는 강력한 기능을 사용할 수 있다.
    • 하지만 객체 지향형 모델 개념을 완전히 데이터 베이스에 적용하는 것은 쉽지 않기 때문에 이를 적용한 사용 DBMS는 많지 않다. 다만 여러 DBMS제품군이 '관계형 데이터 모델'을 바탕으로 객체 개념을 도입하여 '객체 관계형 DBMS'로 영역을 확장하고 있다.


  • 관계형 데이터 모델 (Relational Data Model)
    • 개체 집합에 대한 속성 관계를 표현하기 위하여 개체를 테이블(table)로 사용하고 개체 집합들 사이의 관계는 공통 속성으로 연결하는 독립된 형태의 데이터 모델

관계형 데이터 모델의 핵심 구성 요소

이름 설명
개체
(entity)		 데이터베이스에서 데이터화하려는 사물, 개념의 정보 단위
관계형 데이터베이스의 테이블(table) 개념과 대응되며 테이블은 릴레이션(relation)으로 표기하기도 한다.
속성
(attribute)		 개체를 구성하는 데이터의 가장 작은 논리적 단위로서 데이터의 종류, 특성, 상태 등을 정의한다.
관계형 데이터 베이스의 열(column)개념과 대응된다.
관계
(relationship)		 개체와 개체 또는 속성 간의 연관성을 나타내기 위해 사용
관계형 데이터베이스에서는 테이블 간의 관계를 외래키(foreign key)등으로 구현하여 사용한다.

관계형 모델의 구성 요소

  • 테이블 (table)
    • 관계형 모델은 기본적으로 데이터를 2차원 표 형태로 저장,관리한다.
    • 이 표형태의 데이터 저장 공간을 테이블이라고 한다.
    • 테이블의 내용은 실제적인 행의 집합으로 간주된다.
  • 행 (row)
    • 테이블의 가로줄을 말한다.
    • 저장하려는 하나의 개체를 구성하는 여러 값을 가로로 늘어뜨린 형태
    • 순서가 정해져 있지 않다.
  • 열(column)
    • 테이블의 세로줄을 말한다.
    • 저장하려는 데이터를 대표하는 이름과 공통 특성을 정의한다.
    • 저장 조건과 범위를 지정할 수 있다.


키 (key)

데이터를 구별할 수 있는 유일한 값으로, 종류별로 데이터를 구별하거나 테이블 간의 연관 관계를 표현할 때 키로 지정한 열을 사용한다.

  • 기본키 (PK : Primary Key)
    • 테이블에 저장된 행을 식별할 수 있는 유일한 값
    • 한 테이블 내에서 중복되지 않는 값만 가질 수 있는 키
    • NULL 값을 가질 수 없다.

기본키는 학번, 주민등록번호 등 처럼 개인 정보 노출이 가장 적은 데이터를 선정한다.

  • 보조키 (대체키 alternate key)

    • 후보키(candidate key)에 속해 있는 키로 후보키 중에서 기본키로 지정되지 않는 열이다.
    • 예를들어 기본키로 선택한 주민등록번호를 제외한 학번, 아이디가 보조키가 된다.

  • 외래키(FK: Foreign Key)

    • 특정 테이블에 포함되어 있으면서 다른 테이블의 기본키로 지정된 키를 의미한다.
    • 외래키는 데이터의 중복을 피하기 위해 테이블 사이의 관계를 규명하기 위한다.

사진에서 학생 정보 테이블을 보면 열 중에 학과 정보 테이블의 기본키인 '학과 코드'가 있다. 이 학과 코드가 바로 학생 정보 테이블과 학과 정보 테이블을 이어 주는 '외래키' 역할을 한다. 즉! 학생 정보 테이블은 학과 코드를 통해 학과 정보 테이블의 세부 정보를 찾아 갈 수 있다. 이를 학생 정보 테이블이 학과 코드를 '참조'한다고 표현한다.

  • 복합키 (composite key)
    • 여러 열을 조합하여 기본키 역할을 할 수 있게 만든 키를 뜻한다.
    • 하나의 열만으로 행을 식별하는 것이 불가능하여 두 개 이상의 열 값을 함께 사용해야 각 행이 유일한 데이터로서 가치를 지닌다.

만약 같은 과목을 여러 교수가 가르치거나, 한 교수가 서로 다른 과목을 가르치는 경우에는 테이블 행을 정확히 구분하는 것이 불가능하다.

이때 각 과목별 과목 코드와 담당 교수 열을 조합하여 하나의 키로 지정한다면 과목 정보 테이블의 행을 정확히 구분할 수 있다. 즉 '과목 코드 + 담당 교수' 가 복합키로서 기본키 역할을 하게 된다.




SQL이란?

  • Structured Query Language의 약자로서 관계형 데이터 베이스 언어이다.
  • 데이터의 삽입, 삭제, 갱신, 질의, 보호(보안) 명령문으로 구성되어 있다.
  • SQL은 비절차적 데이터베이스 언어로 분류한다.

SQL 기능에 따른 분류

종류 설명
데이터 정의어(DDL) 테이블이나 관계의 구조를 생성하는데 사용한다.
Create, Alter, Drop 문 등이 있다.
데이터 조작어(DML) 테이블에 데이터를 검색, 삽입, 수정, 삭제하는데 사용한다.
select, insert, delete, update 문 등이 있다.
데이터 제어어(DCL) 데이터의 사용 권한을 관리하는데 사용한다.
grant, revoke문 등이 있다.		 







참고자료 : <Do it! 오라클로 배우는 데이터베이스 입문>
]]> <![CDATA[[JAVA] 컬렉션 프레임워크(Collection Framework)]]> https://velog.io/@hyun_ha/JAVA-%EC%BB%AC%EB%A0%89%EC%85%98-%ED%94%84%EB%A0%88%EC%9E%84%EC%9B%8C%ED%81%ACCollection-Framework https://velog.io/@hyun_ha/JAVA-%EC%BB%AC%EB%A0%89%EC%85%98-%ED%94%84%EB%A0%88%EC%9E%84%EC%9B%8C%ED%81%ACCollection-Framework Sun, 15 May 2022 02:23:54 GMT

📝 컬렉션 프레임워크(Collection Framework)

  • 기존 배열의 문제점을 해결하고, 다수의 데이터를 쉽게 처리할 수 있는 표준화 된 방법을 제공하는 클래스이다.

자바 컬렉션 프레임워크는 몇 가지 인터페이스를 통해서 다양한 컬렉션 클래스를 이용할 수 있도록 한다.

주요 인터페이스로는 List, Set, Map이 있다.

List와 Set은 서로 많은 공통점이 있어서, 공통된 부분을 모아 collection 인터페이스를 정의할 수 있지만 Map은 다른 형태로 컬렉션을 다루기 때문에 같은 상속계층도에 포함되지 못했다.


인터페이스 특징 구현클래스
List 순서가 있는 데이터의 집합

데이터 중복을 허용		 ArrayList, LinkedList,
Stack, Vector
Set 순서가 없는 데이터의 집합

데이터의 중복을 허용하지 않음		 HashSet, TreeSet
Map 키(Key)와 값(value)의 쌍으로 이루어진 데이터의 집합

순서는 유지되는 않는다.

키(Key)는 중복을 허용하지 않지만, 값(value)은 중복을 허용한다.		 HashMap, TreeMap,
Hashtable, Properties



List 인터페이스

  • 객체를 일렬로 늘어놓은 구조를 가지고 있다.
  • 객체를 인덱스로 관리하기 때문에 객체를 저장하면 자동 인덱스가 부여되고 인덱스로 객체를 검색, 삭제할 수 있는 기능을 제공한다.
  • List 인터페이스는 중복을 허용하면서 저장순서가 유지되는 컬렉션을 구현하는데 사용된다.

List 인터페이스에 정의된 메서드

메서드 설명
void add(int index, Object element)
boolean addAll(int index, Collection c)		 지정된 위치(index)에 객체(element) 또는 컬렉션에 포함된 객체들을 추가한다.
Object get(int index) 지정된 위치(index)에 있는 객체를 리턴한다.
int indexOf(Object o) 지정된 객체의 위치(index)를 리턴한다.
(List의 첫 번째 요소부터 순방향으로 찾는다.)
int lastIndexOf(Object o) 지정된 객체의 위치(index)를 리턴한다.
(List의 마지막 요소부터 순방향으로 찾는다.)
int size() 저장되어 있는 객체의 개수를 리턴한다.
Object remove(int index) 지정된 위치(index)에 있는 객체를 삭제한다.
void clear() 저장된 모든 객체를 삭제한다.
Object set(int index, Object element) 지정된 위치(index)에 객체(element)를 저장한다.
void sort(Comparator c) 지정된 비교자(comparator)로 List를 정렬한다.
List subList(int fromIndex, int toIndex) 지정된 범위(fromIndex부터 toIndex)에 있는 객체를 반환한다.



ArrayList

  • 배열기반

  • ArrayList는 List 인터페이스를 상속받는 클래스로, 데이터를 이름표 없이 무제한으로 보관할 수 있다.

  • ArrayList에 추가되는 데이터는 저장순서가 유지되고 중복을 허용한다.

  • ArrayList에서 특정 인덱스의 객체를 삭제하거나 추가할 경우 바로 뒤 인덱스부터 인덱스가 바뀐다.

📌 일반 배열과의 차이점 📌

  - 배열은 생성할 때 크기가 고정되고 사용 중에 크기를 변경할 수 없지만,
  ArrayList는 저장 용량(capacity)가 초과한 객체들이 들어오면 
  자동적으로 저장 용량(capacity)이 늘어난다.

ArrayList의 선언

List<저장할 객체 타입> list = new ArrayList<저장할 객체 타입>();

✍ ArrayList 코드 예시)

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        List<Integer> numberList = new ArrayList<Integer>();

        // 데이터 추가하기
        for (int i = 1; i <= 10; i++) {
            numberList.add(i);
        }

        System.out.println("데이터의 크기 : " + numberList.size());
        System.out.println("--------------------------------");

        // 5번째 요소의 값 얻기, 
        System.out.println("5번째 요소의 값 : " + numberList.get(4));
        System.out.println("--------------------------------");

        // 5번째 요소의 값 삭제
        numberList.remove(4);

        // 하나를 삭제 후, 전체 크기 다시 조회
        System.out.println("데이터의 크기 : " + numberList.size());
        System.out.println("--------------------------------");

        // 5번째 요소의 값 다시 얻기
        System.out.println("5번째 요소의 값 : " + numberList.get(4));
        System.out.println("--------------------------------");

        // 5번째 자리에 데이터 추가
        numberList.add(4, 123);
        System.out.println("5번째 요소의 값 : " + numberList.get(4));
        System.out.println("--------------------------------");

        // 전체 삭제
        numberList.clear();
        System.out.println("데이터의 크기 : " + numberList.size());

    }

}

👉 실행 결과

데이터의 크기 : 10
--------------------------------
5번째 요소의 값 : 5
--------------------------------
데이터의 크기 : 9
--------------------------------
5번째 요소의 값 : 6
--------------------------------
5번째 요소의 값 : 123
--------------------------------
데이터의 크기 : 0



LinkedList

  • LinkedList는 List 구현 클래스이므로 ArrayList와 사용 방법은 똑같지만 내부 구조는 완전히 다르다.

  • ArrayList는 모든 데이터가 연속적으로 존재하지만 LinkedList는 불연속적으로 존재하는 데이터를 서로 연결(link)한 형태로 구성되어 있다.

    • LinkedList의 각 요소들은 자신과 연결된 다음 요소에 대한 참조(주소값)와 데이터로 구성되어 있다.

  • 특정 인덱스의 객체를 추가 또는 삭제할 경우 앞뒤 링크만 변경되고 나머지 링크는 변경되지 않는다.
    • 앞뒤 링크 정보만 변경하면 되므로 처리속도가 매우 빠르다.

  • LinkedList는 불연속적으로 위치한 각 요소들이 서로 연결된 것이라 처음부터 n번째 데이터까지 차례대로 따라가야만 원하는 값을 얻을 수 있다.
    그래서 LinkedList는 저장해야하는 데이터의 개수가 많아질수록 데이터를 읽어 오는 시간(접근시간)이 길어진다는 단점이 있다.

  • ArrayList와 LinkedList의 비교
컬렉션 읽기 (접근시간) 순차적 추가/삭제 중간에 추가/삭제 비고
ArrayList 빠르다 빠르다 느리다 비효율적인 메모리 사용
검색이 빠르다
LinkedList 느리다 느리다 빠르다 데이터가 많을수록 접근성이 떨어진다.
검색이 느리다

LinkedList의 선언

List<저장할 객체 타입> list = new LinkedList<저장할 객체 타입>();



Set 인터페이스

  • 중복을 허용하지 않고 저장순서가 유지되지 않는다.

    • 하나의 null만 저장할 수 있다.

  • 인덱스로 관리하지 않기 때문에 인덱스를 매개값으로 갖는 메서드가 없다.


Set 인터페이스에 정의된 메서드

메서드 설명
boolean add(Object o) 주어진 객체를 저장
객체가 성공적으로 저장되면 true, 중복 객체면 false를 리턴한다.
boolean contains(Object o) 주어진 객체가 저장되어 있는지 확인한다.
void clear() 저장된 모든 객체를 삭제한다.
boolean remove(Object o) 주어진 객체를 삭제한다.
boolean equals(Object o) 동일한 컬렉션인지 비교한다.
boolean isEmpty() 컬렉션이 비어 있는지 확인한다.
lterator iterator() 저장된 객체를 한 번씩 가져오는 반복자 리턴
int size() 저장되어 있는 전체 객체 수 리턴한다.

  • Set 컬렉션은 인덱스로 객체를 검색해서 가져오는 메서드가 없다. 그래서 전체 객체를 대상으로 한번씩 반복해서 가져오는 반복자(Iterator)를 제공한다.

Iterator 인터페이스

  • Iterator는 컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스이다.
  • iterator() 메서드를 호출하면 얻을 수 있다.

Iterator 인터페이스에 선언된 메서드
리턴 타입 메서드명 설명
boolean hasNext() 가져올 객체가 있으면 true, 없으면 false를 리턴한다.
E
(제네릭 타입)		 next() 컬렉션에서 하나의 객체를 가져온다.
next() 메서드를 사용하기 전에 hasNext() 메서드로 가져올 객체가 있는지 확인하는 것이 좋다.
void remove() Set 컬렉션에서 객체를 제거한다.



HashSet

  • Set인터페이스를 구현한 가장 대표적인 컬렉션이며, 중복된 요소를 저장하지 않는다.

  • 이미 저장되어 있는 요소와 중복된 요소를 추가하고자 한다면 add메서드는 false를 리턴함으로써 중복된 요소이기 때문에 추가에 실패했다는 것을 알린다.

  • 저장 순서를 유지하지 않으므로 저장순서를 유지하고자 한다면 LinkedHashSet을 사용해야한다.


중복을 걸러내는 과정

  • HashSet은 객체를 저장하기 전에 먼저 객체의 hashCode() 메서드를 호출해서 해시코드를 얻어낸다.

  • 그리고 이미 저장되어 있는 객체들의 해시코드와 비교한다.

  • 동일한 해시코드가 있다면 다시 equals() 메서드로 두 객체를 비교해서 true가 나오면 동일한 객체로 판단하고 중복 저장을 하지 않는다.


HashSet의 선언

Set<저장할 객체 타입> set = new HashSet<저장할 객체 타입>();

✍ HashSet 코드 예시)

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Main {

    public static void main(String[] args) {

        Set<String> color = new HashSet<String>();

        // 데이터 추가하기
        color.add("Red");
        color.add("Blue");
        color.add("Black");
        color.add("White");
        color.add("Pink");

        System.out.println("데이터의 크기 : " + color.size());
        System.out.println("numSet = " + color);    // 저장순서를 유지하지 않는다.
        System.out.println("--------------------------------");

        // 중복된 값 추가
        //     -> 중복된 값은 저장되지 않는다.
        color.add("Red");
        System.out.println("데이터의 크기 : " + color.size());        
        System.out.println("--------------------------------");

        // 데이터 전체 출력하기 
        Iterator<String> ite = color.iterator();

        while(ite.hasNext()) {     // 값이 있으면 true, 없으면 false
            System.out.print(ite.next() + " "); 
        }
        System.out.println("\n--------------------------------");

        // 데이터 삭제
        color.remove("Blue");

        // 값 검색하기
        System.out.println(color.contains("Blue"));
        System.out.println(color.contains("Red"));

    }

}

👉 실행 결과

데이터의 크기 : 5
numSet = [Red, White, Pink, Blue, Black]
--------------------------------
데이터의 크기 : 5
--------------------------------
Red White Pink Blue Black 
--------------------------------
false
true



TreeSet

  • 이진 탐색 트리(binary search tree)라는 자료구조의 형태로 데이터를 저장하는 컬렉션 클래스이다.
  • 중복된 데이터의 저장을 허용하지 않으며 정렬된 위치에 저장하므로 저장순서를 유지하지도 않는다.

TreeSet의 선언

TreeSet<저장할 객체 타입> treeSet = new TreeSet<저장할 객체 타입>();

이진 탐색 트리(binary search tree)

  • 이진 트리의 한 종류로 정렬, 검색, 범위검색(range search)에 높은 성능을 보이는 자료구조이다.
이진 트리(binary tree)란?

- 여러 개의 노드(node)가 트리 형태로 연결된 구조로,
'루트(root)'라고 불리는 하나의 노드에서부터 시작해서 각 노드에 최대 2개의
노드를 연결할 수 있는 구조를 가지고 있다.
- 위 아래로 연결된 두 노드를 '부모-자식관계'에 있다고 하며 
위의 노드를 부모 노드, 아래의 노드를 자식 노드라 한다.
- 하나의 부모 노드는 최대 두 개의 자식 노드와 연결될 수 있다.

  • 이진 탐색 트리는 왼쪽 자식노드의 값은 부모노드의 값보다 작고, 오른쪽 자식노드의 값은 부모노드의 값보다 커야한다.

왼쪽 마지막 값에서부터 오른쪽 값까지 값을 '왼쪽 노드 -> 부모 노드 -> 오른쪽노드' 순으로 읽어오면 오름차순으로 정렬된 순서를 얻을 수 있다.

  • 즉, 정렬에 유리하다.

  • TreeSet은 이처럼 정렬된 상태을 유지하기 때문에 단일 값 검색과 범위검색이 매우 빠르다.

  • 하지만 반복 비교로 자리를 찾아 저장하기 때문에 노드의 추가 삭제에 시간이 걸린다.


TreeSet의 메서드

생성자 또는 메서드 설명
Comparator comparator() TreeSet의 정렬기준(Comparator)을 반환
NavigableSet descendingSet() TreeSet의 저장된 요소들을 역순으로 정렬해서 반환
Object first() 정렬된 순서에서 첫 번째 객체(제일 낮은 객체)를 반환
Object last() 정렬된 순서에서 마지막 객체(제일 높은 객체)를 반환
Object lower(Object o) 지정된 객체보다 작은 값을 가진 객체 중 제일 가까운 값의 객체를 반환
없으면 null
Object higher(Object o) 지정된 객체보다 높은 값을 가진 객체 중 제일 가까운 값의 객체를 반환
없으면 null
Object floor(Object o) 지정된 객체와 같은 객체를 반환
없으면 작은 값을 가진 객체 중 제일 가까운 객체를 반환
없으면 null
Object ceiling(Object o) 지정된 객체와 같은 객체를 반환
없으면 높은 값을 가진 객체 중 제일 가까운 객체를 반환
없으면 null
Object pollFirst() TreeSet의 첫 번째 요소(제일 작은 값의 객체)를 반환 후 컬렉션에서 제거함
Object pollLast() TreeSet의 마지막 요소(제일 높은 값의 객체)를 반환 후 컬렉션에서 제거함
NavigableSet headSet(Object toElement, boolean inclusive) 지정된 객체보다 작은 값의 객체들을 반환
inclusive가 true이면, 같은 값의 객체도 포함
NavigableSet tailSet(Object toElement, boolean inclusive) 지정된 객체보다 높은 값의 객체들을 반환
inclusive가 true이면, 같은 값의 객체도 포함
NavigableSet sunSet(Object fromElement, boolean fromInclusive, Object toElement, boolean toInclusive 범위 검색(fromElement와 toElement사이)의 결과를 반환
fromInclusive가 true면 시작값이 포함되고, toInclusive가 true면 끝값이 포함된다.

✍ TreeSet 코드 예시)

import java.util.NavigableSet;
import java.util.TreeSet;

public class Main {

    public static void main(String[] args) {

        TreeSet<Integer> scores = new TreeSet<Integer>();

        // 데이터 추가하기
        scores.add(new Integer(87));
        scores.add(new Integer(64));
        scores.add(new Integer(98));
        scores.add(new Integer(75));
        scores.add(new Integer(95));
        scores.add(new Integer(80));

        // 특정 객체 찾기
        System.out.println("가장 낮은 점수 : " + scores.first());
        System.out.println("가장 높은 점수 : " + scores.last() + "\n");

        System.out.println("90점 아래 점수 : " + scores.lower(new Integer(90)));
        System.out.println("90점 위의 점수 : " + scores.higher(new Integer(90)) + "\n");

        // 객체 정렬하기
        NavigableSet<Integer> descendingSet = scores.descendingSet();
        for (Integer score : descendingSet) {
            System.out.print(score + " ");
        }
        System.out.println("\n");

        // pollFirst() 메서드
        while (!scores.isEmpty()) {
            System.out.println(scores.pollFirst() + " [남은 객체 수 : " 
                                + scores.size() + "]" );
        }

    }

}

👉 실행 결과

가장 낮은 점수 : 64
가장 높은 점수 : 98

90점 아래 점수 : 87
90점 위의 점수 : 95

98 95 87 80 75 64 

64 [남은 객체 수 : 5]
75 [남은 객체 수 : 4]
80 [남은 객체 수 : 3]
87 [남은 객체 수 : 2]
95 [남은 객체 수 : 1]
98 [남은 객체 수 : 0]

✍ TreeSet 코드 예시2)

import java.util.NavigableSet;
import java.util.TreeSet;

public class Main {

    public static void main(String[] args) {

        TreeSet<String> words = new TreeSet<String>();

        words.add("apple");
        words.add("cherry");
        words.add("forever");
        words.add("zoo");
        words.add("dance");
        words.add("car");
        words.add("flower");
        words.add("green");

        // 범위 검색하기
        System.out.println("[c~f 사이의 단어 검색]");

        NavigableSet<String> rangeSearch = words.subSet("c", true, "g", true);
        for(String word : rangeSearch) {
            System.out.println(word);
        }

    }

}

👉 실행 결과

[c~f 사이의 단어 검색]
car
cherry
dance
flower
forever



Map 인터페이스

  • 키(key)와 값(value)을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는데 사용된다.
    • 여기서 키와 값은 모두 객체이다.
  • 키는 중복될 수 없지만 값은 중복을 허용한다.
  • 기존에 저장된 데이터와 중복된 키와 값을 저장하려면 기존의 값은 없어지고, 마지막에 저장된 값이 남게 된다.
  • 키로 객체들을 관리하기 때문에 키를 매개값으로 갖는 메서드가 많다.

Map 인터페이스에 정의된 메서드

메서드 설명
Object put(Object key, Object value) 주어진 키로 값을 저장
새로운 키일 경우 null을 리턴하고 동일한 키가 있을 경우 값을 대체하고 이전 값을 리턴한다.
void clear() Map의 모든 객체를 삭제
Object remove(Object key) 지정한 key객체와 일치하는 key-value객체를 삭제
boolean containsKey(Object key) 지정된 키가 있는지 여부
boolean containsValue(Object value) 지정된 값이 있는지 여부
Set keySet() Map에 저장된 모든 key객체를 리턴
Collection values() 저장된 모든 값을 Collection에 담아서 리턴
Set entrySet() Map에 저장되어 있는 key-value쌍을 Map.Entry타입의 객체로 저장한 Set으로 리턴
Object get(Object key) 지정된 키가 있는 값을 리턴
boolean equals(Object o) 동일한 Map인지 비교
boolean isEmpty() Map이 비어있는지 여부
int size() 저장된 키의 총 수를 리턴



HashMap

  • Map 인터페이스를 구현한 대표적인 Map 컬렉션이다.
  • Map의 특징, 키(key)와 값(value)을 묶어서 하나의 데이터(entry)로 저장한다는 특징을 갖는다.
  • 해싱(hashing)을 사용하기 때문에 많은 양의 데이터를 검색하는데 있어서 뛰어난 성능을 보인다.
  • 키(key)는 주로 String을 많이 사용한다.
    • 키는 저장된 값을 찾는데 사용되는 것이기 때문에 컬렉션 내에서 유일(unique)해야 한다.
    • String은 문자열이 같은 경우 동등 객체가 될 수 있도록 hashcod()와 equuals()메서드가 재정의 되어 있다.

HashMap의 선언

Map<키 타입, 값 타입> map = new HashMap<키 타입, 값 타입>();

✍ HashMap 코드 예시)

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<String, Integer>();

        // 데이터 추가하기
        // -> 중복을 허용하지 않는다. (마지막에 들어간 값이 저장된다.)
        map.put("국어", 95);
        map.put("수학", 90);
        map.put("영어", 85);
        map.put("수학", 100);
        map.put("영어", null);     // 객체를 넣는 것이므로 Null 사용 가능

        // 저장된 갯수을 얻기
        System.out.println("HashMap size : " + map.size());
        System.out.println("-------------------------------------");

        // 데이터 꺼내기
        System.out.println(map.get("국어"));
        System.out.println(map.get("영어"));
        System.out.println(map.get("수학"));
        System.out.println("-------------------------------------");

        // 반복문으로 탐색 -> HashMap은 순서가 유지되지 않는다.
        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while(it.hasNext()) {
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key + " : " + value);
        }

    }

}

👉 실행 결과

HashMap size : 3
-------------------------------------
95
null
100
-------------------------------------
국어 : 95
수학 : 100
영어 : null




참고자료 : <Java의 정석>, <이것이 자바다>
]]> <![CDATA[[JAVA] Calendar 클래스 & 형식화]]> https://velog.io/@hyun_ha/JAVA-Calendar-%ED%81%B4%EB%9E%98%EC%8A%A4-%ED%98%95%EC%8B%9D%ED%99%94 https://velog.io/@hyun_ha/JAVA-Calendar-%ED%81%B4%EB%9E%98%EC%8A%A4-%ED%98%95%EC%8B%9D%ED%99%94 Thu, 05 May 2022 14:40:33 GMT

📝 Calendar 클래스

  • Date 클래스처럼 날짜와 시간을 다루는 클래스이다.
  • java.util 패키지에 포함되어 있다.

Calendar 클래스는 추상클래스이기 때문에 직접 객체를 생성할 수 없고, 메서드를 통해서 완전히 구현된 클래스의 인스턴스를 얻어야 한다.

// 캘린더 객체의 생성 -> 싱글톤 객체
Calendar cal = Calendar.getInstance();
  • getInstance()메서드는 Calendar클래스를 구현한 클래스의 인스턴스를 반환한다.



Calendar 클래스의 주요 상수

Calendar 객체를 얻었다면 get() 메서드를 이용해서 날짜와 시간에 대한 정보를 읽을 수 있다.

  • get() 메서드의 매개변수로 사용되는 int값들은 Calendar에 정의된 static상수이다.

상수 설명
YEAR 년도
MONTH 월

값의 범위는 0 ~ 11이기 때문에 0이면 1월을 의미한다.
DAY_OF_MONTH 일
DAY_OF_WEEK 요일

일 = 1 ~ 토 = 7
AM_PM 오전_오후

0 : 오전, 1: 오후
HOUR 시간 (0~11)
HOUR_OF_DAY 시간 (0~23)
MINUTE 분
SECOND 초
DATE 이 달의 마지막 일

✍ 코드 예시)

import java.util.Calendar;

public class Main01 {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();

        // 년, 월, 일, 시, 분, 초 >> 24시간제
        int yy = cal.get(Calendar.YEAR);
        int mm = cal.get(Calendar.MONTH) + 1;
        int dd = cal.get(Calendar.DAY_OF_MONTH);
        int hh = cal.get(Calendar.HOUR_OF_DAY);
        int mi = cal.get(Calendar.MINUTE);
        int ss = cal.get(Calendar.SECOND);

        System.out.printf("%04d년 %02d월 %02d일 %02d시 %02d분 %02d초\n"
                        ,yy, mm, dd, hh, mi, ss);

        // 년, 월, 일, 시, 분, 초 >> 12시간제
        yy = cal.get(Calendar.YEAR);
        mm = cal.get(Calendar.MONTH) + 1;
        dd= cal.get(Calendar.DAY_OF_MONTH);
        hh = cal.get(Calendar.HOUR);
        mi = cal.get(Calendar.MINUTE);
        ss = cal.get(Calendar.SECOND);

        // 오전(=0), 오후(=1)
        int ampm = cal.get(Calendar.AM_PM);
        String[] apName = {"오전", "오후"};

        System.out.printf("%04d년 %02d월 %02d일 %s %02d시 %02d분 %02d초\n"
                        ,yy, mm, dd, apName[ampm], hh, mi, ss);

    }

}

👉 실행결과

2022년 05월 05일 17시 19분 12초
2022년 05월 05일 오후 05시 19분 12초

✍ 코드 예시2)

import java.util.Calendar;

// 캘린더 클래스를 파라미터로 전달받아, 그 객체가 포함하고 있는
// 시간을 출력하는 메서드
public class DatePrinter {

    public static void printDateTime(Calendar cal) {

        int yy = cal.get(Calendar.YEAR);
        int mm = cal.get(Calendar.MONTH) + 1;
        int dd = cal.get(Calendar.DAY_OF_MONTH);
        int hh = cal.get(Calendar.HOUR_OF_DAY);
        int mi = cal.get(Calendar.MINUTE);
        int ss = cal.get(Calendar.SECOND);

        System.out.printf("%04d년 %02d월 %02d일 %02d시 %02d분 %02d초\n"
                        ,yy, mm, dd, hh, mi, ss);

    }

}
import java.util.Calendar;

public class Main0 {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        DatePrinter.printDateTime(cal);
        System.out.println("-----------------------------");

        // 지금으로 부터 100일 후 
        cal.add(Calendar.DAY_OF_MONTH, 100);
        DatePrinter.printDateTime(cal);
        System.out.println("-----------------------------");

        // 75년 전
        cal.add(Calendar.YEAR, -75);
        DatePrinter.printDateTime(cal);
        System.out.println("-----------------------------");

        // 9시간 후
        cal.add(Calendar.HOUR, 9);
        DatePrinter.printDateTime(cal);
        System.out.println("-----------------------------");

        // 8달 후
        cal.add(Calendar.MONTH, 8);
        DatePrinter.printDateTime(cal);
        System.out.println("-----------------------------");

    }

}

👉 실행결과

2022년 05월 05일 21시 36분 44초
-----------------------------
2022년 08월 13일 21시 36분 44초
-----------------------------
1947년 08월 13일 21시 36분 44초
-----------------------------
1947년 08월 14일 06시 36분 44초
-----------------------------
1948년 04월 14일 06시 36분 44초
-----------------------------



날짜 & 시간 설정하기

  • set메서드

    날짜와 시간을 원하는 값으로 변경하려면 set메서드를 사용하면 된다.

✍ 코드 예시)

import java.util.Calendar;

public class Main {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        DatePrinter.printDateTime(cal);

        // 특정 날짜로 지정
        cal.set(Calendar.YEAR, 2020);
        cal.set(Calendar.MONTH, 4);        // month는 0부터 시작해서 4로 했으면 5월이다.
        cal.set(Calendar.DAY_OF_MONTH, 5);
        cal.set(Calendar.HOUR_OF_DAY, 15);
        cal.set(Calendar.MINUTE, 30);
        cal.set(Calendar.SECOND, 33);
        DatePrinter.printDateTime(cal);

        // 특정 날짜로 지정(또 다른 방법)
        cal.set(1982, 5, 17);
        DatePrinter.printDateTime(cal);

        // 특정 날짜로 지정(또 다른 방법> 시, 분, 초 포함 / 24시간제만 가능)
        cal.set(1982, 5, 17, 1, 2, 3);
        DatePrinter.printDateTime(cal);

        // 년, 월, 시, 분, 초는 가만히 두고, 날짜만 1일로 변경하는 경우
        cal.set(Calendar.DAY_OF_MONTH, 1);
        DatePrinter.printDateTime(cal);

    }

}

👉 실행결과

2022년 05월 05일 21시 11분 00초
2020년 05월 05일 15시 30분 33초
1982년 06월 17일 15시 30분 33초
1982년 06월 17일 01시 02분 03초
1982년 06월 01일 01시 02분 03초

✍ 코드 예시2)

import java.util.Calendar;

public class Main04 {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();

        // 요일에 해당하는 인덱스 (일 = 1 ~ 토 = 7)
        int day = cal.get(Calendar.DAY_OF_WEEK);
        System.out.println("요일 인덱스 = " + day);

        // 요일을 출력하기
        String[] day_name = {"일", "월", "화", "수", "목", "금", "토"};
        System.out.println("요일 = " + day_name[day - 1]);

        // 이번 달은 몇 주로 되어 있는가?
        int week_count = cal.getActualMaximum(Calendar.WEEK_OF_MONTH);
        System.out.println("이번 달은 " + week_count + "주로 되어 있다.");

        // 이번 달은 몇 일까지 있는가?
        int day_count = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println("이번 달은 " + day_count + "일 까지 있다.");

        // 이번 달은 무슨 요일부터 시작하는가?
        cal.set(Calendar.DAY_OF_MONTH, 1);
        int first_day = cal.get(Calendar.DAY_OF_WEEK);
        System.out.println("이번 달의 시작 요일 인덱스 = " + first_day);
        System.out.println("이번 달의 시작 요일 = " + day_name[first_day - 1]);

    }

}

👉 실행결과

요일 인덱스 = 5
요일 = 목
이번 달은 5주로 되어 있다.
이번 달은 31일 까지 있다.
이번 달의 시작 요일 인덱스 = 1
이번 달의 시작 요일 = 일




📝 형식화 클래스

  • 숫자, 날짜, 텍스트 데이터를 일정한 형식에 맞게 문자열로 표현할 수 있는 클래스이다.
  • java.text패키지에 포함되어 있다.

형식화 클래스는 데이터를 정의된 패턴에 맞춰 형식화 할 수 있을 뿐만 아니라 역으로 형식화된 데이터에서 원래의 데이터를 얻어낼 수도 있다.


DecimalFormat

  • 숫자 형식 클래스

  • DecimalFormat은 숫자 데이터를 원하는 형식으로 표현하기 위해서 패턴을 사용한다.

기호 의미
0 10진수 (값이 없을 때는 0)
# 10진수
. 소수점
- 음수부호
, 단위 구분자
E 지수 기호
; 패턴구분자
% 퍼센트
\u2030 퍼밀 (퍼센트 * 10)
\u00A4 통화기호
' escape문자

DecimalFormat 사용 방법

  • 적용할 패턴을 작성하여 DecimalFormat 생성자 매개값으로 지정해서 객체를 생성한 다음,
  • format() 메서드를 호출하면 패턴이 적용된 문자열을 얻을 수 있다.

✍ 코드 예시)

import java.text.DecimalFormat;

public class Main {

    public static void main(String[] args) {

        double num = 1234567.89;

        DecimalFormat df = new DecimalFormat("#,###.0");
        String result = df.format(num);

        System.out.println(result);

    }

}

👉 실행결과

1,234,567.9



SimpleDateFormat

  • 날짜 형식 클래스

  • 날짜를 원하는 형식으로 표현하기 위해서 패턴을 사용한다.

기호 의미
G 연대 (BC, AD)
y 년도
M 월 (112 또는 1월12월)
w 년의 몇 번째 주 (1~53)
W 월의 몇 번째 주 (1~5)
D 년의 몇 번째 일 (1~366)
d 월의 몇 번째 일( 1~31)
F 월의 몇 번째 요일 (1~5)
E 요일
a 오전/오후 (AM,PM)
H 시간 (0~23)
k 시간 (1~24)
K 시간 (0~11)
h 시간 (1~12)
m 분 (0~59)
s 초 (0~59)
S 천분의 일초 (0~999)
z Time zone (General time zone)

ex) GMT+9:00
Z Time zone (RFC 822 time zone)

ex) +0900
' escape문자 (특수문자를 표현하는데 사용)

SimpleDateFormat 사용 방법

  • 적용할 패턴을 작성하여 SimpleDateFormat 생성자 매개값으로 지정해서 객체를 생성한 다음,
  • format(Date d)를 호출하면 지정한 출력형식에 맞게 변환된 문자열을 얻을 수 있다.

✍ 코드 예시)

import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {

    public static void main(String[] args) {

        Date today = new Date();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd \n오늘은 올 해의 w번째 주입니다.");
        String result = sdf.format(today);

        System.out.println(result);
    }

}

👉 실행 결과

2022-05-06 
오늘은 올 해의 19번째 주입니다.



MessageFormat

  • 문자열 형식 클래스

  • MessageFormat 클래스를 사용하면 문자열에 데이터가 들어갈 자리를 표시해 두고, 프로그램이 실행하면서 동적으로 데이터를 삽입해 문자열을 완성시킬 수 있다.

  • MessageFormat은 정적 format() 메서드를 호출해서 완성된 문자열을 리턴시킨다.

    • 메서드의 첫 번째 파라미터는 매개 변수화된 문자열을 지정, 두 번째 이후 파라미터는 인덱스 순서에 맞게 값을 나열하면 된다.

✍ 코드 예시)

public class Main {

    public static void main(String[] args) {

        String id = "java";
        String name = "자바";
        String tel = "010-1234-1234";

        String text = "id : {0}, 이름 : {1}, 전화번호 : {2}";
        String result = MessageFormat.format(text, id, name, tel);

        System.out.println(result);

    }

}

👉 실행 결과

id : java, 이름 : 자바, 전화번호 : 010-1234-1234







참고자료 : <Java의 정석>, <이것이 자바다>
]]> <![CDATA[[JAVA] 예외처리]]> https://velog.io/@hyun_ha/JAVA-%EC%98%88%EC%99%B8%EC%B2%98%EB%A6%AC https://velog.io/@hyun_ha/JAVA-%EC%98%88%EC%99%B8%EC%B2%98%EB%A6%AC Thu, 05 May 2022 01:00:14 GMT

📝 프로그램 오류

  • 프로그램이 실행 중 어떤 원인에 의해서 오작동을 하거나 비정상적으로 종료되는 경우 이러한 원인을 프로그램 '에러' 또는 '오류'라고 한다.

  • 이를 발생시점에 따라 '컴파일 에러'와 '런타임 에러'로 나눌 수 있다.



👾 에러의 종류

  • 컴파일 에러

    • 소스코드의 구문 오류로 인하여 컴파일이 불가능한 상태

    • 이클립스에서 빨간색으로 표시되는 경우 해당한다.

    • 프로그램을 실행하기 전에 발견되므로 상대적으로 고치기 쉽다.


  • 런타임 에러

    • 구문상의 에러는 없지만, 프로그램이 실행되는 과정에서 다양한 경우의 수에 대응하지 못하여 발생하는 예외상황

    • 런타임 에러가 발생하면 프로그램은 강제로 종료된다.

    • 우리가 프로그램의 에러라고 부르는 현상은 대부분 런타임 에러에 해당한다.



런타임 에러의 종류

  • 논리 오류

    • 프로그램 자체의 구조적인 문제로 인한 오류로 논리적 모순이 생기지 않도록 코드를 작성해야 한다.

  • 자바 가상머신 자체의 오류

    • 프로그래머가 책임질 수 있는 수준의 오류가 아니다.

  • 예외(Exception)

    • 프로그램 코드에 의해서 수습될 수 있는 다소 미약한 오류

    • 자바 가상 머신은 프로그램 실행중에 예외가 발생하면 관련된 예외 클래스로부터 예외 객체를 생성하여 프로그램에서 지정된 예외처리 구문으로 넘긴다.

    • 예외가 발생하면 프로그램에 지정된 예외 처리 구문이 자바 가상머신에 의해 호출되고, 이때 전달되는 예외 객체를 넘겨받아 적절한 처리를 수행한다.



예외처리 - (try ~ catch문)

  • 예외처리란? : 프로그램 실행 시 발생할 수 있는 예기치 못한 예외의 발생에 대비한 코드를 작성하는 것이다.

  • 예외처리의 목적 : 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지할 수 있도록 하는 것이다.


try ~ catch문

  • 예외를 처리하기 위해서는 try-catch문을 사용한다.

📌 try ~ catch문 구조

    try{
        // 기본적으로 실행되는 부분
    } catch (예외클래스이름 객체이름) {
        // try 블록에서 예외가 발생한 경우 이 곳으로 제어가 넘어온다.
    } finally {
        // 예외 상황의 발생 여부에 상관 없이 무조건 실행되는 부분
        // finally 블록은 생략 가능하다.
    }

  • try 블록 실행도중 catch에서 명시한 예외 클래스에 해당하는 런타임 에러가 발생하면, try 블록을 즉시 중단하고 catch 블록이 실행 된 후, finally 블록이 실행된다.

  • 예외가 발생하지 않을 경우에는 try 블록 종료 후 finally 블록이 실행된다.


catch블록을 사용한 복잡한 에러처리

  • catch 블록은 에러가 예상되는 상황에 대해 복수로 명시하는 것이 가능하다.
    try{
        // 
    } catch (NumberFormatException e) {
    } catch (ArrayIndexOutOfBoundsException e) {
    }



✍ 코드 예시 - 런타임 에러가 발생한 경우

public class Main {

    public static void main(String[] args) {

        String year = "두 살";
        int age = 2022 - Integer.parseInt(year) + 1;
        System.out.println(age);

        System.out.println("--------프로그램 종료--------");

    }

}

👉 실행 결과

문자열은 숫자로 변환할 수 없으므로, 에러가 발생한다.

  • java 프로그램은 예외 상황을 만나면 그 즉시 실행을 중단하고 강제 종료 된다.
  • 때문에 이 프로그램의 맨 마지막에 출력하려는 메시지는 표시되지 않는다.



✍ 코드 예시 - try ~ catch문

public class Main {

    public static void main(String[] args) {

        try {
            String year = "두 살";
            int age = 2022 - Integer.parseInt(year) + 1;
            System.out.println(age);
        } catch (NumberFormatException e) {
            System.out.println("에러가 발생했습니다.");
        }

        System.out.println("--------프로그램 종료--------");

    }

}

👉 실행 결과

에러가 발생했습니다.
--------프로그램 종료--------

try ~ catch 블록으로 예외처리가 적용된 경우에는, 에러가 발생하더라도 프로그램 자체가 다운되지는 않는다.



예외 클래스의 종류

예외 종류를 의미하는 모든 클래스는 java.lang.Exception 클래스를 상속받는다.



Exception 클래스

  • Java에서 예외 상황을 의미하는 모든 클래스들의 최상위 클래스

  • Exception 클래스로 catch 블록을 구성하면, 모든 예외 상황에 일괄적으로 대응할 수 있지만, catch 블록이 세분화된 경우와는 달리 상황별 개별적인 처리는 불가능하다.

  • Exception 클래스에 대한 예외처리는 맨 마지막 catch 블록에 명시하여 '마지막 알 수 없는 에러'를 의미하도록 구성한다.

    try{
        //
    } catch (NumberFormatException e) {
    } catch (ArrayIndexOutOfBoundsException e) {
    } catch (Exception e) {
    }



printStackTrace() & getMessage()

  • printStackTrace() 또는 getMessage()와 같은 메서드를 통해서 예외의 발생원인을 알 수 있다.

  • printStackTrace()

    • 실제 예외 상황시에 출력되는 메시지를 강제로 출력한다.
    • 개발자가 catch 블록 안에서 예외 상황을 분석하기 위한 용도로 사용한다.

  • getMessage()

    • 간략한 에러 메시지를 리턴한다.
    • e.getLocalisMessage()도 같은 기능을 한다.

✍ 코드 예시)

public class Main {

    public static void main(String[] args) {

        try {
            String year = "두 살";
            int age = 2022 - Integer.parseInt(year) + 1;
            System.out.println(age);
        } catch (NumberFormatException e) {
            System.out.println("에러가 발생했습니다.");
            System.out.println("원인 : " + e.getMessage());

            // 개발자가 보려는 용도로 출력하는 시스템 에러 메시지
            e.printStackTrace();
        }

        System.out.println("--------프로그램 종료--------");

    }

}

👉 실행결과

이 결과는 비정상적으로 종료되었을 때의 결과와 비슷하지만 예외는 try-catch문에 의해 처리되었으며 프로그램은 정상적으로 종료되었다.



예외 발생시키기

  • throw 키워드를 사용해서 프로그래머가 고의로 예외를 발생시킬 수 있다.

  • 예외 발생시키는 방법

    1. new 연산자를 이용해서 발생시키려는 예외 클래스의 객체를 만든다.
      Exception e = new Exception("고의로 발생시킴");
    2. throw 키워드를 이용해서 예외를 발생시킨다.
      throw e;

✍ 코드예시)

public class Main {

    public static void main(String[] args) {

        try {
            Exception e = new Exception("고의로 발생시킴");
            throw e;
        } catch (Exception e) {
            System.out.println("에러 메시지 : " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println("-----프로그램 정상 종료-----");
    }

}

👉 실행결과

Exception인스턴스를 생성할 때, 생성자에 String을 넣어주면, 이 String이 Exception인스턴스에 메시지로 저장된다. 이 메시지는 getMessage()를 이용해서 얻을 수 있다.



메서드에 예외 선언하기

  • 예외를 처리하는 방법에는 try-catch문을 사용하는 것 외에, 예외를 메서드에 선언하는 방법이 있다. 이때 사용하는 키워드는 throws이다.

  • throws 키워드는 메서드에서 처리하지 않은 예외를 호출한 곳으로 떠넘기는 역할을 한다.


  • 메서드에 예외 선언하는 방법

    • throws 키워드를 메서드 선언부 끝에 작성한다.

    • 예외가 여러 개일 경우에는 쉼표( , )로 구분한다.

      리턴타입 메서드명() throws Exception1, Exception2 .. ExceptionN {
      // 메서드 내용
}

    • 아래와 같이 모든 예외의 최고조상인 Exception클래스를 메서드에 선언하면, 모든 예외를 간단히 떠넘길 수도 있다.

      리턴타입 메서드명() throws Exception{
      // 메서드 내용
}

      ### ✍ 코드예시) ```java public class Example {

      public void method(String year) throws NumberFormatException{

      int age = 2022 - Integer.parseInt(year) + 1;

System.out.println(age);

      }

}

```java
// Main 클래스
public class Main {

    public static void main(String[] args) {

        Example ex = new Example();

        try {
            ex.method("천구백오십년");    // 메서드 호출
        } catch (NumberFormatException e) {
            System.out.println("입력값이 숫자가 아닙니다.");    
        }
    }

}

👉 실행결과

입력값이 숫자가 아닙니다.

코드 예시 설명

throws 키워드가 붙어있는 method()메서드를 사용할 때 NumberFormatException 예외가 발생하면, 메서드를 사용한 곳에서 예외처리를 해야한다.

그래서 코드 예시에서 method()를 호출하는 main()메서드에서 try-catch문으로 예외 처리를 했다.


📙 throws 키워드 정리

  • throws 키워드가 붙어있는 메서드는 반드시 try 블록 내에서 호출되어야 한다.
  • 그리고 catch 블록에서 떠넘겨 받은 예외를 처리해야 한다.
  • main() 메서드에서도 throws 키워드를 사용해서 예외를 떠넘길 수 있는데. 결국 JVM이 예외의 내용을 console에 출력하는 것으로 예외 처리를 한다.
    • 하지만 main()메서드에서 throws Exception을 붙이는 것은 사용자가 프로그램이 알 수 없는 예외 내용을 출력하고 종료되기 때문에 좋지 못한 예외 처리 방법이다.
    • 그렇기 때문에 main()에서 try-catch문으로 최종 처리하는 것이 가장 바람직하다.







참고자료 : <Java의 정석>, <이것이 자바다>
]]> <![CDATA[[Git & GitHub] Git의 작업 영역 & 파일 상태]]> https://velog.io/@hyun_ha/Git-GitHub-Git%EC%9D%98-3%EA%B0%80%EC%A7%80-%EC%9E%91%EC%97%85-%EC%98%81%EC%97%AD https://velog.io/@hyun_ha/Git-GitHub-Git%EC%9D%98-3%EA%B0%80%EC%A7%80-%EC%9E%91%EC%97%85-%EC%98%81%EC%97%AD Wed, 04 May 2022 13:35:17 GMT

📌 Git은 내부적으로 크게 3가지 종류의 작업 영역을 가지고 있다.

  1. working directory

  2. staging area

  3. repository


📝 1. working directory (working tree)

  • 첫 번째 작업영역인 working directory는 작업을 하는 프로젝트 디렉토리를 말한다.
  • .git 디렉토리를 제외한 모든 영역이다.

📝 2. staging area (index)

  • 두 번째 작업영역인 staging area는 git add를 한 파일들이 존재하는 영역이다.
  • 이 곳에 있는 파일들만 커밋에 반영된다.

📝 3. repository

  • working directory의 변경 이력들이 저장되어 있는 영역이다. 즉, 커밋들이 저장되는 영역이다.
  • .git 디렉토리가 repository이다.



작업 영역의 관계

  1. working directory에서 A.txt 파일과 B.txt 파일을 작성하고

  2. git add A.txt와 git add B.txt를 실행해서 staging area에 올라간다.

  3. git commit -m "1st commit"을 실행해서 staging area에 있던 파일들의 모습이 스냅샷처럼 하나의 버전으로 Repository에 저장된다.



예시)

  • working directory에서 A, B.txt의 내용을 추가하고

  • git add B.txt만 실행해서 B.txt 파일만 staging area에 올렸을 때

  • git commit -m "2nd commit"을 하면 A.txt는 수정전, B.txt는 수정후 파일이 커밋에 반영되었다.

❗❗ 즉 working directory에서 수정을 해도 staging area에 올렸는지 여부에 따라 그 최신 모습이 커밋에 반영되는지가 달라진다.





📌 Git으로 관리되는 파일은 4가지의 상태(status)를 가지고 있다.

  • Untracked
  • Staged
  • Unmodified
  • Modified

Git에서 파일들은 크게 2가지 상태를 가진다.

  • Untracked
  • Tracked

그리고 Tracked 상태는 다시 3가지 상태로 나눌 수 있다.

  • Staged
  • Unmodified
  • Modified

📝 1. Untracked

  • Untracked는 '추적되지 않고 있는'이라는 뜻으로 파일이 Git에 의해서 그 변동사항이 전혀 추적되고 있지 않는 상태

  • 파일을 새로 생성하고 그 파일을 한 번도 git add 해주지 않은 상태를 Untracked라고 한다.


📝 2. Tracked

  • 파일이 Git에 의해 그 변동사항이 추적되고 있는 상태
  • Tracked 상태는 그 특성에 따라 3가지 상태로 나뉜다.

2-1. Staged

  • staging area에 올라와있는 상태를 말한다.
새로 생성한 파일에 내용을 쓰고 git add를 해주거나,

한 번이라도 커밋에 포함됐었던 파일이라도 내용을 수정하고 git add를 해주면 이 상태이다.

2-2. Unmodified

  • 현재 파일의 내용이 최신 커밋의 모습과 비교했을 때 전혀 바뀐 게 없는 상태면 그 파일은 Unmodified(수정되지 않은, 변한 게 없는) 상태이다.

  • 커밋을 하고 난 직후에는 working directory 안의 모든 파일들이 이 상태이다.


2-3. Modified

  • 최신 커밋의 모습과 비교했을 때 조금이라도 바뀐 내용이 있는 상태면 그 파일은 Modified(수정된) 상태이다.



파일의 라이프사이클

상황 설명
Add the file Untracked 상태의 파일을 처음으로 git add 해주면 Staged 상태가 된다.
Edit the file 최신 커밋과 비교했을 때 차이가 없는 Unmodified 상태의 파일의 내용을 수정하면 Modified 상태가 된다.
Stage the file Modified 상태의 파일을 git add 해주면 Staged 상태가 된다.
Remove the file 파일을 삭제하면 Git에서 더이상 인식하지 못하는 Untracked 상태가 된다.
Commit 커밋을 하면 staging area에 있던 파일들이 커밋에 반영되고,
이제 모든 파일들은 최신 커밋과 차이가 없게 되니까 Unmodified 상태가 된다.		 







이 글은 CODEIT의 강의를 기반으로 작성했습니다.
]]> <![CDATA[[JAVA] 정규 표현식 & Pattern 클래스]]> https://velog.io/@hyun_ha/JAVA-%EC%A0%95%EA%B7%9C-%ED%91%9C%ED%98%84%EC%8B%9D-Pattern-%ED%81%B4%EB%9E%98%EC%8A%A4 https://velog.io/@hyun_ha/JAVA-%EC%A0%95%EA%B7%9C-%ED%91%9C%ED%98%84%EC%8B%9D-Pattern-%ED%81%B4%EB%9E%98%EC%8A%A4 Sun, 01 May 2022 09:46:08 GMT

📝 정규 표현식

  • 특정한 규칙을 가진 문자열의 집합을 표현하는데 사용하는 '형식언어'이다.

  • 정규표현식은 많은 텍스트 편집기와 프로그래밍 언어에서 '문자열의 검색과 치환'을 위해 지원하고 있다.

  • java.util.regex 패키지에 포함되어있다.


정규 표현식 종류

출처 https://hamait.tistory.com/342



📝 Pattern 클래스

  • Pattern 클래스의 matches()메서드는 문자열을 정규 표현식으로 검증하는 기능을 한다.
boolean java.util.regex.Pattern.matches(String arg0, CharSequence arg1);
  • arg0 : 정규표현식 문자열이다.
  • arg1 : 형식을 검사받기 위한 내용이다.
  • 즉 위의 기능은 arg1이 arg0의 형식에 맞는지를 검사하고 결과를 boolean으로 리턴한다.

✍ 코드 예시)

import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {

        // 회원가입시에 입력한 내용을 가정한 변수값들
        String name = "자바학생";
        String age = "22";
        String email = "user@java.com";
        String phone = "01012345678";

        // 한글 여부 검사
        boolean isKor = Pattern.matches("^[ㄱ-ㅎ가-힣]*$", name);

        if (!isKor) {
            System.out.println("이름은 한글로 입력해 주세요.");
            return;
        }

        // 숫자인지 검사
        boolean isNum = Pattern.matches("^[0-9]*$", age);

        if (!isNum) {
            System.out.println("나이는 숫자로만 입력해 주세요.");
            return;
        }

        // 이메일 검사
        boolean isEmail = Pattern.matches("^[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*.[a-zA-Z]{2,3}$", email);

        if (!isEmail) {
            System.out.println("이메일 형식이 맞지 않습니다.");
            return;
        }

        // 휴대폰 형식 검사
        boolean isPhone = Pattern.matches("^01(?:0|1|[6-9])(?:\\d{3}|\\d{4})\\d{4}$", phone);

        if (!isPhone) {
            System.out.println("전화번호 형식이 맞지 않습니다.");
            return;
        }

        System.out.println("회원가입 절차를 시작합니다.");

    }

}

👉 실행 결과

회원가입 절차를 시작합니다.

✍ 코드 예시2 )

❗ 정규식과 일치하지 않을 경우

import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {

        String name = "java학생";

        // 한글 여부 검사
        boolean isKor = Pattern.matches("^[ㄱ-ㅎ가-힣]*$", name);

        if (!isKor) {
            System.out.println("정규식과 일치하지 않습니다.");
            return;
        } else {
            System.out.println("정규식과 일치합니다.");
        }

    }    
}

👉 실행 결과

정규식과 일치하지 않습니다.







참고자료 : <이것이 자바다>
]]> <![CDATA[[JAVA] Wrapper Class]]> https://velog.io/@hyun_ha/JAVA-Wrapper-Class https://velog.io/@hyun_ha/JAVA-Wrapper-Class Fri, 29 Apr 2022 05:05:44 GMT

📝 Wrapper Class

  • 포장 클래스(Wrapper Class)는 특정 기본형 타입을 객체로 다룰 때 사용된다.

  • Java는 데이터를 관리하기 위하여 기본 데이터 타입을 지원하지만, 클래스를 통해서 만들어진 객체를 통한 데이터 관리도 가능하다.

  • 어떤 상황에서는 기본 데이터 타입의 변수를 객체 형태로 사용해야 하는 경우가 있는데, 이때 기본형 타입을 객체로 포장할 필요가 있다.



Wrapper class의 종류



Boxing & Unboxing

  • Boxing

    • 기본 타입의 값을 wrapper class의 객체로 만드는 과정
    • wrapper class의 생성자 파라미터값으로 기본타입의 값 또는 문자열을 넘겨주면 된다.
      Integer wrapper = new Integer(10);

  • Unboxing

    • wrapper class에서 기본 타입의 값을 얻어내는 과정
    • 각 wrapper class마다 가지고 있는 "기본타입명 + Value()" 메소드를 호출하면 된다.
      int num = wrapper.intValue();

AutoBoxing & AutoUnBoxing

  • 기본 자료형과 Wrapper 클래스 간에는 서로 암묵적 형변환이 가능하다.

  • AutoBoxing은 Wrapper 클래스 타입에 기본값이 대입될 경우, AutoUnBoxing은 기본 타입에 wrapper class의 객체가 대입될 경우 발생한다.

    int num = 100;
Integer wrpper = num;        // 자동 박싱 (AutoBoxing)

Integer wrapper2 = new Integer(200); int num = wrapper2; // 자동 언박싱 (AutoUnBoxing)


<br><br>

## Wrapper 클래스의 static 데이터
- 모든 Wrapper 클래스는 static 데이터 형태로 Wrapper 클래스에 대응되는
   자료형에 대한 최소 값과 최대 값을 가지고 있다.
```java
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;



문자열 데이터의 형변환

  • wrapper 클래스의 가장 중요한 기능은 기본 자료형의 모양을 띄고 있는 문자열 데이터를 실제 기본 자료형으로 변환시키는 기능이다.

  • 대부분의 wrapper 클래스에는 'parse + 기본타입' 메소드를 이용해 문자열을 파라미터로 받아 기본 타입 값으로 변환한다.

    • 이때 각 자료형에 알맞은 문자열을 사용해야 한다.


✍ 코드 예시

public class Main {

    public static void main(String[] args) {
        String a = "20";
        String b = "3.14";

        System.out.println(a + b);
        System.out.println("-------------------------------------");

        // 형변환
        int num_a = Integer.parseInt(a);
        float num_b = Float.parseFloat(b);

        System.out.println(num_a + num_b);
        System.out.println("-------------------------------------");

    }

}

👉 실행 결과

203.14
-------------------------------------
23.14

변환된 값은 사칙연산이 가능하다. 또한 기본 데이터 형과 객체화 된 데이터도 서로 연산이 가능하다. 

    int v1 = num_a + 500;
    float v2 = num_b + 500;
    System.out.println("v1 = " + v1);
    System.out.println("v2 = " + v2);
    System.out.println("-------------------------------------");

    // 기본 데이터 형의 객체화
    Integer i = new Integer(500);

    int j = i + 300;
    System.out.println("j = " + j);

👉 실행 결과

v1 = 520
v2 = 503.14
-------------------------------------
j = 800



Wrapper 클래스 값 비교

  • Wrapper 클래스의 객체는 내부의 값을 비교하는 것이 아니라 객체의 잠조를 비교하기 때문에 ==와 != 연산자를 사용할 수 없다.

  • 그러므로 직접 내부 값을 언박싱해서 비교하거나, equals() 메서드로 내부 값을 비교해야 한다.

  • Wrapper 클래스들은 모두 equals()가 오버라이딩되어 있어서 주소값이 아닌 객체가 가지고 있는 값을 비교할 수 있다.


✍ 코드 예시

public class Main {

    public static void main(String[] args) {
        Integer a = new Integer(200);
        Integer b = new Integer(200);

        System.out.println("equals() 결과 : " + a.equals(b));
    }

}

👉 실행 결과

equals() 결과 : true

이렇게 equals()를 이용한 두 Integer객체의 비교결과가 ture라는 것을 알 수 있다.

]]> <![CDATA[[JAVA] 패키지(Package) 정리]]> https://velog.io/@hyun_ha/JAVA-%ED%8C%A8%ED%82%A4%EC%A7%80Package https://velog.io/@hyun_ha/JAVA-%ED%8C%A8%ED%82%A4%EC%A7%80Package Tue, 26 Apr 2022 14:07:12 GMT

📝 패키지(Package)

  • 패키지란?

    • 클래스의 묶음으로 클래스를 용도별이나, 기능별로 그룹화 한 것을 말한다.

  • 패키지는 물리적으로 하나의 디렉토리(파일 시스템의 폴더) 이다.

  • 클래스를 유일하게 만들어주는 식별자 역할을 한다.

  • 같은 이름의 클래스 일지라도 서로 다른 패키지에 존재하는 것이 가능하므로, 자신만의 패키지 체계를 유지함으로써 충돌이 발생하지 않는다.



패키지 추가하기

클래스의 전체 이름은 "패키지명 + 클래스명"인데 패키지가 상,하위로 구분되어 있다면 도트( . )를 사용해서 다음과 같이 표현한다.

상위패키지.하위패키지.클래스

패키지 추가하기 예시)

Car 클래스가 com.mycompany 패키지에 속해 있다면,

  • Car 클래스의 전체 이름 -> com.mycompany.Car

  • 실제 파일 시스템 -> com\mycompany 폴더에 Car.class가 위치한다.


예를 들어 Car 클래스가 com.mycompany 패키지에 소속되어 있을 경우, 파일 시스템 com\yourcompany 폴더에 강제로 Car.class를 이동하면 Car 클래스를 사용할 수 없다.

  • ❗❗ 클래스만 따로 복사해서 다른 패키지로 이동하면 클래스는 사용할 수 없다.
    • 즉, 클래스를 이동할 경우에는 패키지 전체를 이동시켜야 한다.



패키지 선언

  • 패키지에 소속된 클래스 파일은 첫 번째 라인에서 자신이 소속된 클래스 패키지 이름을 선언해야 한다.

    package 패키지명;

  • 패키지 선언은 하나의 소스파일에 단 한 번만 선언될 수 있다.

  • 소스파일에 자신이 속할 패키지를 지정하지 않은 클래스는 자동적으로 '이름 없는 패키지(unnamed package)'에 속하게 된다.


여러 개발 회사가 함께 참여하는 대규모 프로젝트나, 다른 회사의 패키지를 이용해서 개발할 경우, 패키지 이름이 중복될 가능성이 있다. 그래서 패키지가 중복되지 않도록 회사의 도메인 이름으로 패키지를 만든다.

도메인 이름으로 패키지를 만들 경우, 도메인 이름 역순 + 마지막에 프로젝트 이름을 붙여준다. ( 포괄적인 이름이 상위 패키지가 되도록 하기 위해 역순으로 한다.)

ex)
com.samsung.projectName
com.lg.projectName
com.hyudai.projectName



패키지 사용하기

같은 패키지에 속하는 클래스들은 아무런 조건 없이 다른 클래스를 사용할 수 있지만 다른 패키지에 속하는 클래스를 사용하려면 두 가지 방법 중 하나를 선택해야 한다.

1. 패키지와 클래스를 모두 기술하는 방법

  • 패키지에 속해 있는 클래스에 대한 객체 생성을 해야한다.
  • 패키지 이름을 포함한 FullName으로 사용해야 한다.

예시) com.hankook 패키지에 소속된 Tire 클래스를 이용해서 필드를 선언 후 객체를 생성

package com.mycompany;

public class Car {
    com.hankook.Tire tire = new com.hankook.Tire();
}
  • 단점
    • 패키지 이름이 길거나 이렇게 사용해야 할 클래스 수가 많다면 이 방법은 전체 코드를 난잡해 보이게 할 수 있다.

그래서 두 번째 방법인 import문을 주로 사용한다.


2. import문

import문의 역할은 컴파일러에게 소스파일에 사용된 클래스의 패키지에 대한 정보를 제공하는 것이다. import문으로 사용하고자 하는 클래스의 패키지를 미리 명시해주면 소스코드에 사용되는 클래스이름에서 패키지명은 생략할 수 있다.

import문 선언

import 패키지명.클래스명;

        또는

import 패키지명.*;

  • 패키지 선언과 클래스 사이에 선언해야 한다.

  • import문의 개수는 제한이 없다.

  • 같은 패키지에서 여러 개의 클래스가 사용될 때, ' 패키지명.* '을 이용해서 지정된 패키지에 속하는 모든 클래스를 패키지명 없이 사용할 수 있다.


ex)

package com.mycompany;

import com.hankook.Tire;

public class Car {
    Tire tire = new Tire();
}




🔥 패키지 사용시 주의할 점 🔥

  • import문으로 지정된 패키지의 하위 패키지는 import 대상이 아니다.

    • 하위 패키지에 있는 클래스들도 사용하고 싶다면 import문을 하나 더 작성해야 한다.

  • 서로 다른 패키지에 동일한 클래스 이름이 존재하고, 두 패키지가 모두 import되어 있을 경우 패키지 이름 전체를 기술해야 한다.

]]> <![CDATA[[Git & GitHub] 시작하기]]> https://velog.io/@hyun_ha/Git-GitHub-%EC%B4%88%EA%B8%B0-%EC%84%A4%EC%A0%95 https://velog.io/@hyun_ha/Git-GitHub-%EC%B4%88%EA%B8%B0-%EC%84%A4%EC%A0%95 Sun, 24 Apr 2022 06:48:45 GMT 📝 1. 사용자 정보 설정

Git은 협업을 전제로 하는 버전 관리 도구이다. 따라서 작업을 할 때 누구의 작업인지 기록해야 한다.

Git에서는 commit을 할 때 사용할 이름과 이메일을 지정할 수 있으며, 이 때 commit에 기록된 이메일은 GitHub의 사용자를 연결할 때도 사용된다.

❗❗ 처음 git을 설치한 후 한 번만 실행하면 된다.


1. git bash 실행


2. 사용자 이름, 이메일 등록하기

git config --global user.name "Your Name Here"

“Your Name Here” 에 사용자 이름 (github의 이름)

git config --global user.email "your_email@yourmail.com"

"your_email@yourmail.com"에는 GitHub 가입할 때 사용한 이메일을 적고 명령어를 실행시킨다. 

--global 옵션은 현재 시스템에서 기본값으로 사용자 설정할 때 쓰는 옵션이다.
( ❗❗ --global 옵션으로 설정하는 것은 딱 한 번만 하면 된다. )

만약 프로젝트마다 다른 이름과 이메일 주소를 사용하고 싶으면 
--global 옵션을 빼고 명령어를 실행시키면 된다.

3. 사용자 정보 설정 확인하기

git config --list

명령어를 실행시키면 설정한 정보를 확인할 수 있다.




📝 2. 온라인 저장소(remote repository) 생성

Git의 원격저장소 즉 GitHub의 저장소를 리모트 레포지토리(remote repository)라고 한다.

1. github.com 로그인 후 Repositories -> New 클릭


2. 저장소 생성하기

  • 필수여부 설명
    Repository name 필수 저장소의 이름
    Description (선택) 저장소에 대한 설명
    Public, Private 필수 저장소 공개 여부
    Initialize this repository with a README (선택) README.md 파일 생성 여부
    Add .gitignore (선택) github에서 관리하지 않을 파일 선택
    Add a license (선택) license 파일 추가 (ex. 저작권)
    - 이 프로젝트가 어떤 라이센스에 속할지 선택
  • README 파일은 저장소를 소개하는 텍스트 파일이다.

Create repository 클릭 후 이 화면이 보이면 저장소가 생성된 것이다.

❗ 빨간 박스로 표시해 둔 곳이 저장소의 주소이므로 복사해 둔다.




📝 3. 로컬 저장소(Local Repository) 생성

본인의 컴퓨터에 저장소를 로컬 저장소(Local Repository) 라고 한다.

온라인과 로컬 저장소들은 오로지 저장소일 뿐 작업 공간이 아니다. 실제 작업공간은 컴퓨터이기 떄문에 로컬 디렉토리에 만들 저장소에 실제로 미러링해야 한다.

1. local repository 생성하고자 하는 위치로 이동

  • 저장소로 등록하고 싶은 프로그램의 폴더로 경로로 이동

  • 마우스 우클릭 -> git Bash 실행


2. git을 초기화 시켜 로컬 저장소 생성

git init

이 명령어를 입력하면 현재 폴더를 로컬 저장소로 초기화 한다는 의미로 git의 버전관리가 가능한 폴더로 지정된다.

  • 2-1. 로컬 저장소 상태 확인

git status

로컬 저장소 상태 확인할 수 있는 명령어다.

on branch master - 이 프로젝트는 master branch 상에 있다. No commits yet , nothing added to commit - 커밋 내역이 없다. Untracked files - git add나 git commit을 하지 않았기에 Untracked 상태인 파일을 가리킨다.

  • Untracked files는 git에 의해 아직 추적되지 않고있는 파일이다.

3. Untracked file을 버전관리 대상으로 추가하기

untracked file은 버전관리 대상파일이 아니다. 그래서 이 파일을 버전관리의 대상으로 추가하기 위해 git add를 해야 한다.

git add .

이 곳에 있는 '모든' 파일을 add한다는 명령어이다.

❗❗ commit을 하기 전 꼭 커밋할 파일을 git add 해야한다. ❗❗

( add 뒤에 ' . ' 은 '모든' 파일을 의미한다. 만약 특정 파일만 add할 경우 'git add 파일이름' 을 입력하면 된다. )

add 후 로컬 저장소 상태를 확인하면 추가된 것을 확인할 수 있다. 즉 commit할 수 잇는 상태가 된 것이다.

4. commit 하기

git commit -m "커밋에 대한 정보"

-m 은 메세지 옵션으로 " "에 해당 commit을 설명하는 내용을 입력을 해야한다.

어느 부분을 수정했는지 등의 주석 같은 것을 적은 후 커밋하는 것이다.

git status 상태를 확인하면 다음과 같다.

이렇게 로컬 저장소의 생성이 완료되었다.




📝 4. 로컬 저장소와 온라인 저장소 연결하기

GitHub에 생성한 온라인 저장소와 로컬 저장소를 연결하기 위해서 저장소의 URL가 필요하다.

온라인 저장소를 생성한 화면에서 push 부분을 한 줄씩 입력해주면 된다.

🔥 git bash에서 일반적인 복붙 단축키 ctrl c, ctrl v는 사용할 수 없다. 🔥

❗❗ git bash에서 복붙 단축키 ❗❗

  • 복사하기 - ctrl + insert
  • 붙여넣기 - shift + insert

1. [ git remote add origin 자기주소 ]

git remote add origin 자기주소

git remote -v

git remote -v 명령어를 입력하면 fetch와 push가 가능한 온라인 저장소를 추가했음을 확인할 수 있다

2. git push

git push는 현재 로컬 저장소의 파일을 온라인 저장소로 올리는 작업을 말한다.

git branch -M main

git push -u origin main

순서대로 입력하면 온라인 저장소와 동기화 된 것을 볼 수 있다

이 후 github에 들어가면 파일이 올라온 것을 확인할 수 있다.

]]> <![CDATA[🔎 Git & GitHub 기본개념 ]]> https://velog.io/@hyun_ha/Git-GitHub-%EA%B8%B0%EB%B3%B8%EA%B0%9C%EB%85%90 https://velog.io/@hyun_ha/Git-GitHub-%EA%B8%B0%EB%B3%B8%EA%B0%9C%EB%85%90 Thu, 21 Apr 2022 06:05:54 GMT

Git & GitHub 시작하기 전 알아두면 좋은 개념을 정리한 글이다.



📙 용어 정리

  • 커맨드 라인 ( Command Line )
    • 텍스트로 입력을 받아 명령을 수행하는 프로그램
    • 윈도우 - cmd, Mac - teminal 이라고 한다.

  • 레포지토리 ( Repository )

    • 저장소를 의미한다.

    • 원격 저장소(Remote Repository) : GitHub에서 만든 저장소 로컬 저장소(Local Repository) : 내 PC의 저장소

    • 커밋 ( Commit )

      • 프로젝트 디렉토리의 특정 모습을 하나의 버전으로 남기는 행위 & 결과물 ( ' 체크포인트 ' 라고 생각하면 된다.)

  • 브랜치 ( Branch )

    • ' 나뭇가지 '라는 뜻의 하나의 코드 관리 흐름이다.

    • 여러 개발자들이 동시에 다양한 작업을 할 수 있게 만든 기능이다. 각자 독립적인 작업 내용을 나중에 합쳐서 새로운 버전을 만들 수 있다.

      (ex. 하나의 프로그램을 유료ver, 무료ver 이렇게 나눠서 만든다고 생각하면 된다.)




📕 리눅스 주요 명령어


명령어 설명
pwd 현재 나의 디렉토리 경로
cd [이동경로] 이동경로로 이동

cd ../ : 상위 레포지토리 이동
ls 폴더 리스트 조회
ls -al 폴더 리스트 상세 조회
clear 화면 깨끗하게 보기
mkdir [폴더이름] 폴더 생성
rm -rf [폴더이름] 폴더 삭제
rm -r [파일이름] 파일 삭제
vim [파일이름] 해당 파일 편집,
해당 파일이 없을때는 새로 생성

i : 입력이 가능한 상태
esc : insert 상태를 빠져나온다.
:wq : 저장 후 종료
:q : 종료
:q! : 강제 종료
cat [파일이름] 파일내용을 확인 할 수 있다.
]]> <![CDATA[[JAVA] 디자인 패턴 - 싱글톤 (SingleTon)]]> https://velog.io/@hyun_ha/JAVA-%EB%94%94%EC%9E%90%EC%9D%B8-%ED%8C%A8%ED%84%B4-%EC%8B%B1%EA%B8%80%ED%86%A4-SingleTon https://velog.io/@hyun_ha/JAVA-%EB%94%94%EC%9E%90%EC%9D%B8-%ED%8C%A8%ED%84%B4-%EC%8B%B1%EA%B8%80%ED%86%A4-SingleTon Tue, 19 Apr 2022 14:01:01 GMT 디자인 패턴(Design Pattern)
  • 디자인 패턴이란 기존 환경 내에서 반복적으로 일어나는 문제들을 어떻게 풀어나갈 것인가에 대한 일종의 솔루션 같은 것이다.
  • 디자인 패턴은 설계자들이 "올바른" 설계를 "빨리" 만들 수 있도록 도와준다.

📝 싱글톤 (SingleTon)

  • JAVA에서 많이 사용되는 디자인 패턴
  • 어떤 클래스가 최초 한번만 메모리를 할당하고(Static) 그 메모리에 객체를 만들어 사용하는 디자인 패턴
  • 즉 생성자의 호출이 반복적으로 이뤄져도 실제로 생성되는 객체는 최초 생성된 객체를 반환 해주는 것이다.

SingleTon 객체의 이점

  • 메모리를 효율적으로 사용할 수 있다.

    • 프로그램의 전역에서 활용할 재료로 사용되는 공유 기능을 하나만 생성하여 여러 곳에서 재사용할 수 있다.

  • 다른 클래스 간에 데이터 공유가 쉽다

    • 싱글톤 객체가 전역으로 사용되는 객체이기 때문에 다른 클래스의 객체들이 접근하여 사용할 수 있다. ❗❗ 단, 여러 클래스의 객체에서 싱글톤 객체의 데이터에 동시에 접근하게 되면 동시성 문제가 발생할 수 있다.

SingleTon 생성

  • 1. 스스로의 객체를 static으로 선언

    • static이 적용된 자원은 메모리의 고정영역에 생성되기 때문에, 클래스 자체의 객체나, 그 안에 포함된 멤버변수, 메서드와는 메모리 상에서 구별된다고 볼 수 있다.
      // 싱글톤 예시

public class Calc{ static Calc current; }


- ### 2. 외부에서 이 객체에 직접적인 접근을 못하도록 은닉시킨다. 
```java
public class Calc{
    private static Calc current;
}

  • 3. 외부에서 객체 생성을 못하도록 객체 할당 금지하기

    • 기본 생성자를 private 형태로 정의하면 객체 생성자가 은닉 처리되어 외부에서 new 연산자를 사용한 객체 할당이 금지된다.
public class Calc{
    private static Calc current;

    // 생성자를 private
    private Calc() {}
}

  • 4. 은닉된 객체를 할당하거나 메모리에서 삭제하는 기능 추가

    • current객체를 private으로 지정하였기 때문에 객체를 메모리에서 간접적으로 할당하고 삭제하기 위한 메서드가 필요하다.
      • 객체를 메모리에서 제어하기 위해서는 null을 사용한다.
public class Calc{
    private static Calc current;

    private Calc() {}

    // 객체 할당 처리
    // 객체가 할당되지 않은 경우에만 할당하도록 하여 중복 할당을 방지한다.
    public static Calc getInstance() {
        if(current == null) {
            current = new Calc();
        }                        
        return current;
    }

    // 객체에 null을 대입하면 메모리에서 삭제된다.
    public static void freeInstance() {
        current = null;
    }
}


✍ 코드 예시

public class Calc {
    // ------------------------ 싱글톤 객체 생성을 위한 준비 시작 ----------------------
    private static Calc current;

    private Calc() {}

    public static Calc getInstance() {
        if(current == null) {
            current = new Calc();
        }

        return current;
    }

    public static void freeInstance() {
        current = null;
    }
    // ------------------------ 싱글톤 객체 생성을 위한 준비 끝 ----------------------

    // 이 클래스가 구현해야 하는 기능
    public void plus(int x, int y) {
        int z = x + y;
        System.out.println(x + " + " + y + " = " + z);
    }

    public void minus(int x, int y) {
        int z = x - y;
        System.out.println(x + " - " + y + " = " + z);
    }

}
public class Main {

    public static void main(String[] args) {
        // 별도의 객체에 참조시키는 경우
        Calc loader1 = Calc.getInstance();
        loader1.plus(10, 20);

        // 참조처리를 생략하고 직접 사용하는 경우
        Calc.getInstance().minus(100, 50);
        Calc.getInstance().plus(100, 50);
    }

}

👉 실행 결과

10 + 20 = 30
100 - 50 = 50
100 + 50 = 150


📙 정리

  • 싱글톤은 getInstance() 메서드를 사용하여 객체를 리턴 받는 형식으로 사용한다.

  • 여러개의 객체를 리턴 받더라도 모두 하나의 static 객체를 참조하게 되기 때문에 전역 객체 하나만이 메모리에 할당되게 된다.

]]> <![CDATA[[JAVA] static 키워드 & 컴퓨터의 메모리 구조]]> https://velog.io/@hyun_ha/JAVA-static-%ED%82%A4%EC%9B%8C%EB%93%9C-%EC%BB%B4%ED%93%A8%ED%84%B0%EC%9D%98-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B5%AC%EC%A1%B0 https://velog.io/@hyun_ha/JAVA-static-%ED%82%A4%EC%9B%8C%EB%93%9C-%EC%BB%B4%ED%93%A8%ED%84%B0%EC%9D%98-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B5%AC%EC%A1%B0 Mon, 18 Apr 2022 13:11:09 GMT

📝 static

  • static은 '고정된' 또는 '공통적인'의 의미를 가지고 있다. 즉 모든 객체가 공유하는 값이다.
  • static 값은 클래스 이름을 통해서 접근해야 하며, 객체를 생성하지 않고도 사용할 수 있다.

static 예시

하나의 게시물을 표현하기 위한 클래스가 있다.

public class Article{
    private int num;            // 글 번호
    private String title;        // 제목
    private String regDate;        // 날짜    
}

이 클래스에 게시물이 새로 등록될 때 마다, 전체 글 수를 의미하는 count, 카테고리 정보를 담을 변수를 추가 할려고 한다.

public class Article{
    int count;             // 전체 글 수        
    String category;    // 카테고리

    private int num;            // 글 번호
    private String title;        // 제목
    private String regDate;        // 날짜    
}

이렇게 전체 글 수, 카테고리정보를 선언한 후 여러 객체를 생성할 때 다음과 같은 문제가 발생한다.

public class Main {

    public static void main(String[] args) {
        Article a1 = new Article(1, "첫번째 글제목", "20XX-01-01");
        a1.category = "공지사항";
        a1.count++;

        Article a2 = new Article(2, "두번째 글제목", "20XX-01-02");
        a2.category = "공지사항";
        a1.count++;
        a2.count = a1.count;

        Article a3 = new Article(3, "세번째 글제목", "20XX-01-03");
        a3.category = "공지사항";
        a1.count++;
        a2.count++;
        a3.count = a2.count;

        System.out.println(a1.toString());
        System.out.println(a2.toString());
        System.out.println(a3.toString());
    }

}

👉 실행 결과

Article [count=3, category=공지사항, num=1, title=첫번째 글제목, regDate=20XX-01-01]
Article [count=3, category=공지사항, num=2, title=두번째 글제목, regDate=20XX-01-02]
Article [count=3, category=공지사항, num=3, title=세번째 글제목, regDate=20XX-01-03]

이 코드처럼 객체를 생성할 때마다 count, category 변수들을 바꿔줘야 하는 번거로움이 생긴다. 또한 반복적인 코드가 많아서 좋지 못한 코드라고 볼 수 있다.
멤버변수는 모든 객체가 독립적으로 갖는 고유 데이터이기 때문에 count 라는 공유 데이터를 모든 게시물이 갖게 된다. 즉, 각각의 객체가 중복된 데이터를 갖게 된다.

이러한 문제를 해결하려면 다음과 같다.

모든 객체에서 공통적으로 사용해야 하는 값에 'static'을 붙인다.

public class Article{
    static int count;                 // 전체 글 수        
    static String category;            // 카테고리

    private int num;                // 글 번호
    private String title;            // 제목
    private String regDate;            // 날짜    
}

static이 붙은 멤버변수는 객체의 개수에 상관 없이 단 하나만 생성되며, 이를 모든 객체가 공유하기 때문에 메모리를 효율적으로 사용할 수 있다.

<static이 붙은 멤버변수를 사용할 땐 대문자로 쓴 클래스 이름을 사용하면 된다.> 

public class Main {

    public static void main(String[] args) {
        Article.category = "공지사항";

        Article a1 = new Article(1, "첫번째 글제목", "20XX-01-01");
        Article.count++;

        Article a2 = new Article(2, "두번째 글제목", "20XX-01-02");
        Article.count++;

        Article a3 = new Article(3, "세번째 글제목", "20XX-01-03");
        Article.count++;

        System.out.println(a1.toString());
        System.out.println(a2.toString());
        System.out.println(a3.toString());
    }

}

많이 깔끔해졌지만 Article.count++; 매번 해줘야 하는 번거로움이 있다. -> 객체가 생성될 때마다 Article.count가 1씩 증가되기 때문에 아예 생성자에 이 줄을 넣으면 된다.
✍ 최종 코드

public class Article {
    static int count;             // 전체 글 수        
    static String category;        // 카테고리

    private int num;            // 글 번호
    private String title;        // 제목
    private String regDate;        // 날짜

    public Article(int num, String title, String regDate) {
        this.num = num;
        this.title = title;
        this.regDate = regDate;

        count++;
    }

    public String toString() {
        return "Article [count=" + count 
                + ", category=" + category 
                + ", num=" + num 
                + ", title=" + title 
                + ", regDate=" + regDate + "]";
    }
}    
public class Main {

    public static void main(String[] args) {
        Article.category = "공지사항";

        Article a1 = new Article(1, "첫번째 글제목", "20XX-01-01");
        Article a2 = new Article(2, "두번째 글제목", "20XX-01-02");
        Article a3 = new Article(3, "세번째 글제목", "20XX-01-03");

        System.out.println(a1.toString());
        System.out.println(a2.toString());
        System.out.println(a3.toString());
    }

}

👉 실행 결과

Article [count=3, category=공지사항, num=1, title=첫번째 글제목, regDate=20XX-01-01]
Article [count=3, category=공지사항, num=2, title=두번째 글제목, regDate=20XX-01-02]
Article [count=3, category=공지사항, num=3, title=세번째 글제목, regDate=20XX-01-03]



멤버변수와 static 멤버변수의 차이

  • 멤버변수는 객체가 생성될 때 마다 생성되므로 객체마다 각기 다른 값을 유지할 수 있다.

  • static 변수는 모든 객체가 하나의 저장공간을 공유하므로, 항상 공통된 값을 갖는다.

  • static 변수는 객체가 생성되지 않았더라도 이미 존재하고 있기 때문에 객체의 이름을 통해 접근하는 것이 아니라, 클래스의 이름을 통해서 접근해야 한다.

    • 단, static 변수가 선언된 클래스 안에서는 변수 이름으로 직접 접근이 허용된다.
// Article 클래스 및 다른 클래스에서 접근하는 경우
    Article.count = 9;
    Article.categoty = "공지사항";

// Article 클레스에서 접근하는 경우
    count = 15;
    categoty = "Q&A게시판";

📝 컴퓨터의 메모리 구조

  • 컴퓨터의 운영체제는 프로그램의 실행을 위해 다양한 메모리 공간을 제공하고 있다.
  • 메모리 공간은 다음과 같은 4가지 영역으로 나누어진다.


코드 영역 (고정영역)

  • 프로그램의 코드가 저장되는 영역
  • 이 영역에 저장된 명령어들을 CPU가 하나씩 가져가 실행한다.

데이터 영역 (고정영역)

  • 전역변수와 static으로 선언되는 변수가 할당된다.
  • 이 영역에 할당되는 변수들은 프로그램 시작과 동시에 메모리 공간이 할당되어 종료될 때 까지 남아있게 된다.

힙 영역 (동적영역)

  • 프로그래머가 원하는 시점에 변수를 할당하고 소멸시키는 영역
  • 메모리 동적 할당시 사용된다.
  • 객체가 생성되는 영역이다.

스택 영역 (동적영역)

  • 함수가 실행될 때 사용되는 파라미터와 지역변수에 대한 메모리 공간
  • 함수의 종료와 함께 소멸된다.



하나의 프로그램이 사용하는 메모리 영역

  • 고정영역

    • 프로그램이 실행되면 실행파일이 메모리에 로드되면서, 실행파일의 용량만큼 RAM을 사용한다.

    • 실행 파일의 크기는 변할 수 없으므로 이 영역의 크기는 고정 크기를 갖는다.

    • 이 영역의 자원들은 프로그램이 실행되는 동안 항상 존재한다.

  • 동적영역

    • 프로그래머가 new 키워드를 사용해서 객체나 배열을 생성하면 사용된다. (힙 영역)

    • 메서드가 호출되는 동안 사용될 파라미터와 지역변수가 생성된다. (스택영역)

    • 메서드가 종료되거나 객체가 더 이상 사용되지 않으면 생성된 변수나 객체는 메모리에서 사라지므로, 이 영역은 유동적인 크기를 갖게 된다.


프로그램이 메모리를 사용하는 순서

  • 최초 실행 시 고정 영역에 실행파일만큼의 메모리를 점유한다.
  • 프로그램이 각종 동작을 수행하는 동안 동적영역을 사용한다.

💥 static 메서드 & static 변수

  • 메모리 영역의 차이 때문에 static 메서드는 동적 메모리 영역의 멤버변수를 사용하거나, static이 아닌 일반 멤버변수를 호출할 수 없다.

  • 메서드의 정의 과정에서 static 키워드를 사용하면 static 자원에 접근하기 위한 메서드를 만들 수 있다.

  • 고정 영역

    • 동적 메모리 영역의 자원들은 항상 존재하는 것이 아니기 때문에 static 멤버함수는 동적 메모리 영역의 멤버변수를 사용하거나, static이 아닌 일반 멤버함수를 호출할 수 없다.

  • 동적 영역

    • static 자원은 항상 존재하는 것이므로 동적 영역에서는 static 변수를 활용하거나, static 멤버함수를 호출할 수 있다. 
public class Article{
        private static int count;

        public static void setCount(int count) {
            Article.count = count;
        }

        public static int getCount() {
            return Article.count;
        }

    }


📙 정리

대상 의미
멤버변수 - 모든 객체에 공통적으로 사용되는 클래스 변수가 된다.
- 클래스 변수는 인스턴스를 생성하지 않고도 사용 가능하다.
- 클래스가 메모리에 로드될 때 생성된다.
메서드 - 객체를 생성하지 않고도 호출이 가능한 static 메서드가 된다.
- static메서드 내에서는 인스턴스멤버들을 직접 사용할 수 없다.

static을 언제 붙여야 할까?

  • 멤버변수 중 모든 객체에 공통으로 사용하는 것에 static을 붙인다.
  • 메서드 내에서 인스턴스 변수나 인스턴스 메서드를 사용하지 않는 메서드에 staitc을 붙이는 것을 고려한다.
]]> <![CDATA[[JAVA] 인터페이스 (Interface)]]> https://velog.io/@hyun_ha/JAVA-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4-Interface https://velog.io/@hyun_ha/JAVA-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4-Interface Sat, 16 Apr 2022 07:51:58 GMT 추상 클래스의 한계
  • 자바 클래스간의 상속에서는 하나의 부모만 존재할 수 있기 때문에, 다중 상속의 구현은 불가능하다.
  • 하지만, 인터페이스는 다중 상속이 가능하다.

📝 인터페이스 (Interface)

  • 일종의 추상클래스이다.
  • 오직 추상메서드와 상수만을 구성 멤버로 가진다.
  • 다중 상속이 가능하기 때문에 용도별로 세분화 하여 필요한 요소만 상속할 수 있다.

인터페이스의 장점

  • 개발시간을 단축시킬 수 있다.
  • 표준화가 가능하다.
  • 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다.
  • 독립적인 프로그래밍이 가능하다.

인터페이스 정의

  • 클래스를 작성하는 것과 같다. ❗❗ 다만, class 키워드 대신 interface를 사용해야 한다.

  • 인터페이스 내의 모든 메서드는 추상 메서드이기 때문에 'abstract' 키워드를 명시할 필요가 없다.

public interface 인터페이스명 {

    public 리턴타입 메서드명(파라미터,...);

}

인터페이스 상속

  • 인터페이스의 상속은 implements 키워드를 사용한다.

  • 인터페이스도 추상화를 구현하고 있기 때문에, 인터페이스를 상속받는 클래스는 인터페이스내의 모든 메서드들을 반드시 재정의 해야 한다.

  • 인터페이스는 클래스와 달리 Object클래스와 같은 최상위 클래스가 없다.

  • 다중 상속이 가능하다.

    • 인터페이스는 콤마( , )로 연결하여 여러개를 동시에 상속받을 수 있다.
      • 필요한 경우 다른 클래스와 동시에 상속받을 수 있다.
        // 콤마(,)로 연결하여 동시에 상속한 경우
public class Monster implements Fight, Move {
...
}

    // 다른 클래스와 동시에 상속한 경우 public class Monster extends User implements Fight, Move{

    ...

    }

    </br>

인터페이스 예시


public abstract class Unit{
        public abstract void attack();        // 공격
        public abstract void shield();        // 방어
        public abstract void walk();        // 걷다
        public abstract void run();            // 뛰다    
        public abstract void jump();        // 점프
        public abstract void pickup();        // 아이템 줍기
    }

추상클래스인 Unit 클래스가 있다.

주인공과 몬스터 클래스가 Unit을 상속받을 경우

주인공 클래스는 Unit의 모든 기능을 사용하지만, 몬스터 클래스는 사용하지 않는 기능도 재정의해야하는 문제가 발생한다.


그래서 추상 클래스인 Unit의 기능을 용도별로 분할하여 나누어 놓고, 주인공과 몬스터가 각각의 기능 중에서 자신에게 필요한 것들만 상속받도록 해야한다.

클래스 다이어그램으로 표현하면 다음과 같다.


✍ 코드 예시

// Action 인터페이스
public interface Action {

    public void pickup();        // 줍다

}

// Fight 인터페이스
public interface Fight {

    public void attack();        // 공격
    public void shield();        // 방어

}

// Move 인터페이스
public interface Move {

    public void walk();        // 걷기
    public void run();        // 뛰기
    public void jump();        // 점프

}
// Monster 클래스 
public class Monster implements Fight, Move{
    private String name;                // 몬스터 이름

    public Monster(String name) {        // 생성자
        super();
        this.name = name;
    }

    // 다음과 같이 메서드 재정의가 이루어지면 필요한 기능을 구현한다.
    @Override
    public void walk() {
        System.out.println(this.name + " >> 걷다");
    }

    @Override
    public void run() {
        System.out.println(this.name + " >> 뛰다");
    }

    @Override
    public void jump() {
        System.out.println(this.name + " >> 점프");
    }

    @Override
    public void attack() {
        System.out.println(this.name + " >> 공격");
    }

    @Override
    public void shield() {
        System.out.println(this.name + " >> 방어");
    }

}
// Character 클래스
public class Character implements Action, Fight, Move{
    private String name;                // 캐릭터 이름

    public Character(String name) {        // 생성자
        super();
        this.name = name;
    }

    @Override
    public void attack() {
        System.out.println(this.name + " >> 공격");
    }

    @Override
    public void shield() {
        System.out.println(this.name + " >> 방어");
    }

    @Override
    public void pickup() {
        System.out.println(this.name + " >> 아이템을 줍다");
    }

    @Override
    public void walk() {
        System.out.println(this.name + " >> 걷다");
    }

    @Override
    public void run() {
        System.out.println(this.name + " >> 뛰다");
    }

    @Override
    public void jump() {
        System.out.println(this.name + " >> 점프");
    }

}

// Main 클래스
public class Main {

    public static void main(String[] args) {
        Character c = new Character("주인공");

        c.walk();
        c.run();
        c.attack();
        c.shield();
        c.pickup();
        c.jump();

        System.out.println("------------------------------------");

        Monster m = new Monster("몬스터");

        m.attack();
        m.shield();
        m.walk();
        m.run();
        m.jump();

    }

}

👉 실행 결과

주인공 >> 걷다
주인공 >> 뛰다
주인공 >> 공격
주인공 >> 방어
주인공 >> 아이템을 줍다
주인공 >> 점프
------------------------------------
몬스터 >> 공격
몬스터 >> 방어
몬스터 >> 걷다
몬스터 >> 뛰다
몬스터 >> 점프


📙 정리

일반 클래스 추상 클래스 인터페이스
생성자, 멤버변수 가능 가능 불가능
(상수만 가능)
일반 메서드 가능 가능 불가능
추상 메서드 불가능 가능 가능
]]> <![CDATA[[JAVA] 추상 클래스 및 메서드]]> https://velog.io/@hyun_ha/JAVA-%EC%B6%94%EC%83%81-%ED%81%B4%EB%9E%98%EC%8A%A4-%EB%B0%8F-%EB%A9%94%EC%84%9C%EB%93%9C https://velog.io/@hyun_ha/JAVA-%EC%B6%94%EC%83%81-%ED%81%B4%EB%9E%98%EC%8A%A4-%EB%B0%8F-%EB%A9%94%EC%84%9C%EB%93%9C Sat, 16 Apr 2022 02:24:58 GMT 추상화란?
  • 사전적 의미는 실체 간에 공통되는 특성을 추출한 것을 말한다.
  • JAVA에서의 추상화는 클래스들의 중요하고 공통된 성질들을 추출하여 부모 클래스를 선정하는 개념이다.

JAVA에서의 추상화 기법

  • 특정 클래스를 상속받은 경우, 부모의 특정 메서드들을 무조건 재정의하도록 강제하는 기법이다.
  • 특정 메서드를 재정의하도록 강제함으로써, 자식 클래스들을 작성하기 위한 가이드의 역할을 할 수 있다.
  • 즉, 추상화 기법은 java 클래스를 작성하기 위한 설계도를 소스코드 형태로 제시하는 역할을 한다.

추상화의 장점

  • 상속을 통해 간결한 코드
  • 생산성과 가독성 증가
  • 에러 감소
  • 유지 보수시 시간 단축
  • 코드의 재사용성 증가


📝 추상 클래스 (abstract class)

  • 클래스를 설계도에 비유한다면, 추상 클래스는 미완성 설계도에 비유할 수 있다.
  • 추상 클래스는 객체를 생성할 수 없고, 반드시 상속을 통해서만 사용될 수 있다.
  • 추상 메서드를 하나 이상 포함하고 있는 클래스는 반드시 '추상 클래스'로 정의되어야 한다.
  • 추상 클래스는 다른 자식 클래스를 위한 '가이드라인'의 역할을 한다.

추상 클래스 선언

  • 추상 클래스 'abstract'키워드를 사용하여 정의할 수 있다.
  • 추상 클래스는 생성자, 멤버변수, 일반 메서드등을 포함할 수 있다.
    • 즉 공통 기능과 가이드라인을 모두 정의하여 다른 클래스에게 상속된다.
      public abstract class Hello{
// 멤버변수
// 생성자
// 일반 메서드
// 추상 메서드
...
}

추상 클래스의 상속

  • 일반 클래스의 상속과 동일하게 'extends' 키워드를 사용한다.


📝 추상 메서드 (abstract method)

  • 추상 클래스에서만 선언할 수 있다.
  • 메서드의 선언부만 있고 구현부가 없는 '미완성 메서드'이다.
  • 추상 메서드는 자식 클래스가 구현해야 하는 메서드의 가이드라인만 제시하기 위한 목적으로 사용된다.

추상 메서드 선언

  • 'abstract' 키워드를 사용하여 메서드를 정의한다.
  • 선언만 가능하고, 구현부를 위한 블록이 존재하지 않는다.
    • 중괄호{} 대신 문장의 끝을 알리는 세미콜론 ( ; ) 을 적어준다.
  • 추상 클래스를 상속받으면 자식은 부모의 모든 추상 메서드를 재정의 해야한다. 
    public abstract void sayHello();


✍ 코드 예시

// 육군 / 해군 / 공군 의 공통 기능을 명시하기 위한 부모 클래스

public abstract class Unit {
    private String name;

    public Unit(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 자식들이 재정의할 메서드를 추상으로 명시
    public abstract void attack();

    public abstract void move();

}
// 자식 클래스 

// 육군
public class Army extends Unit {

    public Army(String name) {
        super(name);
    }

    // 추상 메서드의 재정의를 요구한다.
    @Override
    public void attack() {
        System.out.println(this.getName() + ">> 육상공격");
    }

    @Override
    public void move() {
        System.out.println(this.getName() + ">> 육상이동");
    }

}

// 해군
public class Navy extends Unit {

    public Navy(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println(this.getName() + ">> 해안공격");
    }

    @Override
    public void move() {
        System.out.println(this.getName() + ">> 해안이동");
    }

}

// 공군
public class AirForce extends Unit {

    public AirForce(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println(this.getName() + ">> 공중공격");
    }

    @Override
    public void move() {
        System.out.println(this.getName() + ">> 공중이동");
    }

}
// Main 클래스

public class Main {

    public static void main(String[] args) {
        Unit[] u = new Unit[3];

        u[0] = new Army("육군");
        u[1] = new Navy("해군");
        u[2] = new AirForce("공군");

        for (int i = 0; i < u.length; i++) {
            u[i].attack();
            u[i].move();
            System.out.println("------------------------------------------");
        }

    }

}

👉 실행 결과

육군>> 육상공격
육군>> 육상이동
------------------------------------------
해군>> 해안공격
해군>> 해안이동
------------------------------------------
공군>> 공중공격
공군>> 공중이동
------------------------------------------
]]> <![CDATA[[JAVA] 객체 배열 & instanceof]]> https://velog.io/@hyun_ha/JAVA-%EA%B0%9D%EC%B2%B4-%EB%B0%B0%EC%97%B4-instanceof https://velog.io/@hyun_ha/JAVA-%EA%B0%9D%EC%B2%B4-%EB%B0%B0%EC%97%B4-instanceof Thu, 14 Apr 2022 15:15:51 GMT

📝 객체 배열

  • 일반 데이터 타입의 배열과 동일한 개념으로, 같은 클래스의 객체 여러 개를 그룹화 할 수 있다.
  • 동일한 클래스의 객체는 배열로 묶어서 여러 개를 한꺼번에 제어할 수 있다.


일반 데이터 형의 배열과 객체 배열 비교

  1. 생성
   - 일반 데이터형의 배열
    int[] data = new int[3];

    - 객체 배열의 경우
    Army[] data = new army[3];

  1. 배열의 요소 할당처리

    - 일반 데이터 형 배열의 경우
   data[0] = 10;
   data[1] = 20;
   data[2] = 35;

- 객체 배열의 경우
   Army a1 = new Army();
   data[0] = new Army();
   data[1] = new Army();
   data[2] = new Army();
  • 일반 데이터 형은 단순히 값을 대입하지만, 객체 배열은 'new'를 사용하여 객체를 할당해야 한다.

객체 배열의 활용

  • 부모 클래스의 배열에 자식 클래스의 객체 넣기
    • 배열의 생성이 부모 클래스로 지정되었을 경우, 모든 자식 클래스의 객체들은 그 배열에 포함 될 수 있다.
       Unit[] unit = new Unit[3];
// 배열의 요소 할당과정에서 암묵적 형변환이 이루어진다.
unit[0] = new Army();
unit[1] = new Navy();
unit[2] = new AirForce();

instanceof 연산자

  • 객체 타입 확인하는 연산자
  • 배열의 각 요소가 확장한 기능을 사용하기 위해서는 원래의 클래스 형태로 명시적 형변환이 이루어 져야 한다. 하지만 몇번째 요소가 어떤 클래스에서 최초로 생성되었는지 판단하기 어렵다.
  • 이 경우 instanceof 연산자를 사용하면 어떤 객체에 대한 출처를 판단하여 boolean형으로 결과를 반환할 수 있다.
class Parent{}
class Child extends Parent{}

public class Main {

    public static void main(String[] args) {
        Parent p = new Parent();
        Child c = new Child();

        System.out.println(p instanceof Parent);        
        System.out.println(p instanceof Child);                
        System.out.println(c instanceof Parent);            
        System.out.println(c instanceof Child);            

    }

}

👉 실행 결과

true
false
true
true


✍ 객체 배열 & instanceof 코드 예시) - <객체 형변환 글에 있는 코드 참고>

public class Main {

    public static void main(String[] args) {
        // 부대지정
        Unit[] units = new Unit[5];

        units[0] = new AirForce("공군1호");
        units[1] = new AirForce("공군2호");
        units[2] = new Navy("해군1호");
        units[3] = new Army("육군1호");
        units[4] = new Army("육군2호");

        // 부대 일괄 공격 attak();
        for (int i = 0; i < units.length; i++) {
            units[i].attack();

            // 각 기능의 고유한 기능 호출
            if (units[i] instanceof Army) {
                Army temp1 = (Army)units[i];
                temp1.tank();
            } 

            if (units[i] instanceof Navy) {
                Navy temp2 = (Navy)units[i];
                temp2.nucleus();
            } 

            if (units[i] instanceof AirForce) {
                AirForce temp3 = (AirForce)units[i];
                temp3.bombing();
            }

            System.out.println("-----------------------------");
        }

    }

}

👉 실행 결과

공군1호 >>> 공격준비 
공군1호 >> 이륙
공군1호 >> 공중공격 실행
공군1호 >> 폭격
-----------------------------
공군2호 >>> 공격준비 
공군2호 >> 이륙
공군2호 >> 공중공격 실행
공군2호 >> 폭격
-----------------------------
해군1호 >>> 공격준비 
해군1호 >> 어뢰발사
해군1호 >> 지상 상륙
해군1호 >> 핵미사일
-----------------------------
육군1호 >>> 공격준비 
육군1호 >> 지상공격 실행
육군1호 >> 탱크공격
-----------------------------
육군2호 >>> 공격준비 
육군2호 >> 지상공격 실행
육군2호 >> 탱크공격
-----------------------------
]]> <![CDATA[[JAVA] 객체 형변환]]> https://velog.io/@hyun_ha/JAVA-%EA%B0%9D%EC%B2%B4-%ED%98%95%EB%B3%80%ED%99%98 https://velog.io/@hyun_ha/JAVA-%EA%B0%9D%EC%B2%B4-%ED%98%95%EB%B3%80%ED%99%98 Thu, 14 Apr 2022 13:07:51 GMT

📝 객체 형변환

  • 기본형 변수처럼 참조변수도 형변환(Casting)이 가능하다.
  • 단, 서로 상속 관계에 있는 클래스 사이에서만 가능하다. 

Parent parent = new Child();
  • 위의 대입연산에서 왼쪽 항(부모, Parent)과 오른쪽 항(자식, child)의 객체 유형이 서로 다른 경우, 두 유형이 서로 상속관계에 있고 왼쪽 객체가 오른쪽 객체의 상위 클래스인 경우에만 암묵적 형변환이 일어난다.
  • 하위 클래스에서 상위클래스 유형으로 할당하는 것은 가능하나 그 반대의 경우에는
  • 명시적 형변환*을 해야 한다.

📃 암묵적 형변환

  • 자식클래스가 부모클래스에게 상속받은 기능만 사용하도록 제한
  • 주의할 점은 기능의 제한이지 기능의 변경은 아니라는 것이다.
  • 모든 객체는 자신의 상위 형태로 암묵적 형변환이 가능하다.

즉 오버라이드된 기능만 사용가능하고, 추가적으로 구현한 기능은 사용할 수 없다.


암묵적 형변환 가능한 경우

    // 👉 가능하다.
    A a1 = new B();
    A a2 = new X();
    -------------------
    A a3 = new C();
    A a4 = new Y();
    -------------------                
    B b1 = new C();
    X x1 = new Y();
    -------------------
    C c = new C();
    B b2 = c;
    -------------------
    Y y = new Y();
    X x2 = y;

    // ❗❗ 불가능하다.
    C c1 = new B();
    C c2 = new X();

✍ 암묵적 형변환 코드 예시 )

// 부모 클래스
public class Unit {
    private String name;

    // 생성자 정의
    public Unit(String name) {
        super(); 
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 재정의 대상
    public void attack() {
        System.out.println(this.name + " >>> 공격준비 ");
    }
}
// 자식 클래스

// 육군
public class Army extends Unit {

    // 부모 클래스의 생성자를 강제 호출하기 위한 생성자
    public Army(String name) {
        super(name);
    }

    // 공격의 형태를 육군에 맞게 변경하지만,
    // 부모 클래스가 가지고 있는 공격 준비 기능을
    // super 키워드를 통해 보전
    @Override
    public void attack() {
        super.attack();
        System.out.println(super.getName() + " >> 지상공격 실행");
    }

    public void tank() {
        System.out.println(super.getName() + " >> 탱크공격");
    }

}

// 해군
public class Navy extends Unit{

    public Navy(String name) {
        super(name);
    }

    @Override
    public void attack() {
        super.attack();
        System.out.println(this.getName() + " >> 어뢰발사");
        System.out.println(this.getName() + " >> 지상 상륙");
    }

    public void nucleus() {
        System.out.println(this.getName() + " >> 핵미사일");
    }
}

// 공군
public class AirForce extends Unit {

    public AirForce(String name) {
        super(name);
    }

    @Override
    public void attack() {
        super.attack();
        System.out.println(super.getName() + " >> 이륙");
        System.out.println(super.getName() + " >> 공중공격 실행");
    }

    public void bombing() {
        System.out.println(this.getName() + " >> 폭격");
    }
}
// Main 클래스
public class Main01 {

    public static void main(String[] args) {
        // army, navy, airforce로 각각의 객체생성
        Army army = new Army("육군");
        Navy navy = new Navy("해군");
        AirForce air = new AirForce("공군");

        // 그 각각의 객체의 고유 기능을 사용
        army.tank();
        navy.nucleus();
        air.bombing();

        System.out.println("----------------------------------");

        // 상위 객체 형태로 암묵적 형변환
        Unit temp1 = army;
        Unit temp2 = navy;
        Unit temp3 = air;

        // 형변환이 되더라도 상속받거나 재정의한(Override)
        // 자신들의 기본 특성들은 그대로 유지
        temp1.attack();
        System.out.println();
        temp2.attack();
        System.out.println();
        temp3.attack();

        // 상위 클래스 형태로 형변환이 되면, 자신들의 독립 기능은
        // 사용하지 못한다.
//        temp1.tank();
//        temp2.nucleus();
//        temp3.bombing();

    }

}

👉 실행 결과

육군 >> 탱크공격
해군 >> 핵미사일
공군 >> 폭격
----------------------------------
육군 >>> 공격준비 
육군 >> 지상공격 실행

해군 >>> 공격준비 
해군 >> 어뢰발사
해군 >> 지상 상륙

공군 >>> 공격준비 
공군 >> 이륙
공군 >> 공중공격 실행

📙 암묵적 형변환 정리

객체가 상위클래스의 형태로 형변환 되더라도 Override된 자신의 기능은 잃지 않는다. 하지만, 추가적으로 구현한 기능은 사용할 수 없다.


📃 명시적 형변환

  • 부모 클래스의 객체를 자식 클래스 형태로 변환하는 것
  • 형변환을 위해서는 다음과 같이 변환할 클래스 이름을 명시적으로 지정해 주어야 한다.
ChildClass child = (ChildClass)parent;

❗❗ 객체가 최초로 생성될 때 자식 클래스 형태로 생성되고, 부모 형태로 암묵적 형변환이 된 상태를 다시 원래의 자식 클래스 형태로 되돌릴 경우에만 가능해진다.

   ChildClass child1 = new ChildClass();
ParentClass parent = child1;        // 암묵적 형변환
ChildClass child2 = (ChildClass)parent;    // 명시적 형변환

명시적 형변환 가능한 경우


✍ 명시적 형변환 코드 예시 ) 

public class Main01 {

    public static void main(String[] args) {
        // army, navy, airforce로 각각의 객체생성
        Army army = new Army("육군");
        Navy navy = new Navy("해군");
        AirForce air = new AirForce("공군");

        System.out.println("----------------------------------");

        // 상위 객체 형태로 암묵적 형변환
        Unit temp1 = army;
        Unit temp2 = navy;
        Unit temp3 = air;

        temp1.attack();
        System.out.println();
        temp2.attack();
        System.out.println();
        temp3.attack();

        System.out.println("----------------------------------");

        // 하위 클래스 형태로 명시적 형변환
        Army re1 = (Army)temp1;
        Navy re2 = (Navy)temp2;
        AirForce re3 = (AirForce)temp3;

        re1.tank();
        re2.nucleus();
        re3.bombing();

    }

}

👉 실행 결과

육군 >>> 공격준비 
육군 >> 지상공격 실행

해군 >>> 공격준비 
해군 >> 어뢰발사
해군 >> 지상 상륙

공군 >>> 공격준비 
공군 >> 이륙
공군 >> 공중공격 실행
----------------------------------
육군 >> 탱크공격
해군 >> 핵미사일
공군 >> 폭격

✍ 명시적 형변환이 불가능한 경우 

Unit u = new Unit();
Army army = (Army)u;        // 최초 객체 생성이 부모 형태로 만들어진 경우 불가능하다.
Army army = new Army();
Unit u = army;
Navy navy = (Navy)u;        // 다른클래스로 만들어진 객체에 명시적 형변환은 불가능하다.

📙 암묵적 형변환 정리

하위 클래스 형태로 명시적 형변환을 함으로써, 자신들의 독립 기능(메서드)들을 사용할 수 있다.

]]> <![CDATA[[JAVA] 다형성 - 오버라이드, 오버로드]]> https://velog.io/@hyun_ha/JAVA-%EB%8B%A4%ED%98%95%EC%84%B1-%EC%98%A4%EB%B2%84%EB%9D%BC%EC%9D%B4%EB%93%9C-%EC%98%A4%EB%B2%84%EB%A1%9C%EB%94%A9 https://velog.io/@hyun_ha/JAVA-%EB%8B%A4%ED%98%95%EC%84%B1-%EC%98%A4%EB%B2%84%EB%9D%BC%EC%9D%B4%EB%93%9C-%EC%98%A4%EB%B2%84%EB%A1%9C%EB%94%A9 Wed, 13 Apr 2022 07:42:27 GMT 다형성이란?
  1. 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미한다.
  2. 부모 클래스 타입으로 자식 클래스 객체를 참조 할 수 있다. 반대로 자식 클래스의 타입으로 부모 클래스 객체를 참조할 수는 없다.
  3. 객체지향 프로그래밍의 유연성, 재활용성, 유지보수성에 기본이 되는 특징이다.
  4. 대표적으로 오버라이드, 오버로딩이 있다.



📝 오버라이드 ( Override )

  • 부모 클래스로부터 상속받은 메서드의 기능을 재정의 하는 것을 말한다.

✍ 코드 예시 1)

// 부모 클래스
class Hello {

    public void say() {
        System.out.println("Hello!!!!!");
    }

}

// 자식 클래스 
class Korean extends Hello {

    public void say() {        // 부모 클래스의 say() 메서드를 재정의(오버라이드) 
        System.out.println("안녕하세요.");
    }

}
// Main 클래스
public class Main {

    public static void main(String[] args) {
        Korean k = new Korean();
        k.say();    
    }

}

👉 실행 결과

안녕하세요.

❗ 자식 클래스인 Korean에서 부모 클래스의 메서드인 say()를 재정의 하였기 때문에, Korean 클래스의 객체는 부모 클래스의 메서드 기능에 접근하지 못한다.


✍ 코드 예시 2)

// 부모 클래스
class Hello {

    public void say() {
        System.out.println("Hello!!!!!");
    }

}

// 자식 클래스 
class Korean extends Hello {

    public void say() {        // 부모 클래스의 say() 메서드를 재정의(오버라이드) 
        super.say();        // super 키워드 사용
        System.out.println("안녕하세요.");
    }

}
// Main 클래스
public class Main {

    public static void main(String[] args) {
        Korean k = new Korean();
        k.say();    
    }

}

👉 실행 결과

Hello!!!!!
안녕하세요.

❗ super 키워드는 부모 클래스의 메서드를 호출하는 기능을 가지고 있기 때문에 Override 된 자식 클래스의 메서드에서 super 키워드를 사용하면, 재정의 되기 이전의 부모 클래스에 대한 메서드를 호출할 수 있다.

❗ 즉 부모의 메서드를 호출한 뒤에 추가적인 기능을 정의하고 있으므로, 부모의 원본 메서드에 대한 기능 확장 효과가 있다.


@Override 옵션

  • 부모 클래스의 say() 메서드를 재정의 하는 과정에서 개발자의 실수로 인해 "sai()"라고 메서드가 추가되었다면, Java는 새로운 메서드를 추가한 것으로 인식하고, 특별한 에러를 표시하지 않는다.

    • 이 때 부모의 메서드를 오버라이드하는 것이라는 걸 컴파일러에게 알려주는 역할을 하는 것이 @Override 이다.
    • "@Override"은 이 키워드가 명시된 위치 아래에 정의되는 메서드가 부모 클래스에 존재하지 않을 경우 구문 에러로 처리한다.
    • 즉 부모 클래스의 메서드를 재정의 하고자 할 경우 의도치 않은 실수를 예방하기 위한 '오타 방지 옵션'이다.
    • 여러 개의 메서드를 재정의 한다면 재정의 되는 모든 메서드를 위에 각기 명시해야 한다.

✍ 코드 예시

// 부모 클래스
class Hello {

    public void say() {
        System.out.println("Hello!!!!!");
    }

}

// 자식 클래스 
class Korean extends Hello {

    @Override
    public void sai() {        // 🔥 ERROR - say()메서드 이름이 틀렸기 때문에 구문 에러가 난다.
        System.out.println("안녕하세요.");
    }

}


📝 오버로드 ( Overload )

  • 한 클래스 내에 같은 이름의 메서드를 여러 개 정의하는 것을 말한다.

오버로드가 성립하는 조건

  1. 메서드 이름이 같아야 한다.
  2. 파라미터의 개수 또는 타입이 달라야 한다.
  3. return 타입은 관계 없다.

✍ 코드 예시 )

public class Calc {

    int add (int a, int b) {
        return a + b;
    }

    int add (int a, int b, int c) {        // 파라미터 개수가 다른 경우
        return a + b + c;
    }

    double add (double a, double b) {    // 파라미터 타입이 다른 경우
        return a + b;
    }

}
public class Main {

    public static void main(String[] args) {
        Calc c = new Calc();

        System.out.println(c.add(2, 4));

        System.out.println(c.add(2, 4, 6));

        System.out.println(c.add(1.2, 1.3));

    }

}

👉 실행 결과

6
12
2.5

생성자의 Overload

  • 생성자를 Overload할 경우, 해당 클래스에 대해 '객체를 생성하는 방법'을 다양하게 준비할 수 있게 된다.
  • this 키워드를 사용한 생성자 Overload
    • 메서드처럼 사용할 경우, 현재 클래스의 다른 생성자를 의미한다.
    • 파라미터가 서로 다른 생성자들이 하나의 완전한 생성자를 호출하도록 하여, 데이터의 초기화를 한 곳에서 일괄적으로 처리하도록 구현할 수 있다.

✍ 코드 예시 )

public class Article {
    private int seq;        // 글 번호
    private String subject;    // 글 제목
    private String writer;    // 글 작성자

    //파라미터가 있는 생성자
    public Article(int seq, String subject, String writer) {
        this.seq = seq;
        this.subject = subject;
        this.writer = writer;
    }

    public Article(int seq, String writer) {        // this 키워드를 사용한 생성자 Overload
        this(seq, "제목없음", writer);
    }

    public Article(int seq) {                        // this 키워드를 사용한 생성자 Overload
        this(seq, "제목없음", "익명");
    }

    // toString()
    public String toString() {
        return "Article [seq = " + seq + ", subject = " + subject + ", writer = " + writer + "]";
    }

}
public class Main {

    public static void main(String[] args) {
        Article a1 = new Article(1, "첫 번째 게시물", "자바학생");
        System.out.println(a1.toString());

        Article a2 = new Article(2, "자바학생2");
        System.out.println(a2);        // 이렇게 객체만 출력해도 toString을 우선적으로 찾아서 실행시켜준다.
                                    // 단, toString이 정의되지 않으면 주소값이 나온다.

        Article a3 = new Article(3);
        System.out.println(a3);
    }

}

👉 실행 결과

Article [seq = 1, subject = 첫 번째 게시물, writer = 자바학생]
Article [seq = 2, subject = 제목없음, writer = 자바학생2]
Article [seq = 3, subject = 제목없음, writer = 익명]


📙 오버라이드(Override) vs 오버로드(Overload)


오버라이드(Override) 오버로드(Overload)
정의 상속받은 메서드의 내용을 변경하는 것 기존에 없는 새로운 메서드를 정의하는 것
조건 메서드 이름, 파라미터 개수와 타입, 리턴타입이 모두 동일해야 한다. 메서드 이름은 동일하지만 파라미터 개수와 타입이 달라야 한다.
관계 상속 관계 동일한 클래스 내 or 상속 관계
]]>