📌 백엔드 구현 단계

BCrypt로 비밀번호 암호화 및 검증 Spring Data JPA와 MySQL 사용 CORS 문제 해결

1. DB 생성

```sql
CREATE TABLE user (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(100) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL
);
```

2. 의존성 추가

<pom.xml>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-crypto</artifactId>
</dependency>

3. Security 설정

<SecurityConfig.java>

package com.dearu.backend.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .csrf().disable()  // CSRF 비활성화
                .authorizeHttpRequests()
                .requestMatchers("/api/users/**", "/api/invitations/**").permitAll()  // 사용자, 초대장 API는 인증 없이 접근 허용
                .anyRequest().authenticated()
                .and()
                .formLogin().disable(); // 기본 로그인 폼 비활성화
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

4. 회원 엔티티 및 DTO 작성

<User.java>

• BCrypt를 사용하여 비밀번호 암호화 및 검증

  package com.dearu.backend.model;
  

import jakarta.persistence.*; import lombok.Getter; import lombok.Setter;

@Entity @Table(name = "user") @Getter @Setter public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;

@Column(unique = true, nullable = false)
private String username;

@Column(nullable = false)
private String password;

}

<UserDTO.java>
```java
package com.dearu.backend.dto;

import lombok.Data;

@Data
public class UserDTO {
    private String username;
    private String password;
}

5. 회원 저장 및 조회

<UserRepository.java>

package com.dearu.backend.repository;

import com.dearu.backend.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

<UserService.java>

• BCrypt로 비밀번호를 검증

  package com.dearu.backend.service;
  

import com.dearu.backend.model.User; import com.dearu.backend.repository.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.stereotype.Service;

@Service public class UserService {

@Autowired
private UserRepository userRepository;

@Autowired
private PasswordEncoder passwordEncoder;

// 회원가입
public User register(User user) {
    user.setPassword(passwordEncoder.encode(user.getPassword()));
    return userRepository.save(user);
}

// 로그인
public boolean login(String username, String rawPassword) {
    User user = userRepository.findByUsername(username);
    if (user != null) {
        return passwordEncoder.matches(rawPassword, user.getPassword());
    }
    return false;
}

}

### 6. BCrypt를 이용한 비밀번호 암호화 및 비교
- **회원가입:** `passwordEncoder.encode(rawPassword)` 사용하여 암호화 후 저장
- **로그인:** `passwordEncoder.matches(rawPassword, encodedPassword)` 사용하여 비교
### 7. 로그인 API
<UserController.java>
```java
package com.dearu.backend.controller;

import com.dearu.backend.dto.UserDTO;
import com.dearu.backend.model.User;
import com.dearu.backend.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@CrossOrigin(origins = "http://localhost:3001")
@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    // 회원가입
    @PostMapping("/register")
    public String register(@RequestBody UserDTO userDTO) {
        User user = new User();
        user.setUsername(userDTO.getUsername());
        user.setPassword(userDTO.getPassword());
        userService.register(user);
        return "회원가입 성공!";
    }

    // 로그인
    @PostMapping("/login")
    public String login(@RequestBody UserDTO userDTO) {
        boolean isAuthenticated = userService.login(userDTO.getUsername(), userDTO.getPassword());
        return isAuthenticated ? "로그인 성공!" : "로그인 실패!";
    }
}

8. PostMan Test

<회원가입>

<로그인>

📌 프론트엔드 구현 단계 - 매우 간단하게 구현함

Axios를 사용한 HTTP 요청 로그인 UI 및 상태 관리 로그인 성공 시 토큰 저장 및 페이지 이동

1. API 연결 설정

<api.ts>

// 회원가입
export const registerUser = async (userData: { username: string; password: string }) => {
    try {
        const response = await axios.post(`${API_BASE_URL}/users/register`, userData, {
            headers: {
                "Content-Type": "application/json"
            },
            withCredentials: true
        });
        return response.data;
    } catch (error) {
        console.error("Error registering user:", error);
        throw error;
    }
};

// 로그인
export const loginUser = async (userData: { username: string; password: string }) => {
    try {
        const response = await axios.post(`${API_BASE_URL}/users/login`, userData, {
            headers: {
                "Content-Type": "application/json"
            },
            withCredentials: true
        });
        return response.data;
    } catch (error) {
        console.error("Error logging in:", error);
        throw error;
    }
};

2. Login 컴포넌트 작성

<Login.tsx>

• 로그인 성공 시 토큰을 Local Storage에 저장

  import React, { useState } from "react";
  import { loginUser } from "../services/api";
  import { useNavigate } from "react-router-dom";
  

const Login: React.FC = () => { const [username, setUsername] = useState(""); const [password, setPassword] = useState(""); const navigate = useNavigate();

const handleLogin = async (event: React.FormEvent) => {
    event.preventDefault();
    try {
        const response = await loginUser({ username, password });
        alert(response); // 로그인 성공 메시지
        navigate("/");   // 로그인 성공 시 홈으로 이동
    } catch (error) {
        alert("로그인 실패. 다시 시도하세요.");
    }
};

return (
    <div className="login-container">
        <h2>로그인</h2>
        <form onSubmit={handleLogin}>
            <input
                type="text"
                placeholder="아이디"
                value={username}
                onChange={(e) => setUsername(e.target.value)}
                required
            />
            <input
                type="password"
                placeholder="비밀번호"
                value={password}
                onChange={(e) => setPassword(e.target.value)}
                required
            />
            <button type="submit">로그인</button>
        </form>
        <p>
            계정이 없으신가요? <a href="/register">회원가입</a>
        </p>
    </div>
);

};

export default Login;

### 3. Register 컴포넌트 작성 
<Register.tsx>
```tsx
import React, { useState } from "react";
import { registerUser } from "../services/api";
import { useNavigate } from "react-router-dom";

const Register: React.FC = () => {
    const [username, setUsername] = useState("");
    const [password, setPassword] = useState("");
    const navigate = useNavigate();

    const handleRegister = async (event: React.FormEvent) => {
        event.preventDefault();
        try {
            const response = await registerUser({ username, password });
            alert(response); // 회원가입 성공 메시지
            navigate("/login"); // 회원가입 후 로그인 페이지로 이동
        } catch (error) {
            alert("회원가입 실패. 다시 시도하세요.");
        }
    };

    return (
        <div className="register-container">
            <h2>회원가입</h2>
            <form onSubmit={handleRegister}>
                <input
                    type="text"
                    placeholder="아이디"
                    value={username}
                    onChange={(e) => setUsername(e.target.value)}
                    required
                />
                <input
                    type="password"
                    placeholder="비밀번호"
                    value={password}
                    onChange={(e) => setPassword(e.target.value)}
                    required
                />
                <button type="submit">회원가입</button>
            </form>
            <p>
                이미 계정이 있으신가요? <a href="/login">로그인</a>
            </p>
        </div>
    );
};

export default Register;

4. React Router 설정

<App.tsx>

• react-router-dom을 사용하여 페이지 이동

  {/* ✅ 로그인 & 회원가입 추가 */}
  <Route path="/login" element={<Login />} />
  <Route path="/register" element={<Register />} />

  5. 화면 테스트

  <로그인> <회원가입>

6. CORS 문제 해결 (Spring Boot)

1. Controller 에 @CrossOrigin 어노테이션 사용

   @CrossOrigin(origins = "http://localhost:3000")

2. WebConfig.java에서 글로벌 설정

   @Configuration
   public class WebConfig {
   
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                        .allowedOrigins("http://localhost:3000")
                        .allowedMethods("GET", "POST", "PUT", "DELETE")
                        .allowCredentials(true);
            }
        };
    }
   }

초대장 앱을 만들어 보자!

💡 주요 기능 (concept)

1. 초대장 생성 및 관리

• 사용자가 이벤트(결혼식, 돌잔치, 생일 등)를 선택하여 초대장 생성 가능

• 초대장 꾸미기 및 미리보기 기능

  2.초대장 전송 및 RSVP 관리

• 이메일, 문자(SMS), 카카오톡, 링크 공유 방식으로 초대장 전송

• 참석 여부(RSVP) 응답 기능 (참석 / 불참 / 미정)

• 참석자 목록 관리 (참석자 수 카운트 및 실시간 업데이트)

3. 일정 및 알림 시스템

• 캘린더 연동 (Google Calendar, Outlook 등)
• 초대장 받은 사람에게 일정 리마인더 알림 전송

4. 추가기능

• 개발 진행 하면서 추가 기능 개발 예정..

🛠️ 기술 스택

📌 프론트엔드 (React)

• UI 라이브러리: Material-UI, Ant Design 또는 TailwindCSS
• 상태 관리: Redux 또는 React Context API
• 지도 API: Google Maps API 또는 Kakao 지도 API
• 이미지/동영상 업로드: Firebase Storage 또는 AWS S3

📌 백엔드 (Java, Spring Boot)

• API 설계: RESTful API 또는 GraphQL
• 데이터베이스: MySQL (참석자 및 이벤트 데이터 저장)
• 이메일/SMS 발송: Twilio, SendGrid, AWS SES
• 결제 시스템: Stripe, Toss Payments (축의금, 선물 기능 추가 시)
• 실시간 알림: WebSocket 또는 Firebase Cloud Messaging (FCM)

🛠️ 프로젝트 구조

/dearU
 ├── frontend (React + TypeScript)
 │   ├── src
 │   │   ├── components  (재사용 가능한 UI 컴포넌트)
 │   │   ├── pages       (각 페이지 라우트)
 │   │   ├── assets      (이미지, 아이콘 등)
 │   │   ├── store       (상태 관리)
 │   │   ├── services    (API 호출)
 │   │   ├── types       (TypeScript 타입 정의)
 │   ├── tsconfig.json  (TypeScript 설정)
 │   ├── package.json
 │
 ├── backend (Spring Boot)
 │   ├── src/main/java/com/dearu
 │   │   ├── config              
 │   │   ├── controller  (API 엔드포인트)
 │   │   ├── service     (비즈니스 로직)
 │   │   ├── repository  (DB 연동)
 │   │   ├── model       (데이터 모델)
 │   ├── pom.xml
 │
 ├── README.md

개발 진행

1. 프론트 환경 구성(React+TypeScript)

npx create-react-app frontend --template typescript --use-npm
cd frontend
npm install react@18 react-dom@18
npm install --save-dev @types/react@18 @types/react-dom@18

npm start

2. GitHub 연동

https://github.com/sein0121/dearU

3. 백엔드 환경 구성(SrpingBoot)

3-1. 프로젝트 생성

3-2. MySQL 설정

application.properties

# ✅ MySQL 연결 정보
spring.datasource.url=jdbc:mysql://localhost:3306/dearu?serverTimezone=UTC&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=your_password  # ← 본인의 MySQL 비밀번호 입력

# ✅ JPA 설정
spring.jpa.hibernate.ddl-auto=update  # 애플리케이션 실행 시 자동 테이블 생성
spring.jpa.show-sql=true  # 콘솔에 SQL 출력
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.sql.init.mode=always  # 초기 SQL 실행 (선택사항)

# ✅ 서버 포트 설정 (기본값: 8080)
server.port=8080

3-3. 프론트와 연결

npm install axios

api.ts 생성

import axios from "axios";

const API_BASE_URL = "http://localhost:8080/api";

export const getEvents = async () => {
    const response = await axios.get(`${API_BASE_URL}/events`);
    return response.data;
};

export const createEvent = async (event: { title: string; description: string }) => {
    const response = await axios.post(`${API_BASE_URL}/events`, event);
    return response.data;
};

개요

개별 투자자들의 투자 트랜드를 분석하여 "최근 개인이 많이 매수한 종목, 매매동향, 관심종목, 관련 뉴스 등"을 보여주는 서비스

주요 기능

1. 최근 1주일/1개월 개인 투자자 순매수 상위 종목 조회
2. 기관 & 외국인 투자잦와 비교하여 매매 동향 분석
3. AI 기반 투자자 관심 종목 추천
4. 관심종목 저장 및 조회
5. 사용자의 관심 종목 기반 뉴스 크롤링

활용 데이터

한국 거래소 - 투자자별 매매동향 , 네이버 금융 크롤링

개발 스택

• 언어: Java 17+
• 프레임워크: Spring Boot 3.x
• 데이터베이스: MySQL
• API 호출: RestTemplate 또는 WebClient (KRX 데이터 가져오기)
• 배포: 로컬 서버 실행

개발

프로젝트 초기 설정

Spring Boot를 사용한 RESTful API 형태로 개발 진행

1. 프로젝트 생성 및 세팅

vscode 에서 프로젝트 열고 src/main/resources/application.properties 수정

# MySQL 데이터베이스 설정
spring.datasource.url=jdbc:mysql://localhost:3306/stock_trend?useSSL=false&serverTimezone=Asia/Seoul
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA 설정
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect

mysql 접속 후

CREATE DATABASE stock_trend;

터미널에

.\mvnw.cmd spring-boot:run

test 코드

<Controller/TrendContrller.java>

package com.example.personal_investor_trend;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/trend")
public class TrendController {

    @GetMapping("/top-buyers")
    public List<Map<String, String>> getTopBuyers() {
        return List.of(
                Map.of("ticker", "005930", "name", "삼성전자", "net_buy", "150억"),
                Map.of("ticker", "000660", "name", "SK하이닉스", "net_buy", "120억")
        );
    }

    @GetMapping("/comparison")
    public Map<String, String> getComparison() {
        return Map.of(
                "개인 투자자", "삼성전자 +150억",
                "기관 투자자", "삼성전자 -80억",
                "외국인 투자자", "삼성전자 -70억"
        );
    }
}

KRX 데이터 가져오기 & 저장하기

1. KRX 투자자별 매매 동향 데이터 가져오기

• http://openapi.krx.co.kr/contents/OPP/MAIN/main/index.cmd 에서 인증키 받고 원하는 데이터 api 신청

• <KrxService.java>

           package com.example.personal_investor_trend.service;
  
            import org.springframework.http.*;
            import org.springframework.stereotype.Service;
            import org.springframework.web.client.RestTemplate;
  
            import java.util.Collections;
            import java.util.Map;
  
            @Service
            public class KrxService {
  
                private final RestTemplate restTemplate = new RestTemplate();
                private static final String API_URL = "http://data-dbg.krx.co.kr/svc/apis/sto/ksq_bydd_trd"; // KRX OpenAPI URL
    public String getKrxData(String basDd) {
                    //요청 데이터(JSON)
                    Map<String, String> requestBody = Collections.singletonMap("basDd", basDd);
  
                    //HTTP 헤더
                    HttpHeaders headers = new HttpHeaders();
                    headers.setContentType(MediaType.APPLICATION_JSON);
                     headers.set("Authorization", "Bearer API인증키");
  
                    //HTTP 요청 객체 
                    HttpEntity<Map<String, String>> requestEntity = new HttpEntity<>(requestBody, headers);
  
                    //API 호출
                    ResponseEntity<String> response = restTemplate.exchange(API_URL, HttpMethod.POST, requestEntity, String.class);
  
                    return response.getBody();
  
                }
            }

• <TrendController.java>

  package com.example.personal_investor_trend.controller;
  

import org.springframework.web.bind.annotation.*;

import com.example.personal_investor_trend.service.KrxService;

import java.util.List; import java.util.Map;

@RestController @RequestMapping("/api/trend") public class TrendController {

private final KrxService krxService;

public TrendController(KrxService krxService){ this.krxService = krxService; }

@PostMapping("/krx") public String getKrxData(@RequestBody Map<String, String> request) { return krxService.getKrxData(request.get("basDd")); } }

* 결과 확인 
    * Method : POST
    * URL : http://localhost:8080/api/trend/krx
    * Header : Content-Type: application/json , Authorization: Bearer YOUR_API_KEY
    * Body (raw JSON) 

        ```
      {
           "basDd": "20250210"
         }

![](https://velog.velcdn.com/images/baby_potato/post/d7f3f8df-8c7e-493a-a512-cfb11e4b0b3d/image.png)

#### 2. 데이터 적재
<StockTransaction.java>
```java
package com.example.personal_investor_trend.model;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Entity
@Getter
@Setter
@NoArgsConstructor
@Table(name = "stock_transactions")
public class StockTransaction {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String basDd;   // 기준일자
    private String isuCd;   // 종목코드
    private String isuNm;   // 종목명
    private String mktNm;   // 시장 구분
    private Long accTrdVol; // 거래량
    private Long mktCap;    // 시가총액
}

<StockTransactionRepository.java>

package com.example.personal_investor_trend.repository;

import com.example.personal_investor_trend.model.StockTransaction;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface StockTransactionRepository extends JpaRepository<StockTransaction, Long> {
    List<StockTransaction> findByBasDd(String basDd);
}

<KrxService.java>

package com.example.personal_investor_trend.service;

import com.example.personal_investor_trend.model.StockTransaction;
import com.example.personal_investor_trend.repository.StockTransactionRepository;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collections;
import java.util.List;
import java.util.Map;

@Service
public class KrxService {

    private final RestTemplate restTemplate = new RestTemplate();
    private static final String API_URL = "http://data-dbg.krx.co.kr/svc/apis/sto/ksq_bydd_trd"; // KRX OpenAPI URL

    private final StockTransactionRepository repository;

    public KrxService(StockTransactionRepository repository){
        this.repository = repository;
    }

    public String getKrxData(String basDd) {
        //요청 데이터(JSON)
        Map<String, String> requestBody = Collections.singletonMap("basDd", basDd);

        //HTTP 헤더
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
         headers.set("Authorization", "Bearer D6274193FC6A4043B50121146C47226E67C50DB5");

        //HTTP 요청 객체 
        HttpEntity<Map<String, String>> requestEntity = new HttpEntity<>(requestBody, headers);

        //API 호출
        ResponseEntity<String> response = restTemplate.exchange(API_URL, HttpMethod.POST, requestEntity, String.class);

        // 데이터 저장 로직 실행
        return saveKrxData(response.getBody(), basDd);

    }

    @Transactional
    public String saveKrxData(String jsonResponse, String basDd){
        try{
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode rootNode = objectMapper.readTree(jsonResponse).get("OutBlock_1");

            for (JsonNode node: rootNode){
                StockTransaction transaction = new StockTransaction();
                transaction.setBasDd(basDd);
                // transaction.setBasDd(node.get("BAS_DD").asText());
                transaction.setIsuCd(node.get("ISU_CD").asText());
                transaction.setIsuNm(node.get("ISU_NM").asText());
                transaction.setMktNm(node.get("MKT_NM").asText());
                transaction.setAccTrdVol(node.get("ACC_TRDVOL").asLong());
                transaction.setMktCap(node.get("MKTCAP").asLong());

                repository.save(transaction);
            }
            return "🍩🍩🍩 KRX 데이터 저장 완료";
        }catch (Exception e) {
            e.printStackTrace();
            return "💥💥💥 KRX 데이터 저장 실패!";
        }
    }
}

<TrenController.java>

package com.example.personal_investor_trend.controller;

import com.example.personal_investor_trend.model.StockTransaction;
import com.example.personal_investor_trend.repository.StockTransactionRepository;
import com.example.personal_investor_trend.service.KrxService;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/trend")
public class TrendController {

   private final KrxService krxService;
   private final StockTransactionRepository repository;

   public TrendController(KrxService krxService, StockTransactionRepository repository){
    this.krxService = krxService;
    this.repository = repository;
   }

   @PostMapping("/krx")
    public String getKrxData(@RequestBody Map<String, String> request) {
        return krxService.getKrxData(request.get("basDd"));
    }

    @GetMapping("/stored-data")
    public List<StockTransaction> getStoredData(@RequestParam String basDd){
        return repository.findByBasDd(basDd);
    }
}

• 결과

부가 기능 개발

1. 최근 1주일/1개월 개인 투자자 순매수 상위 종목 조회

엔드포인트 : /api/trend/top-buyers HTTP 메서드 : GET 요청 파라미터 : period = week / month (type:String)

• <TrendController.java> - /top-buyers 추가

  @GetMapping("/top-buyers")
    public List<Map<String, Object>> getTopBuyers(@RequestParam String period) {
        // 조회 기간 설정 (7일 or 30일)
        String startDate = period.equals("week") 
                ? LocalDate.now().minusDays(7).toString()
                : LocalDate.now().minusDays(30).toString();
  
        // JPA Repository 호출
        List<Object[]> results = repository.findTopBuyers(startDate);
  
        // 응답 데이터를 JSON 형태로 가공
        return results.stream().map(result -> Map.of(
                "종목코드", result[0],
                "종목명", result[1],
                "순매수량", result[2]
        )).toList();
    }

• <StockTransactionRepository.java> - 상위 10개 조회 및 findTopBuyers 정의

  / 최근 7일 또는 30일 동안 개인 투자자 순매수 상위 10개 조회
    @Query("SELECT s.isuCd, s.isuNm, SUM(s.accTrdVol) AS totalTrdVol " +
           "FROM StockTransaction s " +
           "WHERE s.basDd >= :startDate " +
           "GROUP BY s.isuCd, s.isuNm " +
           "ORDER BY totalTrdVol DESC")
  
    List<Object[]> findTopBuyers(@Param("startDate") String startDate);

• 결과

2. 기관 & 외국인 투자자와 비교하여 매매 동향 분석

• 최근 7일 / 30일 기준으로 동안 개인 vs 기관 vs 외국인의 매수/매도 흐름을 비교 엔드포인트 : /api/trend/comparison HTTP 메서드 : GET 요청 파라미터 : period = week / month (type:String)

• 기관(instTrdVol) & 외국인(foreignTrdVol) 거래량 컬럼 생성

  private Long instTrdVol; // 기관 거래량 
  private Long foreignTrdVol; // 외국인 거래량 

• 기관(instTrdVol) & 외국인(foreignTrdVol) 거래량 저장

  transaction.setInstTrdVol(node.get("INST_TRDVOL").asLong()); 
  transaction.setForeignTrdVol(node.get("FOREIGN_TRDVOL").asLong()); 

• 기관 & 외국인과 비교하여 매매 동향 조회하는 쿼리 생성

  @Query("SELECT s.isuCd, s.isuNm, SUM(s.accTrdVol) AS 개인, SUM(s.instTrdVol) AS 기관, SUM(s.foreignTrdVol) AS 외국인 " +
       "FROM StockTransaction s " +
       "WHERE s.basDd >= :startDate " +
       "GROUP BY s.isuCd, s.isuNm")
  List<Object[]> compareInvestorTrends(@Param("startDate") String startDate);

• 엔드포인트 추가

  @GetMapping("/comparison")
    public List<Map<String, Object>> getComparison(@RequestParam String period){
        String startDate = period.equals("week") 
                ? LocalDate.now().minusDays(7).toString()
                : LocalDate.now().minusDays(30).toString();
  
        List<Object[]> results = repository.compareInvestorTrends(startDate);
  
        return results.stream().map(result -> Map.of(
            "종목코드", result[0],
            "종목명", result[1],
            "개인 순매수량", result[2],
            "기관 순매수량", result[3],
            "외국인 순매수량", result[4]
        )).toList();
    }

• 결과

3. AI 기반 투자자 관심 종목 추천

최근 1개월 동안 개인 투자자가 많이 매수한 종목을 분석하여 비슷한 매매 패턴을 보이는 종목을 찾아 연관 종목 추천하는 기능

• 단순 추천 로직을 사용해 기본적인 종목 추천 기능 개발

• 추후 AI 모델을 추가할 수 있도록 확장 가능하게 설계

• 최근 1개월 개인 순매수 상위10개 조회

  @Query("SELECT s.isuCd, s.isuNm, SUM(s.accTrdVol) AS totalTrdVol " +
       "FROM StockTransaction s " +
       "WHERE s.basDd >= :startDate " +
       "GROUP BY s.isuCd, s.isuNm " +
       "ORDER BY totalTrdVol DESC")
        List<Object[]> findTopPersonalStocks(@Param("startDate") String startDate, Pageable pageable);

  • 처음에 LIMIT 10 으로 쿼리 줬다니 ERROR -> JPA/HQL 에서는 LIMIT 은 직접 사용이 불가, 대신 Spring Data JPA의 Pageable 사용

• RecommendationService 생성

  package com.example.personal_investor_trend.service;
  

import com.example.personal_investor_trend.repository.StockTransactionRepository; import org.springframework.stereotype.Service; import org.springframework.data.domain.PageRequest;

import java.time.LocalDate; import java.util.*;

@Service public class RecommendationService {

private final StockTransactionRepository repository;

public RecommendationService(StockTransactionRepository repository) {
    this.repository = repository;
}

public List<Map<String, String>> getRecommendedStocks() {
    String startDate = LocalDate.now().minusDays(30).toString();

    List<Object[]> topStocks = repository.findTopPersonalStocks(startDate, PageRequest.of(0, 10));

    // 연관 종목 ex
    Map<String, String> similarStocks = Map.of(
        "090710", "056080",  
        "027040", "080220",  
        "466100", "056080",  
        "452450", "108860"  
    );

    List<Map<String, String>> recommendations = new ArrayList<>();

    for (Object[] stock : topStocks) {
        String isuCd = (String) stock[0];
        String isuNm = (String) stock[1];

        if (similarStocks.containsKey(isuCd)) {
            recommendations.add(Map.of(
                "추천 종목코드", similarStocks.get(isuCd),
                "추천 종목명", getStockName(similarStocks.get(isuCd)),
                "추천 이유", isuNm + "과 비슷한 매매 패턴을 보임"
            ));
        }
    }

    return recommendations;
}

private String getStockName(String isuCd) {
    // 종목 코드 → 종목명 매핑 (추후 DB 조회 가능)
    Map<String, String> stockNames = Map.of(
        "090710", "휴림로봇",
        "056080", "유진로봇",
        "027040", "서울전자통신",
        "080220", "제주반도체",
        "466100", "클로봇",
        "108860", "셀바스AI",
        "452450", "피아이이"
    );
    return stockNames.getOrDefault(isuCd, "알 수 없음");
}

}

* 엔드포인트 생성
```java
@GetMapping("/recommendations")
    public List<Map<String, String>> getRecommendations(){
        return RecommendationService.getRecommendedStocks();
    }

• 결과

4. 관심종목 저장 및 조회

• 사용자가 관심있는 종목을 선택해서 저장 엔드포인트 : /api/user/watchlist HTTP 메서드 : POST Req Body : {

    "userId": 1,
    "stockCode": "005930",
    "stockName": "삼성전자"

  } Res : {"message": "삼성전자 (005930) 관심 종목으로 저장 완료!"}

• 사용자 괌심종목 테이블 생성

  package com.example.personal_investor_trend.model;
  

import jakarta.persistence.*; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter;

@Entity @Getter @Setter @NoArgsConstructor @Table(name = "user_watchlist") public class UserWatchlist {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private Long userId;  // 사용자 ID
private String stockCode;  // 종목 코드
private String stockName;  // 종목명

}

* Repository 생성
```java
package com.example.personal_investor_trend.repository;

import com.example.personal_investor_trend.model.UserWatchlist;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserWatchlistRepository extends JpaRepository<UserWatchlist, Long> {
    List<UserWatchlist> findByUserId(Long userId);
}

• Service 생성

  package com.example.personal_investor_trend.service;
  

import com.example.personal_investor_trend.model.UserWatchlist; import com.example.personal_investor_trend.repository.UserWatchlistRepository; import org.springframework.stereotype.Service;

import java.util.List;

@Service public class UserWatchlistService {

private final UserWatchlistRepository repository;

public UserWatchlistService(UserWatchlistRepository repository) {
    this.repository = repository;
}

public UserWatchlist addWatchlist(Long userId, String stockCode, String stockName) {
    UserWatchlist watchlist = new UserWatchlist();
    watchlist.setUserId(userId);
    watchlist.setStockCode(stockCode);
    watchlist.setStockName(stockName);
    return repository.save(watchlist);
}

public List<UserWatchlist> getUserWatchlist(Long userId) {
    return repository.findByUserId(userId);
}

}

*  Controller 생성
```java
package com.example.personal_investor_trend.controller;

import com.example.personal_investor_trend.model.UserWatchlist;
import com.example.personal_investor_trend.service.UserWatchlistService;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/user")
public class UserController {

    private final UserWatchlistService watchlistService;

    public UserController(UserWatchlistService watchlistService) {
        this.watchlistService = watchlistService;
    }

    // 관심 종목 저장 (POST)
    @PostMapping("/watchlist")
    public Map<String, String> addWatchlist(@RequestBody Map<String, String> request) {
        Long userId = Long.parseLong(request.get("userId"));
        String stockCode = request.get("stockCode");
        String stockName = request.get("stockName");

        watchlistService.addWatchlist(userId, stockCode, stockName);
        return Map.of("message", stockName + " (" + stockCode + ") 관심 종목으로 저장 완료!");
    }

    // 사용자의 관심 종목 조회 (GET)
    @GetMapping("/watchlist")
    public List<UserWatchlist> getUserWatchlist(@RequestParam Long userId) {
        return watchlistService.getUserWatchlist(userId);
    }
}

• 결과

  • 관심종목 저장

* 데이터 적재
![](https://velog.velcdn.com/images/baby_potato/post/fcaa9836-eed0-4ca2-872c-55a7f7a94220/image.png)

* 관심종목 조회
![](https://velog.velcdn.com/images/baby_potato/post/8950ad4f-bcaa-40d6-89b9-e8967585513e/image.png)

5. 사용자의 관심 종목 기반 뉴스 크롤링 - 웹크롤링 설정 필요

• 사용자의 관심 종목(user_watchlist 테이블)에서 stockCode 목록을 가져와 뉴스 크롤링 엔드포인트 : HTTP 메서드 : POST

• repository

  List<UserWatchlist> findStockCodeByUserId(Long userId);

• <pom.xml> - dependency 추가

  <dependency>
  <groupId>org.jsoup</groupId>
  <artifactId>jsoup</artifactId>
  <version>1.16.1</version>
  </dependency>

• <NewsService.java>

  package com.example.personal_investor_trend.service;
  

import com.example.personal_investor_trend.model.UserWatchList; import com.example.personal_investor_trend.repository.UserWatchListRepository; import org.jsoup.Jsoup; import org.jsoup.nodes.Document; import org.jsoup.nodes.Element; import org.jsoup.select.Elements; import org.springframework.stereotype.Service;

import java.io.IOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; import java.util.*;

@Service public class NewsService {

private final UserWatchListRepository watchlistRepository;

public NewsService(UserWatchListRepository watchlistRepository) {
    this.watchlistRepository = watchlistRepository;
}

public List<Map<String, Object>> getNewsForUser(Long userId) {
    List<UserWatchList> watchlist = watchlistRepository.findByUserId(userId);
    List<Map<String, Object>> newsData = new ArrayList<>();

    for (UserWatchList stock : watchlist) {
        String stockCode = stock.getStockCode();
        String stockName = stock.getStockName();

        List<Map<String, String>> newsList = getStockNews(stockName);

        newsData.add(Map.of("종목코드", stockCode, "종목명", stockName, "관련 뉴스", newsList));
    }

    return newsData;
}

// 크롤링 메서드
private List<Map<String, String>> getStockNews(String stockName) {
    List<Map<String, String>> newsList = new ArrayList<>();
    try {
        String encodedQuery = URLEncoder.encode(stockName, StandardCharsets.UTF_8);
        //네이버 뉴스 
        String url = "https://search.naver.com/search.naver?where=news&ie=utf8&sm=nws_hty&query=" + encodedQuery;

        Document doc = Jsoup.connect(url).get();
        Elements newsElements = doc.select(".list_news .news_area"); 

        for (Element news : newsElements) {
            Element titleElement = news.selectFirst(".news_tit"); //제목
            if (titleElement == null) continue;

            String title = titleElement.text();
            String link = titleElement.attr("href");

            newsList.add(Map.of("제목", title, "링크", link));

            if (newsList.size() >= 5) break; // 최대 5개 
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    return newsList;
}

}

* <NewsController.java>
```java
package com.example.personal_investor_trend.controller;

import com.example.personal_investor_trend.service.NewsService;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/user")
public class NewsController {

    private final NewsService newsService;

    public NewsController(NewsService newsService) {
        this.newsService = newsService;
    }

    // 사용자 관심 종목 뉴스 조회 
    @PostMapping("/news")
    public List<Map<String, Object>> getUserNews(@RequestBody Map<String, String> request) {
        Long userId = Long.parseLong(request.get("userId"));
        return newsService.getNewsForUser(userId);
    }
}

• 결과

끝

• 한국거래소(KRX)의 OpenAPI데이터를 활용해서 REST API 호출
• JSOUP -> 실시간 웹 크롤링 사용

위의 두가지를 제일 신경 쓴 간단한 프로젝트였다!

추후에 딥하게 들어간다면 실시간으로 주식 시세나 알림을 사용자에게 제공하고 AI기반으로 투자를 추천해준다거나 더 많은 공공데이터를 함께 사용해서 종목에 대한 분석을 강화할 수 있지 않을까?!

개발 중인 프로젝트에서 로그인 권한별로 기능을 제한하기로 했다.(당연한 기능이긴 함)

FastAPI를 사용하여 토큰 기반으로 사용자의 권한을 체크하고 특정 권한만 삭제, 수정 등이 가능하도록 구현하기로 했다.

Solve

1. 클라이언트 -> 서버

• 사용자는 로그인 후 서버에서 발급한 token 을 쿠키에 저장하고 API요청 시 쿠키를 포함하여 요청을 보냄

2. 서버-> 토큰인증

• request.cookies.get("token") 을 사용해 쿠키에서 토큰을 가져옴.
• util_authentication.authentication("/clsf/delete", token) 을 호출해 토큰을 검증하고 사용자 정보(userId, role)를 추출.

3. Role 확인 후 기능 제한

• <util_authentication.py> -> JWT토큰을 디코딩해서 사용자 정보 추출 코드 -> JWT 토큰을 HS256 알고리즘을 사용하여 검증

  import os
  from typing import Any, Dict, Optional, Union
  import jwt
  from fastapi_base.web.response_base import Result, SodaflowResponseBase
  

ENV_EMAIl 을 가져오는데 없다면 aaa@gmail.com로

ENV_EMAIl = os.getenv('ENV_EMAIl', 'aaa@gmail.com') ENV_EMAIL_ENCODE = ENV_EMAIl.encode() #util_authentication.ENV_EMAIl.encode() ALGORITHM = "HS256"

checkedRole = [ { 'endpoint': "/clsf/delete/", 'roles': ['000', '001', '002'] }, ]

def authentication( endpoint: str, token: Optional[str] ) -> Union[SodaflowResponseBase[None], SodaflowResponseBase[Dict[str, Any]]]: failed_result = SodaflowResponseBase[None]( data=None, result=Result(code=-1, message="Permission is denied.") ) if token is None: return failed_result

data: Dict[str, Any] = jwt.decode(
    token, ENV_EMAIL_ENCODE, algorithms=[ALGORITHM]
)

# checkedRole 리스트를 순회하여 endpoint 찾기
for role in checkedRole:
    if role["endpoint"] == endpoint:
        # endpoint가 일치하면 roles 배열 안에 data['role']이 있는지 확인
        if data["role"] in role["roles"]:
            return SodaflowResponseBase(
                data=data,
                result=Result(
                    code=0, message="Authentication successful."
                ),
            )

return failed_result

### 4. 제한 조건 만족 시 기능 실행
* delete_clsf_service() 호출
![](https://velog.velcdn.com/images/baby_potato/post/b60061c9-313e-4a13-b7c3-0768b5ada3f9/image.png)

자바 메모리 구조

자바의 메모리 구조는 크게 메서드 영역, 스택 영역, 힙 영역 3개로 나눌 수 있다.

• 메서드 영역 : 클래스정보를 보관 (붕어빵 틀)
• 스택 영역 : 실제 프로그램이 실행되는 영역, 메서드를 실행할 때마다 하나씩 쌓인다.
• 힙 영역 : 객체(인스턴스)가 생성되는 영역, new 명령어를 사용(생성된 붕어빵이 존재하는 공간)

• 메서드 영역 : 메서드 영역은 프로그램을 실행하는데 필요한 공통 데이터를 관리한다. 이 영역은 프로그램의 모든 영역에서 공유한다.
  • 클래스 정보: 클래스의 실행 코드(바이트 코드), 필드, 메서드와 생성자 코드등 모든 실행코드가 존재
  • static 영역: static 변수들을 보관.
  • 런타임 상수 풀: 프로그램을 실행하는데 필요한 공통 리터럴 상수를 보관. 예를 들어서 프로그램에 "hello" 라는 리터럴 문자가 있으면 이런 문자를 공통으로 묶어서 관리한다. 이 외에도 프로그램을 효율적으로 관리하기 위한 상수들을 관리한다. (참고로 문자열을 다루는 문자열 풀은 자바 7부터 힙 영역으로 이동했다.)
• 스택 영역 : 자바 실행 시, 하나의 실행 스택이 생성된다. 각 스택 프레임은 지역 변수, 중간 연산 결과, 메서드 호출 정보 등을 포함한다.
  • 스택 프레임: 스택 영역에 쌓이는 네모 박스가 하나의 스택 프레임이다. 메서드를 호출할 때 마다 하나의 스택 프레임이 쌓이고, 메서드가 종료되면 해당 스택 프레임이 제거됨.
• 힙 영역 : 객체(인스턴스)와 배열이 생성되는 영역이다. 가비지 컬렉션(GC)이 이루어지는 주요 영역이며, 더 이상 참조되지 않는 객체는 GC에 의해 제거된다.

스택과 큐 자료구조

• 후입 선출(LIFO, Last In First Out) : 여기서 가장 마지막에 넣은 3번이 가장 먼저 나온다. 이렇게 나중에 넣은 것이 가장 먼저 나오는 것을 후입 선출이라 하고, 이런 자료 구조를 스택이라 한다.
• 선입 선출(FIFO, First In First Out) : 후입 선출과 반대로 가장 먼저 넣은 것이 가장 먼저 나오는 것을 선입 선출이라 한다. 이런 자료 구조를 큐(Queue)라고 한다.

스택영역

<JavaMemoryMain1.java>

package memory;

public class JavaMemoryMain1 {
    public static void main(String[] args) {
        System.out.println("main start");
        method1(10);
        System.out.println("main end");
    }
    static void method1(int m1){
        System.out.println("method1 start");
        int cal = m1 * 2 ;
        method2(cal);
        System.out.println("method1 end");
    }
    static void method2(int m2){
        System.out.println("method2 start");
        System.out.println("method2 end");
    }

}

-> 스택 구조

• 자바는 스택 영역을 사용해서 메서드 호출과 지역 변수(매개변수 포함)를 관리한다.

• 메서드를 계속 호출하면 스택 프레임이 계속 쌓인다.
• 지역 변수(매개변수 포함)는 스택 영역에서 관리한다.
• 스택 프레임이 종료되면 지역 변수도 함께 제거된다.
• 스택 프레임이 모두 제거되면 프로그램도 종료된다.

스택 영역과 힙 영역

<Data.java>

package memory;

public class Data {
    private int value;

    public Data(int value){
        this.value = value;
    }
    public int getValue(){
        return value;
    }
}

<JavaMemoryMain2.java>

package memory;

public class JavaMemoryMain2 {
    public static void main(String[] args) {
        System.out.println("main start");
        method1();
        System.out.println("main end");
    }
    static void method1(){
        System.out.println("method1 start");
        Data data1 = new Data(10);
        method2(data1);
        System.out.println("method1 end");
    }
    static void method2(Data data2){
        System.out.println("method2 start");
        System.out.println("data.value = "+ data2.getValue());
        System.out.println("method2 end");
    }

}

• method1에서 Data 클래스의 인스턴스 생성
• method1() 에서 method2() 를 호출할 때 매개변수에 Data 인스턴스의 참조값을 전달
• method1() 은 지역 변수로 Data data1 을 가지고 있다. 이 지역 변수도 스택 프레임에 포함된다.
• method1() 은 new Data(10) 를 사용해서 힙 영역에 Data 인스턴스를 생성한다. 그리고 참조값을 data1에 보관한다.
• method1() 은 method2() 를 호출하면서 Data data2 매개변수에 x001 참조값을 넘긴다.
• 이제 method1() 에 있는 data1 과 method2() 에 있는 data2 지역 변수(매개변수 포함)는 둘다 같은 x001 인스턴스를 참조한다.

지역 변수는 스택 영역에, 객체(인스턴스)는 힙 영역에 관리되는 것을 확인했다. 이제 나머지 하나가 남았다. 바로 메서드 영역이다. 메서드 영역이 관리하는 변수도 있다. 이것을 이해하기 위해서는 먼저 static 키워드를 알아야 한다. static 키워드는 메서드 영역과 밀접한 연관이 있다.

static 변수1

생성된 데이터들의 갯수세기

인스턴스 내부 변수에 카운트 저장

<Data1.java>

package static1;

public class Data1 {
    public String name;
    public int count;

    public Data1(String name){
        this.name = name;
        count++;
    }
}

<DataCountMain1.java>

package static1;

public class DataCountMain1 {
    public static void main(String[] args) {
        Data1 data1 = new Data1("A");
        System.out.println("A count=" + data1.count);

        Data1 data2 = new Data1("B");
        System.out.println("B count=" + data2.count);

        Data1 data3 = new Data1("C");
        System.out.println("C count=" + data3.count);
    }
}

-> 이 프로그램은 당연히 기대한 대로 작동하지 않는다. 객체를 생성할 때 마다 Data1 인스턴스는 새로 만들어진다. 그리고 인스턴스에 포함된 count 변수도 새로 만들어지기 때문이다.(count 는 계속 초기화된다.) =>인스턴스에 사용되는 멤버 변수 count 값은 인스턴스끼리 서로 공유되지 않는다. 따라서 원하는 답을 구할 수 없다. 이 문제를 해결하려면 변수를 서로 공유해야 한다.

외부 인스턴스에 카운트 저장

<Counter.java>

package static1;

public class Counter {
    public int count;
}

<Data2.java>

package static1;

public class Data2 {
    public String name;

    public Data2(String name, Counter counter){
        this.name=name;
        counter.count++;
    }
}

<DataCountMain2.java>

package static1;

public class DataCountMain2 {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Data2 data1 = new Data2("A",counter);
        System.out.println("A count="+ counter.count);

        Data2 data2 = new Data2("B",counter);
        System.out.println("B count="+ counter.count);

        Data2 data3 = new Data2("C",counter);
        System.out.println("C count="+ counter.count);
    }
}

-> Data2의 인스턴스는 3개가 생성 => 하지만 Data2 클래스와 관련된 일인데, Counter 라는 별도의 클래스를 추가로 사용해야 하고, 생성자 매개변수 추가로 생성자와 생성자 호출부분이 복잡해진다. => 외부의 도움을 받지 않는 방법?(Counter 메서드를 따로 만들지 않는 법?) =static

static 변수2

특정 클래스에서 공용으로 함께 사용할 수 있는 변수를 만들 수 있다면 편리할 것이다. static 키워드를 사용하면 공용으로 함께 사용하는 변수를 만들 수 있다. <Data3.java>

package static1;

public class Data3 {
    public String name;
    public static int count;

    public Data3(String name){
        this.name = name;
        count++;
    }
}

멤버 변수에 static 을 붙이면 static변수, 정적변수 또는 클래스변수라 한다.

• 객체가 생성되면 생성자에서 정적 변수 count 의 값을 하나 증가시킨다.

<DataCountMain3.java>

package static1;

public class DataCountMain3 {
    public static void main(String[] args) {
        Data3 data1 = new Data3("A");
        System.out.println("A count="+ Data3.count);

        Data3 data2 = new Data3("B");
        System.out.println("B count="+ Data3.count);

        Data3 data3 = new Data3("C");
        System.out.println("C count="+ Data3.count);
    }
}

-> Data3.count 는 마치 클래스에 직접 접근하는 것 처럼 느껴짐

• static 이 붙은 멤버 변수는 메서드 영역에서 관리한다. static 이 붙은 멤버 변수 count 는 인스턴스 영역에 생성되지 않는다. 대신에 메서드 영역에서 이 변수를 관리한다.
• Data3("A") 인스턴스를 생성하면 생성자가 호출된다.
• 생성자에는 count++ 코드가 있다. count 는 static 이 붙은 정적 변수다. 정적 변수는 인스턴스 영역이 아니라 메서드 영역에서 관리한다. 따라서 이 경우 메서드 영역에 있는 count 의 값이 하나 증가된다.

=>static 변수는 쉽게 이야기해서 클래스인 붕어빵 틀이 특별히 관리하는 변수이다. 붕어빵 틀은 1개이므로 클래스 변수도 하나만 존재한다. 반면에 인스턴스 변수는 붕어빵인 인스턴스의 수 만큼 존재한다.

static 변수 3

public class Data3 {
    public String name;
    public static int count;

    public Data3(String name){
        this.name = name;
        count++;
    }
}

• name.count -> 멤버변수(필드)

멤버변수는 static의 유무로 두가지로 나뉨

• 인스턴스 변수 : static이 붙지 않은 변수 예)name
  • static 이 붙지 않은 멤버 변수는 인스턴스를 생성해야 사용할 수 있고, 인스턴스에 소속되어 있다. 따라서 인스턴스 변수라 한다.
  • 인스턴스 변수는 인스턴스를 만들 때 마다 새로 만들어진다.
• 클래스 변수 : static 이 붙은 멤버 변수, 예) count
  • 클래스 변수, 정적 변수, static 변수 등으로 부른다. 용어를 모두 사용하니 주의하자!
  • static 이 붙은 멤버 변수는 인스턴스와 무관하게 클래스에 바로 접근해서 사용할 수 있고, 클래스 자체에 소속되어 있다. 따라서 클래스 변수라 한다.
  • 클래스 변수는 자바 프로그램을 시작할 때 딱 1개가 만들어진다. 인스턴스와는 다르게 보통 여러곳에서 공유하는 목적으로 사용된다.

변수와 생명주기

• 지역변수 : 스택영역에 생성, 메서드가 종료되면 스택 프레임이 제거되면서 지역변수도 같이 제거
• 인스턴스 변수 : 힙 영역에 생성, GC가 발생하기 전까지만 생존
• 클래스 변수 : 메서드 영역에 생성, JVM 이 종료되기 전까지 생존

static 은 정적변수다. 왜냐하면 인스턴스변수는 힙영역에서 동적으로 제거되고 생성되지만 static은 프로그램이 시작하면서 종료될때까지 존재하기 때문이다.

정적변수 접근법

static 변수는 클래스를 통해 바로 접근할 수도 있고, 인스턴스를 통해서도 접근할 수 있다.

<DataCountMain3.java>

package static1;

public class DataCountMain3 {
    public static void main(String[] args) {
        Data3 data1 = new Data3("A");
        System.out.println("A count="+ Data3.count);

        Data3 data2 = new Data3("B");
        System.out.println("B count="+ Data3.count);

        Data3 data3 = new Data3("C");
        System.out.println("C count="+ Data3.count);

        //추가
        //인스턴스를 통한 접근
        Data3 data4 = new Data3("D");
        System.out.println(data4.count);

        //클래스를 통한 접근
        System.out.println(Data3.count);
    }
}

인스턴스를 통한 접근은 권장하지 않는다. 왜냐? 가져다 쓰는 입장에서 data4.count는 인스턴스변수인가? 하는 의문이 들 수 있지만 Data3.count는 누가봐도 static 이네!가 가능해서..

static 메서드1

인스턴스 메서드

<DecoUtil1.java>

package static2;

public class DecoUtil1 {
    public String deco(String str){ //deco 메서드는 멤버변수도 없고 단순히 기능만 제공
        String result = "*" + str + "*";
        return result;
    }
}

<DecoMain1.java>

package static2;

public class DecoMain1 {
    public static void main(String[] args) {
        String s = "hello JAVA";

        DecoUtil1 utils = new DecoUtil1();
        String deco = utils.deco(s);

        System.out.println("before: "+s);
        System.out.println("after: "+deco);

    }
}

위의 코드에서 deco() 메서드는 멤버변수도 없고 기능만 제공하는 메서드이다. 그런데 굳이 Main 코드에서 정의하고 호출까지 해야할까?

static 메서드

<DecoUtil2.java>

package static2;

public class DecoUtil2 {
    public static String deco(String str){ //정적 메서드 : 인스턴스 생성 없이 클래스로 바로 호출 가능
        String result = "*" + str + "*";
        return result;
    }
}

<DecoMain2.java>

package static2;

public class DecoMain2 {
    public static void main(String[] args) {
        String s = "hello JAVA";

        String deco = DecoUtil2.deco(s); //static 때문에 바로 호출 가능

        System.out.println("before: "+s);
        System.out.println("after: "+deco);

    }
}

메서드에 static이 붙음으로써 정적메서드가 된다. 이렇게 하면 인스턴스 생성없이 클래스명으로 바로 호출이 가능하다. -> 불필요한 객체생성이 없어짐

• static이 붙은 메서드를 정적 메서드 or 클래스메서드라 한다.
• static이 붙지 않은 메서드는 인스턴스 메서드

static메서드2

정적메서드 사용법

• static은 static만 사용가능
  • 정적 메서드는 static이 붙은 정적메서드나 정적변수만 사용할 수 있다.
  • 인스턴스는 불가능
• static은 어느곳에서도 호출이 가능

<DecoData.java>

package static2;

public class DecoData {
    private int instanceValue;
    private static int staticValue;

    public static void staticCall(){
//        instanceValue ++; // 인스턴스 변수 접근 - 불가능
//        instanceMethod(); // 인스턴스 메서드 접근 - 불가능

        staticValue++; //정적 변수에 접근, 호출 가능
        staticMethod();

        //static 은 static만 호출가능
    }

    public void instanceCall(){
        instanceValue++;
        instanceMethod();

        staticValue++;
        staticMethod();

        //instance는 instance, static 호출가능
    }

    public static void staticCall(DecoData data){
        data.instanceValue++;
        data.instanceMethod();
        //static에서 instance 호출 가능하지만 여기 있는 data는 외부에 생긴 새로운 참조값
    }

    private void instanceMethod(){
        System.out.println("instanceValue=" + instanceValue);
    }
    private static void staticMethod(){
        System.out.println("staticValue=" + staticValue);
    }
}

<DecoDataMain.java>

package static2;

public class DecoDataMain {
    public static void main(String[] args) {
        System.out.println("1.정적 호출");
        DecoData.staticCall();

        System.out.println("2.인스턴스 호출-인스턴스");
        DecoData decoData = new DecoData();
        decoData.instanceCall();

        System.out.println("3.인스턴스 호출-정적");
        DecoData.staticCall();

        System.out.println("3.정적 호출-외부참조");
        DecoData.staticCall(decoData);
    }
}

• 정적-> 정적 => 정적 메서드는 클래스 이름을 통해 바로 호출, 인스턴스처럼 참조값이 존재하지 않는다. BUT 객체의 참조값을 매개변수로 전달하면 인스턴스 호출 가능(외부에서 참조값을 생성하기때문에..ex.3.정적 호출-외부참조)
• 인스턴스 -> 정적 & 인스턴스

static메서드3

용어 정리

• 인스턴스 메서드: static이 붙지 않은 메서드
• 클래스 메서드: static이 붙은 메서드 - 정적메서드, static메서드 등으로 불림

정적 메서드 활용

객체 생성이 필요 없이 메서드 호출만으로 필요한 기능을 수행할 때 사용, 유틸리티성 메서드

정적메서드 접근법

둘다 결과적으로는 정적 메서드에 접근하지만 위의 것은 코드를 읽을 때 마치 인스턴스메서드에 접근하는 것처럼 오해 할 수 있음

static import

정적메서드를 자주 사용한다면 import 기능 사용 Alt+Enter

import static static2.DecoData.*; // 모든 정적메서드에 적용

main() 메서드는 정적메서드

정적메서드인 main()메서드가 같은 클래스에서 호출하는 메서드도 정적메서드로 선언해야함.

package static2;

import oop1.ValueData;

public class ValueDataMain {
    public static void main(String[] args) { //static이기 때문에
        ValueData valueData = new ValueData();
        add(valueData);
    }
    static void add(ValueData valueData) {//static 으로 선언
        valueData.value++;
        System.out.println("숫자 증가 value=" + valueData.value);
    }
}

final

final 변수와 상수1

final은 이름 그대로 끝! 이라는 뜻, 변경이 불가능

package final1;

public class FinalLocalMain {
    public static void main(String[] args) {
        //final 지역변수
        final int data1;
        data1 = 10; //최초 한번만 할당 가능
//        data2 = 20; //컴파일 오류

        //final 지역변수2
        final int data2=10;
//        data2 =20;//컴파일 오류

        method(10);
    }
    static void method(final int parameter){
//        parameter = 10; //컴파일 오류 , 메서드 내에서 매개변수를 줄 수 없다.

    }
}

• final 을 지역변수에 설정할 경우 최초 한번만 할당 가능
• 매개변수에 final이 붙으면 메서드 내부에서 매개변수의 값을 변경할 수 없다.

package final1;

public class ConstructInit {
    final int value; // 이것만 하면 에러 남 -> 아래처럼 생성자를 통해서 넣어야함

    public ConstructInit(int value){
        this.value = value;
    }
}

• final을 필드에 사용하면 해당 필드는 생성자를 통해서 한번만 초기화 될 수 있다.

package final1;

public class FieldInit {
    static final int CONST_VALUE = 10; //static final 대문자 -> 관례

//    final int value = 10; // 초기 값을  경우에는 아래처럼 생성자를 통해서 할당이 불가
//    public FieldInit(int value){
//        this.value = value;
//    }

    final int value = 10;

}

• final 필드를 필드에서 초기화하면 이미 값이 설정되었기 때문에 생성자를 통해서도 초기화 할 수 없다

이유는.. 기존에 api 는 http 호출이었는데 갑자기 https 호출을 한다는것 ..!

Https는 데이터 전송에 암호화가 걸리는 것이기 때문에 생각보다 고려해야할 게 너무 많아서 오래 걸렸다..

간단하게 작업을 나열하자면

1. SSL/TLS 인증서 발급 및 설정 서버에 인증서 받기 -> 이부분은 고객사와 서버관리팀에 요청해서 발급받고 설정할 수 있었다.
2. 그 외 설정
   • 포트 변경 기존에 9100포트를 사용하였지만 보안 포트인 443 포트로 변경
   • kubenetes ingress
     도메인 설정 서비스 연결 SSL/TLS 설정 등
   • 인터페이스 설정 SSL/TLS 설정 port, ip 변경 소스 수정 등

1. SSL/TLS 인증서

(.key 파일 없고 .pem 파일만 있을 때) A. .key파일 생성

openssl rsa -in key.pem -out cert.key

B. 도메인에 대하여 인증서 등록

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ./tls/project-https-secret/tls.key -out ./tls/project-https-secret/tls.crt -subj 도메인명

C. k8s 에서 인증서를 사용할 수 있도록 생성

kubectl -n project명 create secret tls twinreader-https --key ./tls/project-https-secret/tls.key --cert ./tls/project-https-secret/tls.crt

D. nginx.yaml 에서 사용할 https port 선언(예시) 및 재기동

spec:
  type: NodePort
  externalIPs:
    - IP입력
  ports:
    - name: http
      port: 8080
      protocol: TCP
      targetPort: 80
    - name: https
      port: 443
      protocol: TCP
      targetPort: 443

E. ingress.yaml 설정 가지고 있는 ingress 폴더에 하위에 생성한 secret 선언

2. 그 외 설정

A. 인터페이스 SSL/TLS 설정 Keystore.p12생성 tls 디렉토리 접근 후

openssl pkcs12 -export -in /home/agilesoda/install/config/nginx/tls/twinreader-https-secret/tls.crt -inkey /home/agilesoda/install/config/nginx/tls/twinreader-https-secret/tls.key -out keystore.p12 -name tomcat

생성된 keystore.p12를 인터페이스에 적용 <application.properties>

server.ssl.key-store=/keystore.p12
server.ssl.key-store-type=PKCS12
server.ssl.key-store-password=패스워드

그리고 나는 도커로 말아서 올릴거니까 Dockerfile 에

ADD /install/keystore.p12 keystore.p12

이거 추가

그리고그리고 Kubernetes 클러스터에 배포하기 위한 deployment.yaml 수정

ports:
  - name: https
    protocol: TCP
    #appProtocol: https
    port: 443
    targetPort: 9000
  - name: http
    protocol: TCP
    port: 9100
    targetPort: 9100

B. 개발 소스 수정 org.apache.coyote.http11.Http11NioProtocol"을 사용하여 HTTP/1.1 NIO 프로토콜을 지정하고 커넥터가 사용하는 포트를 9100 으로 설정..

@Configuration
  public class TomcatConfig {

    @Bean
    public ServletWebServerFactory servletContainer() {
      TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
      tomcat.addAdditionalTomcatConnectors(createStandardConnector());
      return tomcat;
    }

    private Connector createStandardConnector() {
      Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
      connector.setPort(9100);
      return connector;
    }
  }

C. Ingress 설정 클러스터 외부에서 내부 서비스로 HTTP 및 HTTPS 경로를 라우팅하는 규칙을 설정 <project-pension-ingress.yaml>

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: project
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/secure-backends: "true"
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
    #nginx.ingress.kubernetes.io/rewrite-target: /$2
    nginx.ingress.kubernetes.io/cors-allow-methods: "GET,POST"
spec:
  tls:
  - hosts:
    - "도메인명"
    secretName: twinreader-https
  rules:
  - host: "도메인명"
    http:
      paths:
      - path: /api/v1/aiocrSyncLoad(/|$)(.*)
        backend:
          serviceName: project
          servicePort: 443

yaml 파일 수정후 반영(kubectl delete, apply..)

이슈요약..

처음엔 인증서만 받아서 보안포트 사용하면 되는거겟지~ 했는데 우선 인증서 발급과 반영에 대해 무지해서 도움을 많이 받았다.

인증서 적용 후 내 인터페이스의 POST 방식의 호출만 호출이 안되어서 그부분도 확인해보니 redirect 가 이상한 곳으로 가길래 ingress.yaml 의 rewrite 부분을 그냥 주석 해버렸더니 해결 되었었다. 해당 에러는

Resolved [org.springframework.web.HttpRequestMethodNotSupportedException: Request method 'POST' not supported]

이렇게 생겼었고

#logging.level.org.springframework=debug
#logging.level.org.springframework.web=debug
#logging.level.org.springframework.web.servlet.DispatcherServlet=DEBUG

해당 설정값을 추가해 자세히 로그를 보니 알 수 있었다.

다음으론 인터페이스 내부였다.. 인터페이스 내부에는 회사 제품을 호출하고 결과를 받아서 그결과를 보정한 후 전달하게 되는데 https로 들어와서 제품 호출하고 제품에서 http 로 다시 인터페이스를 콜백하는데 그 통신이 안되는것이었다.. 그래서 인터페이스 deployment.yaml 을 보면 https 와 http 포트를 구분지어서 통신에따라 다르게 들어오게 처리 해줬다! 이런식으로 port 가 두개!

느낀점

그.. k8s 버전도 중요.. 꼭 버전에 맞는걸로 테스트 해보시길.. 버전마다 안되는 설정값이 있어서 이것도 애먹었다...

이제 앞으로는 처음 개발 시에 통신에 대해 정하고 시작하기로 다짐했다. 물론 당연히 데이터가 주고받는일에 단순히 내부통신이라고 보안을 생각못한 내잘 못도 있지만.. 같이 테스트 하고 컨펌해줬으면서 갑자기 바꾸는 갈대 같은 고객사는... 어쩔 수 없지 뭐....

아직도 서버는 잘 모르겠지만...이렇게 틈틈이 접하다보면 괜찮아지겟지?

패키지 시작

기능이 점점 추가되어서 프로그램이 아주 커진다면? -> 매우 많은 클래스가 등장하면서 관련있는 기능들을 분류해서 관리해야한다.

패키지 = 폴더, 디렉토리

패키지 사용

<pack.Data.java>

package pack;

public class Data {
    public Data(){
        System.out.println("패키지 pack Data 생성");
    }
}

• 패키지 사용 시 항상 코드 첫줄에 package packageName을 작성

<pack.a.User.java>

package pack.a;

public class User {
    public User(){
        System.out.println("패키지 pack.a 회원 생성");
    }
}

참고 : 생성자에 public 사용 -> 다른 패키지에서 이 클래스의 생성자를 호출하려면 public을 사용해야한다.

<PackageMain1.java>

package pack;

public class PackageMain1 {
    public static void main(String[] args) {
        Data data = new Data();
        pack.a.User user = new pack.a.User();

    }
}

<결과>

import

<PackageMain2.java>

package pack;
import pack.a.User;

public class PackageMain2 {
    public static void main(String[] args) {
        Data data = new Data();
        User user = new User(); //import 사용으로 패키지명 생략가능

    }
}

• 코드 첫줄에는 package, 다음줄에는 import 사용
• import 를 사용하면 다른 패키지에 있는 클래스를 가져와서 사용가능
• 특정 패키지의 모든 클래스를 포함하고 싶다면 "*"을 사용

패키지(*) 사용

package pack;
//import pack.a.User;
import pack.a.*; //pack.a의 모든 클래스 사용
public class PackageMain2 {
    public static void main(String[] args) {
        Data data = new Data();
        User user = new User(); //import 사용으로 패키지명 생략가능

    }
}

클래스 이름 중복

<pack.b.User.java>

package pack.b;

public class User {
    public User() {
        System.out.println("패키지 pack.b 회원 생성");
    }
}

<PackageMain3.java>

package pack;
//import pack.a.User;

import pack.a.User;

public class PackageMain3 {
    public static void main(String[] args) {
        User userA = new User(); //import 사용으로 패키지명 생략가능
        pack.b.User userB = new pack.b.User();
    }
}

=> 같은 이름의 클래스가 있다면 import는 둘중 하나만 선택할 수 있다. 이때는 자주 사용하는 클래스를 import 하고 나머지를 패키지를 포함한 전체 경로를 적어준다. 물론 둘다 전체 경로를 적어준다면 import 는 사용하지 않아도 됨

패키지 규칙

• 패키지의 이름과 위치는 폴더(디렉토리) 위치와 같아야 한다. (필수)
• 패키지 이름은 모두 소문자를 사용한다. (관례)
• 패키지 이름의 앞 부분에는 일반적으로 회사의 도메인 이름을 거꾸로 사용한다. 예를 들어, com.company.myapp 과 같이 사용한다. (관례)

패키지와 계층구조

a , a.b , a.c 이렇게 3개의 패키지가 존재한다. 패키지가 계층 구조를 이루더라도 모든 패키지는 서로 다른 패키지이다.

패키지 활용

전체구조도

<com.helloshop.user.User.java>

package com.helloshop.user;

public class User {
    String userId;
    String name;

}

<com.helloshop.user.UserService.java>

package com.helloshop.user;

public class UserService {
}

<com.helloshop.product.Product.java>

package com.helloshop.product;

public class Product {
    String productId;
    int price;
}

<com.helloshop.product.ProductService.java>

package com.helloshop.product;

public class ProductService {
}

<com.helloshop.order.Order.java>

package com.helloshop.order;
import com.helloshop.product.Product;
import com.helloshop.user.User;
public class Order {
    User user;
    Product product;

    public Order(User user, Product product){
        this.user = user;
        this.product=product;
    }
}

=> public Order(User user, Product product)에서 public : 접근제어자 -> public이 있어야 다른 패키지에서 order를 호출할 수 있다. <com.helloshop.order.OrderService.java>

package com.helloshop.order;
import com.helloshop.product.Product;
import com.helloshop.user.User;

public class OrderService {
    public void order(){
        User user =new User();
        Product product = new Product();
        Order order = new Order(user, product);
    }
}

접근제어자

자바는 public, private 같은 접근 제어자(access modifier) 를 제공한다. 접근 제어자를 사용하면 해당 클래스 외부에서 특정 필드나 메서드에 접근하는것을 허용하거나 제항 할 수 있다.

<Speaker.java>

package access;

public class Speaker {
    int volume;

    Speaker(int volume){
        this.volume = volume;
    }
    void volumeUp(){
        if(volume>=100){
            System.out.println("음량을 증가할 수 없습니다. 최대 음량입니다.");
        }else {
            volume+=10;
            System.out.println("음량을 10 증가합니다.");
        }
    }
    void volumeDown(){
        volume-=10;
        System.out.println("음량을 10 감소합니다.");
    }
    void showVolume(){
        System.out.println("현재 음량: "+ volume);
    }
}

<SpeakerMain.java>

package access;

public class SpeakerMain {
    public static void main(String[] args) {
        Speaker speaker = new Speaker(90);

        speaker.showVolume();

        speaker.volumeUp();
        speaker.showVolume();

        speaker.volumeUp();
        speaker.showVolume();
    }
}

<결과>

소리를 더 올리고 싶은 새로운 개발자는 max 를 200으로 올렸다가 제품이 고장나게 된다. volume 필드 직접 접근해서 수정 했다

<SpeakerMain.java>

package access;

public class SpeakerMain {
    public static void main(String[] args) {
        Speaker speaker = new Speaker(90);

        speaker.showVolume();

        speaker.volumeUp();
        speaker.showVolume();

        speaker.volumeUp();
        speaker.showVolume();

        //필드에 직접 접근
        System.out.println("volume 필드 직접 접근");
        speaker.volume = 200;
        speaker.showVolume();
    }
}

<결과>

why? Speaker 객체를 사용하는 사용자는 Speaker 의 volume 필드와 메서드에 모두 접근할 수 있다. -> 앞서 volumeUp() 과 같은 메서드를 만들어서 음량이 100을 넘지 못하도록 기능을 개발했지만 소용이 없다. 왜냐하면 Speaker 를 사용하는 입장에서는 volume 필드에 직접 접근해서 원하는 값을 설정할 수 있기 때문이다. => volume 필드의 외부 접근을 막아야한다.

<Speaker.java>

package access;

public class Speaker {
    private int volume; //private 사용

    Speaker(int volume){
        this.volume = volume;
    }
    void volumeUp(){
        if(volume>=100){
            System.out.println("음량을 증가할 수 없습니다. 최대 음량입니다.");
        }else {
            volume+=10;
            System.out.println("음량을 10 증가합니다.");
        }
    }
    void volumeDown(){
        volume-=10;
        System.out.println("음량을 10 감소합니다.");
    }
    void showVolume(){
        System.out.println("현재 음량: "+ volume);
    }
}

=> private 접근 제어자는 모든 외부 호출을 막는다. 따라서 private 이 붙은 경우 해당 클래스 내부에서만 호출할 수 있다.

좋은 프로그램은 무한한 자유도가 주어지는 프로그램이 아니라 적절한 제약을 제공하는 프로그램이다.

접근제어자 종류

• private : 모든 외부 호출을 막는다.

• default (package-private): 같은 패키지안에서 호출은 허용한다.

• protected : 같은 패키지안에서 호출은 허용한다. 패키지가 달라도 상속 관계의 호출은 허용한다.

• public : 모든 외부 호출을 허용한다

• 순서대로 private 이 가장 많이 차단하고, public 이 가장 많이 허용한다. private -> default -> protected -> public

package-private

• 접근 제어자를 명시하지 않으면 같은 패키지 안에서 호출을 허용하는 default 접근 제어자가 적용
• 동일한 패키지 내의 다른 클래스에서만 접근이 가능

접근제어자 사용위치

접근 제어자는 필드와 메서드, 생성자에 사용된다. 추가로 클래스 레벨에도 일부 접근 제어자를 사용할 수 있다..

예시

public class Speaker { //클래스 레벨
 private int volume; //필드
 public Speaker(int volume) {} //생성자
 public void volumeUp() {} //메서드
 public void volumeDown() {}
 public void showVolume() {}
}

접근 제어자의 핵심은 속성과 기능을 외부로부터 숨기는 것

• private 은 나의 클래스 안으로 속성과 기능을 숨길 때 사용, 외부 클래스에서 해당 기능을 호출할 수 없다.
• default 는 나의 패키지 안으로 속성과 기능을 숨길 때 사용, 외부 패키지에서 해당 기능을 호출할 수 없다.
• protected 는 상속 관계로 속성과 기능을 숨길 때 사용, 상속 관계가 아닌 곳에서 해당 기능을 호출할 수 없다.
• public 은 기능을 숨기지 않고 어디서든 호출할 수 있게 공개한다.

접근제어자 사용 - 필드,메서드

<access.a.AccessData.java>

package access.a;

public class AccessData {
    public int publicField;
    int defaultField;
    private int privateField;

    public void publicMethod(){
        System.out.println("publicMethod 호출 "+ publicField);
    }
    void defaultMethod(){
        System.out.println("defaultMethod 호출 "+ defaultField);
    }
    void privateMethod(){
        System.out.println("privateMethod 호출 "+ privateField);
    }

    public void innerAccess(){
        System.out.println("내부 호출");
        publicField = 100;
        defaultField = 200;
        privateField = 300;
        publicMethod();
        defaultMethod();
        privateMethod();
    }
}

=> innerAccess()는 내부호출 메서드. 내부호출은 자기자신에게 접근하라는 것 = private을 포함한 모든 곳에 접근 가능

<access.a.AccessInnerMain.java>

package access.a;

public class AccessInnerMain {
    public static void main(String[] args) {
        AccessData data = new AccessData();

        //public 호출 가능
        data.publicField =1;
        data.publicMethod();

        //같은 패키지 default 호출가능
        data.defaultField = 2;
        data.defaultMethod();

        //private 호출 불가
//        data.privateField =3;
//        data.privateMethod();

        data.innerAccess();
    }
}

=> public : 모든 접근 허용 default : 같은 패키지만 허용 <결과>

<access.a.AccessOuterMain.java>

package access.b;

import access.a.AccessData;

public class AccessOuterMain {
    public static void main(String[] args) {
        AccessData data = new AccessData();

        //public 호출 가능
        data.publicField =1;
        data.publicMethod();

        //같은 패키지 default 호출가능
//        data.defaultField = 2;
//        data.defaultMethod();

        //private 호출 불가
//        data.privateField =3;
//        data.privateMethod();

        data.innerAccess();
    }
}

<결과>

접근제어자 사용 - 클래스레벨

클래스 레벨의 접근 제어자 규칙

• 클래스 레벨의 접근 제어자는 public , default 만 사용할 수 있다. private , protected 는 사용할 수 없다.
• public 클래스는 반드시 파일명과 이름이 같아야 한다. 하나의 자바 파일에 public 클래스는 하나만 등장할 수 있다. 하나의 자바 파일에 default 접근 제어자를 사용하는 클래스는 무한정 만들 수 있다.

<access.a.PublicClass.java>

package access.a;

public class PublicClass {
    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();
        DefaultClass1 class1 = new DefaultClass1();
        DefaultClass2 class2 = new DefaultClass2();

    }
}
class DefaultClass1{

}
class DefaultClass2{

}

<access.a.PublicClassInnerMain.java>

package access.a;

public class PublicClassInnerMain {
    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();
        DefaultClass1 class1 = new DefaultClass1();
        DefaultClass2 class2 = new DefaultClass2();
    }
}

<access.b.PublicClassOuterMain.java>

package access.b;

//import access.a.DefaultClass1;
//import access.a.DefaultClass2;
import access.a.PublicClass;

public class PublicClassOuterMain {
    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();

        //다른 패키지로 접근 불가
//        DefaultClass1 class1 = new DefaultClass1();
//        DefaultClass2 class2 = new DefaultClass2();
    }
}

캡슐화

캡슐화(Encapsulation)는 데이터와 해당 데이터를 처리하는 메서드를 하나로 묶어서 외부에서의 접근을 제한하는 것을 말한다. 캡슐화를 통해 데이터의 직접적인 변경을 방지하거나 제한할 수 있다. 캡술화를 안전하게 완성할 수 있게 해주는 장치가 접근제어자 이다.

쉽게 말해서 속성과 기능을 하나로 묶고, 외부에 필요한 기능만 노출하고 나머지는 모두 내부로 숨기는 것

1. 데이터(속성) 숨기기

왠만하면 멤버변수들은 private 으로 막아둔다.

2. 기능 숨기기

기능 중 외부에서 사용하지 않고 내부에서만 사용하는 기능들은 숨기는 것이 좋다.

캡슐화 예시

<BankAccount.java>

package access;

public class BankAccount {
    private int balance;

    public BankAccount(){
        balance = 0;
    }

    //public 메서드 : deposit
    public void deposit(int amount){
        if (isAmountValid((amount))) {
            balance += amount;
        }else {
            System.out.println("유효하지 않은 금액입니다.");
        }
    }

    public void withdraw(int amount){
        if(isAmountValid(amount) && balance -amount >=0){
            balance -= amount;
        }else{
            System.out.println("유효하지 않은 금액이거나 잔액이 부족합니다.");
        }
    }

    public int getBalance(){
        return balance;
    }

    private boolean isAmountValid(int amount){
        return amount>0;
    }
}

<BankAccountMain.java>

package access;

public class BankAccountMain {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(10000);
        account.withdraw(3000);
        System.out.println("balance = "+account.getBalance());
    }
}

isAmountValid 가 public 이라면 개발자는 해당 메서드를 사용해서 검증해야하는지 의문을 가질 수가 있다.

문제와 풀이1

<MaxCounter.java>

package access.ex;

public class MaxCounter {
    private int count;
    public int max;

    public MaxCounter(int max){
        this.max = max;
    }

    public void increment(){
        //검증로직
        if(count>=max){
            System.out.println("최대값을 초과할 수 없습니다.");
            return; //검즈에서 통과 못하면 실행으로 넘어가지 못함, else 를 사용하지 않아도됨
        }
        //실행 로직
        count++;
    }

    public int getCount(){
        return count;
    }
}

<CounterMain.java>

package access.ex;

public class CounterMain {
    public static void main(String[] args) {
        MaxCounter maxCounter = new MaxCounter(3);

        maxCounter.increment();
        maxCounter.increment();
        maxCounter.increment();
        maxCounter.increment();
        int count = maxCounter.getCount();
        System.out.println(count);
    }
}

문제와 풀이2

<Item.java>

package access.ex;

public class Item {
    private String name;
    private int price;

    private int quantity;

    public  Item(String name, int price, int quantity){
        this.name = name;
        this.price = price;
        this. quantity = quantity;
    }

    public String getName(){
        return name;
    }

    public int getTotalProce(){
        return price*quantity;
    }
}

<ShoppingCart.java>

package access.ex;

public class ShoppingCart {
    private  Item[] items = new Item[10];
    private int itemCount;

    public void addItem(Item item){
        if(itemCount >= items.length){
            System.out.println("장바구니가 꽉 찼습니다.");
            return;
        }

        items[itemCount] = item;
        itemCount++;
    }

    public  void displayItems(){
        System.out.println("장바구니 상품 출력");
        for (int i=0; i<itemCount; i++){
            Item item = items[i];
            System.out.println("상품명: "+ item.getName()+"  합계: "+ item.getTotalProce());
        }

        System.out.println("전체 가격 합 : " + calTotalPrice());
    }

    private int calTotalPrice(){
        int totalPrice = 0;
        for (int i=0; i<itemCount; i++){
            Item item = items[i];
            totalPrice += item.getTotalProce();
        }
        return totalPrice;
    }


}

<ShoppingCartMain.java>

package access.ex;

public class ShoppingCartMain {
    public static void main(String[] args) {
        ShoppingCart shoppingCart = new ShoppingCart();

        Item item1 = new Item("사과",1000,2);
        Item item2 = new Item("바나나",500,3);
        Item item3 = new Item("망고",3000,2);

        shoppingCart.addItem(item1);
        shoppingCart.addItem(item2);
        shoppingCart.addItem(item3);

        shoppingCart.displayItems();
    }
}

<결과>

data는 단순히 예시이며 실제 데이터는 솔루션 결과들이었다!

const data = 'John,Doe|1\n Jane|2\nMary,a|3'

이런 데이터를 A열에만 '\n' 기준으로 행으로 쌓인 엑셀파일로 변환하고 싶었다. 엑셀 파일은 /data/test.xlsx 였다.

Problem 1

그런데 이렇게 쌓이는 데이터를 발견했고, 쉼표 기준으로 열이 분리된다는 엑셀의 특징을 알게되었다.

Solve 2

기존의 나의 코드는 단순했다.

const dir = '/data/test.csv';
const data = 'John,Doe|1\n Jane|2\nMary,a|3';
fsPromises.appendFile(dir,data); //nodeJs 라이브러리

쉼표를 문자취급을 해줘야하기때문에 ''으로 감싸야 했고 그래서 나는 data 의 구조를 배열로 변경했다. 그리고 xlsx 라이브러리를 사용하기로 했다.

const dir = '/data/test.csv';
//구조변경
const data = ['John,Doe|1', 'Jane|2', 'Mary,a|3'];

//엑셀 워크북 생성
const workbook = xlsx.utils.book_new();
//각 데이터가 시트의 한 행 (2차원배열)
const worksheet = xlsx.utils.aoa_to_sheet(data.map(row => [row]));

//시트를 워크북에 추가
xlsx.utils.book_append_sheet(workbook, worksheet, 'Sheet1');

// 엑셀 파일 저장 (디렉토리를 포함한 경로)
xlsx.writeFile(workbook, dir);

이렇게 하니 원하는대로 적재가 되었다!

History2

다 된줄 알았으나 여러가지의 엑셀파일을 하나의 엑셀로 합치려고 하다가 또다른 이슈를 발견했다. </a/name.csv>

John,Doe|1 
Jane|2

</b/name.csv>

Dan|1 
Sarah|8

이런 2개의 엑셀을 </total/name.csv> 이렇게 하나의 엑셀로 합쳐서 전달하려했다.

Problem2

문제는.. total/name.csv 에 a/name.csv를 적재하고 덮어쓰기로 b/name.csv 를 적재하는데 결과가 이런식으로 a.csv의 마지막행과 b.csv의 첫번째 행이 합쳐진다는 문제였다.

우선 각각 a,b 디렉토리에서 name.csv 파일을 읽어오고, 그 파일들을 name.csv 로 합치는 로직이었고 쉘스크립트로 작성하였다.

for ((i=1; i${#dirList[@]}; i++));
do
    # 각각의 디렉토리 접근 (a,b 디렉토리)
    VALUE=${dirList[i]};
    cd ${VALUE##*/}

    csvList=( `find . -type f` );
    #디렉토리 csv 파일 탐색
    for((j=0; j<${#csvList[@]}; j++));
    do
        #덮어쓰기
        cat ${csvList[j]} >> /total/name.csv
    done 
done

Solve2

덮어쓰는 부분에서 cat 대신 tail -n +1 로 사용해 보았는데 b.csv 의 첫행이 날아가고 두번째 행부터 적재가 되더라..

생각보다 해결방안은 단순했다. 줄바꿈 이었다! 처음엔 csv 내에 마지막행에 직접 '\n'으로 해볼까도 싶었는데 그러면 데이터를 직접 건드리는 거라 쉘에서 처리 해보기로 했다.

for ((i=1; i${#dirList[@]}; i++));
do
    # 각각의 디렉토리 접근 (a,b 디렉토리)
    VALUE=${dirList[i]};
    cd ${VALUE##*/}

    csvList=( `find . -type f` );
    #디렉토리 csv 파일 탐색
    for((j=0; j<${#csvList[@]}; j++));
    do
        #덮어쓰기
        cat ${csvList[j]} >> /total/name.csv
        #줄바꿈처리
        echo "" >> /total/name.csv
    done 
done

이렇게 하면 각 파일의 내용에 별도의 행이 추가된다.

End

빅데이터팀과 협업하게 되면 DB 에 직접 데이터를 쌓아주는게 좋지만 지금 프로젝트에서는 빅데이터팀 DB에 접근할 수 있는 환경이 안돼서 엑셀 파일로 전달을 하게 되었다. (빅데이터의 원천데이터들은 txt나 엑셀 파일로 이루어지면 데이터 관리와 보정이 편하기 때문일 듯)

엑셀파일로 변환하는 작업은 이렇게 쉼표기준으로 분리되거나 한글변환이 안되거나 등 이슈가 많음으로 꼭꼭 많은 검토를 통해 이슈사항을 확인해야하는 것 같다.

그리고 쉘은 crontab 을 사용하여 호출하게 했다~!

절차지향프로그래밍

• 절차지향 프로그래밍 실행 순서를 중요시 하는 프로그래밍, 프로그램의 흐름을 순차적으로 따르며 처리하는 방식

• 객체 지향 프로그래밍 객체를 지향한다. 쉽게 이야기해서 객체를 중요하게 생각하는 방식 객체 지향 프로그래밍은 실제 세계의 사물이나 사건을 객체로 보고, 이러한 객체들 간의 상호작용을 중심으로 프로그래밍하는 방식

• 차이점 : 절차지향은 데이터와 해당 데이터에 대한 처리 방식이 분리되어 있다. 객체지향은 데이터와 그 데이터에 대한 행동(메서드)이 하나의 '객체' 안에 포함되어 있다.

음악 플레이어 만들기

절차 지향 프로그래밍을 만들고 객체 지향으로 바꿔보자!

<MusicPalyerMain1.java>

package oop1;

public class MusicPalyerMain1 {
    public static void main(String[] args) {
        int volume = 0;
        boolean isOn = false;

        //음악 플레이어 켜기
        isOn = true;
        System.out.println("음악 플레이어를 시작합니다");

        //볼륨 증가
        volume++;
        System.out.println("음악 플레이어 볼륨:" + volume);

        //볼륨 증가
        volume++;
        System.out.println("음악 플레이어 볼륨:" + volume);

        //볼륨 감소
        volume--;
        System.out.println("음악 플레이어 볼륨:" + volume);

        //음악 플레이어 상태
        System.out.println("음악 플레이어 상태 확인");
        if (isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }

        //음악 플레이어 끄기
        isOn = false;
        System.out.println("음악 플레이어를 종료합니다");

    }
}

<결과>

데이터 묶음

MusicPlayerData 라는 클래스로 사용되는 데이터들을 여기에 묶어서 멤버변수로 사용하자 <MusicPlayerData.java>

package oop1;

public class MusicPlayerData {
    int volume=0;
    boolean isOn = false;
}

<MusicPalyerMain2.java>

package oop1;

public class MusicPalyerMain2 {
    public static void main(String[] args) {
        MusicPlayerData data = new MusicPlayerData();

        //음악 플레이어 켜기
        data.isOn = true;
        System.out.println("음악 플레이어를 시작합니다");

        //볼륨 증가
        data.volume++;
        System.out.println("음악 플레이어 볼륨:" + data.volume);

        //볼륨 증가
        data.volume++;
        System.out.println("음악 플레이어 볼륨:" + data.volume);

        //볼륨 감소
        data.volume--;
        System.out.println("음악 플레이어 볼륨:" + data.volume);

        //음악 플레이어 상태
        System.out.println("음악 플레이어 상태 확인");
        if (data.isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + data.volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }

        //음악 플레이어 끄기
        data.isOn = false;
        System.out.println("음악 플레이어를 종료합니다");

    }
}

다양한 변수들이 추가되더라도 쉽게 관리 할 수 있다.

메서드 추출

중복되는 부분들을 정리하자 -> 재사용하기 쉬움 <MusicPlayerMain3.java>

package oop1;

public class MusicPalyerMain3 {
    public static void main(String[] args) {
        MusicPlayerData data = new MusicPlayerData();

        //음악 플레이어 켜기
        on(data);

        //볼륨 증가
       volumeUp(data);

        //볼륨 증가
        volumeUp(data);

        //볼륨 감소
        volumeDown(data);

        //음악 플레이어 상태
        showStatus(data);

        //음악 플레이어 끄기
        off(data);
    }

    static void on(MusicPlayerData data){
        data.isOn = true;
        System.out.println("음악 플레이어를 시작합니다");
    }
    static void off(MusicPlayerData data){
        data.isOn = false;
        System.out.println("음악 플레이어를 종료합니다");
    }

    static void volumeUp(MusicPlayerData data){
        data.volume++;
        System.out.println("음악 플레이어 볼륨:" + data.volume);
    }
    static void volumeDown(MusicPlayerData data){
        data.volume--;
        System.out.println("음악 플레이어 볼륨:" + data.volume);
    }

    static void showStatus(MusicPlayerData data){
        System.out.println("음악 플레이어 상태 확인");
        if (data.isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + data.volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }
    }
}

각각의 기능을 메서드로 만들어 모듈화 시켰다. => 중복 제거, 변경영향범위(기능 수정 시 해당 메서드만 수정), 메서드이름을 통해 코드를 쉽게 이해할 수 있다.

절차지향프로그램의 한계 데이터(MusicPlayerData)와 기능(MusicPlayerMain3)이 분리되어 있어서 유지보수 관점에서 2곳을 관리하여야한다. => 객체지향 프로그램으로 데이터와 기능을 온전히 하나로 묶어서 사용

클래스와 메서드

<ValueData.java>

package oop1;

public class ValueData {
    int value;
}

<ValueDataMain.java>

package oop1;

public class ValueDataMain {
    public static void main(String[] args) {
        ValueData valueData = new ValueData();

        add(valueData);
        add(valueData);
        add(valueData);

        System.out.println("최종 숫자 = "+ valueData.value);
    }
    static void add(ValueData valueData){
        valueData.value++;
        System.out.println("숫자증가 value= " + valueData.value);
    }
}

<결과>

객체지향

클래스 내부에 속성(데이터)과 기능(메서드)을 함께 포함할 수 있다. <ValueData.java>

package oop1;

public class ValueData {
    int value;

    void add(){
        value++;
        System.out.println("숫자증가 value= " + value);
    }
}

<ValueObjectMain.java>

package oop1;

public class ValueObjectMain {
    public static void main(String[] args) {
        ValueData valueData = new ValueData();

        valueData.add();
        valueData.add();
        valueData.add();

        System.out.println("최종 숫자 = " + valueData.value);
    }
}

• 클래스는 속성(데이터, 멤버 변수)과 기능(메서드)을 정의할 수 있다.

• 객체는 자신의 메서드를 통해 자신의 멤버 변수에 접근할 수 있다
• 객체의 메서드 내부에서 접근하는 멤버 변수는 객체 자신의 멤버 변수이다.

객체지향 프로그래밍

음악 플레이어를 만들어서 제공하는 개발자와 플레이어를 사용하는 개발자가 분리되어있다고 생각하자!

• 속성 : volume, isOn

• 기능 : on(), off(), volumeUp(), volumeDown(), showStatus()

<MusicPlayer.java>

package oop1;

public class MusicPlayer {
    int volume =0;
    boolean isOn =false;

    void on(){
        isOn = true;
        System.out.println("음악 플레이어를 시작합니다");
    }
    void off(){
        isOn = false;
        System.out.println("음악 플레이어를 종료합니다");
    }

    void volumeUp(){
        volume++;
        System.out.println("음악 플레이어 볼륨:" + volume);
    }
    void volumeDown(){
        volume--;
        System.out.println("음악 플레이어 볼륨:" + volume);
    }

    void showStatus(){
        System.out.println("음악 플레이어 상태 확인");
        if (isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }
    }
}

=> 음악 플레이어를 사용하는데 필요한 모든 속성과 기능이 하나의 클래스에 포함되어 있다

<MusicPlayerMain4.java>

package oop1;

public class MusicPlayerMain4 {
    public static void main(String[] args) {
        MusicPlayer player = new MusicPlayer();

        //음악 플레이어 켜기
        player.on();
        //볼륨 증가
        player.volumeUp();
        //볼륨 증가
        player.volumeUp();
        //볼륨 감소
        player.volumeDown();
        //음악 플레이어 상태
        player.showStatus();
        //음악 플레이어 끄기
        player.off();

    }
}

MusicPlayer 를 사용하는 입장에서는 이제 MusicPlayer 내부에 어떤 속성(데이터)이 있는지 전혀 몰라도 된다. MusicPlayer 를 사용하는 입장에서는 단순하게 MusicPlayer 가 제공하는 기능 중에 필요한 기능을 호출해서 사용하기만 하면 된다.

캡슐화

MusicPlayer 를 보면 음악 플레이어를 구성하기 위한 속성과 기능이 마치 하나의 캡슐에 쌓여있는 것 같다. 이렇게 속성과 기능을 하나로 묶어서 필요한 기능을 메서드를 통해 외부에 제공하는 것을 캡슐화라 한다.

문제와 풀이

<RectangleProceduralMain.java>

package oop1.ex;

public class RectangleProceduralMain {
    public static void main(String[] args) {
        int width=5;
        int height=8;

        int area = calculateArea(width, height);
        System.out.println("넓이: " + area);
        int perimeter = calculatePerimeter(width, height);
        System.out.println("둘레 길이: " + perimeter);
        boolean square = isSquare(width, height);
        System.out.println("정사각형 여부: " + square);

    }
    static int calculateArea(int width,int height){
        int area = width*height;
        return area;
    }
    static int calculatePerimeter(int width,int height){
        int perimeter = (width+height)*2;
        return perimeter;
    }
    static boolean isSquare(int width,int height){
        return width == height;
    }
}

객체 지향

<RectangleProceduralMain.java>

package oop1.ex;

public class RectangleProceduralMain {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.width=5;
        rectangle.height=8;

        int area = rectangle.calculateArea();
        System.out.println("넓이: " + area);
        int perimeter = rectangle.calculatePerimeter();
        System.out.println("둘레 길이: " + perimeter);
        boolean square = rectangle.isSquare();
        System.out.println("정사각형 여부: " + square);

    }

}

<Rectangle.java>

package oop1.ex;

public class RectangleProceduralMain {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.width=5;
        rectangle.height=8;

        int area = rectangle.calculateArea();
        System.out.println("넓이: " + area);
        int perimeter = rectangle.calculatePerimeter();
        System.out.println("둘레 길이: " + perimeter);
        boolean square = rectangle.isSquare();
        System.out.println("정사각형 여부: " + square);

    }

}

문제와 풀이2

<Account.java>

package oop1.ex;

public class Account {
    int balance;

    void deposit(int amount){
        balance+=amount;
    }
    void withdraw(int amount){
        if(balance>=amount){
            balance-=amount;
        }else{
            System.out.println("잔액이 부족합니다.");
        }
    }
}

<AccountMain.java>

package oop1.ex;

public class AccountMain {
    public static void main(String[] args) {
        Account account = new Account();

        account.deposit(10000);
        account.withdraw(9000);
        account.withdraw(2000);

        System.out.println("잔고 : "+ account.balance);

    }
}

생성자

필요한 이유

객체를 생성하는 시점에 어떤 작업을 하고 싶다면 생성자(Constructor)를 이용하면 된다. <MemberInit.java>

package construct;

public class MemberInit {
    String name;
    int age;
    int grade;

}

<MemberInitMain1.java>

package construct;

public class MethodInitMain1 {
    public static void main(String[] args) {
        MemberInit member1= new MemberInit();

        member1.name = "user1";
        member1.age = 15;
        member1.grade=90;

        MemberInit member2 = new MemberInit();
        member2.name = "user2";
        member2.age = 16;
        member2.grade=80;

        MemberInit[] members = {member1,member2};

        for(MemberInit s: members){
            System.out.println("이름: "+s.name+"  나이:"+s.age+"  성적:"+s.grade);
        }
    }
}

=> 회원의 초기값을 설정하는 부분이 반복 된다. 메서드(initMember)를 사용하여 반복을 제거하자. <MemberInitMain2.java>

package construct;

public class MethodInitMain2 {
    public static void main(String[] args) {
        MemberInit member1= new MemberInit();
        initMember(member1,"user1",15,90);

        MemberInit member2 = new MemberInit();
        initMember(member2,"user2",16,80);

        MemberInit[] members = {member1,member2};

        for(MemberInit s: members){
            System.out.println("이름:"+ s.name+"  나이:"+s.age+ "  성적: "+ s.grade);
        }
    }
    static void initMember(MemberInit member, String name, int age, int grade){
        member.name = name;
        member.age = age;
        member.grade = grade;
    }
}

this

<MemberInit.java> 에 initMember() 추가

package construct;

public class MemberInit {
    String name;
    int age;
    int grade;

    //추가
    void initMember(String name, int age, int grade){
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
}

<MemberInitMain3.java>

package construct;

public class MethodInitMain3 {
    public static void main(String[] args) {
        MemberInit member1= new MemberInit();
        member1.initMember("user1",15,90);

        MemberInit member2 = new MemberInit();
        member2.initMember("user2",16,80);

        MemberInit[] members = {member1,member2};

        for(MemberInit s: members){
            System.out.println("이름:"+ s.name+"  나이:"+s.age+ "  성적: "+ s.grade);
        }
    }
}

this

• this.name =name 에서 name 을 구분하는 법?, 멤버변수와 매개변수의 이름이 똑같은 때 구분하는 법? => 멤버변수보다 매개변수가 코드블럭의 더 안쪽에 있기 때문에 매개변수가 우선순위를 가진다.
• 둘의 이름이 같을 땐 this를 사용해서 명확히 구분 해야한다.
• 멤버변수에 접근하려면 this를 사용
• this 는 인스턴스 자신을 가리킨다.

this의 생략

this 는 생략할 수 있다. 이 경우 변수를 찾을 때 가까운 지역변수(매개변수도 지역변수다)를 먼저 찾고 없으면 그 다음으로 멤버 변수를 찾는다. 멤버 변수도 없으면 오류가 발생한다.

<MemberThis.java>

package construct;

public class MemberThis {
    String nameField;

    void initMember(String nameParameter){
        nameField = nameParameter;
    }
}

this의 코딩 스타일

항상 this를 사용하는 스타일 <MemberThis.java>

package construct;

public class MemberThis {
    String nameField;

    void initMember(String nameParameter){
        this.nameField = nameParameter;
    }
}

=> 헷갈릴 땐 그냥 추가 해도된다. 이렇게하면 이 코드가 멤버 변수를 사용한다는 것을 눈으로 쉽게 확인할 수 있다. BUT 요즘은 잘 안쓴다. 권장하지 않는다.

도입

프로그래밍을 하다보면 객체 생성후 바로 초기값을 할당해야하는 경우가 생기는데 그럴 때마다 매번 메서드를 만들어야 한다. 그래서 대부분의 객체지향언어는 객체를 생성하자마자 즉시 필요한 기능을 좀 더 편리하게 수행할 수 있도록 생성자라는 기능을 제공한다.

<MemberConstruct.java>

package construct;

public class MemberConstruct {
    String name;
    int age;
    int grade;

//생성자
    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name= "+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade = grade;
    }
}

• 생정자의 이름은 클래스 이름과 동일해야한다. 따라서 첫글자도 대문자로 시작한다.

• 생정자는 반환타입이 없다.
• 나머지는 메서드와 동일

<ConstructMain1.java>

package construct;

public class ConstructMain1 {
    public static void main(String[] args) {
        MemberConstruct member1 = new MemberConstruct("user1", 15,90);
        MemberConstruct member2 = new MemberConstruct("user2", 16 ,80);

        MemberConstruct[] members = {member1,member2};

        for (MemberConstruct s : members) {
            System.out.println("이름:" + s.name + " 나이:" + s.age + " 성적:" +
                    s.grade);
        }
    }
}

생성자 장점

1. 중복 호출 제거 객체를 생성하면서 동시에 필요한 작업을 한번에 처리할 수 있다.
2. 객체를 생성할 때 직접 정의한 생성자가 있다면 직접 정의한 생성자를 반드시 호출해야 한다.

기본생성자

<MemberInit.java>, <MethodInitMain3.java> 을 보면 알 수 있다.

• 매개변수가 없는 생성자를 기본 생성자라고 한다.
• 클래스에 생성자가 하나도 없으면 자바 컴파일러는 매개변수가 없고, 작동하는 코드가 없는 기본 생성자를 자동으로 만들어준다.
• 생성자가 하나라도 있으면 자바는 기본 생성자를 만들지 않는다.

<MemberDefault.java>

package construct;

public class MemberDefault {
    String name;

    //java에서 기본생성자 만들어줌
//    MemberDefault(){
//
//    }

    //직접 기본생성자 정의
    MemberDefault() {
        System.out.println("생성자 호출");
    }
}

<MemberDefaultMain.java>

package construct;

public class MemberDefaultMain {
    public static void main(String[] args) {
        MemberDefault memberDefault = new MemberDefault();
    }
}

오버로딩과 this()

<MemberConstruct.java>

package construct;

public class MemberConstruct {
    String name;
    int age;
    int grade;

    //오버로딩 추가
    MemberConstruct(String name, int age){
        this.name =name;
        this.age = age;
        this.grade = 50;
    }

    //변경
//    MemberConstruct(String name, int age){
//        this(name, age,50);
//    }

    //생성자
    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name= "+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade = grade;
    }
}

기존의 MemberConstruct에 생성자를 하나 추가해서 생성자가 2개가 됨

MemberConstruct(String name, int age)
MemberConstruct(String name, int age, int grade) 

새로 추가한 생성자는 grade를 받지 않고 50점으로 초기화.

<ConstructMain2.java>

package construct;

public class ConstructMain2 {
    public static void main(String[] args) {
        MemberConstruct member1 = new MemberConstruct("user1", 15,90);
        MemberConstruct member2 = new MemberConstruct("user2", 16);

        MemberConstruct[] members = {member1,member2};

        for (MemberConstruct s : members) {
            System.out.println("이름:" + s.name + " 나이:" + s.age + " 성적:" +
                    s.grade);
        }
    }
}

<결과> => 오버로딩으로 성적 입력이 필요한 경우에는 grade가 있는 생성자 호출, 없는 경우에는 grade가 없는 생성자 호출!

MemberConstruct.java 의 중복된 코드 this.name ... => <MemberConstruct.java>

package construct;

public class MemberConstruct {
    String name;
    int age;
    int grade;

    //오버로딩 추가
//    MemberConstruct(String name, int age){
//        this.name =name;
//        this.age = age;
//        this.grade = 50;
//    }

    //변경
    MemberConstruct(String name, int age){
        this(name, age,50);
    }

    //생성자
    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name= "+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade = grade;
    }
}

첫번째 생성자 내부에서 두번째 생성자를 호출한다.

MemberConstruct(String name, int age) -> MemberConstruct(String name, int age,int grade)

=> this()를 사용하면 생성자 내부에서 다른 생성자를 호출 할 수 있다 -> 중복 제거

this 의 규칙

• this()는 생성자 코드의 첫줄에만 작성가능하다. <규칙위반>

  public MemberConstruct(String name, int age) {
  System.out.println("go");
  this(name, age, 50);
  }

  문제와풀이1

  <Book.java>

  package construct.ex;
  

public class Book { String title; String author; int page;

Book(String title, String author){
    this(title, author,0);
}
Book(String title, String author, int page){
    this.title = title;
    this.author=author;
    this.page = page;
}

}

<BookMain.java>
```java
package construct.ex;

public class BookMain {
    public static void main(String[] args) {
        Book book0 = new Book("","");
        Book book1 = new Book("Hello Java", "Seo");
        Book book2 = new Book("JPA 프로그래밍", "kim",700);

        Book[] books = {book0,book1,book2};
        for (Book b:books){
            System.out.println("제목: "+b.title+"  저자:"+b.author+ "  페이지:"+b.page);
        }
    }
}

데이터베이스 연동을 위해 CRUD 구현을 위해 수정 할 부분

1.먼저 Service 와 Controller 파일에서 로직들을 다 수정해야 하기 때문에 원래 있던 부분들을 주석 처리 한다.

2. 메모리에 데이터 저장이 아니니 Service에 board 배열을 지워줍니다.

3. 게시물 데이터를 정의하는데 Entity를 이용하기 때문에 Board Model 파일에 있는 Board Interface는 지우고

4. Status Enum 은 아직도 필요하기 때문에 이 부분만을 위한 파일을 생성해서 넣어줍니다.

• board.model.ts 파일을 board-status.enum.ts 으로 변경

5. 데이터베이스 이용으로 인한 불필요한 경로 지워주기

• board-status-validation.pipe.ts BoardStatus
• boards.controller.ts
• board.entity.ts BoardStatus
• uuid

아이디를 이용해서 특정 게시물 가져오기

이제는 메모리에서 데이터를 가져오는게 아닌 데이터베이스에서 가져오고 TypeORM을 쓸 때는 Repository 패턴을 사용한다고 했기 때문에 Board 서비스(service)에 Board 리포지터리(Repository)를 넣어줘야한다.(종속성주입, Inject)

Service에 Repository 넣어주기 (Repository Injection)

<board.service.ts>

constructor(
        @InjectRepository(BoardRepository)
        private boardRepository: BoardRepository,
        //private 을 사용하면 암묵적으로 boardRepository 인자가 프로퍼티로 선언이 된다.
    ){}

@InjectRepository

• 이 데코레이터를 이용해서 이 서비스에서 BoardRepository를 이용한다고 하고 이걸boardRepository 변수에 넣어준다.

Service에서 getBoardById 메소드 생성하기

• typeOrm 에서 제공하는 findOne 메소드 사용
• async await을 이용해서 데이터베이스 작업이 끝난 후 결과값을 받을 수 있게 해준다

<service.ts>

async getBoardById(id: number): Promise <Board>{
        const found = await this.boardRepository.findOne({ where: { id } });

        if(!found){
            throw new NotFoundException(`Can't find Voard with id ${id}`)
        }
        return found;
    }

Controller 부분도 수정하기

<controller.ts>

@Get('/:id')
    getBoardById(@Param('id') id: number): Promise<Board>{
        return this.boardsService.getBoardById(id);
    }

<결과>

게시물 생성하기

<board.service.ts>

async createBoard(createBoardDto: createBoardDto): Promise<Board>{
        const {title, description} = createBoardDto;
        const board = this.boardRepository.create({
            title,
            description,
            status: BoardStatus.PUBLIC 
        })
        await this.boardRepository.save(board);
        return board;
    }

<board.controller.ts>

 @Post()
    @UsePipes(ValidationPipe)
    createBoard(@Body() createBoardDto: createBoardDto): Promise<Board>{
        return this.boardsService.createBoard(createBoardDto);
    }

데이터베이스에 관련된 로직은 Repository로 이동...

Repository Pattern은 서비스에 있는 데이테베이스관련 로직을 Repository 쪽으로 옮기면 된다.

<board.repository.ts>

import { EntityRepository, Repository } from "typeorm";
import { Board } from "./board.entity";
import { createBoardDto } from "./dto/create-board.dto";
import { BoardStatus } from "./board-status.enum";

@EntityRepository(Board)
export class BoardRepository extends Repository<Board>{
    async createBoard(createBoardDto: createBoardDto) : Promise<Board> {
        const {title, description} = createBoardDto;

        const board = this.create({
            title,
            description,
            status: BoardStatus.PUBLIC
        })

        await this.save(board);
        return board;
    }

}

<board.service.ts>

//게시물생성하기2
    createBoard(createBoardDto: createBoardDto): Promise<Board> {
        return this.boardRepository.createBoard(createBoardDto);
    }

<결과> ???

게시물 삭제하기

remove() vs delete()

• remove 를 사용하려면 삭제대상 아이템이 무조건 데이터베이스 안에 있어야한다. 그렇지 않으면 에러(404)

• delete: 아이템이 존재하면 지우고 존재하지 않으면 아무런 영향이 없다.

이러한 차이 때문에 remove를 이용하면 하나의 아이템을 지울 때 두번 데이터베이스를 이용해야한다.(아이템 유무 + 지우기) 따라서 데이터베이스에 한번만 접근해도 되는 delete 메소드를 사용해준다.

<board.service.ts>

async deleteBoard(id: number): Promise<void> {
        const result = await this.boardRepository.delete(id);

        console.log('result', result);
    }

<board.controller.ts>

@Delete('/:id')
    deleteBoard(@Param('id', ParseIntPipe) id: number): Promise<void> {
        return this.boardsService.deleteBoard(id);
    }

• ParseIntPipe

delete를 사용하면 없는 id 를 지우더라고 에러가 발생하지 않는다. => 따로 에러메세지를 출력해보자. <serviec.ts>

async deleteBoard(id: number): Promise<void> {
        const result = await this.boardRepository.delete(id);

        if(result.affected ===0){
            throw new NotFoundException(`Can't find Board with id ${id}`)
        }
        console.log('result', result);
    }
    ```
![](https://velog.velcdn.com/images/baby_potato/post/df1f4c4a-0fe1-4ec1-bd70-998325b6e808/image.png)

# 게시물 상태 업데이트하기

<board.service.ts>
```ts
async updateBoardStatus(id: number, status: BoardStatus): Promise<Board> {
        const board = await this.getBoardById(id);
        board.status = status;

        await this.boardRepository.save(board);

        return board;
    }

<board.controller.ts>

 @Patch('/:id/status')
    updateBoardStatus(
        @Param( 'id', ParseIntPipe) id: number,
        @Body('status', BoardStatusValidationPipe) status: BoardStatus,
    ): Promise<Board> {
        return this,this.boardsService.updateBoardStatus(id,status);
    }
    ```

 ![](https://velog.velcdn.com/images/baby_potato/post/30c8be7d-6349-4f2c-8477-bf12bd519f83/image.png)

# 모든 게시물 가져오기
<board.service.ts>
```ts
async getAllBoards(): Promise<Board[]> {
        return this.boardRepository.find();
    }

<board.controller.ts>

@Get('/')
    getAllBoard(): Promise<Board[]> {
        return this.boardsService.getAllBoards();
    }

Pipe

• 파이프는 @Injectable () 데코레이터로 주석이 달린 클래스

• data transformation과 data validation을 위해서 사용
• 파이프는 컨트롤러 경로 처리기에 의해 처리되는 인수에 대해 작동

Nest는 메소드가 호출되기 직전에 파이프를 삽입하고 파이프는 메소드로 향하는 인수를 수신하고 이에 대해 작동합니다.

Data Transformation

입력 데이터를 원하는 형식으로 변환 (예 : 문자열에서 정수로) 숫자를 받길 원하는데 문자열 형식으로 온다면 파이프에서 자동으로 숫자로 바꿔준다. String to Integer EX) string '7' => Integer 7

Data validation

입력 데이터를 평가하고 유효한 경우 변경되지 않은 상태로 전달하면 된다. 그렇지 않으면 데이터가 올바르지 않아 예외를 발생시킵니다. 만약 이름의 길이가 10자 이하여야 하는데 10자 이상 되면 에러를 발생

PIPE 사용하는 법(Binding Pipes)

파이프를 사용하는 방법(Binding pipes)은 세가지로 나눠질수 있다.

1. Handler-level Pipes

핸들러 레벨에서 @UsePipes() 데코레이터를 이용한다. 이 파이프는 모든 파라미터에 적용된다. (title, description)

2. Parameter-level Pipes

파라미터 레벨의 파이프 이기에 특정한 파라미터에게만 적용이 되는 파이프

3. Global-level Pipes

글로벌 파이프로서 애플리케이션 레벨의 파이브 클라이언트에서 들어오는 모든 요청에 적용 가장 상단 영역인 main.ts에 작성

Built-in Pipes

Nest JS 에 기본적으로 사용할 수 있게 만들어 놓은 6가지의 파이프가 있다.

• ValidationPipe
• ParseIntPipe
• ParseBoolPipe
• ParseArrayPipe
• ParseUUIDPipe
• DefaultValuePipe

파이프를 이용한 유효성 체크

모듈 설치

class-validator , class-transformer npm install class-validator class-transformer --save

-참조 ⬇⬇ Documentation 페이지

파이프 생성하기

현재는 게시물을 생성할 때 이름과 설명에 아무런 값을 주지 않아도 아무 문제 없이 생성이 된다.=> 파이프로 수정 <create-board.dto.ts>

import { IsNotEmpty } from "class-validator";

export class createBoardDto{
    @IsNotEmpty() // null 불허
    title: string;

    @IsNotEmpty()
    description: string;
}

<controller.ts>

@Post()
    @UsePipes(ValidationPipe) //유효성 체크
    createBoard(
        @Body() createBoardDto: createBoardDto
    ): Board { //return 값의 타입은 Board, Board[]로 주면 안됨 : service의 createBoard의 return 값이 board 하나이기 때문에
        return this.boardsService.createBoard(createBoardDto);
    }

<결과> 에러가 나온다!

특정 게시물을 찾을 때 없는 경우 결과 값 처리

현재 특정 게시물을 ID로 가져올 때 만약 없는 아이디의 게시물을 가져오려고 한다면 결과값으로 아무 내용이 없이 돌아온다. => 가져오려는 내용이 없다는 결과를 클라이언트로 보내준다. <service.ts> 기존의 getBoardId를 수정

 getBoardId(id: string): Board{ //게시물 하나를 return 하기 때문에 Board[] X
        const found = this.boards.find((board)=>board.id === id);

        if(!found){
            throw new NotFoundException(`Can't find Board with id ${id}`);
        }
        return found;
    }

<결과>

없는 게시물을 지우려 할 때 결과 값 처리

<service.ts>의 deleteBoard를 수정

deleteBoard(id: string): void{ // return 을 따로 주지 않아도 되기 때문에 void
        const found = this.getBoardId(id);
        this.boards = this.boards.filter((board) => board.id !==found.id);
    }

커스텀 파이프를 이용한 유효성 체크

지금까지는 NestJS에서 이미 구성해놓은 built-in 파이프를 사용해보았다. 따로 생성해서 사용할 수 있는 CUSTOM PIPE를 만들어보자!

커스텀 파이프 구현 방법

**PipeTransform이란 인터페이스**를 새롭게 만들 커스텀 파이프에 구현해줘야 한다. 
이 PipeTransform 인터페이스는 모든 파이프에서 구현해줘야 하는 인터페이스이다. 
그리고 이것과 함께 모든 파이프는 **transform()** 메소드가 필요하다. 이 메소드는 NestJS가  인자(arguments)를 처리하기 위해서 사용된다.

<board-status-validation.pipe.ts>

import { ArgumentMetadata, PipeTransform } from "@nestjs/common";

export class BoardStatusValidationPipe implements PipeTransform{
    transform(value: any, metadata: ArgumentMetadata) {
        console.log('value',value)
        console.log('metadata',metadata)

        return value;
    }
}

transform() 메소드

두개의 파라미터를 가지는 메소드 첫번째 파라미터는 처리가 된 인자의 값(value)이며, 두번째 파라미터는 인자에 대한 메타 데이터를 포함한 객체이다.

transform()메소드에서 Return 된 값은 Route 핸들러로 전해진다. 만약 예외(Exception)가 발생하면 클라이언트에 바로 전해진다.

실제로 value 와 metadata값 콘솔로 찍어보기

1. 커스텀 파이프 생성
2. 게시물에 업데이트하는 핸들러에 커스텀 파이프 넣어주기
3. 포스트 맨으로 요청 보내기

<controller.ts>의 :id/status 부분 수정 status 를 바꿀 때 유효성 체크(status 값만!)

@Patch('/:id/status')
    updateBoardStatus(
        @Param('id') id: string,
        @Body('status', BoardStatusValidationPipe) status: BoardStatus,
    ): Board {
        return this.boardsService.updateBoardStatus(id, status);
    }

<postman 호출 시> <terminal 콘솔>

커스텀 파이프로 실제 기능 구현하기

구현 할 기능 : 상태(Status)는 PUBLIC과 PRIVATE만 올 수 있기 때문에 이외의 값이 오면 에러 전송 <board-status-validation.pipe.ts>

import { ArgumentMetadata, BadRequestException, PipeTransform } from "@nestjs/common";
import { BoardStatus } from "../board.model";

export class BoardStatusValidationPipe implements PipeTransform{
    //readonly : 클래스 외부에서 접근은 가능하지만 변경은 불가!
    readonly StatusOptions =[
        BoardStatus.PRIVATE,
        BoardStatus.PUBLIC
    ]

    transform(value: any) { // value : 사용자가 입력한 status
        value = value.toUpperCase(); //대문자 변환

        if(!this.isStatusValid(value)){
            throw new BadRequestException(`${value} isn'i in the status`)
        }

        return value;
    }

    private isStatusValid(status: any){
        const index = this.StatusOptions.indexOf(status); //배열안에 있는지, 있으면 그 배열내 인덱스값
        return index !== -1;
    }
}

<결과1> <결과2>

PostgresSQL 설치하기

애플리케이션에 데이터베이스를 연결해서 데이터베이스에 보관, 데이터베이스는 Postgres를 사용

<설치 목록>

1. PostgresSQL
2. pgAdmin (데이터베이스를 보는 툴(Tool)입니다.)

pgAdmin 실행

1. Servers > register Server
2. BoardProject 우클릭 > Create > database

TypeORM (Object Relational Mapping)소개

TypeORM

TypeORM은 node.js에서 실행되고 TypeScript로 작성된 객체 관계형 매퍼 라이브러리

TypeORM은 MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, SAP Hana 및 WebSQL과 같은 여러 데이터베이스를 지원한다.

ORM (Object Relational Mapping) 이란?

객체와 관계형 데이터베이스의 데이터를 자동으로 변형 및 연결하는 작업

ORM을 이용한 개발은 객체와 데이터베이스의 변형에 유연하게 사용할 수 있다.

TypeORM vs Pure Javascript

const boards = Board.find({ title: 'Hello' , status: 'PUBLIC' });

db.query('SELECT * FROM boards WHERE title = "Hello" AND status = "PUBLIC" , (err, result) => {
       if(err) { 
          throw new Error('Error')
      }
      boards = result.rows;
})

TypeORM 특징과 이점

• 모델을 기반으로 데이터베이스 테이블 체계를 자동으로 생성
• 데이터베이스에서 개체를 쉽게 삽입, 업데이트 및 삭제할 수 있다.
• 테이블 간의 매핑 (일대일, 일대 다 및 다 대다)을 만든다.
• 간단한 CLI 명령을 제공
• TypeORM은 간단한 코딩으로 ORM 프레임 워크를 사용하기 쉽다.
• TypeORM은 다른 모듈과 쉽게 통합된다.

TypeORM 애플리케이션에서 이용하기

TypeORM을 사용하기 위해서 설치해야하는 모듈들

*@nestjs/typeorm *

• NestJS에서 TypeOrm을 사용하기 위해 연동시켜주는 모듈

*typeorm *

• TypeORM 모듈

pg

• Postgres 모듈

npm install pg typeorm @nestjs/typeorm --save 

database DOC

TypeORM 애플리케이션에 연결하기

<typeorm.config.ts>

import { TypeOrmModuleOptions } from "@nestjs/typeorm";

export const typeORMConfig : TypeOrmModuleOptions = {
    //Database Type
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username:'postgres',
    password: '0121',
    database: 'board-app',
    //엔티티는 하나씩 넣을 수도 있지만 이렇게 다 포함하게 할 수 있다. 
    entities: [__dirname+'/../**/*.entity.{js,ts}'],
    synchronize: true 

}

• synchronize: true 일때 : 애플리케이션을 다시 실행할 때 엔티티안에서 수정된 컬럼의 길이 타입 변경 값등을 해당 테이블을 Drop 후 다시 생성해줌

<app.module.ts> -typeOrm 사용 설정

import { Module } from '@nestjs/common';

import { BoardsModule } from './boards/boards.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { typeORMConfig } from './configs/typeorm.config';

@Module({
  imports: [
    TypeOrmModule.forRoot(typeORMConfig),
    BoardsModule],

})
export class AppModule {}

• forRoot안에 넣어준 설정(configuration)은 모든 Sub-Module 부수적인 모듈들에 다 적용이 된다.

게시물을 위한 엔티티(Entity) 생성하기

왜 Entity를 생성해야하나?

원래 ORM 없이 데이터베이스 테이블을 생성할 때는 아래와 같다.

CREATE TABLE board ( 
   id     INTEGER AUTO_INCREMENT PRIMARY KEY. 
   title  VARCHAR(255)  NOT NULL,
   decsription VARCHAR(255) NOT NULL  
)

하지만 TypeORM을 사용할 때는 Class를 사용해서 데이터베이스 테이블로 변환시켜주기 때문에 클래스를 생성한 후 그 안에 컬럼들을 정의해주면 된다.

엔티티 생성 코드

<board.entity.ts>

@Entity()

Entity () 데코레이터 클래스는 Board 클래스가 엔티티임을 나타내는 데 사용 (sql 문의 CREATE TABLE board 부분)

@PrimaryGeneratedColumn()

PrimaryGeneratedColumn () 데코레이터 클래스는 id 열이 Board 엔터티의 기본 키 열임을 나타내는 데 사용

@Column()

Column () 데코레이터 클래스는 Board 엔터티의 title 및 description과 같은 다른 열을 나타내는 데 사용

Repository 생성하기

Repository

리포지토리는 엔터티 개체와 함께 작동하며 엔티티 찾기, 삽입, 업데이트, 삭제 등을 처리 Repository란? 데이터베이스에 관련 된 일(INSERT, FIND, DELETE..등등)은 서비스에서 하는게 아닌 Repository에서 해주면 된다. 이것을 Repository Pattern 이라고도 한다.

Repository 생성하기

1. 리포지토리 파일 생성하기

2. 생성한 파일에 리포지토리를 위한 클래스 생성하기 (BoardRepository) <board.repository.ts>

   import { EntityRepository, Repository } from "typeorm";
   import { Board } from "./board.entity";
   

@EntityRepository(Board) export class BoardRepository extends Repository{

}

- 생성 시 Repository 클래스를 Extends 해줍니다. (Find, Insert, Delete 등 엔티티를 컨트롤 해줄 수 있습니다.) 

@EntityRepository()
- 클래스를 사용자 정의(CUSTOM) 저장소로 선언하는 데 사용
사용자 지정 저장소는 일부 특정 엔터티를 관리하거나 일반 저장소 일 수 있다. 

3. 생성한 Repository를 다른곳에서도 사용할 수 있기 위해서(Injectable) board.module에서 import 해준다. 
< board.module.ts>
```ts
import { Module } from '@nestjs/common';
import { BoardsController } from './boards.controller';
import { BoardsService } from './boards.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { BoardRepository } from './board.repository';

@Module({
  imports:[TypeOrmModule.forFeature([BoardRepository])],
  controllers: [BoardsController],
  providers: [BoardsService]
})
export class BoardsModule {}

Cannot find module '@nestjs/core' or its corresponding type declarations.

라는 오류였고, 쉽게 해결 할 수 있었다. terminal 에 'npm install @nestjs/core'와 'npm install @nestjs/common' 을 입력하여 해결하였다.

모든 게시물을 가져오는 서비스 만들기 (CRUD => R)

모든 게시물 데이터를 데이터베이스에서 가져오는 로직 구현

로직은 Service에서 구현. 바로 데이터베이스와 연동해서 하면 되지만 처음부터 데이터베이스 연결해서 하면 헷갈릴수있기 때문에 우선 데이터를 로컬 메모리에 담아서 처리 <board.service.ts>

 import { Injectable } from '@nestjs/common';

@Injectable()
export class BoardsService {
    private boards =[];

    getAllBoards(){
        return this.boards;
    }
}

private boards의 private 사용 이유 : 사용하지 않으면 다른 컴포넌트에서 이 BoardsService에 접근해서 이 boards 배열 값을 수정할 수 있기 때문

<board.controller.ts>

import { Controller, Get } from '@nestjs/common';
import { BoardsService } from './boards.service';

@Controller('boards')
export class BoardsController {
    constructor(private boardService: BoardsService) {}

    @Get()
    getAllBoard() {
        return this.boardService.getAllBoards;
    }
}

'npm run start:dev' 로 실행, localhost:3000/boards 확인 => 클라이언트에서 요청을 보내면 먼저 컨트롤러로 가며 컨트롤러에서 알맞은 요청 경로에 라우팅해서 해당 핸들러로 가게 한다. 그런 후에 요청을 처리해주기 위해서 서비스로 들어가며 그 요청에 맞는 로직을 서비스에서 처리해준 후 컨트롤러에 리턴값을 보내준후 컨트롤러에서 클라이언트로 결과값을 보내준다. *컨트롤러에서는 요청을 처리하고 결과값을 리턴해주는 역할을 한다. *

Board Model 정의하기

게시물 데이터에는 ID가 필요하고 이름이나 설명등이 필요 하다는 정의를 토대로 시작!

모델을 정의하기 위해서

Class를 이용하거나 Interface 이용

• Interface : 변수의 타입만 체크
• Classes : 변수의 타입, 인스턴스 또한 생성 가능

우선 Interface 사용

• status : 게시글이 공개인지 비공개인지 나눠주는 것 두가지 상태 이외의 것은 나오면 안되기 때문에 타입스크립스의 기능인 enumeration을 사용

<board.model.ts>

export interface Board{
    id : string,
    title : string,
    dedcription: string,
    status: BoardStatus; //PUBLIC or PRIVATE
}

export enum BoardStatus {
    PUBLIC = 'PUBLIC',
    PRIVATE ='PRIVATE' 
}

생성한 Board 모델을 이용해서 타입을 정의 ⬇ <boards.service.ts>

import { Injectable } from '@nestjs/common';
import { Board } from './board.model';

@Injectable()
export class BoardsService {
    private boards: Board[] = []; // 배열주의

    getAllBoards(): Board[] { //배열주의
        return this.boards;
    }
}

<boards.controller.ts>

import { Controller, Get } from '@nestjs/common';
import { BoardsService } from './boards.service';
import { Board } from './board.model';

@Controller('boards')
export class BoardsController {
    constructor(private boardsService: BoardsService) {}

    @Get('/')
    getAllBoard(): Board[] { //배열주의
        return this.boardsService.getAllBoards();
    }
}

타입을 정의하면 좋은 이유

1. 타입을 정의해주므로서 원하는 타입과 다른 코드를 사용할 시 에러가 발생
2. 코드를 읽는 입장에서 더 코드를 쉽게 이해하며 읽을 수 있다. (readable)

게시물 생성하기 (CRUD => C) : Service

게시물 생성 기능 만들기

게시물에 관한 로직을 처리하는 부분은 Service , Service 에서 처리 후 Controller에서 서비스를 호출

id 는 모든 게시물에 유니크 해야한다. 만약 데이터베이스에 데이터를 넣어주는 경우라면 데이터베이스에서 알아서 유니크한 값을 주지만 지금은 임의로 값을 주어야함 => uuid 모듈을 이용

uuid 모듈

npm install uuid --save

service 에 'import { v1 as uuid } from 'uuid';' 추가

<boards.service.ts>

import { Injectable } from '@nestjs/common';
import { Board, BoardStatus } from './board.model';
import { v1 as uuid } from 'uuid';

@Injectable()
export class BoardsService {
    private boards: Board[] = [];

    getAllBoards(): Board[] {
        return this.boards;
    }

    createBoard(title: string, description: string){
        const board: Board={
            id: uuid(),
            //title: title -> 그냥 title로 생략가능 : 앞뒤 변수명이 동일
            title,
            // description: description
            description,
            status: BoardStatus.PUBLIC
        }

        //게시판에 게시글 생성한 것을 넣어주기
        this.boards.push(board);
        return board;
    }
}

게시물 생성하기 (CRUD => C) : Controller

Request, Response

controller 에 정의

클라이언트에서 보내온 값을 핸들러에 가져오기

클라이언트에서의 정보 받아오기 => @Body body .. <boards.controller.ts>

import { Body, Controller, Get, Post } from '@nestjs/common';
import { BoardsService } from './boards.service';
import { Board } from './board.model';

@Controller('boards')
export class BoardsController {
    constructor(private boardsService: BoardsService) {}

    @Get('/')
    getAllBoard(): Board[] {
        return this.boardsService.getAllBoards();
    }

    //body 전체 한번에 가져오기
    // @Post()
    // createBoard(@Body() body) {
    //     console.log('body', body);
    // }

    //body 의 특정 값만 가져오기
    // @Post()
    // createBoard(@Body('title') title: string, @Body('description') description: string) {
    //     console.log('title', title);
    //     console.log('description', description);
    // }

    @Post()
    createBoard(@Body('title') title: string, @Body('description') description: string): Board { //return 값의 타입은 Board, Board[]로 주면 안됨 : service의 createBoard의 return 값이 board 하나이기 때문에
        return this.boardsService.createBoard(title, description);
    }

}

위의 주석 중요!!

POSTMAN 으로 테스트

Data transfer Object(DTO)

DTO (Data Transfer Object)

• 계층간 데이터 교환을 위한 객체

• DB에서 데이터를 얻어 Service나 Controller 등으로 보낼 때 사용하는 객체
• DTO는 데이터가 네트워크를 통해 전송되는 방법을 정의하는 객체
• interface나 class를 이용해서 정의 될 수 있다. (하지만 클래스를 이용하는것을 Nest JS에서는 추천)

DTO를 쓰는 이유

• 데이터 유효성을 체크하는데 효율적
• 더 안정적인 코드로 만들어 준다.
• 타입스크립트의 타입으로도 사용된다.

프로퍼티(title, description...)가 많을 때 프로퍼티의 이름을 바꿔야한다면 controller, service 등 여러 곳에서 바꿔줘야한다. => 유지보수가 힘듦 => DTO 사용

게시물 생성을 위한 DTO

DTO 파일 작성

클래스는 인터페이스와 다르게 런타임에서 작동하기 때문에 파이프 같은 기능을 이용할 때 더 유용하다. => 클래스를 사용해서 DTO를 작성 <create-board.dto.ts>

export class createBoardDto{
    title: string;
    description: string;
}

DTO 적용하기

<boards.controller.ts>

import { Body, Controller, Get, Post } from '@nestjs/common';
import { BoardsService } from './boards.service';
import { Board } from './board.model';
import { createBoardDto } from './dto/create-board.dto';

@Controller('boards')
export class BoardsController {
    constructor(private boardsService: BoardsService) {}

    @Get('/')
    getAllBoard(): Board[] {
        return this.boardsService.getAllBoards();
    }

    //body 전체 한번에 가져오기
    // @Post()
    // createBoard(@Body() body) {
    //     console.log('body', body);
    // }

    //body 의 특정 값만 가져오기
    // @Post()
    // createBoard(@Body('title') title: string, @Body('description') description: string) {
    //     console.log('title', title);
    //     console.log('description', description);
    // }

    @Post()
    createBoard(
        @Body() createBoardDto: createBoardDto
    ): Board { //return 값의 타입은 Board, Board[]로 주면 안됨 : service의 createBoard의 return 값이 board 하나이기 때문에
        return this.boardsService.createBoard(createBoardDto);
    }

}

<boards.service.ts>

import { Injectable } from '@nestjs/common';
import { Board, BoardStatus } from './board.model';
import { v1 as uuid } from 'uuid';
import { createBoardDto } from './dto/create-board.dto';

@Injectable()
export class BoardsService {
    private boards: Board[] = [];

    getAllBoards(): Board[] {
        return this.boards;
    }

    createBoard(createBoardDto: createBoardDto){
        // const title = createBoardDto.title;
        // const description = createBoardDto.description;
        const { title, description }= createBoardDto;
        const board: Board={
            id: uuid(),
            //title: title -> 그냥 title로 생략가능 : 앞뒤 변수명이 동일
            title,
            // description: description
            description,
            status: BoardStatus.PUBLIC
        }

        //게시판에 게시글 생성한 것을 넣어주기
        this.boards.push(board);
        return board;
    }
}

ID로 특정 게시물 가져오기

service -> controller

<service.ts>

getBoardIs(id: string): Board{ //게시물 하나를 return 하기 때문에 Board[] X
        return this.boards.find((board)=>board.id === id);
    }

<controller.ts>

@Get('/:id')
    getBoardById(@Param('id') id: string): Board{
        return this.boardsService.getBoardId(id);
    }

Param

//ex) localhost:3000?id=11111 일 때는 
findOne(@Param('id') id: string)
//ex) localhost:3000?id=11111&title=abcd 일 때는 
findOne(@Param() params: string[])

ID로 특정 게시물 지우기

service -> controller

<service.ts>

deleteBoard(id: string): void{ // return 을 따로 주지 않아도 되기 때문에 void
        this.boards = this.boards.filter((board) => board.id !==id);
    }

<controller.ts>

@Delete('/:id')
    deleteBoard(@Param('id') id: string): void {
        this.boardsService.deleteBoard(id);
    }

특정 게시물의 상태 업데이트

특정 게시물의 상태(PUBLIC 또는 PRIVATE)을 업데이트 해주는 기능 <service.ts>

updateBoardStatus(id:string, status: BoardStatus):Board {
        const board = this.getBoardId(id);
        board.status = status;
        return board;
    }

<controller.ts>

@Patch('/:id/status')
    updateBoardStatus(
        @Param('id') id: string,
        @Body('status') status: BoardStatus
    ) {
        return this.boardsService.updateBoardStatus(id, status);
    }

NestJS는 효율적이고 확장가능한 Node.js 어플리케이션을 구축하기 위한 프레임워크이다.

내부적으로 Nest는 Express (기본값)와 같은 강력한 HTTP 서버 프레임 워크를 사용하며 선택적으로 Fastify를 사용하도록 구성 할 수도 있다.

Nest JS CLI 설치

게시물 CRUD 어플리케이션 소개

이러한 어플리케이션을 제작할 예정이다.

• 게시글에 관한 모듈(BoardModule)
• 게시글을 만드는 사람에 대한 인증 모듈(AuthModule)

프로젝트 시작하기

프로젝트 생성

1. 원하는 디렉토리 내에 프로젝트 폴더 생성

   mkdir nestjs-board-app

2. 프로젝트 폴더로 이동 후

   nest new ./  입력
   npm 선택

3. vscode 로 프로젝트 폴더 열기

NestJS 기본 구조 설명

• eslintrc.js
  • 규칙을 가지고 코드를 깔끔하게 짤수있게 도와주는 라이브러리
  • 타입스크립트 가이드라인 제시, 문법에 오류가 나면 알려주는 역할
• .prettierrc
  • 코드의 형식을 맞춰준다.
  • 작은따옴표(')를 사용할지 큰 따옴표(")를 사용할지,Indent 값을 2로 줄지 4로 줄지 등등
  • 에러를 찾는 것이 아닌 코드 포멧터 역할(eslintrc.js와 차이점)
• nest-cli.json
  • nest 프로젝트를 위해 특정한 설정을 할 수 있는 json 파일
• tsconfig.json
• tsconfig.build.json
• package.json
  • 프로젝트 이름, 작성자 등등
  • 라이브러리 목록, 명령어 목록 등등
• src
  • 프로젝트를 위한 로직들이 들어가있음
  • main.ts : 앱을 생성하고 실행, 시작점..
  • app.module.ts : 앱 모듈을 정의

실행해보고 싶다면 터미널에

npm run start:dev
#start:dev 는 package.json에 나옴

<결과> main.ts 의 await app.listen(3000); => 3000번 포트이기 때문에

기본 구조에서 살펴보는 NestJS 로직 흐름

Hello World 텍스트를 출력하는 API

main.ts의

 const app = await NestFactory.create(AppModule);

AppModule에 가면 AppController, AppService 가 등록이 되어있다.

클라이언트(브라우저)에서 서버(nestjs-app)로 요청을 주면 app.controller 로 온다. Get 메서드로 실행, app.service 를 return getHello 실행하여 브라우저로 return

NestJS 모듈이란?

NestJS를 사용해서 만드는 앱 구조

App Module안에 BoardModule과 AuthModule이 있으면 각 모듈안에 Controller Entity Service등이 있다.

NestJS?

모듈은 @Module () 데코레이터로 주석이 달린 클래스다. @Module () 데코레이터는 Nest가 애플리케이션 구조를 구성하는 데 사용하는 메타 데이터를 제공한다. 각 응용 프로그램에는 하나 이상의 모듈 (루트 모듈) 이 있다. 루트 모듈은 Nest가 사용하는 시작점이다. 모듈은 기본적으로 싱글 톤이므로 여러 모듈간에 쉽게 공급자의 동일한 인스턴스를 공유 할 수 있다. => 어떠한 모듈 하나를 만들면 여러 모듈에서 사용이 가능한다.(밑 이미지)

Board Module 생성하기

우선 src 에 app.service, appcontroller, app.spec 파일 삭제, app.moule의 내용 수정, test 폴더 삭제 <app.module.ts>

import { Module } from '@nestjs/common';

@Module({
  imports: [],

})
export class AppModule {}

모듈 생성하기

nest g module boards

nest: using nestcli g: generate module: schematic that i want to create boards: name of the schematic

위 명령어를 입력하니 nest.ps1 파일을 로드할 수 없다는 에러가 발생해서 Window PowerShell을 관리자 권한으로 연 후

get-ExecutionPolicy
=> Restricted 확인

Set-ExecutionPolicy Unrestricted
Y 입력

get-ExecutionPolicy
=> Unrestricted 확인

위의 과정을 하고 실행하니 정상적으로 되었다. boards 폴더 생성확인 ! BoardsModule import 확인 ! <app.module.ts>

import { Module } from '@nestjs/common';
import { BoardsModule } from './boards/boards.module';
@Module({
  imports: [BoardsModule],
})
export class AppModule {}

NestJS Controllers 이란?

Controller란?

컨트롤러는 들어오는 요청을 처리하고 클라이언트에 응답을 반환한다.

@Controller 데코레이터로 클래스를 데코레이션하여 정의된다.

Handler 란 ?

핸들러는 @Get, @Post, @Delete 등과 같은 데코레이터로 장식된 컨트롤러 클래스 내의 단순한 메서드이다.

Boards Controller 생성하기

nest g controller boards --no-spec
=> boards.controller.ts 생성

nest: using nestcli g: generate controller: controller schematic boards: name of the schematic --no-spec: 테스트를 위한 소스 코드 생성 x

CLI로 명령어 입력 시 Controller 만드는 순서

NestJS Providers, Service 란?

Provides 란?

프로바이더는 Nest의 기본 개념이다. 대부분의 기본 Nest 클래스는 서비스, 리포지토리, 팩토리, 헬퍼등 프로바이더로 취급될 수 있다. 프로바이더의 주요 아이디어는 종속성으로 주입할 수 있다는 것이다. 즉, 객체는 서로 다양한 관계를 만들 수 있으며 객체의 인스턴스를 "연결"하는 기능은 대부분 Nest 런타임 시스템에 위임될 수 있다. => Controller 에서 필요하는 많은 것들을 Controller 내에서 다 처리할 수 없으므로 기능별로 서비스, 리포지토리, 팩토리, 헬퍼 등을 넣어서 사용한다 . => 종속성을 주입한다.

Service 란?

@Injectable 데코레이터로 감싸져서 모듈에 제공되며, 이 서비스 인스턴스는 애플리케이션 전체에서 사용 될 수 있다. 서비스는 컨트롤러에서 데이터의 유효성 체크를 하거나 데이터베이스에 아이템을 생성하는 등의 작업을 하는 부분을 처리한다.

Service를 Controller에서 이용할 수 있는 방법( Dependency Injection)

위에 보면 Contoller에서 this.appService.getHello(); 이런식으로 Service에 정의해놓은 메소드를 Controller에서 가져와서 쓰는 걸 볼 수 있다. 위에 보면 BoardsService를 Constructor 클래스에서 가져오고(Injected) 있다. 그런 후에 Private 문법을 사용하고 있다. 이렇게 해서 boardsService를 정의해서 Controller안에서 사용할수 있게 한다. => 이렇게 할 수 있는 이유는 타입스크립트의 기능을 이용해서 종속성을 타입으로 해결할수 있기 때문이다.

Provider 등록하기

Provider를 사용하기 위해서는 이것을 Nest에 등록해줘야지 사용할 수 있다. 등록하기 위해서는 module 파일에서 할 수 있습다. module 파일에 providers항목안에 해당 모듈에서 사용하고자 하는 Provider 를 넣어주시면 됩니다.

Boards Service 만들기

nest g service boards --no-spec
=>boards.service.ts 생성

Board Service

boards.service.ts 파일 안에는 Injectable 데코레이터가 있으며 이 NestJS는 이것을 이용해서 다른 컴포넌트에서 이 서비스를 사용 할 수있게(Injectable)만들어준다. 그리고 CLI로 Service 생성시에는 module에도 자동으로 Service가 추가된다.

 providers: [BoardsService]

Board Service를 Board Controller에서 이용할 수 있게 해주기(Dependency Injection)(종속성 주입)

Controller class의 constructor 안에서 종속성 주입이 이루어진다.

원래는..

Typescriptdml 기능으로 코드를 간결하게 할 수 있다. (자바스크립트에서는 private같은 접근 제한자(Access modifier)를 사용할수 없지만 Typescript에서는 사용가능하다.)

1. boardsService 파라미터에 BoardsService 객체를 타입으로 지정
2. 이 boardsService 파라미터를 BoardsController 클래스 안에서 사용하기 위해서 this.boardsService 프로퍼티에 boardsService 파라미터를 할당
3. 하지만 타입스크립트에서는 선언한 값만 객체의 프로퍼티로 사용가능하기 때문에 위에 boardsService: BoardsService로 선언
4. 이렇게 갖게된 boardsService 프로퍼티를 이용해서 BoardsController 클래스안에서 활용을 할수가 있다.

   접근 제한자를 이용해서 소스 간단하게 하기

접근 제한자(public, protected, private) 을 생성자(constructor) 파라미터에 선언 =>접근 제한자가 사용된 생성자 파라미터는 암묵적으로 클래스 프로퍼티로 선언

Private을 사용하면 ?

private이 선언되었기 때문에 boardsService 프로퍼티는 BoardsController 클래스 *내부에서만 * 사용 가능

사용하는 값을 변수에 직접 넣을 수 있는 기 본형, 그리고 이전에 본 Student student1 과 같이 객체가 저장된 메모리의 위치를 가리키는 참조값을 넣을 수 있는 참조형으로 분류할 수 있다.

• 기본형(Primitive Type): int , long , double , boolean 처럼 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입을 기본형이라 한다.
  • 참조형(Reference Type): Student student1 , int[] students 와 같이 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입을 참조형이라 한다. 참조형은 객체 또는 배열에 사용된다.
    • 객체는 . (dot)을 통해서 메모리 상에 생성된 객체를 찾아가야 사용할 수 있다.
    • 배열은 [] 를 통해서 메모리 상에 생성된 배열을 찾아가야 사용할 수 있다.

기본형은 연산이 가능하지만 참조형은 연산이 불가능하다.

int a = 10, b = 20;
int sum = a + b;

Student s1 = new Student();
Student s2 = new Student();
s1 + s2 //오류 발생

Student s1 = new Student();
s1.grade = 100;
Student s2 = new Student();
s2.grade = 90;
int sum = s1.grade + s2.grade; //연산 가능

기본형을 제외한 나머지는 모두 참조형이다.

• 기본형은 모두 소문자로 시작한다. int, long, double,boolean...
• 클래스는 대문자로 시작한다. 클래스는 모두 참조형이다.

기본형 vs 참조형2 - 변수 대입

대원칙: 자바는 항상 변수의 값을 복사해서 대입한다

• 기본형 대입

  int a = 10;
  int b = a;

• 참조형 대입

  Student s1 = new Student();
  Student s2 = s1;

  =>_참조형의 경우 실제 사용하는 객체가 아니라 객체의 위치를 가리키는 참조값만 복사_된다. 쉽게 이야기해서 실제 건물이 복사가 되는 것이 아니라 건물의 위치인 주소만 복사되는 것이다. 따라서 같은 건물을 찾아갈 수 있는 방법이 하나 늘어날 뿐이다.

기본형과 변수 대입

<VarChange1.java>

public class VarChange1 {
    public static void main(String[] args) {
        int a = 10;
        int b = a;
        System.out.println("a = " + a); //10
        System.out.println("b = " + b); //10

        //a 변경
        a = 20;
        System.out.println("변경 a = 20");
        System.out.println("a = " + a); //20
        System.out.println("b = " + b); //10

        //b 변경
        b = 30;
        System.out.println("변경 b = 30");
        System.out.println("a = " + a); //20
        System.out.println("b = " + b); //30
    }
}

참조형 변수 대입

<Data.java>

package ref;

public class Data {
    int value;
}

<VarChange2.java>

package ref;

public class VarChange2 {

        public static void main(String[] args) {
            Data dataA = new Data();
            dataA.value = 10;
            Data dataB = dataA;

            System.out.println("dataA 참조값=" + dataA);
            System.out.println("dataB 참조값=" + dataB);
            System.out.println("dataA.value = " + dataA.value); //10
            System.out.println("dataB.value = " + dataB.value); //10

            //dataA 변경
            dataA.value = 20;
            System.out.println("변경 dataA.value = 20");
            System.out.println("dataA.value = " + dataA.value); //20
            System.out.println("dataB.value = " + dataB.value); //20

            //dataB 변경
            dataB.value = 30;
            System.out.println("변경 dataB.value = 30");
            System.out.println("dataA.value = " + dataA.value); //30
            System.out.println("dataB.value = " + dataB.value); //30
        }

}

** 참조값이 같다.** dataA와 dataB는 같은 참조값을 가지게 되고, 두 변수는 같은 객체 인스턴스를 참조하게된다.

기본형 vs 참조형3 - 메서드 호출

기본형과 메서드 호출

<MethodChange1.java>

package ref;

public class MethodChange1 {
    public static void main(String[] args) {
        int a = 10;
        System.out.println("메서드 호출 전: a = " + a); //10
        changePrimitive(a);
        System.out.println("메서드 호출 후: a = " + a); //10
    }
    static void changePrimitive(int x) {
        x = 20;
    }
}

1. a , x 각각 숫자 10 을 가지고 있다.

2. x 의 값만 20 으로 변경되고, a 의 값은 10 으로 유지

참조형과 메서드 호출

<MethodChange2.java>

package ref;

public class MethodChange2 {
    public static void main(String[] args) {
        Data dataA = new Data();
        dataA.value = 10;
        System.out.println("메서드 호출 전: dataA.value = " + dataA.value); // 10
        changeReference(dataA);
        System.out.println("메서드 호출 후: dataA.value = " + dataA.value);// 20
    }
    static void changeReference(Data dataX) {
        dataX.value = 20;
    }
}

dataX 에 변수 dataA 의 값을 전달

Data dataX = dataA

변수 dataA 는 참조값 x001 을 가지고 있으므로 참조값을 복사해서 전달했다. 따라서 변수 dataA , dataX 둘다 같은 참조값인 x001 을 가지게 된다. 이제 dataX 를 통해서도 x001 에 있는 Data 인스턴스에 접근할 수 있다.

기본형과 참조형의 메서드 호출

• 기본형: 메서드로 기본형 데이터를 전달하면, 해당 값이 복사되어 전달된다. 이 경우, 메서드 내부에서 매개변수(파라미터)의 값을 변경해도, 호출자의 변수 값에는 영향이 없다.
• 참조형: 메서드로 참조형 데이터를 전달하면, 참조값이 복사되어 전달된다. 이 경우, 메서드 내부에서 매개변수(파라미터)로 전달된 객체의 멤버 변수를 변경하면, 호출자의 객체도 변경된다.

참조형과 메서드 호출 - 활용

<Method1.java>

package ref;

public class Method1 {
    public static void main(String[] args) {
        Student student1 = new Student();
        initStudent(student1,"학생1", 16, 85);

        Student student2 = new Student();
        initStudent(student2, "학생2",19, 90);

        printStudent(student1);
        printStudent(student2);
    }
    static void initStudent(Student student, String name, int age, int grade){
        student.name = name;
        student.age = age;
        student.grade = grade;
    }
    static void printStudent(Student student){
        System.out.println("이름:" + student.name + " 나이:" + student.age + " 성적:" + student.grade);
    }

}

** 주의 **

```java
package ref;

import class1.Student;

public class Method1 {
 ...
}

• import class1.Student; 이 선언되어 있으면 안된다.

메서드에서 객체 변환

학생정보를 입력하는 부분이 중복으로 나오는데 이부분도 하나로 합쳐보자. <Method2.java>

package ref;

public class Method2 {
    public static void main(String[] args) {

        Student student1 = createStudent("학생1", 16, 85);
        Student student2 = createStudent( "학생2",19, 90);

        printStudent(student1);
        printStudent(student2);
    }
    static Student createStudent(String name, int age, int grade){
        Student student = new Student();
        student.name = name;
        student.age = age;
        student.grade = grade;
        return student;
    }
    static void printStudent(Student student){
        System.out.println("이름:" + student.name + " 나이:" + student.age + " 성적:" + student.grade);
    }

}

createStudent() 는 생성한 Student 인스턴스의 참조값을 반환한다. 이렇게 반환된 참조값을 student1 변수에 저장했다. 앞으로는 student1 을 통해 Student 인스턴스를 사용할 수 있다.

변수와 초기화

변수의 종류

• 멤버변수(필드) : 클래스에 선언
• 지역변수 : 메서드에 선언, 매개변수도 지역변수의 한 종류이다.

  변수의 값 초기화

• 멤버변수 : 자동초기화
  • 인스턴스의 멤버 변수는 인스턴스를 생성할때 자동으로 초기화된다.
  • int =0, boolean = false, 참조형 =null
• 지역변수 : 수동 초기화

null

null 값 할당

<NullMain1.java>

package ref;

public class NullMain1 {
    public static void main(String[] args) {
        Data data = null;
        System.out.println("1.  data = "+data);
        data = new Data();
        System.out.println("2.  data = "+data);
        data=null;
        // data 변수는 앞서 만든 Data 인스턴스를 더는 참조하지 않는다.
        System.out.println("3.  data = "+data);
    }
}

GC(가비지 컬렉션)

data 에 null 을 할당하면 생성한 x001 Data 인스턴스를 더는 아무도 참조하지 않는다. 이렇게 아무도 참조하지 않게 되면 x001 이라는 참조값을 다시 구할 방법이 없다. 따라서 해당 인스턴스에 다시 접근할 방법이 없다. -> 아무도 참조하지 않는 인스턴스는 메모리 낭비 -> 자바는 낭비되는 메모리를 자동으로 삭제해준다.

NullPointerException

null 을 가리키다(Pointer)인데, 이때 발생하는 예외(Exception)다. null 은 없다는 뜻이므로 결국 주소가 없는 곳을 찾아갈 때 발생하는 예외이다.

객체를 참조할 때는 . (dot)을 사용한다. 이렇게 하면 참조값을 사용해서 해당 객체를 찾아갈 수 있다. 그런데 참조값이 null 이라면 값이 없다는 뜻이므로, 찾아갈 수 있는 객체(인스턴스)가 없다. NullPointerException 은 이처럼 null 에 . (dot)을 찍었을 때 발생한다.

<NullMain2.java>

package ref;

public class NullMain2 {
    public static void main(String[] args) {
        Data data = null;
        data.value = 10; //=null.value = 10
        System.out.println("data = "+data.value);
    }
}

=> java.lang.NullPointerException 이 발생

멤버변수와 null

<NullMain3.java>

package ref;

public class NullMain3 {
    public static void main(String[] args) {
        BigData bigData = new BigData();
        System.out.println("bigData.count = "+ bigData.count);
        System.out.println("bigData.data = "+ bigData.data);

        //NullPointerException
        System.out.println("bigData.data.value=" + bigData.data.value);
        //null 값에 .(dot)을 찍으면 예외가 발생한다.
    }
}

=> null 에러

<NullMain4.java>

package ref;

public class NullMain4 {
    public static void main(String[] args) {
        BigData bigData = new BigData();
        bigData.data = new Data();
        System.out.println("bigData.count = "+ bigData.count);
        System.out.println("bigData.data = "+ bigData.data);

        System.out.println("bigData.data.value=" + bigData.data.value);
    }
}

문제와 풀이

<ProductOrderMain2.java>

package ref.ex;

public class ProductOrderMain2 {
    public static void main(String[] args) {
        int total;
        ProductOrder[] productOrders = {
                createOrder("사과",2000,3),
                createOrder("바나나",1000,7)
        };
        printOrder(productOrders);
        total= getTotal(productOrders);
        System.out.println("총 금액 : "+total);

    }
    static ProductOrder createOrder(String name, int price, int quantity){
        ProductOrder productOrder = new ProductOrder();
        productOrder.name = name;
        productOrder.price = price;
        productOrder.quantity = quantity;

        return productOrder;
    }
    static void printOrder(ProductOrder[] orders){

        for (ProductOrder order :orders){
            System.out.println("이름 : "+order.name +"  가격 : "+ order.price+ "   수량 : "+order.quantity);
        }
    }

    public static int  getTotal(ProductOrder[] orders){
        int total =0;
        for(ProductOrder order: orders){
            total += order.price*order.quantity;
        }
        return total;
    }
}

<ProductOrderMain3.java>

package ref.ex;

import java.util.Scanner;

public class ProductOrderMain3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("입력할 주문의 개수를 입력하세요:");
        int count = input.nextInt();
        input.nextLine();

        ProductOrder[] productOrders = new ProductOrder[count];

        for(int i =0; i<count;i++){
            System.out.println((i+1)+"번째 주문 정보를 입력하세요.");

            System.out.print("상품명: " );
            String name = input.nextLine();

            System.out.print("가격: ");
            int price = input.nextInt();

            System.out.print("수량: ");
            int quantity = input.nextInt();

            input.nextLine(); // 입력 버퍼를 비우기 위한 코드

            productOrders[i]=createOrder(name, price, quantity);
        }

        printOrder(productOrders);
        int total= getTotal(productOrders);
        System.out.println("총 금액 : "+total);

    }
    static ProductOrder createOrder(String name, int price, int quantity){
        ProductOrder productOrder = new ProductOrder();
        productOrder.name = name;
        productOrder.price = price;
        productOrder.quantity = quantity;

        return productOrder;
    }
    static void printOrder(ProductOrder[] orders){

        for (ProductOrder order :orders){
            System.out.println("이름 : "+order.name +"  가격 : "+ order.price+ "   수량 : "+order.quantity);
        }
    }

    public static int  getTotal(ProductOrder[] orders){
        int total =0;
        for(ProductOrder order: orders){
            total += order.price*order.quantity;
        }
        return total;
    }
}

클래스가 필요한 이유

<ClassStart1.java>

package class1;

public class ClassStart1 {
    public static void main(String[] args) {
        String student1Name = "학생1";
        int student1Age = 15;
        int student1Grade = 90;

        String student2Name = "학생2";
        int student2Age = 16;
        int student2Grade = 80;

        System.out.println("이름:" + student1Name + " 나이:" + student1Age + " 성 적:" + student1Grade);
        System.out.println("이름:" + student2Name + " 나이:" + student2Age + " 성 적:" + student2Grade);
    }
}

=> 학생이 늘어날 때 마다 변수를 추가로 선언해야하고, 출력코드 또한 추가해야한다.

<ClassStart2.java>

package class1;

public class ClassStart2 {
    public static void main(String[] args) {
        String[] studentNames = {"학생1", "학생2"};
        int[] studentAges = {15, 16};
        int[] studentGrades = {90, 80};

        for (int i = 0; i < studentNames.length; i++) {
            System.out.println("이름:" + studentNames[i] + " 나이:" +
                    studentAges[i] + " 성적:" + studentGrades[i]);
        }
    }
}

=> 배열을 활용, 배열에 학생의 데이터만 추가하면 된다. => 배열의 한계 : 한 학생의 데이터를 지우기 위해 3개의 배열의 인덱스를 맞춰줘야한다.

학생이라는 개념을 하나로 묶고, 각각의 학생 별로 본인의 이름, 나이, 성적을 관리하자!

클래스 도입

<Student 클래스> <Student.java>

package class1;

public class Student {
    String name;
    int age;
    int grade;
}

=> class 키워드를 사용해서 학생클래스(Student)를 정의, 학생 클래스 내부에 이름, 나이, 성적 변수를 가진다.

이렇게** 클래스에 정의한 변수들을 멤버변수 또는 필드**라고 한다.

• 멤버변수(Member Variable): 특정 클래스에 소속된 멤버

• 필드(Field): 데이터 항목을 가리키는 용어
• 자바에서 멤버변수, 필드는 같은 뜻이고 클래스에 소속된 변수를 뜻한다.

클래스는 관례상 대문자로 시작하고 낙타표기법을 사용

<ClassStart3.java>

package class1;

public class ClassStart3 {
    public static void main(String[] args) {
        Student student1;
        student1 = new Student();
        student1.name = "학생1";
        student1.age = 15;
        student1.grade = 90;

        Student student2 = new Student();
        student2.name = "학생2";
        student2.age = 16;
        student2.grade = 80;

        System.out.println("이름:" + student1.name + " 나이:" + student1.age
                + " 성 적:" + student1.grade);
        System.out.println("이름:" + student2.name + " 나이:" + student2.age
                + " 성 적:" + student2.grade);
    }
}

클래스와 사용자 정의 타입

• 클래스를 사용하면 int, String 과 같은 타입을 만들 수 있다.
• 사용자가 직접 정의하는 사용자의 정의타입을 만들려변 설계도가 필요하다. 이 설계도가 바로 클래스이다.
• 설계도인 클래스를 사용해 실제 메모리에 만들어진 실체를 객체 또는 인스턴스라고 한다.
• 클래스를 통해 사용자가 원하는 종류의 타입을 마음껏 정의할 수 있다.

Student 클래스를 기반으로 student1, student2 객체 또는 인스턴스를 만들었다.

객체사용

클래스를 통해 생성한 객체를 사용하려면 먼저 메모리에 존재하는 객체에 접근해야 한다. 객체에 접근하려면 . (점, dot)을 사용하면 된다.

student1.name student1.age student2.grade ...

클래스, 객체, 인스턴스

클래스-Class

클래스는 객체가 가져야할 속석(변수)과 기능(메서드)를 정의한다. 예를 들어 학생이라는 클래스 속성으로 name, age, grade를 가진다.

객체 - Object

객체는 클래스에서 정의한 속성과 기능을 가진 실체이다. 객체는 서로 독립적인 상태를 가진다. student1은 학생1의 속성을 가지는 객체이다.

인스턴스 - Instance

인스턴스는 특정 믈래스로부터 생성된 객체를 의미한다. 인스턴스는 주로 객체가 어떤 클래스에 속해 있는지 강조할 때 사용한다. student1 객체는 Student 클래스의 인스턴스이다.

객체 vs 인스턴스

인스턴스는 객테보다 좀 더 관계에 초점을 맞춘 단어이다. 보통 student1 은 Student 의 객체이다. 라고 말하는 대신 student1 은 Student 의 인스턴스이다. 라고 특정 클래스와의 관계를 명확히 할 때 인스턴스라는 용어를 주로 사용한다. 하지만 둘다 클래스에서 나온 실체라는 핵심 의미는 같기 때문에 보통 둘을 구분하지 않고 사용한다.

배열 도입 - 시작

배열을 사용하면 특정 타입을 연속한 데이터 구조로 묶어서 편리하게 관리할 수 있다. <ClassStart4.java>

package class1;

public class ClassStart4 {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "학생1";
        student1.age = 15;
        student1.grade = 90;

        Student student2 = new Student();
        student2.name = "학생2";
        student2.age = 16;
        student2.grade = 80;

        Student[] students = new Student[2];
        students[0]= student1;
        students[1]= student2;

        System.out.println("이름:" + students[0].name + " 나이:" + students[0].age
                + " 성적:" + students[0].grade);
        System.out.println("이름:" + students[1].name + " 나이:" + students[1].age
                + " 성적:" + students[1].grade);
    }
}

배열 도입 - 리펙토링

package class1;

public class ClassStart5 {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "학생1";
        student1.age = 15;
        student1.grade = 90;

        Student student2 = new Student();
        student2.name = "학생2";
        student2.age = 16;
        student2.grade = 80;

        //배열 선언
        Student[] students = new Student[]{student1, student2};

        //for문 적용
        for (int i = 0; i < students.length; i++) {
            System.out.println("이름:" + students[i].name + " 나이:" +
                    students[i].age + " 성적:" + students[i].grade);
        }
    }
}

Student[] students = new Student[]{student1, student2}; -> Student[] students = {student1, student2}; 최적화 가능

for (int i = 0; i < students.length; i++) {
            System.out.println("이름:" + students[i].name + " 나이:" +
                    students[i].age + " 성적:" + students[i].grade);
        }

=>

for (Student s : students) {
 System.out.println("이름:" + s.name + " 나이:" + s.age + " 성적:" + s.grade);
}

문제와 풀이

<MovieReview.java>

package class1.ex;

public class MovieReview {
    String title;
    String review;

}

<MovieReviewMain1.java>

package class1.ex;

public class MovieReviewMain1 {
    public static void main(String[] args) {
        MovieReview movieReview = new MovieReview();

        movieReview.title="쿵푸팬더";
        movieReview.review="재밌다.";

        System.out.println("영화 제목 : "+movieReview.title+" 리뷰 : "+movieReview.review);
    }
}

<MovieReviewMain2.java>

package class1.ex;

public class MovieReviewMain1 {
    public static void main(String[] args) {
        MovieReview[] reviews = new MovieReview[2];

        MovieReview inception = new MovieReview();
        inception.title = "인셉션";
        inception.review = "인생은 무한 루프";
        reviews[0] = inception;

        MovieReview aboutTime = new MovieReview();
        aboutTime.title = "어바웃 타임";
        aboutTime.review = "인생 시간 영화!";
        reviews[1] = aboutTime;

        for (MovieReview review : reviews) {
            System.out.println("영화 제목: " + review.title + ", 리뷰: " +
                    review.review);
        }
    }
}

문제와 풀이2

<ProductOrder.java>

package class1.ex;

public class ProductOrder {
        String name;
        int price;
        int quantity;

}

<ProductOrderMain1.java>

package class1.ex;

public class ProductOrderMain1 {
    public static void main(String[] args) {
        int total =0;

        ProductOrder order1 = new ProductOrder();
        order1.name =  "사과";
        order1.price=2000;
        order1.quantity=3;

        ProductOrder order2 = new ProductOrder();
        order2.name =  "바나나";
        order2.price=1000;
        order2.quantity=7;

        ProductOrder[] orders = {order1,order2};

        for(ProductOrder o : orders){
            System.out.println("상품명:" +o.name+ "  가격:" +o.price+ "  수량:" +o.quantity);
            total += o.price*o.quantity;
        }
        System.out.println("총 금액: "+ total);

    }
}

메서드 시작

함수 (function)

add(a, b) = a + b

• 이름이 add 이고 a , b 라는 두 값을 받는 함수이다. 그리고 이 함수는 a + b 연산을 수행한다.
• add(1,2) -> 결과:3 add(5,6) -> 결과:11 add(3,5) -> 결과:8
• 같은 함수를 다른 입력 값으로 여러번 호출 할 수 있다.
• 재사용이 가능!

메서드 사용

<Method1Ref.java>

package method;

public class Method1Ref {
    public static void main(String[] args) {
        int sum1 = add(5, 10);
        System.out.println("결과1 출력:" + sum1);

        int sum2 = add(15, 20);
        System.out.println("결과2 출력:" + sum2);
    }
    //add 메서드
    public static int add(int a, int b) {
        System.out.println(a + "+" + b + " 연산 수행");
        int sum = a + b;
        return sum;
    }
}

메서드 선언

public static int add(int a, int b)

• 메서드 이름, 반환타입, 매개변수(파라미터)
• public : 다른 클래스에서 호출할 수 있는 메서드라는 뜻 static : 객체를 생성하지 않고 호출할 수 있는 정적 메서드라는 뜻 int : 반환 타입을 정의, 메서드 실행결과를 반환할 때 사용할 반환 타입을 지정한다. add : 메서드 이름 (int a, int b) : 메서드를 호출할 때 전달하는 입력값을 정의, 파라미터, 매개변수

메서드 본문

//1: 메서드 호출
int sum1 = add(5, 10);
//2: 파라미터 변수 a=5, b=10이 전달되면서 메서드가 수행된다.
public static int add(int a=5, int b=10) {
 int sum = a + b;
 return sum;
}
//3: 메서드가 수행된다.
public static int add(int a=5, int b=10) {
 int sum = a(5) + b(10);
 return sum;
}
//4: return을 사용해서 메서드 실행의 결과인 sum을 반환한다. sum에는 값 15가 들어있으므로 값 15가
반환된다.
public static int add(int a=5, int b=10) {
 int sum = 15;
 return sum(15);
}
//5: 메서드 호출 결과로 메서드에서 반환한 값 15가 나온다. 이 값을 sum1에 대입했다.
int sum1 = 15

메서드 호출과 용어정리

메서드를 호출할 때는 다음과 같이 메서드에 넘기는 값과 매개변수(파라미터)의 타입이 맞아야 한다. 물론 넘기는 값과 매개변수(파라미터)의 순서와 갯수도 맞아야 한다.

호출: call("hello", 20)
메서드 정의: int call(String str, int age)

• 인수(Argument) : 'hello', 20처럼 넘기는 값을 Argument, 인자, 인수라고 한다.
• 매개변수(Parameter) : 메서드를 정의할 때 선언한 변수인 String str , int age 를 매개변수, 파라미터라 한다. 메서드를 호출할 때 인수를 넘기면, 그 인수가 매개변수에 대입된다.

  • 인수라는 용어는 '인’과 '수’의 합성어로, '들어가는 수’라는 의미를 가진다. 즉, 메서드 내부로 들어가는 값을 의미한다. 인자도 같은 의미이다.
  • 매개변수, parameter는 '매개’와 '변수’의 합성어로, '중간에서 전달하는 변수’라는 의미를 가진다. 즉, 메서드 호출부와 메서드 내부 사이에서 값을 전달하는 역할을 하는 변수라는 뜻이다.

메서드 정의

public static int add(int a, int b) {
 //메서드 본문, 실행 코드
}
제어자 반환타입 메서드이름(매개변수 목록) {
 메서드 본문
}

• 제어자(Modifier): public , static 과 같은 부분이다. 제어자는 뒤에서 설명한다. 지금은 항상 public static 키워드를 입력하자.
• 반환 타입(Return Type): 메서드가 실행 된 후 반환하는 데이터의 타입을 지정한다. 메서드가 값을 반환하지 않는 경우, 없다는 뜻의 void 를 사용해야 한다. 예) void print(String str)
• 메서드 이름(Method Name): 메서드의 이름이다. 이 이름은 메서드를 호출하는 데 사용된다.
• 매개변수(Parameter): 입력 값으로, 메서드 내부에서 사용할 수 있는 변수이다. 매개변수는 옵션이다. 입력값이필요 없는 메서드는 매개변수를 지정하지 않아도 된다. 예) add()
• 메서드 본문(Method Body): 실제 메서드의 코드가 위치한다. 중괄호 {} 사이에 코드를 작성한다.

매개변수나 반환타입이 없는 경우

<Method2.java>

package method;

public class Method2 {
    public static void main(String[] args) {
        printHeader();
        System.out.println("프로그램이 동작합니다.");
        printFooter();
    }
    public static void printHeader() {
        System.out.println("= 프로그램을 시작합니다 =");
        return; //void의 경우 생략 가능
    }
    public static void printFooter() {
        System.out.println("= 프로그램을 종료합니다 =");
    }
}

=> String str = printHeader(); 반환 타입이 void 이기 때문에 이렇게 반환 값을 받으면 컴파일 오류가 발생한다.

void 와 return 생략 반환 타입 void 의 경우에는 예외로 printFooter() 와 같이 생략해도 된다. 자바가 반환 타입이 없는 경우에는 return 을 마지막줄에 넣어준다. 참고로 return 을 만나면 해당 메서드는 종료된다.

반환타입

<MethodReturn1.java>

package method;

public class MethodReturn1 {
    public static void main(String[] args) {
        boolean result = odd(2);
        System.out.println(result);
    }
    public static boolean odd(int i){
        if(i%2==0){
            return true;
        }else {
            return false;
        }
    }
}

return 문을 만나면 그 즉시 메서드를 빠져나간다.

<MethodReturn2.java>

package method;

public class MethodReturn2 {
    public static void main(String[] args) {
        checkAge(10);
        checkAge(20);
    }
    public static void checkAge(int age) {
        if (age < 18) {
            System.out.println(age + "살, 미성년자는 출입이 불가능합니다.");
            return;
        }
        System.out.println(age + "살, 입장하세요.");
    }
}

메서드 호출과 값 전달1

<MethodValue1.java>

package method;

public class MethodValue1 {
    public static void main(String[] args) {
        int num1 =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num1);
        changeNum(num1);
        System.out.println("4. changeNum 호출 후, num1 : "+num1);
    }
    public static void changeNum(int num2){
        System.out.println("2. changeNym 변경 전, num2 : "+num2);
        num2 *= 2;
        System.out.println("3. changeNym 변경 후, num2 : "+num2);
    }
}

메서드 호출과 값 전달2

메서드 호출과 이름이 같은 변수

<MethodValue2.java>

package method;

public class MethodValue2 {
    public static void main(String[] args) {
        int num =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num);
        changeNum(num);
        System.out.println("4. changeNum 호출 후, num1 : "+num);
    }
    public static void changeNum(int num){
        System.out.println("2. changeNym 변경 전, num2 : "+num);
        num *= 2;
        System.out.println("3. changeNym 변경 후, num2 : "+num);
    }
}

main() 에 정의한 변수와 메서드의 매개변수(파라미터)의 이름이 둘다 number 로 같다. 하지만 main() 의 number 와 changeNumber() 의 number 는 서로 다른 변수이다.

메서드 호출과 값 반환받기

메서드를 사용해서 값을 변경하기 <MethodValue3.java>

package method;

public class MethodValue3 {
    public static void main(String[] args) {
        int num =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num);
        num = changeNum(num);
        System.out.println("2. changeNum 호출 후, num1 : "+num);
    }
    public static int changeNum(int num){
        num *= 2;
        return num;
    }
}

메서드와 형변환

명시적 형변환

<MethodCasting1.java>

package method;

public class MethodCasting1 {
    public static void main(String[] args) {
        double number = 1.5;
        //printNumber(number); // double을 int형에 대입하므로 컴파일 오류
        printNumber((int) number); // 명시적 형변환을 사용해 double을 int로 변환
    }
    public static void printNumber(int n) {
        System.out.println("숫자: " + n);
    }
}

자동 형변환

int < long < double

package method;

public class MethodCasting2 {
    public static void main(String[] args) {
        int number = 100;
        printNumber(number); // int에서 double로 자동 형변환
    }
    public static void printNumber(double n) {
        System.out.println("숫자: " + n);
    }
}

메서드 오버로딩

add(int a, int b)
add(int a, int b, int c)
add(double a, double b)

=> 이름이 같고 매개변수가 다른 메서드를 여러개 정의하는 것을 메서드 오버로딩(Overloading)이라 한다.

오버로딩 규칙

메서드의 이름이 같아도 매개변수의 타입 및 순서가 다르면 오버로딩을 할 수 있다. 참고로 반환 타입은 인정하지 않는다. <오버로딩 실패>

int add(int a, int b)
double add(int a, int b)

<OverLoading1.java>

package method;

public class OverLoading1 {
    public static void main(String[] args) {
        System.out.println("1: " + add(1, 2));
        System.out.println("2: " + add(1, 2, 3));
    }

    // 첫 번째 add 메서드: 두 정수를 받아서 합을 반환한다.
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }

    // 두 번째 add 메서드: 세 정수를 받아서 합을 반환한다.
    // 첫 번째 메서드와 이름은 같지만, 매개변수 목록이 다르다.
    public static int add(int a, int b, int c) {
        System.out.println("2번 호출");
        return a + b + c;
    }

}

<OverLoading2.java>

package method;

public class OverLoading2 {
    public static void main(String[] args) {
        myMethod(1, 1.2);
        myMethod(1.2, 2);
    }
    public static void myMethod(int a, double b) {
        System.out.println("int a, double b");
    }
    public static void myMethod(double a, int b) {
        System.out.println("double a, int b");
    }
}

<OverLoading3.java>

package method;

public class OverLoading3 {
    public static void main(String[] args) {
        System.out.println("1: " + add(1, 2));
        System.out.println("2: " + add(1.2, 1.5));
    }

    // 첫 번째 add 메서드: 두 정수를 받아서 합을 반환한다.
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }

    // 두 번째 add 메서드: 두 실수를 받아서 합을 반환한다.
    // 첫 번째 메서드와 이름은 같지만, 매개변수의 유형이 다르다.
    public static double add(double a, double b) {
        System.out.println("2번 호출");
        return a + b;
    }

    //첫번째 add 메서드를 지운다 해도 실행이된다. 
    // int 거 double 로 자동 형변환이 이루어지기 때문에!
}

문제와 풀이1

<MethodEx1.java>

package method.ex;

public class MethodEx1 {
    public static void main(String[] args) {
        double average = avg(1,2,3);
        System.out.println("평균값: " + average);

        System.out.println("평균값: " + avg(15,25,35));
    }

    public static double avg(int a, int b, int c){
        int sum = a+b+c;
        double average = sum / 3.0;
        return average;
    }
}

<MethodEx2.java>

package method.ex;

public class MethodEx2 {
    public static void main(String[] args) {
       comment(3);
        System.out.println("----");
       comment(5);
        System.out.println("----");
       comment(7);
    }

    public static void comment(int num){
        String message = "Hello, world!";
        for(int i =0; i<num; i++){
            System.out.println(message);
        }
    }
//
//    public static void printMessage(String message, int times) {
//        for (int i = 0; i < times; i++) {
//            System.out.println(message);
//        }
//    }
}

<MethodEx3.java>

package method.ex;

public class MethodEx3 {
    public static void main(String[] args) {
        int balance = 10000;
        balance = deposit(balance, 1000);
        balance = withdraw(balance,2000);

        System.out.println("최종 잔액: " + balance + "원");
    }
    public static int deposit(int balance,int amount){
        balance+=amount;
        System.out.println(amount + "원을 입금하였습니다. 현재 잔액: " + balance
                + "원");
        return balance;
    }
    public static int withdraw(int balance,int amount){
        if (balance >= amount) {
            balance -= amount;
            System.out.println(amount + "원을 출금하였습니다. 현재 잔액: " +
                    balance + "원");
        } else {
            System.out.println(amount + "원을 출금하려 했으나 잔액이 부족합니다.");
        }
        return balance;
    }
}

문제와 풀이2

<MethodEx4.java>

package method.ex;

import java.util.Scanner;

public class MethodEx4 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int balance = 0;

        while(true){
            System.out.print("선택 : ");
            int option = input.nextInt();

//            if(option==1){
//                System.out.print("입금액 : ");
//                int depositamount = input.nextInt();
//                balance = deposit(balance,depositamount);
//            } else if (option ==2) {
//                System.out.print("출금액 : ");
//                int withdrawAmount = input.nextInt();
//                balance = withdraw(balance,withdrawAmount);
//            } else if (option ==3) {
//                System.out.println("현재 잔액 : " +balance);
//            } else if (option==4) {
//                System.out.println("시스템을 종료합니다.");
//                break;
//            }

            int amount;
            switch (option){
                case 1 :
                    System.out.print("입금액 : ");
                    amount = input.nextInt();
                    balance = deposit(balance,amount);
                    break;
                case 2 :
                    System.out.print("입금액 : ");
                    amount = input.nextInt();
                    balance = withdraw(balance,amount);
                    break;
                case 3:
                    System.out.println("현재 잔액: " + balance + "원");
                    break;
                case 4:
                    System.out.println("시스템을 종료합니다.");
                    return;
                default:
                    System.out.println("올바른 선택이 아닙니다. 다시 선택해주세요.");
            }
        }

    }
    public static int deposit(int balance,int amount){
        balance+=amount;
        System.out.println(amount + "원을 입금하였습니다. 현재 잔액: " + balance
                + "원");
        return balance;
    }
    public static int withdraw(int balance,int amount){
        if (balance >= amount) {
            balance -= amount;
            System.out.println(amount + "원을 출금하였습니다. 현재 잔액: " +
                    balance + "원");
        } else {
            System.out.println(amount + "원을 출금하려 했으나 잔액이 부족합니다.");
        }
        return balance;
    }
}

정리

• 메서드명은 일반적으로 동사로 시작한다.
• 메서드 사용의 장점

  • 코드 재사용 : 메서드는 특정 기능을 캡슐화하므로 필요할 때 마다 사용가능
  • 코드 가독성
  • 모듈성 : 큰 프로젝트, 관리 가능한 부분으로 나눌 수 있다. 이는 코드의 가독성향상 및 디버깅을 쉽게 만든다.
  • 코드유지관리
  • 코드 재사용성과 확장성
  • 추상화 : 프로그램의 다른 부분에서는 복잡한 내부작업에 대해 알 필요가 없다.
  • 테스트와 디버깅 용이성 : 개별 메서드는 독립적으로 테스트하고 디버그 할 수 있다. 이는 신속하게 찾고 수정하는데 도움이 된다.

배열시작

배열이 필요한 이유

같은 타입의 변수를 반복해서 선언하고 반복해서 사용하는 문제를 해결하는 것이 바로 배열이다.

배열의 선언과 생성

<ArrayRef1.java>

package array;

public class ArrayRef1 {
    public static void main(String[] args) {
        int[] students; //배열 변수 선언
        students = new int[5]; // 배열생성
        students[0]=90;
        students[1] = 80;
        students[2] = 70;
        students[3] = 60;
        students[4] = 50;

        System.out.println("학생1 점수: " + students[0]);
        System.out.println("학생2 점수: " + students[1]);
        System.out.println("학생3 점수: " + students[2]);
        System.out.println("학생4 점수: " + students[3]);
        System.out.println("학생5 점수: " + students[4]);

        System.out.println(students);
    }
}

배열사용

인덱스

• 배열은 0부터 시작한다.

기본현 vs 참조형

사용하는 값을 직접 넣을 수 있는 기본형, 배열 변수와 같이 메모리의 참조값을 넣을 수 있는 참조형

• 기본형(Primitive Type): 우리가 지금까지 봤던 int , long , double , boolean 처럼 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입을 기본형(Primitive Type)이라 한다.

• 참조형(Reference Type): int[] students 와 같이 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터타입을 참조형(Reference Type)이라 한다. 뒤에서 학습하는 객체나 클래스를 담을 수 있는 변수들도 모두 참조형이다.

배열 리펙토링

리펙토링(Refactoring)은 기존의 코드 기능은 유지하면서 내부 구조를 개선하여 가독성을 높이고, 유지보수를 용이하게 하는 과정을 뜻한다. 이는 중복을 제거하고, 복잡성을 줄이며, 이해하기 쉬운 코드로 만들기 위해 수행된다. 리펙토링은 버그를 줄이고, 프로그램의 성능을 향상시킬 수도 있으며, 코드의 설계를 개선하는 데에도 도움이 된다. 쉽게 이야기해서 작동하는 기능은 똑같은데, 코드를 개선하는 것을 리펙토링이라 한다

<ArrayRef2.java>

package array;

public class ArrayRef2 {
    public static void main(String[] args) {
        int[] students; //배열 변수 선언
        students = new int[5]; // 배열생성
        students[0]=90;
        students[1] = 80;
        students[2] = 70;
        students[3] = 60;
        students[4] = 50;

        for(int i =0;i<students.length;i++){
            System.out.println("학생"+(i+1)+ " 점수 : "+ students[i]);
        }

        System.out.println(students);
    }
}

• 반복문을 사용하여 효과적으로 변경

<ArrayRef3.java>

package array;

public class ArrayRef3 {
    public static void main(String[] args) {
        int[] students;

        students = new int[]{90, 80, 70, 60, 50}; //배열 생성과 초기화

        for (int i = 0; i < students.length; i++) {
            System.out.println("학생" + (i + 1) + " 점수: " + students[i]);
        }
    }
}

• 배열 생성과 초기화를 한줄로도 표현이 가능하다.

<ArrayRef4.java>

package array;

public class ArrayRef4 {
    public static void main(String[] args) {
        //배열 생성 간략 버전, 배열 선언과 함께 사용시 new int[] 생략 가능
        int[] students = {90, 80, 70, 60, 50};
        for (int i = 0; i < students.length; i++) {
            System.out.println("학생" + (i + 1) + " 점수: " + students[i]);
        }
    }
}

int[] students; students = {90, 80, 70, 60, 50}; => 오류

2차원 배열 - 시작

2차원 배열은 행과 열로 구성된다.

arr[행][열] , arr[row][column]

<ArrayDi0.java>

package array;

public class ArrayDi0 {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열
        //0행 출력
        System.out.print(arr[0][0] + " "); //0열 출력
        System.out.print(arr[0][1] + " "); //1열 출력
        System.out.print(arr[0][2] + " "); //2열 출력
        System.out.println(); //한 행이 끝나면 라인을 변경한다.

        //1행 출력
        System.out.print(arr[1][0] + " "); //0열 출력
        System.out.print(arr[1][1] + " "); //1열 출력
        System.out.print(arr[1][2] + " "); //2열 출력
        System.out.println(); //한 행이 끝나면 라인을 변경한다
    }
}

2차원 배열 - 리펙토링1

for문을 활용하여 출력방법 개선하기 <ArrayDi1.java>

package array;

public class ArrayDi1 {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열

        for (int row = 0; row < 2; row++) {
            System.out.print(arr[row][0] + " "); //0열 출력
            System.out.print(arr[row][1] + " "); //1열 출력
            System.out.print(arr[row][2] + " "); //2열 출력
            System.out.println(); //한 행이 끝나면 라인을 변경한다.
        }
    }
}

<ArrayDi2.java>

package array;

public class ArrayDi2 {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열

        for (int row = 0; row < 2; row++) {
            for (int column = 0; column < 3; column++) {
                System.out.print(arr[row][column] + " ");
            }
            System.out.println(); //한 행이 끝나면 라인을 변경한다.
        }
    }
}

2차원 배열 - 리펙토링1

2차원배열도 쉽게 초기화 할 수 있다. for문에서 배열의 길이 활용하기 <ArrayDi3.java>

package array;

public class ArrayDi3 {
    public static void main(String[] args) {
        // 2x3 2차원 배열, 초기화
        int[][] arr = {
                {1, 2, 3},
                {4, 5, 6}
        };

        // 2차원 배열의 길이를 활용
        for (int row = 0; row < arr.length; row++) {
            for (int column = 0; column < arr[row].length; column++) {
                System.out.print(arr[row][column] + " ");
            }
            System.out.println();
        }
    }
}

구조개선 - 값입력

<ArrayDi4.java>

package array;

public class ArrayDi4 {
    public static void main(String[] args) {
        // 2x3 2차원 배열, 초기화
        int[][] arr = new int[2][3];
        int i = 1;
        // 순서대로 1씩 증가하는 값을 입력한다.
        for (int row = 0; row < arr.length; row++) {
            for (int column = 0; column < arr[row].length; column++) {
                arr[row][column] = i++;
            }
        }
        // 2차원 배열의 길이를 활용
        for (int row = 0; row < arr.length; row++) {
            for (int column = 0; column < arr[row].length; column++) {
                System.out.print(arr[row][column] + " ");
            }
            System.out.println();
        }
    }
}

향상된 for문

for (변수 : 배열 또는 컬렉션) { // 배열 또는 컬렉션의 요소를 순회하면서 수행할 작업 }

<EnhancedFor1.java>

package array;

public class EnhancedFor1 {
    public static void main(String[] args) {
        int[] numbers ={1,2,3,4,5};

        //일반 for문
        for(int i=0; i<numbers.length;i++){
            int number = numbers[i];
            System.out.println(number);
        }

        //향상된 for문
        for(int number:numbers){
            System.out.println(number);
        }
    }
}

• 향상된 for문을 사용하지 못하는 경우 =증가하는 인덱스 값을 직접 사용해야하는 경우

문제와 풀이1

<ArrayEx1.java>

package array.ex;

public class ArrayEx1 {
    public static void main(String[] args) {
        int[] students = {90,80,70,60,50};
        int total = 0;

        for (int i = 0; i < students.length; i++) {
            total += students[i];
        }
        double avg = (double) total / students.length;
        System.out.println("total: "+ total);
        System.out.println("avg: "+avg);
    }
}

<ArrayEx2.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[5] ;
        for(int i = 0; i< arr.length; i++){
            arr[i] = scanner.nextInt();
        }
        for (int i=0; i<arr.length;i++){
            System.out.print(arr[i]);
            if(i< arr.length-1){
                System.out.print(",");
            }
        }
    }
}

<ArrayEx3.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[5] ;
        for(int i = 0; i< arr.length; i++){
            arr[i] = scanner.nextInt();
        }
        System.out.print("기존 배열 : ");
        for (int i=0; i<arr.length;i++){
            System.out.print(arr[i]);
            if(i< arr.length-1){
                System.out.print(",");
            }
        }
        System.out.println();
        System.out.print("역순 배열 : ");
        for(int i =arr.length-1; i>=0 ;i--){
            System.out.print(arr[i]);
            if(i>0){
                System.out.print(",");
            }
        }
    }
}

<ArrayEx4.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[5] ;
        int sum =0;

        for(int i = 0; i< arr.length; i++){
            arr[i] = scanner.nextInt();
        }

        for (int i=0; i<arr.length;i++){
            sum += arr[i];
        }
        System.out.println("합 : " + sum);
        System.out.println("평균 : "+ (double)sum / arr.length );

    }
}

<ArrayEx5.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("입력받을 숫자의 개수 : ");
        int count = scanner.nextInt();

        int[] arr = new int[count] ;
        int sum =0;

        for(int i = 0; i< arr.length; i++){
            arr[i] = scanner.nextInt();
        }

        for (int i=0; i<arr.length;i++){
            sum += arr[i];
        }
        System.out.println("합 : " + sum);
        System.out.println("평균 : "+ (double)sum / count );

    }
}

문제와 풀이2

<ArrayEx5.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("입력받을 숫자의 개수 : ");
        int count = scanner.nextInt();

        int[] arr = new int[count] ;

        for(int i = 0; i< arr.length; i++){
            arr[i] = scanner.nextInt();
        }

        int max = arr[0];
        int min = arr[0];

        for(int i =0;i< arr.length;i++){
            if (arr[i] < min) {
                min = arr[i];
            }
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("가장 작은 정수: " + min);
        System.out.println("가장 큰 정수: " + max);

    }
}

<ArrayEx7.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx7 {
    public static void main(String[] args) {
        int[][] arr = new int[4][3];
        String[] sub = {"국어","영어","수학"};
        Scanner scanner = new Scanner(System.in);


        for(int row=0; row<arr.length; row++){
            System.out.println((row+1)+"번 학생의 성적을 입력하세요 : ");
            for(int col=0; col< arr[row].length;col++){
                System.out.print(sub[col]+ " : ");
                arr[row][col] = scanner.nextInt();
            }
        }

        for(int row=0; row< arr.length; row++){
            int sum =0;
            for(int col=0; col<arr[row].length;col++){
                sum += arr[row][col];
            }
            System.out.println((row+1)+ "번 학생의 총점 : "+sum);
            System.out.println((row+1)+ "번 학생의 평균 : "+ ((double)sum / sub.length));
        }

    }
}

<ArrayEx8.java>

package array.ex;

import java.util.Scanner;

public class ArrayEx8 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("학생 수 입력 : ");
        int count = scanner.nextInt();
        int[][] arr = new int[count][3];
        String[] sub = {"국어","영어","수학"};

        for(int row=0; row<arr.length; row++){
            System.out.println((row+1)+"번 학생의 성적을 입력하세요 : ");
            for(int col=0; col< arr[row].length;col++){
                System.out.print(sub[col]+ " : ");
                arr[row][col] = scanner.nextInt();
            }
        }

        for(int row=0; row< arr.length; row++){
            int sum =0;
            for(int col=0; col<arr[row].length;col++){
                sum += arr[row][col];
            }
            System.out.println((row+1)+ "번 학생의 총점 : "+sum);
            System.out.println((row+1)+ "번 학생의 평균 : "+ ((double)sum / sub.length));
        }

    }
}

문제와 풀이3

<ProductAdminEx.java>

package array.ex;

import java.util.Scanner;

public class ProductAdminEx {
    public static void main(String[] args) {
        int maxProducts = 10;
        String[] productNames = new String[maxProducts];
        int[] productPrices = new int[maxProducts];
        int productCount = 0;
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.print("1. 상품 등록 | 2. 상품 목록 | 3. 종료\n메뉴를 선택하세요:");
            int menu = scanner.nextInt();
            scanner.nextLine();
            if (menu == 1) {
                if (productCount >= maxProducts) {
                    System.out.println("더 이상 상품을 등록할 수 없습니다.");
                    continue;
                }
                System.out.print("상품 이름을 입력하세요:");
                productNames[productCount] = scanner.nextLine();
                System.out.print("상품 가격을 입력하세요:");
                productPrices[productCount] = scanner.nextInt();
                productCount++;
            } else if (menu == 2) {
                if (productCount == 0) {
                    System.out.println("등록된 상품이 없습니다.");
                    continue;
                }
                for (int i = 0; i < productCount; i++) {
                    System.out.println(productNames[i] + ": " + productPrices[i]
                            + "원");
                }
            } else if (menu == 3) {
                System.out.println("프로그램을 종료합니다.");
                break;
            } else {
                System.out.println("잘못된 메뉴를 선택하셨습니다.");
            }
        }
    }
}

Scanner

System.out 을 통해서 출력을 했듯이, System.in 을 통해서 사용자의 입력을 받을 수 있다. System.in 을 통해서 사용자 입력을 받으려면 여러 과정을 거쳐야해서 복잡하고 어렵다. 자바는 이런 문제를 해결하기 위해 Scanner 라는 클래스를 제공한다. <Scanner1.java>

package scanner;

import java.util.Scanner;

public class Scanner1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("문자열을 입력하세요 : ");
        String str = scanner.nextLine();
        System.out.println("입력한 문자열 : "+str);

        System.out.println("정수를 입력하세요 : ");
        int intV = scanner.nextInt();
        System.out.println("입력한 정수 : "+intV);

        System.out.println("실수를 입력하세요 : ");
        double doubleV = scanner.nextDouble();
        System.out.println("입력한 실수 : "+doubleV);
    }
}

• scanner.nextLine() 엔터( \n )을 입력할 때 까지 문자를 가져온다.

<결과>

타입이 다르면 오류가 발생한다. 예제와 같이 숫자에 문자를 입력하면 오류가 발생한다

print() vs printLn()

print() 출력하고 다음라인으로 넘기지 않는다. println() 출력하고 다음라인으로 넘긴다.

Scanner 기본 예제

<Scanner2.java>

package scanner;

import java.util.Scanner;

public class Scanner2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("첫 번째 숫자를 입력하세요:");
        int num1 = scanner.nextInt();

        System.out.print("두 번째 숫자를 입력하세요:");
        int num2 = scanner.nextInt();

        int sum = num1 + num2;
        System.out.println("두 숫자의 합: " + sum);
    }
}

<Scanner3.java>

package scanner;

import java.util.Scanner;

public class Scanner3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();

        if(num1 > num2){
            System.out.println("num1이 더 크다.");
        }
        else if(num2 > num1){
            System.out.println("num2이 더 크다.");
        }else if(num2 == num1){
            System.out.println(" 두수가 같다.");
        }
    }
}

Scanner 반복예제

<ScannerWhile1.java>

package scanner;

import java.util.Scanner;

public class ScannerWhile1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while(true){
            System.out.println("문자열을 입력하세요(exit: 종료):");
            String str = scanner.nextLine();
            if(str.equals("exit")){
                System.out.println("종료");
                break;
            }
        }
    }
}

<결과> <Scanner3.java>

package scanner;

import java.util.Scanner;

public class ScannerWhile2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while(true){
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();

        if(num1==0 && num2==0){
            break;
        }else {
            int sum = num1+num2;
            System.out.println(sum);
        }
        }
    }
}

<ScannerWhile3.java>

package scanner;

import java.util.Scanner;

public class ScannerWhile3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int sum =0;

        while(true){
            int num = scanner.nextInt();
            if(num==0){
                break;
            }else {
                sum = sum + num;
            }
        }
        System.out.println(sum);
    }
}

문제와 풀이

<ScannerEx1.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerEx1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String name = scanner.nextLine();
        int age = scanner.nextInt();

        System.out.println("이름 : "+name+ " 나이 : "+age);
    }
}

<ScannerEx2.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerEx2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int num = scanner.nextInt();
        if(num %2 ==0){
            System.out.println("짝수입니다");
        }else {
            System.out.println("홀수입니다");
        }
    }
}

<ScannerEx3.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerEx3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String foodName = scanner.nextLine();
        int foodPrice = scanner.nextInt();
        int foodQuantity = scanner.nextInt();

        int sum = foodPrice * foodQuantity;

        System.out.println(foodName + " " + foodQuantity+"개를 주문하셨습니다.");
        System.out.println("총 가격은 "+ sum +"원 입니다.");

    }
}

<ScannerEx4.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerEx4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int num = scanner.nextInt();

        for (int i=1; i<=9 ; i++){
            System.out.println(num + " * " + i +" = " + num+i);
        }
    }
}

문제와 풀이2

<ChangeVarEx.java>

package scanner.ex;

public class ChangeVarEx {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int temp;

        temp =a;
        a=b;
        b=temp;

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

<ScannerEx5.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerEx5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();

        if(num1 > num2){
            int temp;
            temp = num1;
            num1 =num2;
            num2 = temp;
        }

        for( int i = num1; i<=num2; i++){
            System.out.print(i);
            if(i!=num2){
                System.out.print(",");
            }
        }
    }
}

문제와 풀이3

<ScannerWhileEx1.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerWhileEx1 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       while(true){
           String name = scanner.nextLine();

           if(name.equals("종료")){
               System.out.println("프로그램을 종료합니다.");
               break;
           }
           int age = scanner.nextInt();
           scanner.nextLine();
           System.out.println("이름 : "+ name + " 나이 : "+ age);

       }
    }
}

scanner.nextLine(); 숫자 입력 후 줄바꿈 처리

<ScannerWhileEx2.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerWhileEx2 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       while(true){
           int price = scanner.nextInt();

           if(price==-1){
               System.out.println("프로그램을 종료합니다.");
               break;
           }
           int quantity = scanner.nextInt();
           int sum = price*quantity;
           System.out.println("총비용 : "+ sum );

       }
    }
}

문제와 풀이

<ScannerWhileEx3.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerWhileEx3 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
        int sum =0;
        double average=0;
        int count =0;

       while(true){
           int num = scanner.nextInt();

           if(num==-1) {
               System.out.println("프로그램을 종료합니다.");
               break;
           }
           sum += num;
           count ++;

       }
        average = (double) sum / count;
        System.out.println("sum : "+sum +" average : "+average);
    }
}

<ScannerWhileEx4.java>

package scanner.ex;

import java.util.Scanner;

public class ScannerWhileEx4 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
        int total=0;
        while(true){
            int option = scanner.nextInt();
            if (option == 1) {
                scanner.nextLine();

                System.out.print("상품명을 입력하세요: ");
                String product = scanner.nextLine();
                System.out.print("상품의 가격을 입력하세요: ");
                int price = scanner.nextInt();
                System.out.print("구매 수량을 입력하세요: ");
                int quantity = scanner.nextInt();
                total = price * quantity;

                System.out.println("상품명:" + product + " 가격:" + price + " 수량:" + quantity + " 합계:" + total);

            } else if (option == 2) {
                System.out.println("총 비용 : " + total);
                total = 0;
            } else if (option == 3) {
                System.out.println("프로그램을 종료합니다.");
                break;
            } else {
                System.out.println("올바른 옵션 값을 입력해주세요.");
            }
        }
    }
}

변수는 선언한 위치에 따라 지역 변수, 멤버 변수(클래스 변수, 인스턴스 변수)와 같이 분류된다. 지역 변수는 이름 그대로 특정 지역에서만 사용할 수 있는 변수라는 뜻이다. 그 특정 지역을 벗어나면 사용할 수 없다. 여기서 말하는 지역이 바로 변수가 선언된 코드 블록( {} ) 이다. 지역 변수는 자신이 선언된 코드 블록( {} ) 안에서만 생 존하고, 자신이 선언된 코드 블록을 벗어나면 제거된다.

<Scope1.java>

package scope;

public class Scope1 {
    public static void main(String[] args) {
        int m = 10; //m 생존 시작
        if (true) {
            int x = 20; //x 생존 시작
            System.out.println("if m = " + m); //블록 내부에서 블록 외부는 접근 가능
            System.out.println("if x = " + x);
        } //x 생존 종료
        //System.out.println("main x = " + x); //오류, 변수 x에 접근 불가
        System.out.println("main m = " + m);
    } //m 종료
}

• int m => main{}의 코드 블록안에서 선언 , if{}블록 내부에서도 m 에 접근가능

• int x => if{} 블록안에서 선언

변수의 접근 가능한 범위를 스코프(Scope) 라 한다.

<Scope2.java>

package scope;

public class Scope2 {
    public static void main(String[] args) {
        int m = 10;
        for (int i = 0; i < 2; i++) { //블록 내부, for문 내
            System.out.println("for m = " + m); //블록 내부에서 외부는 접근 가능
            System.out.println("for i = " + i);
        } //i 생존 종료
        //System.out.println("main i = " + i); //오류, i에 접근 불가
        System.out.println("main m = " + m);
    }
}

스코프2 - 스코프 존재 이유

<Scope3_1.java>

package scope;

public class Scope3_1 {
    public static void main(String[] args) {
        int m=10;
        int temp=0;
        if(m>0){
            temp = m*2;
            System.out.println("temp = " +temp);
        }
        System.out.println("m = "+m);
    }
}

=> temp 는 if 조건이 만족할 때 임시로 잠깐 사용하는 변수이다. 그런데 임시 변수를 main()에 선언하기 되면 다음과 같은 문제가 발생한다.

• 비효율적인 메모리 사용
• 코드 복잡성 증가 <Scope3_2.java>로 보완

  package scope;
  

public class Scope3_2 { public static void main(String[] args) { int m = 10; if (m > 0) { int temp = m * 2; System.out.println("temp = " + temp); } System.out.println("m = " + m); } }

## 형변환1 - 자동 형변환
### 형변환
* 작은 범위에서 큰 범위로는 당연히 값을 넣을 수 있다.
예) int -> long -> double
    int 보다는 long 이, long 보다는 double 이 더 큰 범위를 표현할 수 있다.
* 큰 범위에서 작은 범위는 다음과 같은 문제가 발생할 수 있다.
-소수점 버림
-오버플로우

<Casting1.java>
-> 작은 범위에서 큰 범위에 값을 대입
```java
package scope;

public class Casting1 {
    public static void main(String[] args) {
        int intValue = 10;
        long longValue;
        double doubleValue;

        longValue = intValue; // int -> long
        System.out.println("longValue = " + longValue); //longValue = 10

        doubleValue = intValue; // int -> double
        System.out.println("doubleValue1 = " + doubleValue); //doubleValue1 =10.0

        doubleValue = 20L; // long -> double
        System.out.println("doubleValue2 = " + doubleValue); //doubleValue2 =20.0
    }
}

<결과>

자동 형변환 (묵시적 형변환)

//intValue = 10
doubleValue = intValue
doubleValue = (double) intValue //형 맞추기
doubleValue = (double) 10 //변수 값 읽기
doubleValue = 10.0 //형변환

=> (double)과 같이 적어주면 int형이 double형으로 변한다.

형변환2 - 명시적 형변환

큰 범위에서 작은 범위 대입은 명시적 형변환이 필요하다. double-> int ? <Casting2.java>

package scope;

public class Casting2 {
    public static void main(String[] args) {
        double doubleValue = 1.5;
        int intValue = 0;

        //intValue = doubleValue; //컴파일 오류 발생
        intValue = (int) doubleValue; //형변환
        System.out.println(intValue); //출력:1

    }
}

명시적 형변환 과정

//doubleValue = 1.5
intValue = (int) doubleValue;
intValue = (int) 1.5; //doubleValue에 있는 값을 읽는다.
intValue = 1; //(int)로 형변환 한다. intValue에 int형인 숫자 1을 대입한다.

형변환과 오버플로우

형변환을 할 때 작은숫자가 표현할수 있는 범위를 넘어서면 어떻게 될까? <Casting3.java>

package scope;

public class Casting3 {
    public static void main(String[] args) {
        long maxIntValue = 2147483647; //int 최고값
        long maxIntOver = 2147483648L; //int 최고값 + 1(초과)
        int intValue = 0;

        intValue = (int) maxIntValue; //형변환
        System.out.println("maxIntValue casting=" + intValue); //출력:2147483647

        intValue = (int) maxIntOver; //형변환
        System.out.println("maxIntOver casting=" + intValue); //출력:-2147483648 => 오버플로우

    }
}

<결과> => maxIntOver는 int로 표현 할 수 있는 가장 큰 숫자보다 1이 큼 -> 오버플로우 발생 -> intValue의 타입을 int에서 long 으로 변경

계산과 형변환

<Casting4.java>

package scope;

public class Casting4 {
    public static void main(String[] args) {
        int div1 = 3 / 2;
        System.out.println("div1 = " + div1); //1

        double div2 = 3 / 2;
        System.out.println("div2 = " + div2); //1.0

        double div3 = 3.0 / 2;
        System.out.println("div3 = " + div3); //1.5

        double div4 = (double) 3 / 2;
        System.out.println("div4 = " + div4); //1.5

        int a = 3;
        int b = 2;
        double result = (double) a / b;
        System.out.println("result = " + result); //1.5
    }
}

<결과>

1. 같은 타입끼리의 계산은 같은 타입의 결과를 낸다.
2. 서로 다른 타입의 계산은 큰 범위로 자동 형변환이 이루어진다. int + long -> long + long int + double -> double + double

int div1 = 3 / 2; //int / int
int div1 = 1; //int / int이므로 int타입으로 결과가 나온다.

double div2 = 3 / 2; //int / int
double div2 = 1; //int / int이므로 int타입으로 결과가 나온다.
double div2 = (double) 1; //int -> double에 대입해야 한다. 자동 형변환 발생
double div2 = 1.0; // 1(int) -> 1.0(double)로 형변환 되었다.

double div3 = 3.0 / 2; //double / int
double div3 = 3.0 / (double) 2; //double / int이므로, double / double로 형변환이 발생한다.
double div3 = 3.0 / 2.0; //double / double -> double이 된다.
double div3 = 1.5;

double div4 = (double) 3 / 2; //명시적 형변환을 사용했다. (double) int / int
double div4 = (double) 3 / (double) 2; //double / int이므로, double / double로 형변환이 발생한다.
double div4 = 3.0 / 2.0; //double / double -> double이 된다.
double div4 = 1.5;

정리

int -> long -> double

• 작은 범위에서 큰 범위로 대입이 가능하다. 이것을 묵시적 형변환 또는 자동 형변환이라 한다.
• 큰 범위에서 작은 범위의 대입은 문제가 발생할 수 있기 때문에 명시적 형변환을 사용해야한다. 소수점버림, 오버플로우 등
• 연산과 형변환 같은 타입은 같은 결과를 낸다. 서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다.

특정 코드를 반복해서 실행할 때 사용 while , do-while , for

While문1

while (조건식) { // 코드 }

• 조건식을 확인한다. 참이면 코드 블럭을 실행하고, 거짓이면 while문을 벗어난다.
• 조건식이 참이면 코드 블럭을 실행한다. 이후에 코드 블럭이 끝나면 다시 조건식 검사로 돌아가서 조건식을 검사 한다.(무한 반복)

<while1_2.java>

package loop;
public class While1_2 {
 public static void main(String[] args) {
 int count = 0;
 while (count < 3) {
 count++;
 System.out.println("현재 숫자는:" + count);
 }
 }
}

While문2

<While2_1.java>

package loop;

public class While2_1 {
    public static void main(String[] args) {
        int sum =0;
        int i = 1;
        int endNum =3;

        while(i<=endNum){
            sum = sum +i;
            System.out.println("i="+i+"  sum="+sum);
            i++;
        }
    }
}

=> 코드가 실행되는 횟수를 유연하게 변경할 수 있어야 한다. 한마디로 같은 코드를 반복 실행할 수 있어야 한다.

do-while문

while 문과 비슷하지만, 조건에 상관없이 무조건 한 번은 코드를 실행한다.

do { // 코드 } while (조건식);

<DoWhile1.java>

package loop;
public class DoWhile1 {
    public static void main(String[] args) {
        int i = 10;
        while (i < 3) {
            System.out.println("현재 숫자는:" + i);
            i++;
        }
    }
}

=> i=10 이기 때문에 아무것도 출력되지 않는다.

<DoWhile2.java>

package loop;
public class DoWhile2 {
    public static void main(String[] args) {
        int i = 10;
        do {
            System.out.println("현재 숫자는:" + i);
            i++;
        } while (i < 3);
    }
}

=> 현재숫자는: 10 한번만 실행되고 i<3 조건에 맞지 않기 때문에 do-while 문을 빠져나오게 된다.

break, continue

break는 반복문을 종료하고 즉시 나간다. continue는 반복문의 나머지 부분을 건너뛰고 다음 반복을 진행하는데 사용한다.

** break** while(조건식) { 코드1; break;//즉시 while문 종료로 이동한다. 코드2; }

=> 코드 2가 실행되지 않고 while문 종료된다.

continue while(조건식) { 코드1; continue;//즉시 조건식으로 이동한다. 코드2; }

=> 코드2가 실행되지 않고 다시 조건식으로 이동한다. 조건식이 참이면 while문이 실행된다.

<Break1.java>

package loop;

public class Break1 {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        while (true) { //조건이 항상 참이기 때문에 무한반복
            sum += i;
            if (sum > 10) {
                System.out.println("합이 10보다 크면 종료: i=" + i + " sum=" + sum);
                break; //빠져나오기
            }
            i++;
        }
    }
}

<결과>

<Continue1.java>

package loop;

public class Continue1 {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            if (i == 3) {
                i++;
                continue; // i를 하나 증가하고 continue, sout 실행하지 않고 바로 while문으로 이동
            }
            System.out.println(i);
            i++;
        }
    }
}

<결과>

for문1

for문은 주로 반복 횟수가 정해져 있을 때 사용한다.

for (1.초기식; 2.조건식; 4.증감식) { // 3.코드 }

1. 초기식이 실행된다. 주로 반복 횟수와 관련된 변수를 선언하고 초기화 할 때 사용한다. 초기식은 딱 1번 사용된다.
2. 조건식을 검증한다. 참이면 코드를 실행하고, 거짓이면 for문을 빠져나간다.
3. 코드를 실행한다.
4. 코드가 종료되면 증감식을 실행한다. 주로 초기식에 넣은 반복 횟수와 관련된 변수의 값을 증가할 때 사용한다.
5. 다시 2. 조건식 부터 시작한다. (무한 반복)

<For1.java>

package loop;

public class For1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

<For2.java>

package loop;

public class For2 {
    public static void main(String[] args) {
        int sum =0;
        int endNum=3;

        for(int i=0; i<=endNum; i++){
            sum = sum+i;
            System.out.println("sum : "+ sum);
        }
    }
}

for문2

for (초기식; 조건식; 증감식) { // 코드 } => for 문에서 초기식, 조건식, 증감식은 선택이고 생략이 가능하지만 세미콜론은 유지해야한다.

for (;;) { // 코드 } => 무한반복 while (true) { // 코드 } => 무한반복

<Break2.java>

package loop;

public class Break2 {
    public static void main(String[] args) {
        int sum =0;

        for (int i=0; ;i++){
            sum +=i;
            if(sum>10){
                System.out.println("10보다 큼 : "+ i + "  sum : "+sum);
                break;
            }
        }
    }
}

<결과>

중첩 반복문

<Nested1.java>

package loop;

public class Nested1 {
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            System.out.println("외부 for 시작 i:" + i);
            for (int j = 0; j < 3; j++) {
                System.out.println("-> 내부 for " + i + "-" + j);
            }
            System.out.println("외부 for 종료 i:" + i);
            System.out.println(); //라인 구분을 위해 실행
        }
    }
}

<결과>

문제와 풀이1

<WhileEx1.java>

package loop.ex;

public class WhileEx1 {
    public static void main(String[] args) {
        //while
//        int count = 1;
//
//        while(count<=10){
//            System.out.println(count);
//            count++;
//        }
        //for
        for(int i=1; i<=10;i++){
            System.out.println(i);
        }
    }
}

<WhileEx2.java>

package loop.ex;

public class WhileEx2 {
    public static void main(String[] args) {
        //while
//        int num =1;

//        while (num<=10){
//            System.out.println(num*2);
//            num++;
//        }
//
        //for
        for(int num=1; num<=10; num++){
            System.out.println(num*2);
        }
    }
}

<WhileEx3.java>

package loop.ex;

public class WhileEx3 {
    public static void main(String[] args) {
        //while
//        int max =5;
//        int sum =0;
//        int i =1;
//
//        while(i <=max){
//            sum +=i;
//            System.out.println("i : "+i+ " sum : "+sum);
//            i++;
//        }

        //for
        int max=5;
        int sum=0;
        for(int i=1;i<=max;i++){
            sum +=i;
            System.out.println("i : "+i+ " sum : "+sum);
        }
    }
}

문제와 풀이2

<NestedEx1.java>

package loop.ex;

public class NestedEx1 {
    public static void main(String[] args) {
        for(int i =1; i<=9;i++){
            for(int j=1;j<=9;j++){
                System.out.println(i+"X"+j+"="+i*j);
            }
        }
    }
}

<NestedEx2.java>

package loop.ex;

public class NestedEx2 {
    public static void main(String[] args) {
        int rows = 5;
        for(int i = 1; i <= rows; i++) {
            for(int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}