• http://www.cgv.co.kr 의 무비차트 링크를 가져와 상세페이지 정보를 가져온다
  • https ssl 인증 무효화
  • requests와 BeautifulSoup를 사용하여 구현
  • pandas를 통해 CSV 파일로 출력

페이지에서 상세페이지 url을 가져와 url 안의 정보를 가져오는 방식으로 구현했다.

import requests
import pandas as pd
from bs4 import BeautifulSoup

 

 

# 요청 헤더 user agent 설정
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}

# URL에 대한 GET 요청을 보내서 웹 페이지의 HTML 콘텐츠를 가져옵니다.
resp = requests.get('http://www.cgv.co.kr/movies/?lt=1&ft=0', headers=headers, verify=False)

# 응답 객체의 인코딩을 'utf-8'로 설정합니다.
resp.encoding = 'utf-8'

# 'lxml' 파서를 사용하여 HTML을 구문 분석한다.
soup = BeautifulSoup(resp.text, 'lxml')

 

 

# 1. <ol> 요소를 찾습니다.
ol = soup.find('ol')

# 2. <a> 태그에서 데이터 추출
data_rows = []
links = []
for li in ol.find_all('li'):
    a_tag = li.find('a')
    if a_tag:
        href = a_tag.get('href', '')  # <a> 태그의 href 속성 값
        data_rows.append([href])
        links.append(href)
        print(links)  # 링크 URL을 리스트에 추가

 

출력 결과

['/movies/detail-view/?midx=88499']
['/movies/detail-view/?midx=88499', '/movies/detail-view/?midx=88170']
['/movies/detail-view/?midx=88499', '/movies/detail-view/?midx=88170', '/movies/detail-view/?midx=88454']

 

 

 # 3. 각 링크에 대해 추가 데이터 요청
additional_data = []
for link in links:
        print("url:" , 'http://www.cgv.co.kr' + link )
        response = requests.get('http://www.cgv.co.kr' + link, headers=headers, verify=False)

        response.raise_for_status()  # HTTP 요청 오류 발생 시 예외를 발생시킴.

        page_soup = BeautifulSoup(response.text, 'html.parser')

        # <div class='title'>에서 <strong> 태그의 텍스트 추출
        title_div = page_soup.find('div', class_='title')
        strong_tag = title_div.find('strong')
        additional_info = strong_tag.text.strip()

        # 추가 정보 리스트에 추가
        additional_data.append(additional_info)

# 결과 출력
for data in additional_data:
    print(data)

 

출력 결과

url: http://www.cgv.co.kr/movies/detail-view/?midx=88499
url: http://www.cgv.co.kr/movies/detail-view/?midx=88170
url: http://www.cgv.co.kr/movies/detail-view/?midx=88454
임영웅ㅣ아임 히어로 더 스타디움
에이리언- 로물루스
행복의 나라

 

# 4. 데이터프레임 생성
df = pd.DataFrame(data_rows, columns = ['영화 url'])
df['제목'] = additional_data

# 5. 생성된 DataFrame 출력
print(df)

 

출력 결과

# 4. 데이터프레임 생성
df = pd.DataFrame(data_rows, columns = ['영화 url'])
df['제목'] = additional_data

# 5. 생성된 DataFrame 출력
print(df)# 4. 데이터프레임 생성
df = pd.DataFrame(data_rows, columns = ['영화 url'])
df['제목'] = additional_data

# 5. 생성된 DataFrame 출력
print(df)

 

 

# CSV 파일로 저장
df.to_csv('movies.csv', index=False, encoding='utf-8')

 

DB에 CSV 데이터 넣기

https://velog.io/@seinthemag/CSV%EB%A5%BC-%ED%99%9C%EC%9A%A9%ED%95%9C-DB-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%97%85%EB%A1%9C%EB%93%9C

'CS > ETC' 카테고리의 다른 글

HTML의 종류  (0) 2024.08.12
우분투 서버 연습...  (0) 2024.08.12
인텔리제이로 깃허브 연동을 해보자!  (0) 2024.07.18
컴파일러와 인터프리터의 차이  (0) 2024.03.19
실무 코딩팁  (0) 2024.01.11

JSP는 HTML 내에 자바 코드를 삽입하여 동적인 웹 콘텐츠를 생성한다.

JSP 파일은 일반적으로 .jsp 확장자를 가지며, 웹 서버에서 실행될 때 서블릿으로 변환된다.

이 변환 과정에서 HTML과 자바 코드가 결합되어 최종적으로 클라이언트에게 전달되는 HTML 페이지를 생성한다.

지시어(Directives)

지시어는 JSP 파일의 상단에 위치하며, JSP 페이지의 전반적인 설정을 정의한다.

페이지의 내용 타입, 캐릭터 인코딩 등을 설정한다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

 

스크립틀릿(Scriptlets)

스크립틀릿은 JSP 페이지 내에서 자바 코드를 직접 작성할 수 있는 부분이다.

스크립틀릿은 <% %> 태그로 감싸며, 일반적으로 동적인 데이터 처리나 계산을 수행한다.

<%
    String message = "Hello, World!";
    out.println(message);
%>

 

표현식(Expressions)

표현식은 자바 코드를 실행하고 그 결과를 HTML 콘텐츠로 삽입한다.

표현식은 <%= %> 태그로 감싸며, 주로 페이지의 동적 데이터를 출력하는 데 사용다.

<p>Current time: <%= new java.util.Date() %></p>

선언(Declarations)

선언은 JSP 페이지 내에서 변수나 메서드를 정의한다.

선언은 <%! %> 태그로 감싸며, 페이지의 여러 부분에서 사용할 수 있는 클래스를 정의한다.

<%! 
    private int add(int a, int b) {
        return a + b;
    }
%>

태그 라이브러리(Tag Libraries)

JSP에서 반복적이고 복잡한 작업을 간단하게 처리하기 위해 JSTL(JavaServer Pages Standard Tag Library)와 같은 태그 라이브러리를 사용할 수 있다. JSTL은 조건문, 반복문, 데이터 포맷팅 등 여러 유용한 태그를 제공한다.

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:if test="${user != null}">
    <p>Welcome, ${user.name}!</p>
</c:if>

 


JSP는 서블릿 기술의 확장으로 볼 수 있다. 서블릿은 자바로 작성된 서버측 애플리케이션 컴포넌트로, 클라이언트의 요청을 처리하고 응답을 생성한다. JSP는 HTML과 자바 코드를 혼합할 수 있는 방법을 제공하며, JSP 파일은 실행 시 서블릿으로 변환되어 서블릿과 동일한 방식으로 동작한다.

 

JSTL(JavaServer Pages Standard Tag Library)

JavaServer Pages (JSP)에서 웹 애플리케이션의 동적인 콘텐츠를 보다 쉽게 작성할 수 있도록 도와주는 표준 태그 라이브러리이다. JSTL은 JSP 페이지에서 자주 필요한 작업을 더 간단하게 수행할 수 있는 태그를 제공하며, 자바 코드의 직접 사용을 줄여서 JSP 페이지의 가독성과 유지보수성을 높인다.

 

JSTL은 EL(Expression Language)를 사용하여 표현한다.

Core Library (코어 라이브러리)

기본적인 조건문, 반복문, 변수 설정 등을 제공한다.

접두어: c

 

<c:out>: 데이터를 화면에 출력다. 기본적으로 XSS 공격을 방지하기 위해 HTML 이스케이프 처리가 된다.

<c:out value="${data}" />
<c:out value="${data}" default="값 없음" />

 

<c:set>: 변수를 설정한다. 변수의 범위(scope)는 page, request, session, application 중 하나로 설정할 수 있다.

<c:set scope="request" var="data" value="my_testValue" />

 

<c:forEach>: 컬렉션을 반복하여 처리한. 반복 인덱스나 상태 정보를 제공한다.

<c:forEach var="item" items="${itemList}" varStatus="status">
    <c:out value="${item}" />
</c:forEach>

 

<c:if>: 조건문을 처리한다.

<c:if test="${empty data}">
    data 값이 비어있으면 실행
</c:if>

 

<c:choose>, <c:when>, <c:otherwise>: if문 안의 복잡한 조건을 처리할 때 사용한다.

<c:choose>
    <c:when test="${data == 'A'}">data 값이 A이면 실행</c:when>
    <c:when test="${data == 'B'}">data 값이 B이면 실행</c:when>
    <c:otherwise>data 값이 A, B가 아닐 경우 실행</c:otherwise>
</c:choose>

 

<c:import>: 다른 JSP 페이지의 내용을 현재 페이지에 삽입한다.

<c:import url="header.jsp" />

 

<c:redirect>: 클라이언트를 다른 URL로 리다이렉트한다.

<c:redirect url="http://example.com" />

 

Formatting Library (포맷팅 라이브러리)

날짜, 시간, 숫자를 포맷팅하고 국제화 및 다국어 지원 기능을 제공한다.

접두어: fmt

 

<fmt:formatDate>: 날짜를 형식화한다.

<fmt:formatDate value="${currentDate}" pattern="yyyy-MM-dd" />

 

<fmt:formatNumber>: 숫자를 형식화한다.

<fmt:formatNumber value="${price}" type="currency" />

Functions Library (함수 라이브러리)

문자열 처리와 관련된 함수를 제공한다.

접두어: fn

 

fn:contains: 문자열이 다른 문자열을 포함하는지 확인한다.

 

 

fn:substring: 문자열의 부분 문자열을 추출한다.

 

SQL Library (SQL 라이브러리)

데이터베이스와의 기본적인 CRUD 작업을 지원한다.

기능은 제공하지만 보안 및 성능 문제로 인해 데이터베이스 작업은 서블릿이나 DAO를 통해 처리하는 것이 좋다.

접두어: sql

 

<sql:query>: SQL 쿼리를 실행하고 결과를 반환한다.

<sql:query var="result" dataSource="${dataSource}">
    SELECT * FROM users
</sql:query>

 

<sql:update>: 데이터베이스의 데이터를 업데이트한다.

<sql:update dataSource="${dataSource}">
    UPDATE users SET name='John Doe' WHERE id=1
</sql:update>

XML Library (XML 처리 라이브러리)

XML 문서를 처리하고 쿼리한다.

접두어: x

 

<x:parse>: XML 문서를 파싱하여 DOM 객체를 생성한다.

<x:parse xml="${xmlData}" var="parsedXml" />

 

<x:out>: XML 데이터를 출력한다.

<x:out select="/root/node" />

 

연산자

연산자는 조건문에서 사용하는 비교 및 논리 연산자를 제공한다.

 

== (eq): 두 값이 같은지 비교

${1 == 1}  <!-- true -->
${1 eq 1}  <!-- true -->

 

!= (ne): 두 값이 다른지 비교

${1 != 1}  <!-- false -->
${1 ne 1}  <!-- false -->

 

< (lt), > (gt), <= (le), >= (ge): 값의 비교

${1 < 10}  <!-- true -->
${1 gt 10} <!-- false -->

 

&& (and), || (or), ! (not): 논리 연산

${true && false} <!-- false -->
${true or false} <!-- true -->

 

empty 및 not empty: 변수의 유효성 검사

${empty name}  <!-- name이 null이거나 빈 문자열이면 true -->
${not empty name} <!-- name이 null도 아니고 빈 문자열도 아니면 true -->

Status 속성 제어

<c:forEach> 태그의 varStatus 속성을 사용하여 반복문의 상태 정보를 얻을 수 있다.

<c:forEach items="${RESULT}" var="result" varStatus="status">
    ${status.current}<br/>   <!-- 현재 아이템 -->
    ${status.index}<br/>     <!-- 0부터의 순서 -->
    ${status.count}<br/>     <!-- 1부터의 순서 -->
    ${status.first}<br/>     <!-- 현재 루프가 처음인지 반환 -->
    ${status.last}<br/>      <!-- 현재 루프가 마지막인지 반환 -->
</c:forEach>

JSTL for 문

<c:forEach>를 사용하여 다양한 방식으로 반복문을 제어할 수 있다.

 

인덱스로 접근

<c:forEach var="i" begin="1" end="5" step="1" varStatus="status">
    번호 : ${status.count}
    이름 : ${item[i].name}
    직업 : ${item[i].job}
    급여 : ${item[i].salary}
</c:forEach>

 

begin과 end로 접근

<c:forEach var="item" items="${list}" begin="0" end="5" step="1" varStatus="status">
    번호 : ${status.count}
    이름 : ${item.name}
    직업 : ${item.job}
    급여 : ${item.salary}
</c:forEach>

 

일반적인 접근

<c:forEach var="item" items="${list}" varStatus="status">
    번호 : ${status.count}
    이름 : ${item.name}
    직업 : ${item.job}
    급여 : ${item.salary}
</c:forEach>

 

JSTL break문 구현

JSTL은 기본적으로 break문을 지원하지 않지만, 조건문과 변수를 이용해 비슷한 효과를 낼 수 있다.

<c:set var="doneLoop" value="false" />
<c:forEach var="entity" items="${_STORE}" varStatus="status">
    <c:if test="${status.count % 6 eq 1}">
        <c:set var="doneLoop" value="false" />
    </c:if>
    <c:if test="${not doneLoop}"> 
        <span><input type="checkbox" id="store_id" name="store_id" value="<c:out value="${entity.STORE_ID}"/>" <c:out value="${entity.USE_YN}"/>><c:out value="${entity.STORE_NM}"/></span>
        <c:if test="${status.count % 6 eq 0}"> 
            <c:set var="doneLoop" value="true"/> 
        </c:if>
    </c:if>
</c:forEach>

 

비즈니스 로직과 프리젠테이션 로직의 분할

JSP(JavaServer Pages)에서 날짜 형식을 직접 변경하거나 리다이렉트를 수행하는 것은 바람직하지 않다. 이들 작업은 JSP 페이지의 주요 역할인 프레젠테이션(디스플레이) 로직과 비즈니스 로직의 경계를 흐릴 수 있으며, 코드 유지보수성과 명료성을 떨어뜨릴 수 있다.

 

  • 프레젠테이션 로직: JSP의 주요 역할은 HTML과 자바 코드를 결합하여 동적인 웹 페이지를 생성하는 것이다.
  • 이와 관련된 작업은 주로 데이터를 표시하거나 사용자 인터페이스를 구성하는 데 초점을 맞춘다.
  • 비즈니스 로직: 날짜 형식 변경, 데이터베이스 작업, 리다이렉트와 같은 작업은 비즈니스 로직에 속한다. 이러한 작업은 JSP 페이지가 아니라, 서블릿, 서비스 레이어, 혹은 비즈니스 로직을 처리하는 별도의 컴포넌트에서 처리하는 것이 디자인 패턴에 맞다.

 

'CS > JAVA' 카테고리의 다른 글

클래스, 인스턴스, 인터페이스, 상속  (0) 2024.08.15
인터페이스와 프레임워크의 차이  (0) 2024.08.15
Servlet  (0) 2024.08.14
세션의 값을 저장하고 꺼내는 법  (0) 2024.08.14
추상클래스와 인터페이스  (0) 2024.08.13

함수형 컴포넌트는 상태와 생명 주기 메서드를 가진 클래스형 컴포넌트와 달리 순수 함수로 UI를 정의한다.

이러한 컴포넌트는 불변성을 유지하며 코드를 최소화한다.

import React from 'react';

// 함수형 컴포넌트 정의
const Greeting = ({ name }) => {
    return <h1>Hello, {name}!</h1>;
};

// 함수형 컴포넌트 사용
const App = () => {
    return (
        <div>
            <Greeting name="Alice" />
            <Greeting name="Bob" />
        </div>
    );
};

export default App;

불변성(Immutability)

함수형 클래스는 불변성을 유지한다. 이는 객체의 상태가 생성된 이후에 변경되지 않음을 의미한다.

상태가 변경되지 않기 때문에, 객체를 여러 스레드에서 동시에 안전하게 사용할 수 있다.

함수형 메서드

함수형 클래스는 상태를 변경하지 않는 메서드를 포함한다.

이러한 메서드는 주어진 입력에 대해 일정한 출력을 제공하며, 객체의 상태를 변경하지 않는다.

 

하지만 상태를 가지지 않으므로, 상태를 관리하기 위해 여러 개의 함수형 컴포넌트를 사용할 경우 렌더링 성능에 영향을 준다. 복잡한 상태를 관리해야 하는 경우, 상태 관리 라이브러리(예: Redux)와 결합하여 복잡도가 증가하는 단점이 있다.

데이터 중심 설계

함수형 클래스는 종종 데이터를 중심으로 설계되며, 데이터의 변환이나 조작을 함수형 프로그래밍 패턴에 맞게 처리한다.

이러한 클래스는 사이드 이펙트(side effect)가 없고, 입력값이 동일하면 항상 동일한 출력을 보장한다.

 

장점

  • 스레드 안전성: 불변성을 유지하므로 다중 스레드 환경에서 안전하게 사용할 수 있다.
  • 디버깅 용이성: 상태 변경이 없으므로 프로그램의 동작을 이해하고 디버깅하기가 쉽다.
  • 예측 가능한 동작: 함수형 메서드는 입력이 동일하면 항상 동일한 출력을 보장하므로 예측 가능한 동작을 제공한다.

단점

  • 성능 문제: 객체를 변경할 때마다 새로운 객체를 생성하므로 메모리 사용량이 증가할 수 있다.
  • 복잡성 증가: 불변성과 함수형 프로그래밍 패턴을 강제하면 코드가 복잡해진다.

컴포넌트

컴포넌트는 독립적으로 개발, 배포, 유지보수할 수 있는 모듈이다.

각 컴포넌트는 특정 기능이나 서비스를 제공하며, 시스템 내에서 명확한 역할을 가지고 있다.

예를 들어, 웹 애플리케이션에서 사용자 인터페이스를 구성하는 버튼, 폼, 모달 등이 각각의 컴포넌트로 구현된다.

 

모듈

특정 기능이나 책임을 가진 코드 집합으로, 독립적으로 작동하고 재사용되는 코드의 단위이다.

//프로젝트 구조
│
├── /src
│   ├── /components
│   │   ├── Button.js
│   │   ├── Header.js
│   │   └── Footer.js
│   ├── /utils
│   │   └── formatDate.js
│   ├── /styles
│   │   └── App.css
│   ├── App.js
│   ├── index.js
│   └── index.css
│
└── package.json
package com.example.utils;
// src/components/Button.js
import React from 'react';
import './Button.css';  // 모듈화된 스타일

const Button = ({ label, onClick }) => {
    return (
        <button className="button" onClick={onClick}>
            {label}
        </button>
    );
};

export default Button;
// src/components/Header.js
import React from 'react';
import './Header.css';  // 모듈화된 스타일

const Header = () => {
    return (
        <header className="header">
            <h1>My Application</h1>
        </header>
    );
};

export default Header;
// src/components/Footer.js
import React from 'react';
import './Footer.css';  // 모듈화된 스타일

const Footer = () => {
    return (
        <footer className="footer">
            <p>&copy; 2024 My Application</p>
        </footer>
    );
};

export default Footer;

 

App.js 

// src/App.js
import React from 'react';
import Header from './components/Header';
import Footer from './components/Footer';
import Button from './components/Button';
import formatDate from './utils/formatDate';
import './styles/App.css';  // 모듈화된 스타일

const App = () => {
    const handleClick = () => {
        alert(`Current Date: ${formatDate(new Date())}`);
    };

    return (
        <div className="app">
            <Header />
            <main>
                <h2>Welcome to My App</h2>
                <Button label="Show Date" onClick={handleClick} />
            </main>
            <Footer />
        </div>
    );
};

export default App;

 

index.js는 React와 ReactDOM 모듈을 가져와 HTML 요소에 렌더링한다. 

HTML 요소는 index.html 파일에 정의된 <div id="root"></div>와 같은 컨테이너와 같다.

// src/index.js
import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import './index.css';  // 전역 스타일

ReactDOM.render(
    <React.StrictMode>
        <App />
    </React.StrictMode>,
    document.getElementById('root')
);

 

캡슐화

컴포넌트는 내부 구현을 외부에 노출하지 않고, 필요한 인터페이스만 공개한다.

이를 통해 내부 구현 세부 사항을 숨기고, 외부에서 제공하는 서비스나 기능만을 사용한다.

예를 들어, 컴포넌트가 내부 상태를 유지하더라도, 외부는 컴포넌트가 제공하는 메서드만 사용하여 상호작용한다.

 

재사용성

컴포넌트는 재사용 가능한 단위로 설계되어, 여러 위치에서 동일한 컴포넌트를 사용할 수 있다.

이는 코드 중복을 줄이고, 유지보수를 용이하게 만든다.

예를 들어, 버튼 컴포넌트를 여러 페이지에서 재사용함으로써 일관된 디자인을 유지할 수 있다.

 

확장성

컴포넌트 기반 설계는 시스템을 쉽게 확장할 수 있도록 지원한다.

새로운 기능을 추가하거나 기존 기능을 수정할 때, 전체 시스템에 미치는 영향을 최소화할 수 있다.

새로운 기능을 추가하기 위해 기존 컴포넌트를 수정하거나 새로운 컴포넌트를 추가할 수 있다.

재사용성 컴포넌트는 독립적으로 설계되므로 여러 애플리케이션에서 재사용할 수 있다.
유지보수 용이 컴포넌트 단위로 수정할 수 있어, 시스템 전체를 수정하지 않고도 특정 기능을 변경할 수 있다.
모듈화 시스템을 작은 구성요소로 나누어 개발하므로, 복잡성을 줄이고 이해하기 쉽다.
독립적 개발 및 테스트 각 컴포넌트는 독립적으로 개발 및 테스트할 수 있어, 전체 시스템에 영향을 미치지 않는다.
의존성 관리 컴포넌트 간의 의존성을 명확히 정의하고 관리할 수 있어, 시스템의 안정성을 높일 수 있다.

 

컴포넌트 간 통신 복잡성 컴포넌트 간의 데이터 교환 및 통신이 복잡할 수 있으며,
이를 관리하기 위한 추가적인 설계가 필요하다.
성능 문제 컴포넌트 간의 상호작용이 많을 경우, 성능 저하가 발생할 수 있으며
이는 최적화가 필요하다.
초기 설계 및 구조 설계의 어려움 컴포넌트를 효과적으로 설계하고 구조를 정의하는 것이 어려울 수 있으며
잘못 설계된 경우 유지보수에 문제를 일으킬 수 있다.
버전 관리의 어려움 컴포넌트가 서로 다른 버전을 사용할 경우, 호환성 문제를 일으킬 수 있다.
테스트 복잡성 각 컴포넌트가 독립적으로 테스트되지만, 전체 시스템의 통합 테스트는 복잡할 수 있다.

'CS > JAVASCRIPT' 카테고리의 다른 글

React와 ReactDOM  (0) 2024.08.14
AJAX(Asynchronous JavaScript and XML)  (0) 2024.08.14
REST API  (0) 2024.07.18
JSON  (0) 2024.06.28
var, let, const  (0) 2024.06.28

상속

상속은 기존 클래스(부모 클래스 또는 상위 클래스)를 기반으로 새로운 클래스(자식 클래스 또는 하위 클래스)를 생성한다. 자식 클래스는 부모 클래스의 속성(필드)과 메서드(함수)를 상속받아 사용할 수 있으며, 필요에 따라 이들을 수정하거나 확장할 수 있다.

  • 부모 클래스(Parent Class): 상속의 기반이 되는 클래스이다. 공통된 속성과 메서드를 정의한다.
  • 자식 클래스(Child Class): 부모 클래스를 상속받아 새로운 기능을 추가하거나 기존 기능을 수정한 클래스이다. 부모 클래스의 모든 속성과 메서드를 물려받지만, 자신만의 속성과 메서드를 추가할 수 있다.

다형성 (Polymorphism)

상속을 통해 다형성을 구현할 수 있다. 자식 클래스의 객체를 부모 클래스의 타입으로 참조할 수 있는 것...

단일 상속 (Single Inheritance)

하나의 부모 클래스를 상속받아 자식 클래스를 생성하는 방식이다. 

// 부모 클래스
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

 

다중 상속 (Multiple Inheritance)

하나의 자식 클래스가 여러 부모 클래스를 상속받는 형태이다. 다중 상속은 코드의 복잡성을 증가시키고, 다이아몬드 문제(Diamond Problem)를 유발할 수 있기 때문에 일부 언어에서는 지원하지 않는다. 

 

다이아몬드 문제

class A {
    void doSomething() {
        System.out.println("A's doSomething");
    }
}

class B extends A {
    @Override
    void doSomething() {
        System.out.println("B's doSomething");
    }
}

class C extends A {
    @Override
    void doSomething() {
        System.out.println("C's doSomething");
    }
}

class D extends B, C {
    // 어떤 doSomething()을 상속받아야 할지 모름
}

 

클래스 D는 B와 C를 상속받는다. 클래스 B와 C는 모두 A를 상속받았으며, 각 클래스에서 doSomething() 메서드를 오버라이드했다. 이제 클래스 D에서 doSomething() 메서드를 호출하면, B와 C 두 클래스에서 상속받은 메서드 중 어떤 것이 호출될지 모른다.

계층적 상속 (Hierarchical Inheritance)

계층적 상속은 하나의 부모 클래스로부터 여러 자식 클래스를 생성하는 방식이다.

이 방식은 상속받은 클래스들이 공통된 기능을 공유하면서도 각기 다른 특성으로 확장될 수 있다.

// 부모 클래스
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 자식 클래스 1
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

// 자식 클래스 2
class Cat extends Animal {
    void meow() {
        System.out.println("Cat is meowing");
    }
}

상속을 사용하면 기존 클래스를 재사용하여 새로운 클래스를 만들 수 있다.

이를 통해 중복된 코드를 작성할 필요가 없으며, 공통된 기능을 하나의 부모 클래스에 정의하고,

자식 클래스에서 이를 재사용할 수 있다. 기존의 클래스에서 공통된 기능을 수정하면, 이를 상속받은 모든 자식 클래스에서 자동으로 변경사항이 반영된다. 이는 코드의 일관성을 유지하며, 버그를 수정할 때 일관된 변경을 쉽게 적용할 수 있다.

 

하지만 상속 계층이 깊어질수록 클래스 간의 관계가 복잡해지고

높은 의존성으로 부모 클래스의 메서드가 변경되면, 이를 오버라이드한 자식 클래스의 동작이 영향을 받을 수 있다.

이런 경우, 자식 클래스에서 의도한 대로 동작하지 않게 될 수 있다.

 

메서드 오버라이딩 (Method Overriding)

자식 클래스는 부모 클래스에서 상속받은 메서드를 수정하여 새로운 기능을 구현할 수 있다.

이를 메서드 오버라이딩이라고 한다. 오버라이딩을 통해 부모 클래스의 메서드를 자식 클래스에서 자신에 맞게 수정할 수 있다.

 

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("Dog is eating dog food");
    }
}

클래스 (Class)

클래스는 객체의 상태와 행동을 정의한다. 객체는 클래스의 인스턴스이며, 클래스는 이 객체들이 가지는 데이터와 메서드를 정의한다. 클래스는 OOP의 기본 구성 요소로, 객체를 생성하기 위한 구조와 기능을 제공한다.

 

인스턴스 (Instance)

인스턴스는 클래스의 구체적인 객체이다. 클래스가 정의한 구조와 메서드를 실제로 메모리 상에 구현한 개체로, 프로그램이 실행되는 동안 존재한다. 인스턴스는 클래스의 생성자를 호출함으로써 생성된다. 생성자는 클래스를 기반으로 새로운 객체를 메모리에 할당하고, 객체의 초기 상태를 설정한다.

 

// 클래스 정의
public class Car {
    // 속성
    private String color;
    private String model;

    // 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    // 메서드
    public void displayInfo() {
        System.out.println("Model: " + model + ", Color: " + color);
    }
}

// 인스턴스 생성 및 사용
public class Main {
    public static void main(String[] args) {
        // Car 클래스의 인스턴스 생성
        Car myCar = new Car("Red", "Toyota Corolla");
        
        // 인스턴스 메서드 호출
        myCar.displayInfo(); // 출력: Model: Toyota Corolla, Color: Red
    }
}

 

인스턴스는 클래스에서 정의한 속성과 메서드를 가지고 있으며, 각 인스턴스는 고유한 속성 값을 가진다.

이는 인스턴스가 서로 독립적이게 만들며, 각각의 인스턴스가 서로 다른 상태를 유지할 수 있도록 다.

 

속성 (Attributes)

클래스는 속성을 통해 데이터를 저장한다. 이러한 속성은 클래스의 멤버 변수(필드)로, 객체의 상태를 나타낸다.

예를 들어, Person 클래스는 name, age, address 등의 속성을 가진다.

 

동작 (Methods)

클래스는 메서드를 통해 동작을 정의한다. 메서드는 클래스의 속성에 대해 작업을 수행하며, 객체의 행동을 구현한다. 예를 들어, Person 클래스는 speak() 메서드를 가질 수 있으며, 이는 객체가 대화하는 동작을 구현한다.

 

생성자 (Constructor)

생성자는 객체가 생성될 때 호출되는 특별한 메서드로, 객체의 초기 상태를 설정한다.

생성자는 클래스 이름과 동일하며, 객체가 생성될 때 필수적인 초기화를 수행한다.

 

상속 (Inheritance)

클래스는 다른 클래스를 상속받을 수 있다. 이를 통해 코드의 재사용성을 높이고, 클래스 간의 계층 구조를 만든다.

상속받은 클래스는 부모 클래스의 속성과 메서드를 재사용하거나, 새로운 속성과 메서드를 추가한다.

 

public class Car {
    // 속성
    private String color;
    private String model;
    
    // 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }
    
    // 메서드
    public void start() {
        System.out.println("The car is starting.");
    }
    
    public String getModel() {
        return model;
    }
}

 

인터페이스 (Interface)

인터페이스는 클래스가 구현해야 하는 메서드의 집합을 정의하는 설계이다.

인터페이스는 메서드의 시그니처(메서드 이름, 매개변수)만을 정의하며, 실제 메서드의 구현은 해당 인터페이스를 구현하는 클래스에서 제공한다. 인터페이스는 클래스 간의 공통된 동작을 정의하고, 이를 강제하기 위해 사용된다.

 

메서드 시그니처

메서드 이름: 메서드의 이름은 메서드를 호출할 때 사용하는 식별자이다

매개변수 목록: 메서드가 받는 매개변수의 타입과 순서

public class Example {
    // 메서드 시그니처: "add(int, int)"
    public int add(int a, int b) {
        return a + b;
    }

    // 메서드 시그니처: "add(double, double)"
    public double add(double a, double b) {
        return a + b;
    }
}

 

클래스가 인터페이스를 구현하면, 그 클래스는 인터페이스에서 정의한 모든 메서드를 실제로 구현해야 한다.

즉, 인터페이스의 계약을 준수해야 한다.

 

//클래스
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}
//인터페이스
public interface Animal {
    void eat();
    void sleep();
}

 

다중 상속 (Multiple Inheritance)

클래스는 단일 상속만 지원하지만, 인터페이스는 다중 상속을 지원한다. 인터페이스는 메서드의 구현을 제공하지 않기 때문에 하나의 클래스는 여러 개의 인터페이스를 구현할 수 있으며, 인터페이스에서는 구현을 제공하는 클래스가 중복될 수 없다.

 

'CS > JAVA' 카테고리의 다른 글

JSP + JSTL  (0) 2024.08.15
인터페이스와 프레임워크의 차이  (0) 2024.08.15
Servlet  (0) 2024.08.14
세션의 값을 저장하고 꺼내는 법  (0) 2024.08.14
추상클래스와 인터페이스  (0) 2024.08.13

SQL 쿼리에서 ROW는 테이블의 한 줄을 의미하며, 쿼리 결과의 한 레코드로 이해할 수 있다

아래와 같은 SQL 쿼리가 실행된 결과로 나오는 각 행이 ROW이다.

d	name	department
1	Alice	HR
2	Bob	IT
3	Carol	Finance
SELECT * FROM employees WHERE department = 'IT';

 

department가 'IT'인 모든 ROW를 반환한다.

파일 시스템일 경우 record라고 하며, 데이터베이스 모델링의 경우 튜플이라고 부른다.

 

'CS > DATABASE' 카테고리의 다른 글

Where vs Having vs Group by  (0) 2024.08.15
RDBMS Consumer  (0) 2024.08.14
Apache Kafka  (0) 2024.08.14
기본키와 외래키  (1) 2024.08.13
h2 데이터베이스 사용법  (0) 2024.08.01

1. WHERE

WHERE 절은 데이터베이스 테이블에서 조건에 맞는 행을 선택하는 데 사용된다. (필터링)

조건식으로는 비교 연산자(=, <, >, <=, >=, <>), 논리 연산자(AND, OR, NOT), 패턴 매칭(예: LIKE)

범위 검사(예: BETWEEN), 집합 검사(예: IN), NULL 검사(예: IS NULL) 등이 사용된다.

 

ORDER BY 같은 정렬, 집계 연산 후에 적용되지 않는 특징이 있다.

 

employees 테이블에서 salary가 50,000보다 큰 행을 선택

SELECT *
FROM employees
WHERE salary > 50000;

 

2. HAVING

HAVING 절은 집계 함수(Aggregate Function)로 계산된 결과에 대해 조건을 적용한다.

HAVING 절은 집계 함수의 결과를 필터링하기 위해 사용되며, GROUP BY 절과 함께 사용된다.

 

employees 테이블에서 department별로 직원 수를 집계하고, 직원 수가 10명 이상인 부서만 선택

SELECT department, COUNT(*) AS num_employees
FROM employees
GROUP BY department
HAVING COUNT(*) > 10;

 

3. GROUP BY

GROUP BY 절은 결과 집합을 하나 이상의 열을 기준으로 그룹화한다.

이를 통해 집계 함수(예: COUNT, SUM, AVG, MAX, MIN)를 사용하여 각 그룹에 대한 요약 정보를 계산한다.

SELECT department, AVG(salary) AS average_salary
FROM employees
GROUP BY department;

 

 

항목 Where 절 Having 절
적용 시점 집계 전, 초기 데이터에 적용 집계 후, 그룹화된 데이터에 적용
용도 행 수준에서 조건 적용 (집계 함수 미사용) 집계 함수 결과에 조건 적용
예제 SELECT * FROM employees WHERE salary > 50000 SELECT department, AVG(salary) FROM employees
GROUP BY department HAVING AVG(salary) > 60000

 

'CS > DATABASE' 카테고리의 다른 글

row (record, tuple)  (0) 2024.08.15
RDBMS Consumer  (0) 2024.08.14
Apache Kafka  (0) 2024.08.14
기본키와 외래키  (1) 2024.08.13
h2 데이터베이스 사용법  (0) 2024.08.01

+ Recent posts