수테크📱⌚️👀

1. jUnit : assertArray / asertThrows
2. checkStyle : 코딩 스타일 정량
3. Doxygen : 의존성 분석(다이어그램)

# 1. JUnit 한단계 더 나아가기

예외가 발생하는지 확인하고 그 메세지를 exception에 저장해서 우리가 원하는 에러 문자와 일치하는지까지 확인하기!

@Test
	void testDivide() throws Exception {
//		assertEquals(0.5, calculator.divide(2.0, 4.0));
		assertThrows(Exception.class, () -> 
			calculator.divide(4, 0), "0 예외 처리 발생"
		);
		// calculator.divide(4, 0)실행 시, Exception 여부만 확인
	}	
	
	// 여부만 확인하는게 아니라 문자가 나오는지 확인
	@Test
	public void testDevide_exception() throws Exception {
		Exception exception = assertThrows(Exception.class, () -> 
		calculator.divide(4, 0), "0 예외 처리 발생"
		);
		
		assertEquals("Divide Error", exception.getMessage());
	}

정적 분석 코드 돌리기  : SonarQube(java는 무료) - pmd, checkstyle

1. 개인적인 폴더 내에서 eclipse, Intellij에서 돌리면 SonarLint

2. git에 통체로 올렸을때는 SonarQube(서버) 회사 전체 내부의 코드를 볼 수 있음 

3. Jenkins CI/CD에서 build할때 SonarQube 사용할 수도 있음

JUnit은 단위 테스트를 위한 도구이고 웹/앱에서는 그렇게 필수적이지는 않다!!  

# assertArray 사용!!

package com.calc;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.Arrays;

import org.junit.jupiter.api.Test;

class CalculatorTest_format {

	Calculator calculator = new Calculator();
	
	// assertEquals : 개별 요소 검증
	
	@Test
	void testParseInput_individualCheck() throws Exception {
		String[] result = calculator.parseInput("2 + 3");
		assertEquals("2", result[0]);
		assertEquals("+", result[1]);
		assertEquals("3", result[2]);
	}
	
	// assertEquals : List 로 검증
	@Test
	void testParseInput_listCheck() throws Exception {
		String[] result = calculator.parseInput("2 + 3");
		assertEquals(Arrays.asList("2", "+", "3"), Arrays.asList(result));
	}
	
	// assertEquals
	@Test
	void testParseInput_array() throws Exception {
		String[] result = calculator.parseInput("2 + 3");
		assertArrayEquals(new String[] {"2", "+", "3"}, result, "배열이 예상 값과 다릅니다");
	}
	
	// null, empty 처리 여부 확인
	@Test
	void testParseInput_nullAndEmpty() throws Exception {
		Exception nullException = 
				assertThrows(Exception.class, () -> 
						calculator.parseInput(null));
		assertEquals("null은 입력 불가", nullException.getMessage());
	}
}

# checkStyle 적용하기

# doxygen (의존관계 파악 분석하고 시각화하지만 간략함)

의존성 분석

• 개요
  • 함수 변수의 호출관계를 분석하는 도구
  • 도구가 추구하는 방향에 따라 패키지 클래스(파일) 함수 단위로 표현
• 목적
  • 아키텍처 구조에서 서브 시스템 간의 의존이  적절한지 확인
    • 서브 시스템 레이어에서 각 레이어 간 호출관계
    • 서브 시스템 레벨에서 각 레벨 간 호출 관계
    • 원형의존성(상호 참조)관계
  • 객체지향에 특화되어, 추상화와 구제촤의 정도를 확인 

https://www.doxygen.nl/download.html#google_vignette

# graphvie(Doxygen의 분석 결과를 좋게 시각화 하는 도구, 산출물 제출에 용이함)

https://graphviz.org/download/

# 아키텍처(Architecture)

- 건물의 뼈대뿐 아니라 특성을 결정짓는 기본 구조를 일컫는 말(모든 기술 분야에 적용할 수 있고 종류도 다양함)

- 대형 프로젝트가 복잡성의 문제를 해결하는 방법

• 개발할 소프트웨어의 전체 구조를 가장 먼저 생각
• 소프트웨어의 구조를이루는각 구성요소를 찾음
• 각 구성요소 간의 명확한 관계를 설정
• 일정한 규칙을 따름    

- 소프트웨어 아키텍처 : 상위 수준에서 소프트웨어 구성요소들 간의 관계로 구성된 전체적인 구조를 설계하는활동...   

#  소프트웨어 아키텍처의 역할

• 여러 이해관계자 간의 공통의 의사소통 수단(어느정도의 what과 how가 다 담겨져 있다! 고객 요구 사항에 맞게 가고 있는지..)
• 시스템품질 속성의 사용또는 억제 기준  (소프트웨어 품질 속성 8가지를 사용해서 아키텍처가 어떤 정도의 수준인지, 유지보수 & 재사용 가능하도록 만들도록 함..)
• 변경에 대한 원인 파악 및 유연한 대처가 가능 
• 재사용 가능한 소프트웨어 구성 요소 확보 수단 
  
  

# 아키텍처 설계 시 고려 사항

• 모든 이해관계자 사이의 의사소통 도구로 활용할 수 있어야 함
• 구현에 대한 제약 사항(개발 비용, 기간, 조직의 역량 등)을 정의해야 함
• 모든 이해관계자의 품질요구사항을 반영해 우선순위에 따라 시스템 품질 속성을결정해야 함 (성능 사용성, 보안성, 안정성, 검증 가능성, 변경 용이성 등)
• 특정 문제 영역에 적합한 소프트웨어의 구성 요소를 표준화하고 패턴화해 재사용할 수 있도록 설계해야 함

# 아키텍처 품질 속성 : 시스템 품질 속성

• 가용성(Availability) : 시스템이 실패 없이 운용될수 있는 확률로 시스템이 장애 발생 없이 서비스를 제공할 수 있는 능력
• 변경 용이성(Modifiability): 사용자가 새로운 요구사항을 요청했을 때
• 성능(Performance) : 사용자 요청과 같은 이벤트가 발생했을 때 얼마나 빠르고 효율적으로 기능을 수행할 수 있는 가를 말함
• 보안성 : 허용되지 않은 접근에 대응할 수 있는 능력
• 사용성 : 시스템을사용할 때 발생할 수 있는 여러 가지 상황을 극복할 수 있도록 이를 반영해 아키텍처 설계 작업을 해야 함
• 테스트 용이성  : 테스트 비용을 줄이기 위해서는 앜키텍처 설계부터 테스트를 고려해야 함

# 아키텍처 품질속성 : 아키텍처 품질속성

• 개념적 무결성 : 시스템 설계는 전체 시스템을 나타내는설계와 세부 구성 요소 설계로 나뉨
• 정확성과 완전성 : 정확성과 완전성은 사용자가 요구하는 기능을 충족시키는 정도를 말하며 오구분석명세와 일치하는 정도를 나타냄(요구사항 명세에 있는 내용을 다 포함 해야함 / 필요 없는 내용 넣을 필요 없음)
• 개발 용이성(구축 가능성) : 전체 시스템을 적절한 모듈로 분할한 후 알맞게 분배 해 개발함으로써 정해진 기간 내에 개발을 완성할 수 있고 개발 과정 중에도 쉽게 변경 할 수 있는 능력을 말함 

# 아키텍처의 4 + 1 관점(View)

- 이해 관계자 별로 관점이 다름(QA, 기획자, 개발자....)

- 시스템을 이루는 요소의 집합과 그들의 연관 관꼐를 추상적으로 표현한 것!

# UI / UX

- UI(User Interface) : 사용자와 컴퓨터 사이에서 의사소통을 할 수 있도록 만들어진매게체(화면구성을 어떻게 배치할지)

- UX(User Experience) : 사용자가 어떤 시스템, 제품 서비스를직/간접적으로 사용하면서 느끼고 생각하게 되는 총체적인 경험(어떤 이유로 소비자가 떠나갈까.. 이런느낌)

# 연관 관계 vs 의존관계

- 연관 관계(Association)

- 소유 한다의 의미 (has a)  -> 높은 결합도

- 결합도가 높아서 잘 사용 안함..

- 1:1, 1:N, N:M 관계가 많다...

- 0..* => 0..n과 같은 의미

- 상속도 같은 메서드를사용하니까 실선으로(연관 관계)표시

- 의존관계(Dependency)

- 사용 한다의 의미 (uses a) -> 낮은 결합도

- 호출(call)한다의 관계

# 클래스 타입

- 경계 클래스(Boundary Class)

- 시스템 외부의 액터와 상호 작용하는 클래스

- 사용자 인터페이스를 제어하는 역할

- 시스템의 입력과 출력을 담당 

- Controller의 역할!!

-  제어 클래스(Control Class)

- 경계 클래스와 엔티티 클래스 사이에 중간 역할

- 시스템 내부에서 컨트롤하는 역할 / 시스템 그 자체

- 시스템의 실질적인기능 

- Service의 역할!!

- 엔티티 클래스(Entity Class)

- 시스템에서 유지 및 추적해야 할 정보를 저장하는 클래스(DB와 연결되는 클래스)

- 사용 사례에서 반복되어 나오는 용어

- 명사 추출법을 통해서 추출할 수 있다 

# 소프트웨어 구현

- 개별 소프트웨어 단위를 실행 가능한 형태로 구현하고 이를 문서화하는 활동으로 프로그래밍이라고도 함

# 프로그래밍의 이해

• 주요 용어
  • 프로그램 : 컴퓨터로 해결하기 위해 작성하는 명령어들의 모임
  • 프로그래밍 : 프로그램을 작성하는 과정
  • 프로그래머 : 프로그램을 작성하는 사람 또는 작업
• 프로그래밍 언어 : 프로그램을 작성할 때 사용하는 언어 

# 고급 언어와 저급 언어

- 저급 언어 : 하드웨어 지향의 기계 중심 언어 ex) 기계어, 어셈블리어

- 고급 언어 : 사람이 이해하기 쉬운 일상 언어와 기호를 사용한 인간 중심의 언어 ex) C, C++, 자바, 파이썬...

# 빌드(Build)

- 소스코드를 실행 가능한 독립적인 소프트웨어로 만드는 과정(컴파일 -> 링크 -> 패키징 -> 테스트)

- 컴파일(Compile) : 소스 파일을 컴파일러를 통해 기계어로 변환하는 과정

- 링크(Link) : 여러 개의 개별적인 컴파일 결과물(모듈, 라이브러리 등)을 연결하여 실행 가능한 파일을 만드는 과정

- 패키징 (Packaging) : 컴파일 및 링크된 결과물을 실행 가능한 형테로 묶는 과정(리소스 파일(이미지, 설정 파일 등)을 포함하여 배포 가능한 형식으로 압축)

- 테스트 : 빌드된 결과물이 의도한 대로 작동하는지 검증하는 과정(주로 기능 테스트를 수행)

# 빌드 도구 : Maven

- Java 빌드 관리 도구

- 사용 목적

1. 모두가 동일한 바이너리를 생성하기 위해서(같은 폴더 구조를 가지기 위해서!!)
2. 정형화된 소스코드 구조를 사용하기 위해서
3. 라이브러리 의존성을 관리하기 위해서
4. 다른 도구와 쉽게 연동하기 위해서

- 일반적인 사용 방법

1. 팀의 AA(Application Architect)가 Maven 구조 생성 및 의존성 관리
2. pom.xml파일에 라이브러리 의존성 및 플러그인 관리(QA의 경우, 품질 관련 플러그인 설정)
3. 개발 팀원은 정해진 패키지에서 소스코드 개발 

# 라이프사이클과 단계

1. 라이프사이클
   1. clean : 이전 빌드에서 생성된 산출물을 삭제하는 기능
   2. default : 프로젝트 빌드/배포와 관련된 기능
   3. site : 프로젝트의 사이트 문서 생성과 관련된 기능
2. default 의 단계
   1. validate : 정상적은 프로젝트이고 필요한 모든 정보가 준비되었는지 확인
   2. compile : 프로젝트의 소스코드를 컴파일
   3. test : 컴파일한 소스코드를 단위 테스트 프레임워크를 이용해 테스트
   4. package : JAR와 같이 지정된 포맷으로 패키징
   5. verify : 패키지가 품질 수준을 만족하는지 검증
   6. install : 패키지를 로컬 저장소에 설치
   7. deploy : 최종 패키지를 원격 저장소로 복사
3. Maven 명령

mvn clean package site pmd:pmd jdepend:generate

# Git 소개

- 버전 관리의 대표 도구

- 목적 : 버전 관리와 협업 커뮤니케이션

- 일반적인 사용 방법

1. 별도의 저장소 운영 서버 사용
   1. Git: GitHub, BitBuket, GitLab, Giblit
   2. 통합 저장소 : SCMManager
2. 클라이언트는 Core나 별도의 확장 도구 사용
   1. Eclipse/Intelli J 계열 / VS Code 플러그인 : 기본포함
   2. Tortoise 시리즈
   3. Sourcetree 

실습

1. github에서 저장소 하나 생성 (junit4 프로젝트 fork)

2. github 저장소 (원격) >> local(컴퓨터)에 복제 (git clone)

> 파일 하나 수정

> 수정된 파일 commit

> 로컬 == 원격 동일하게 세팅!

3. eclipse 프로젝트 (maven)

# 품질(Quality) 정의

- 물건이 얼마나 좋은지, 나쁜지를 나타내는 정도

- 품질은 모든 제품에서 가장 중요한 요소이며, 소프트웨어 제품도 예외는 아님

- 명시적, 묵시적요구를 만족시키는 제품 또는서비스의 능력에 관한 특성

(고객의 요구를 만족시키는 것 / 품질은 사용 목적에 일치되는 정도 / 품질은 고객 요구사항에 대한 적합도)

# 소프트웨어 품질의 정의

1.    IEEE
   1. 소프트웨어가 필요한 속성을 보유하고 있는 정도
   2. 사용자의 기대 수준을 만족할 수 있는 정도를 결정하는 소프트웨어의 특성
2. United States Department of Defense (DoD 미 국방부)
   1. 개발된 소프트웨어가 사용자의 요구사항을 만족할 수 있는 능력
3. Roger S.Pressman
   1. 소프트웨어가 기능 성능 및 만족도에 있어서 명시된 요구사항 및 내재된 요구사항을 얼마나 충족하는 가를 나타내는소프트웨어 특성의 총체

# 품질 높은 소프트웨어란?

=> 사용자가 원하는 소프트웨어 + 정상 동작하는 소프트웨어 + 완성도가 높은 소프트웨어

[개발자 관점]  프로그램에 결함이 없고 사용자의 요구를 정의한 요구분석 명세서대로 만든 소프트웨어

# 소프트웨어 품질(Software Quality)

• 제품(Product) 품질
  • 제품 자체가 가지는 품질
  • 완성된 소프트웨어가 운용될 환경에 올려져 최종 시스템이 완성되었을 때, 소비자가 요구하는 바에 얼마나 부합하는지를 나타내는 품질
•  프로세스(Process) 품질
  • 소프트웨어를 개발하기 위해 필요한모든 개발 활동이 계획을 준수하여 개발하였는가를 나타내는 품질
  • 그 활동이 효과적인지에 대해 검토(Review) 및 감사(Audit) 활동을 통해 확인

#   소프트웨어 제품 품질 특정

- 소프트웨어 제품품질이 가져야하는 세부 속성 

- ISO 25010(과거 ISO 9126)에 소프트웨어 품질 특성 정의

• 기능성 : 요구되는 기능을 만족시키는 능력
• 신뢰성 : 규정된 환경에서 결함 없이 의도된 기능 및 작업을 수행하는 능력
• 사용성 : 사용자가 이해하고 배우기 쉬운 정도
• 효율성 : 적절한자원의 사용 및 적정한 반응시간 정도
• 유지보수성 : 소프트웨어의 수정 및 변경의 용이성
• 이식성 : 지원하는 다양한 환경에서 운영될 수 있는 능력
• 상호운영성 : 다른 시스템과의 상호 연동 능력
• 보안성 : 정보 및 데이터를 보호하는 능력
• + 안전성

# 소프트웨어 제품 품질 수준 알기 : V & V

• Verification (검증)
  • 제품이 올바르게 생성되고 있는가? (Are we building the product right?)
  • 소프트웨어가 정확한 요구사항에 부함하여 구현되었음을 보장하는활동
  • 요구사항 명세서에 맞게 올바른 방법으로 제품을 만들고 있음을 보장
  • 완성도가 높은 + 정상 동작하는 제품!!!
• Validation (확인)
  • 올바른 제품을 생성하고 있는가? (Are we building the right product?)
  • 소프트웨어가 고객이 의도한 요구사항에 따라 구현되었음을 보장하는 활동
  • 고객이 의도한 환경이나 사용 목적에 맞게 올바른제품을 만들고 있음을 보장
  • 사용자가 원하는 제품!!!

#   V모델에서의 V & V

- 개발 생명주기의 각 단계와 그에 상응하는 소프트웨어 테스트 단계를 매핑한 모델 : V 모델

- 소프트웨어 개발 프로세스로 폭포수 모델의 확장된 형태 중 하나로, 개발 생명주기의 각 단계와 그에 상응하는 소프트웨어 시험 각 단계의 관계를 나타냄

# 소프트웨어 테스트

- 정상 조건 및 비정상 조근(즉, 결함/버그) 사이의 차이점을 발견하기 위하여 소프트웨어 항목을 분석하고, 분석된 항목의 특성을 평가하는 프로세스

=> 결함의 발견을 목적으로 소프트웨어를 분석하는 활동

# Error, Defect, Failure 용어 정의

1. 에러 (Error) : 결함의 원인으로 사람(SW 개발자, 분석가 등)에 의하여 생성된 실수가 주를 이룸
2. 결합(Defect, Fault), 버그(Bug) : 실패 / 고장 또는 문제의 원인으로 제품에 포함된 결점
3. 실패 / 고장(Failure), 문제(Problem) : 제품의 결함(Defect)이 있는 부분이 실행될때 발생되는 현상

예시...

Input : Distance, Time
Output : Speed = Distance / Time

1. 에러(Error)
Didn't think about the case of <time=0>

2. 결함(Defect, Fault) 
There is no code for handling when <time=0>

3. 실패/고장(Failure)
<Divide by Zero Exception> happened

#  소프트웨어 테스트 종류

1. 정적(Static)인 방법
   1. 소프트웨어를 실행하지 않고 결함을 발견
   2. 여러 참가자들이 모여 소프트웨어를 검토하여 결함을 찾아내거나 정적 검증 도구 이용
   3. 소프트웨어 개발 중에 생성되는 모든 산출물들에 대해서 적용 가능
   4. 프로젝트가 시작할때부터 끝날때까지 수행 가능
   5. 대표적인 방법
      1. 동료 검토(Peer Review)
         1. 인스텍션(Inspection)
         2. 워크스루(Walk-through)
         3. 데스크체크(Desk Check)
      2. 도구를 이용한 정적 분석
         1. 룰 기반 정적분석(PMD, BugFind등)
         2. 의존성 분석
         3. 코드 메트릭 측정  
2. 동적(Dynamic)인 방법(좁은 의미에서의 테스트는 동적 테스트라고도 함)
   1. 소프트웨어를 실행하여 결함을 발견
   2. 발견된 결함은 디버깅 활동으로 확인하여 수정함
   3. 소스코드 만들어진 이후에 수행함!
   4. 대표적인 방법
      1. 테스트
         1. 단위 테스트(Unit Test)
         2. 통합 테스트(Integration Test)
         3. 시스템 테스트(System Test)
         4. 인스 테스트(Acceptance Test)
      2. 테스트
         1. 블랙박스 테스트(명세 기반 테스트)
         2. 화이트박스 테스트(구조 기반 테스트)

# 소프트웨어 테스트 프로세스

- 소프트웨어 테스트를 수행하기 위한 절차/방법, 도구/장비, 인력의 통합

- 테스트 절차 : 테스트 계획 -> 테스트 케이스 설계 -> 테스트 실행 및 측정 -> 테스트 결과 분석 -> 오류 추적 및 추정

- 국제 표준 : ISO/IEC 29119 

- 테스트 활동

• 테스트 계획(Test Planning), 테스트 모니터링 및 제어(Test Monitoring and Control), 테스트 분석(Test Analysis), 테스트 디자인, 테스트 구현, 테스트 실행, 테스트 완료... (다 하지는 않음)

1. 테스트 계획
   1. 테스트 목표를 정의하고 테스트 대상 및 범위를 결정하며, 테스트 계획서를 작성하고 검토
   2. 테스트 계획은 초반에만 하느냐?? 모든 테스트 과정에서 계획이 필요함... 
   3. 소프트웨어 테스트 계획 단계
      1. 입력 : 프로젝트 계획서, 요구분석 명세서
      2. 처리 : 테스트 목표 정의, 테스트 대상 및 범위 결정, 테스트 계획서 작성 및 검토
      3. 결과 : 테스트 요구사항 정의서, 테스트 계획서
2. 테스트 케이스 설계
   1. 테스트 설계 기법을 정의하고, 도출된 테스트 케이스에 입력 값으로 사용 할 원시 데이터를 작성
      1. 소프트웨어 테스트 케이스 설계 단계
         1. 입력 : 테스트 계획서
         2. 처리 : 테스트 설계 기법 정의, 테스트 케이스 도출, 원시 데이터 기반
         3. 결과 : 테스트 케이스 명세서, 테스트 설계서, 테스트 절차서
   2. 테스트 케이스(Test Case)
      
      1. 특정한 요구사항이 제대로 구현되었는지 검증하기 위하여 테스트 조건, 입력 값, 예상 출력 값, 실제 수행한 결과를 기록하는것
   3.  테스트 케이스 작성 시점
      1. 테스트 베이시스(근거 문서)를 작성할때 테스트 케이스 작성
      2. 테스트 케이스 작성을 통해 테스트 베이시스의 품질을 개선

3. 테스트 실행 및 측정

- 테스트 환경을 구축하고 도출된 테스트 케이스를 이용해 테스트를 실시하고 테스트 실행 결과를 문서화

- 실패하는모든 항목에 대해서 결함관리를 수행해야 한다

4.  테스트 결과 분석

- 테스트가 끝나면 계획 대비 결과를 비교 분석하고 테스트 결과에 대한 보고서를 작성

- 입력 : 테스트 계획 단계의 목표 값, 테스트 활동을통해 얻은 결과 값

- 처리 : 테스트 결과 분석, 보고서 작성

- 결과 : 테스트 케이스별 결과 분석서, 소프트웨어 상태 보고서, 테스트 결과 보고서

 5. 오류 추적 및 수정

 - 테스트가 끝나면 계획 대비 결과를 비교 분석하고 테스트 결과에 대한 보고서를 작성

- 입력 : 테스트 결과 보고서, 테스트 케이스별 결과 분석서

- 처리 : 오류 수정 계획, 오류 수정, 수정된 내용 검토

- 결과 : 수정 결과 보고서 

# 테스트 원리

• 테스트는 결함이 존재함을 밝히는 활동
• 완벽한 테스트는 불가능(전수 테스트 불가능)
• 테스트는 개발 초기에 시작
• 결함 집중
• 살충제 패러독스
• 테스트는 정황(Context)에 의존적
• 오류 부재의 궤변  

# 테스트하기 좋은 소스코드 작성 방법

• 메서드는 적정한  크기로 작성
  • LOC 80 라인 이하
• 메서드를 너무 복잡하지 않게 작성
  • 순환 복잡도 10이하 / 인지 복잡도 2-3 권장
  • if(A)는 9개까지. (이 조건문은 CNN1)
• 코드 수정할 때 메서드를 새로 만들 수 있다면, 새로 만들고 Call 해주세요
  • 단위 테스트는 메서드를 대상으로 합니다
• 단일 책임 원칙을 지켜주세요
  • 메서드는 하나의 기능만 수행해야 합니다
• 메서드의 의존을 낮춰주세요
  • 의존이 있는 부분과 없는 부분으로 메서드를 나누는 것이 좋습니다.
• Public, Protected 메서드는 리턴 타입을 명시해주세요
  • 각 접근 지정자의 목적에 맞게 사용해주세요
  • Private도 리턴 타입을 명시하는 것이 좋습니다

# 결함 발생 원인

• Communication : 10명의 사람이 있으면 45개의 Path가 생김
• Short Term memory : 사람이 관리할 수 있는 범위(7digit) / 여러 가지 Interruption이 발생
• Cognitive Dissonance : 자신의 산출물에서 결함을 찾기가 힘듦
• Complexity of work : 설계문서의 복잡성으로 Code 작성이 어려운 경우 발생
• 아무리 능숙한 프로그래머라도 평균적으로 35 Defs/KLoc가 발생함...

# 정적 테스트 단계에서 식별 가능한 결함

• 요구사항 결함 : 불일치, 모호성, 모순, 누락, 부적황성, 중복 등
• 잘못된 인터페이스 명세 : 매개변수의 개수, 유형, 순서 불일치 등
• 설계 결함 : 비효율적인 데이터베이스 구조, 모듈화 불량 등
• 특정유형의 보안 취약성 : 버퍼 오버플로우 등
• 특정 유형의 코딩 결함 : 정의되지 않는 값을 가진 변수 반환 ...등
• 테스트 베이시스 커버리지의 차이 또는 부정확성 : 인수 조건 하나에 대한 테스트 누락 등
• 표준 위반사항 : 코딩 표준 명명규칙을 준수하지 않은 경우 등 

# 정적 분석(Static Analysis)

• 실제 실행 없이 컴퓨터 소프트웨어, 특히 소스코드를 분석하는 것
  • 사용 목적
    • 소스코드의 잠재적인 품질 문제(낮은 품질 발견)
      • 네트워크 지원 누수, 높은 복잡도, 추천하지 않는 패턴등
      • 네트워크 지원 누수  ex) 네트워크 소켓의 open()는 있으나, 명시적인 close()가 없는 경우...
    • 결함의 조기 발견 : 메모리 릭, 버퍼 오버플로우 등
    • 소스코드 표준 준수 확인 : 코딩 컨벤션(명명 규칙), 보안
    • 설계 상의 낮은 품질, 표준 위반 확인 
  • 도구를 이용한 정적 분석
    • 룰 기반 정적분석(PMD, BugFind 등)
    • 의존성 분석
    • 코드 메트릭 측정
    • 시맨틱 분석(실행 오류 분석) 
    • 정형 검증

# 소프트웨어 코딩 표준(표준 코딩 규칙)

- 코딩 규칙(Coding Conventions)은 특정프로그램 언어에 대한 가이드라인 모음(프로그래밍 스타일과 관행을 권고) => Coding Standard

# PMD Rule Set

- 여러 언어를 지원하는 오픈소스 정적코드 분석 도구(룰 셋 개수 총 512개)

- 지원 언어 : Java, JavaScript, Python, C++, HTML, PLSQL, Apex, Swift, Kotlin, Scala, PHP 등..

https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javadoc.html 

# Eclipse에 pmd 설치

# 제품 품질 메트릭

• 규모 관련
  • 라인 수(LOC : Line of Code)
  • 주석 제외 라인 수(NLOC : Non-Comment Lines of Code)
  • 주석 비율 : 20% 이상
  • 함수/파일/패키지 별 라인수 (미국방부 : 80 / NASA : 60 / 폭스바겐 : 50)
• 복잡도 관련
  • 순환 복잡도(Cyclomatic Complexity) : 함수의 제어 흐름이 얼마나 복잡한지 측정. 분기문 + 1
  • 인지 복잡도(Cognitive Complexity) : 함수가 얼마나 중첩문이 많은지 측정, Nesting Depth라고도 표현

# 동료검토

• 동료에게 원시 코드나 여러 가지 산출물에 대한 검토를 의뢰하여 오류를 찾는 방법
  • 정해진 형식도 없고 별도의 격식을 차린 회의를 수행할 필요가 없어 비공식 검토에 속함
  • 동적 테스트에서 발견하기 어려운 산출물에서 발생할 수 있는 누락과 같은 결함을 조기에 발견할 수 있는 이점
  • CMMI에서는 결함을 발견하기 위해 프로젝트를 하는 과정에서 동료가 검통하는 활동이라고 정의함.. 
• 체크리스트를 통해 검토를 진행해야 함
  • 사전 준비 : 공지, 검토자 지정, 배포, 준비
  • 검토 회의 : 문제점해결, 보고서 작성
  • 후속 조치 : 시정조치, 조치 보고  

#  효율적인 체크리스트를 작성 방법

• 체크리스트는 결함 분석에 기초해서 정기적으로 갱신되어야 합니다
• 체크리스트는 한 페이지보다 길지 않아야 합니다
• 체크리스트 아이템은 명령문으로 재 표현될 수 있는 질문의 형태로 표현합니다 
  • 메소드 리턴 값은 적절하게 명시하였는가?
• 체크리스트 아이템은 너무 일반적이지 않아야 합니다
  • 완전하고 일관성 있고 명백한가? (모호하게 작성하지 않아야 함)

# 소스콬드 동료검토 주의 사항

• Review fewer than 200 ~ 400 lines of code at a time 
  • 한번에 200 ~ 400 라인 이내의 단위로 검토
• Aim for an inspection rate of less than 300 ~ 500 LOC/hour
  • 1시간에 300 ~ 500 라인 보다 적게 본다는 느낌으로 검토 / 너무 빨리 검토하는 것은 안 좋음
• Authors should annotate source code before the review begins
  • 검토를 요청하는 개발자는 다른 사람에게 어떤 내용인지 설명을 해주는 것이 좋음
• Establish quantifiable goals for code review and capture metrics so you can imporve tour processes
  • 목적의식을 갖는 것이 중요합니다. 예를 들어 에러율을 현재보다 50% 줄이겠다는 등의 명확한 수치를 설정하면 이를 위해 노력하게 됩니다.
• Managers must foster a good code review culture in which finding defects is viewed positively
  • 관리자들은 검토활동이 잘 되고 있는지 관찰하고, 이를 장려하는 조직문화를 만들어 줘야 합니다
• 동료 검토를 하지 않는다고 하더라도 남이 본다고 생각하고 작성하기!
• Beware the "Big Brother" effect
  • 동료가 자신의 코드에 오류를 많이 발견한다고 해서 너무 기죽지 마세요. 품질을위한 하나의 과정이 뿐이지 누구를 모욕하거나 비하하는 자리가 아닙니다   

# 인스텍션의 주요 특징

• 전문가검토이며 공식적 평가
  • 시작과 종료 조건을 갖는 체크리스트와 규칙을 기반으로 정식 프로세스가 존재
  • 검토할 산출물의 작성자가 아닌 훈련된 진행자에 의한 진행
  • 소프트웨어 구성 요소 혹은 산출물들의 정확성 평가
• 결함 발견이 주요 목적
  • 소프트웨어가 명세를 만족하는지 검증
  • 소프트웨어가 명시된 품질 속성을 만족하는지 검증
  • 소프트웨어가 어플리케이션 규격, 표준, 가이드라인, 계획 및 프로시저와 일치하는지 검증
  • 표준이나 규격과 상이한 부분 식별

# 회귀 테스트(Regression Test)

• 정상 동작하던 기능이 SW 수정 후 문제가 발생하는 회귀 결함의 유무를 확인하기 위해 이전 테스트 케이스를 다시 실행하며 확인하는 테스트 
  • SW 수정으로 인한 부정적인 영향 유무를 확인하기 위한 테스트
• 회귀 결함을 발생시키는 SW 수정의 종류
  • 새로운 결함의 조치
  • 리팩토링
  • 새로운 기능의 추가/변경
• 웹은 필수는 아니지만 결함의 확인이 중요한 임베디드(차량)의 경우는 필수적임.. 

# SW 동적 테스팅의 4단계

1. 단위(Unit) 테스팅
2. 통합(Integration) 테스팅
3. 시스템(System) 테스팅
4. 인수(Acceptance) 테스팅

# 단위 테스팅(Unit Testiong) / 컴포넌트 테스팅(Component Testing)

• 설계된 모듈이 정확히 구현되었는지 확인하고, 모듈과 같은 하나의 소프트웨어 구성요소나 소프트웨어 구성요소의 집합이 프로그램의 요구사항에 맞는지 확인하는 테스팅
• 목적 : 모듈이 올바로 코딩 되었는지 확인
• 수행주체 : 개발자
• 테스트 대상 : 모듈 수행가능(블랙박스), 코드 내부표현(화이트박스), 경계조건
• 완료시점 : 개발자가 더 이상의 오류가 없다고 판단될 때

# 단위 테스트 결함 원인 한정

- 단위 테스트에서 결함이 발생한다면, 그 원인은 테스트 대상 모듈에 한정해야 함

# 통합 테스팅(Integration Testing)

- 시스템의 설계와 요구사항에 부합하는지 보이기 위해 소프트웨어 구성요소, 하드웨어 구성요소 등이 점차 통합되어 전체 시스템으로 통합될 때까지 이루어지는 절차적인 테스팅

# 소프트웨어 통합 전략과 연계

• SW 통합 전략
  • 빅뱅(Big Bang) 기법
    • 모듈을 한꺼번에 통합하여 테스팅을 하는 방법
    • 오류가 발생하였을 경우 어느 부분에서 오류가 났는지 찾기가 힘듦 
  • 하향식(Top-Down) 기법
    • 가장 상위 모듈부터 하위 모듈로 점진적으로 통합하는 방법
    • 상위 모듈 테스팅 시, 하위 모듈에 대한 스템이 필요
  • 상향식(Bottom-Up) 기법
    • 하위 모듈부터 테스팅하고 상위 모듈로 점진적으로 통합하는 방법
    • 하위 모듈 테스팅
  • 지속적 통합 방법(Continuous Integration)
    • SW 통합 오류를 개발초기부터 예방하는 것 

# 시스템 테스팅(System Testing)

• 모듈이 모두 통합된 후, 사용자의 요구사항이 만족되었는지 검사하는 테스팅
• 고객에게 시스템을 전달하기 전, 시스템을 개발한 조직이 주체가 되는 마지막 테스팅
• 테스팅 대상
  • 요구사항 명세서를 기초로 하여 사용자의 기능 요구사항
  • 보안, 성능, 신뢰성, UX 등의 비 기능 요구사항
  • 기능 안전 요구사항

# 인수 테스팅(Acceptance Testing)

• 시스템이 사용자에게 인수되기 전, 사용자에 의해 실시되는 테스팅
• 실제 사용자가 운영하는 환경에서 실시
• 인수 테스팅을 통과해야만 시스템이 정상적으로 사용자에게 인수되고 프로젝트는 종료됨

# 동적 SW 테스트 설계 기법의 종류 (+ 경험 기반 Test)

• 명세 기반 테스트(Black-Box)
  • 소스 코드 자체의 로직(Logic)은 제외하고, 출력 값에만 초점을 두고 테스팅 하는 방법
  • 요구사항 명세서(SRS)나 설계서로부터 테스트 케이스 추출
    • 블랙박스 테스트
    • 모듈의 외부(입력, 출력)
• 구조 기반 테스트(White-Box)
  • 소스 코드 내의 모든 독립적인 경로를 수행하여 봄으로써 잠재적인 오류를 찾아내는 방법
  • 내부구조(소스 코드, 알고리즘)를 기반으로 테스트 케이스 추출 -> 주로 단위테스트에서 쓰임
    • 화이트 박스 테스트
    • 모듈의 내부(로직)

#  블랙박스(Black Box) 테스팅 개요

- 소스 코드 자체의 로직은 제외하고, 출력 값에만 초점을 두고 테스팅 하는 방법으로 요구사항 명세서나 설계서로부터 테스트 케이스 추출

• 테스팅 종류
  • 구문 테스팅(Syntax Testing) : 입력 값을 적합과 부적합 조건으로 분류한 뒤, 테스트 케이스를 작성하여 예상되는 결과를 테스팅
  • 페어와이즈(Pairwise) : 테스트를 하는데 필요한 각 입력 값들이 다른 입력값과 최소한 한번씩 조합을 이루게 하여 테스트 하는 방법 / 페어 : 입력값의 각 쌍의 개별 조합
  • 동등 분할(Equivalence Partitioning) : 입력 값의 범위가 정해져 있을 경우, 각 범위의 대푯값으로 테스트 케이스를 작성하여 예상되는 결과를 테스팅
  • 경계 값 분석(Boundary Value Analysis) : 입력 값의 주요 오류 대상인 경계 값을 입력 값으로 테스트 케이스를 작성하여 예상되는 결과를 테스팅 
  • 의사결정 테이블(Devision Table) : 입/출력값이 True, False로 결정될 수 있는 경우, 입/출력값의 모든 논리적 경우의 수를 확인해볼 수 있는 방법

# 페어와이즈 도구 실습

https://github.com/microsoft/pict/releases/tag/v3.7.4

- 페어와이즈는 cmd 창에서 실행!!(데이터가 뽑아져 나온다)

- 일단 케이스의 경우를 txt 파일에 적어줌

pict 파일명 > 만들고 싶은 파일명.xls  => 테스트 케이스를 엑셀로 가져가줌!!

# 화이트박스(White Box) 테스팅 개요

•  소스 코드 내 모든 독립적인 경로를 수행하여 봄으로써 결함을 찾아내는 방법으로 프로그램 소스 코드로부터 테스트 케이스를 추출
  
  

# 테스트 커버리지(Coverage)

• 테스트 케이스 수행 시 텟트 대상을 몇 %나 실행했는지 알려주는 지표
• 요구사항커버리지
  • 테스트 케이스가 요구사항을 얼마만큼 실행했는지 측정
    • ex) 전체 30개 요구사항 중, 50% 요구사항을테스트 수행
  • 블랙박스 테스트 기법에 주로 사용
• 소스코드 커버리지
  • 테스트 케이스가 소스코드를 얼마만큼 실행했는지 측정
    • 예1) 문장 커버리지 : 소스코드 전체 문장의 40% 문장을 테스트 수행
    • 예2) 결정 커버리지 : 소스코드 전체 if 문의 60%의 참/거짓(결정)을 테스트 수행
  • 화이트박스 테스트 기법에 주로 사용

#   화이트박스 테스팅 종류

• 경로 커버리지(Basis Path Coverage)
  
  • 프로그램 제어구조를 Flow Graph로 표현하고, 순환 복잡도(Cyclomatic Complexity)를 통해 독립적인 경로의 수를 찾아 테스트 케이스로 선정하여 수행하는 테스팅
  • 경로 커버리지 수행 프로세스
    • 1. Flow Graph 작성
    • 2, 순환 복잡도 계산
    • 3. 독립 경로 정의
    • 4. 테스트 케이스 작성
  • 입력에서 출력에 이르기까지의 프로그램 내부구조를 플로우 그래프로 표현
• 함수 커버리지(Function Coverage)
  • 프로그램을 구성하는 함수들의 테스팅 정도를 나타내며 가장 낮은 수준의 커버리지이므로  단위 테스팅을 통해 100% 달성이 필요함
  • 웹에서는 거의 쓸 일이 없음.. 함수를 불러오는거지 그 안의 알고리즘을 보지는 않기 때문에
  • 임베디드에서 모든 모듈을 다 호출했는지, 통합했는지 확인하기 위해서 사용함 
• 문장 커버리지(Line Coverage)
  • 프로그램을 구성하는 문장들이 최소한 한번은 실행될 수 있는 입력 값을 테스트 케이스로 선정하여 수행하는 테스 
  • 문장 커버리지의 단점
    • 소스코드의 로직(Logic)에 영향을 미치는 조건문을 테스트하지 못함
    • 조건문 자체의 결정(Decision이 True/False 인 경우 -> 결정(Decision) 커버리지 적용
    • 조건문의 각 조건(Condition)이 True/False 인 경우 -> 조건(Condition) 커버리지 적용
• 분기 커버리지(Branch Coverage)
  • 분기문 전체가 참 한 번, 거짓 한 번을 갖도록 테스트 케이스를 선정하여 수행하는 테스팅 방법으로 결정(Decision) 커버리지라고도 함 

# Junit 소개와 기본 테스트 구조

• 에릭 감마와 켄트백이 탄생시켜 현재 전 세계적으로 널리 사용되는 Java 단위 테스트 프레임워크
• 기본 테스트구조 : assertEquals() 사용 예제
  • assertEquals(Expected, Actual) : Expected(Object)와 Actual(Object)의 객체 타입 및 값이 동일한지 확인하여 같으면 테스트가 성공함
    
    

# 단위테스트(메서드 단위) 수행 방법 요약

• 테스트 단위
  • public 메서드, API 메서드 등메서드 단위
  • 인터페이스를 구현한 메서드에서 시작
•   테스트 방법
  • JUnit을 활용한 테스트 메서드를 작성하여 특정 메서드의 기능이 정상 동작함을 확인
• 테스트 절차
  • 기능 구현 -> 테스트 케이스 생성 -< 단위테스트 수정 -> 커버리지 측정 -> 리포트 출력
  • 기능 구현과 테스트를 병행하며 점진적 개발 수행
  • 필요시 커버리지 측정 후 테스트가 미흡한 코드에 대해서는 테스트 보완 가능

# JUnit5 실습

package com.calc;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class CalculatorTest {
	
	Calculator calculator = new Calculator();

	@Test
	void testAdd() {
//		assertEquals(기대결과, add());
		assertEquals(6, calculator.add(4, 2));
//		System.out.println(assertEquals(6, calculator.add(4, 2)));
	}
	
	@Test
	void testMinus() {
		assertEquals(2, calculator.minus(4, 2));
	}

	@Test
	void testMulti() {
		assertEquals(8, calculator.multi(4, 2));
	}

	@Test
	void testDivide() throws Exception {
		assertEquals(2, calculator.divide(4, 2));
		assertThrows(Exception.class, () -> 
			calculator.divide(4, 0), "Divide Error"
		);
	}
	
	@Test
    void testCalculate() throws Exception {
        assertEquals(6, calculator.calculate("+", 4, 2)); 
        assertEquals(2, calculator.calculate("-", 4, 2));
        assertEquals(8, calculator.calculate("*", 4, 2)); 
        assertEquals(2, calculator.calculate("/", 4, 2)); 
//        assertEquals(0.5, calculator.calculate("/", 2, 4)); 
    }
	
	// 테스트 케이스는 독립적인 기능을 하도록 모듈을 개발해야하는데.. 하나의 목적을 가지는게 좋아서 정상적으로 수행되지 않는 경우를 빼주는 것을 더욱 추천!
    @Test
    void testUnsupportedOperator() {
        assertThrows(Exception.class, () -> 
            calculator.calculate("%", 4, 2), "Unsupported Operator"
        );
    }
	
	/**
	@Test
	void testParseInput() {
		fail("Not yet implemented");
	}

	@Test
	void testMain() {
		fail("Not yet implemented");
	}
	**/
}

# 테스트 실행 걸차

# 결함 관리 기법

• 결함 감소(Reduction) : 주입된 결함을 가능한 많이 발견하고 제거함
• 결합 봉쇄(Containment) : 결함이 발견되지 않고 그 결함으로 인해 문제가 생겨도 그것이 실패로 이어지지 않게 함
• 결함 예방(Prevention) : 결함을 예측하고 그 원인을 파악하여 방지 및 해결함
• 결함 예방 활동이 제대로 이루어 진다면? => 결함 감소와 봉쇄에 들이는 노력과 비용 감소 가능

# 소프트웨어 결함의 특징

• 소프트웨어 개발은 인력 절약적 작업으로 소프트웨어 결함의 대부분은개발자의 휴먼 에러로 인해 발생
  • 구현 단계의 결함도 휴먼 에러로 인해 발생
  • 휴먼 에러 예방을 통해 구현 단계 결함의 잔존을 방지할 필요가 있음
  • 결함 관리 단계에서 충분한 데이터를 수집해야 함!!

# 결함 예방을 위한 데이터 수집

• 결함 유형 
  • 결함 발견자 입장에서 결함의 모습 : 테스트 단계마다 결함 유형이 달라질 수 있음
• 결함 원인 
  • 결함 제거자(개발자) 입장에서 결함 원인 : 테스트 단계 결함 유형이 달라질 수 있음
• 결함 유입 단계 
  • 결함이 포함된 단계
• 결함 발견 단계 
  • 테스트/리뷰 단계
• 기타 
  • OS, 테스트 환경, 테스트 ID

# 결함의 추적

• 개발자는 소프트웨어를 개발 후 테스터에게 전달
• 테스터는 테스트 계획, 분석 및 설계 방법에 따라 테스트 케이스를 생성하고 실행
• 테스트 케이스 실행 중 결함을 검출하고 검출된 결함을 개발자에게 전달 및 수정 요청
• 개발자는 결함을 수정하고 다시 테스터에게 전달

# 결함 처리 유형

• Fixed : 요청된 결함을 수정 완료한 경우
• Duplicated : 기존의 다른 결함과 중복되는 경우
• Won't fix : 수정이 필요할 정도로 중요하거나 긴급한 것이 아니라 수정하지 않는 경우
• Invalid : 테스트 케이스에 문제가 있는 경우

문제 😵‍💫

https://school.programmers.co.kr/learn/courses/30/lessons/12909?language=java

내 풀🦷

import java.util.*;

class Solution {
    boolean solution(String s) {
        Stack<String> str = new Stack<>();
        boolean answer = true;
        
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            
            if(c == '(') {
                str.push(String.valueOf(c));
            } else if(c ==')') {
                if(str.isEmpty()) {
                    answer = false;
                    break;
                }
                str.pop();
            }
        }
        
        if (!str.isEmpty()) {
            answer = false;
        }
        return answer;
    }
}

정말정말 오랜만에 괄호 검사 문제를 풀었다 ㅎㅎㅎ

진짜 괄호 검사 추억이 많은 문제라 너무 기억나는데 파이썬 했던시절이라 잠시 흠칫했다 ㅎㅎㅎㅎ

당연히 스택 써서 풀어야 겠다 했는데 다른 사람 풀이가 스택도 쓰지 않고 정말 간단하게 썼던 풀이가 있어서 한번 가져와 봤다...

// 다른 사람 풀이

class Solution {
    boolean solution(String s) {
        boolean answer = false;
        int count = 0;
        for(int i = 0; i<s.length();i++){
            if(s.charAt(i) == '('){
                count++;
            }
            if(s.charAt(i) == ')'){
                count--;
            }
            if(count < 0){
                break;
            }
        }
        if(count == 0){
            answer = true;
        }

        return answer;
    }
}

참고하면 좋을 개념들 ✍️

스트링으로 변환 : String.valueOf(바꿀 값);

MariaDB 볼 때 사용하는 tool이 너무 느렸는데요...

VS CODE에서 연동해서 보기 좋게 볼 수 있다더라구요!!

엄청 쉽습니다!!!!

- 일단 Database Client를 깔아줍니다!!

- 왼쪽바에서 데이터베이스 모양을 누르고 + 버튼을 눌러서  Server Type을 선택하고 host, username, 비밀번호를 입력하고 마지막 Connect를 누르면 완료!!!

- 실행은 해당 줄 [ Ctrl ] + [ L ]로 선택해서 [ Ctrl ] + [ Enter ] 선택하면 실행되면서 테이블이 생깁니다!!

UI도 보기 편하고 빨라서 완전 추천드려요!

(월요일)

# String 값 변환에 따른 주소 변환

package thisisjava;

public class str03 {

	public static void main(String[] args) {
		String s1 = "KR";
		s1 = null;
		s1 = "EN";
		s1 = "CH";
		
	}
}

# String 메서드

package thisisjava;

public class str04 {

	public static void main(String[] args) {
		String s1 = "Welcome to Korea";
		
		System.out.println(s1.length());
		System.out.println(s1.charAt(0));
		System.out.println(s1.charAt(5));
		System.out.println(s1.charAt(7) + ", ");
//		System.out.println(s1.charAt(-1)); -1은 파이썬에서만!
		
		System.out.println(s1.replace("K", "C"));
		System.out.println(s1.replace("Korea", "한국"));
		System.out.println(s1.replace("e", "2"));
		
		System.out.println(s1.substring(0, 8));
		System.out.println(s1.substring(3, 14));
		
		System.out.println(s1.indexOf("c")); // c의 위치
		System.out.println(
				s1.substring(
						s1.indexOf("c"), s1.indexOf("r") + 1)); // 두가지 메서드를 혼합하여 간단하게 추출가능
		
		String s2 = "사과,배,바나나,수박";
		String[] sArr = s2.split(",");
		for(int i = 0; i < sArr.length; i++) {
			System.out.println(sArr[i]);
		}
		
		System.out.println();
		
	}
}

# 이중 for문

package thisisjava;

public class arr07 {

	public static void main(String[] args) {
		int[][] iArr01 = {{1, 2, 3}, 
						  {4, 5, 6}, 
						  {7, 8, 9}};
		
		System.out.println(iArr01.length); // 3행
		System.out.println(iArr01[0].length); // 1행의 요소의 개수
		
		System.out.println(iArr01[0][0]);
		
		// 3, 4, 8
		System.out.println(iArr01[0][2]);
		System.out.println(iArr01[1][0]);
		System.out.println(iArr01[2][1]);
		
		System.out.println();
		
		// 1 2 3 / 4 5 6 / 7 8 9 출력하기 
		for(int i = 0; i < iArr01.length; i++) {
			for(int j = 0; j < iArr01[i].length; j++) {
				System.out.print(iArr01[i][j] + " ");
			}
			System.out.println();
		}
	}
}

# string 배열의 복사 : 얕은 복사(shallow copy)

package thisisjava;

public class arr11 {

	public static void main(String[] args) {
		int i1 = 11, i2 = 0;
		int[] iArr01 = {10, 20, 30, 40};
		int[] iArr02 = new int[4];
		
		i2 = i1; i2 = 22;
		System.out.println(i1 + ", " + i2);
		iArr02 = iArr01;
		iArr01[3] = 400;
		
		// ---> 10 20 30 40
		for(int i : iArr02) {
			System.out.print(i + " ");
		}
		
	}
}

# class 기초

package thisisjava;

/*
 class
 - 필드(속성), 메서드, 생성자로 이루어져 있다
 - 값과 참조 타입이 혼합되어 있다
 - 값은 0, 참조는 null이 들어있고 나중에 값이 들어가고 참조된다
 - 붕어빵 틀에 붕어를 찍어내듯 같은 형식의 여러 데이터를 담아낼 수 있다
 */

class Book00 {
	String title; 	// 책명
	String author; 	// 저자
	int price; 		// 가격
	
	// 멤버 메소드
	// 반환Type 이름(입력 Type 입력) {처리; return 반환값;}
	// void : 반환값 없음
	void pBook() {
		System.out.println(title + ", " + author + ", " + price);
	}
}

public class Cla00 {
	public static void main(String[] args) {
		Book00 b1 = new Book00();
		b1.title = "자바"; b1.author = "홍길동"; b1.price = 30000;	
		b1.pBook();
//		System.out.println(b1.title + ", " + b1.author + ", " + b1.price);
		
		
		Book00 b2 = new Book00();
		b2.title = "소공"; b2.author = "김은비"; b2.price = 40000;
		b2.pBook();
//		System.out.println(b2.title + ", " + b2.author + ", " + b2.price);
	}
}

# 클래스 구성 3가지(필드, 생성자, 메서드)

package thisisjava;

public class Book01 {
	// 멤버 필드
	String title;
	String author;
	int price;
	
	// 멤버 생성자(없더라도 은닉되어 있음)
	Book01(String t, String a, int p){
		this.title = t;
		this.author = a;
		this.price = p;
	}
	
	// 멤버 메서드
	void pBook() {
		System.out.println(title + ", " + author + ", " + price);
	}
	
}

# 생성자 메서드 오버로딩

package thisisjava;

class Book03{
	String title; String author; int price;
	// 강사님은 초기값으로 무제/작자미상/0 넣어주심
	
	// 생성자 오버로딩
	Book03(String title, String author, int price) {
		this.title = title;
		this.author = author;
		this.price = price;
	}
	
	Book03(String title, String author) {
		this(title, author, 0);
//		this.title = title;
//		this.author = author;
//		this.price = 0;
	}
	
	Book03(String title) {
		this(title, "작자미상", 0);
//		this.title = title;
//		this.author = "작자미상";
//		this.price = 0;
	}
	
	Book03() {
		this("무제", "작자미상", 0);
//		this.title = "무제";
//		this.author = "작자미상";
//		this.price = 0;
	}
	
	void pBook() {
		System.out.println(this.title + "," + 
						   this.author + "," + this.price);
	}
}

public class Cla03 {

	public static void main(String[] args) {
		Book03 b1 = new Book03("APT", "로제", 10000);
		b1.pBook(); // APT, 로제, 10000;
		Book03 b2 = new Book03("APT", "Tom");
		b2.pBook(); // 자바, Tom, 0
		Book03 b3 = new Book03("기사");
		b3.pBook(); // 기사, 작자미상, 0
		Book03 b4 = new Book03();
		b4.pBook(); // 무제, 작자미상, 0
	}
}

/*
생성자 체이닝 :
- 현업에서 생성자 체이닝은 중복 코드 제거, 유지 보수성 향상, 코드 일관성 확보 등의 이유로 많이 사용되는 기법
- 객체의 초기화 방식을 단순하고 명확하게 유지하는 데 큰 도움이 되므로 
- 초기화의 일관성을 유지하고 중복을 줄이는 방향으로 설계할 때 유용하게 사용
*/

(화요일)

# 객체(Object)

- 물리적으로 존재하거나 개념적인 것 중에서 다른 것과 식별 가능한 것

- 속성과 동작으로 구성, 자바는 이러한 속성과 동작을 각각 필드와 메소드라고 부름

- 실제 존재하는 데이터 하나하나를 인스턴스!

# 객체 지향 프로그래밍(OOP)

- 객체들을먼저 만들고, 이 객체들을하나씩 조립해서 완성된 프로그램을 만드는 기법

# 메서드 오버로딩

package thisisjava;

class Meth06 {
	int Sum(int x, int y) {
		int res = x + y;
		return res;
	}
	
	String Sum(String x, String y) {
		String res = x + y;
		return res;
	}
	
	String Sum(String x, int y, int z) {
		String res2 = x + "결과 : " + Sum(y, z); 
		return res2;
	}	
}

public class Cla06 {
	public static void main(String[] args) {
		Meth06 m1 = new Meth06();
		System.out.println(m1.Sum(20, 10));	
		System.out.println(m1.Sum("대한", "민국"));
		System.out.println(m1.Sum("덧셈", 30, 4));
	}
}

# 가변길이 매개변수 & 오버로딩

package thisisjava;

import java.util.List;

class Meth07 {
	//  배열 매개변수를사용하면 입력받을 때 배열만 허용하기에 여러가지 데이터 타입을 사용할 수는 없다
	int Sum00(int[] iArray) {
		int ans = 0;
		for(int i : iArray) {
			ans += i;
		}
		return ans;
	}
	
	int Sum01(int ... iArray) {
		int ans = 0;
		for(int i : iArray) {
			ans += i;
		}
		return ans;
	}
	
	String Sum01(String ... sArray) {
		String ans2 = "";
		for(String s : sArray) {
			ans2 += s;
		}
		return ans2;
 	}
	
	String Sum00(List<String> string) {
		StringBuilder ans = new StringBuilder();
		for(String s : string) {
			ans.append(s);
		}
		return ans.toString();
	}
}

public class Cla07 {

	public static void main(String[] args) {
		Meth07 m1 = new Meth07(); int res = 0;
		int[] iArr01 = {20, 10, 40};
		res = m1.Sum00(iArr01);
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5});
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5, 3});
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5, 3, 2});
		System.out.println(res);
		
		res = m1.Sum01(20, 10);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5, 3);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5, 3, 2);
		System.out.println(res);
		
		String s;
		s = m1.Sum01("서초", "여성", "인력");
		System.out.println(s);
		s = m1.Sum01("개발", "센터");
		System.out.println(s);
	}
}

# staic 사용

package thisisjava;

class Meth08 {
	static int iMoney; // static이 붙으면 메소드 영역에 static이 생기고 힙 영역에는 만들어지지 않는다
	void setMoney(int i, int o) {
		iMoney = iMoney + i - o;
	}
	void getMoney() { System.out.println(iMoney); }
}

public class Cla08 {
	public static void main(String[] args) {
		Meth08 m = new Meth08();
		Meth08 w = new Meth08();
		
		m.setMoney(20000, 13000); m.getMoney();
		w.setMoney(30000, 10000); w.getMoney();
		
	}
}

# static 사용 2

package thisisjava;

class Meth09 {
	// instance형 method
	void Sum(int x, int y) {
		System.out.println(x + y);
	}
	
	// static 형 method : 공간을 늘릴 필요가 없어서 메모리 사용량을 아낄 수 있다!
	static void Sub(int x, int y) {
		System.out.println(x - y);
	}
}

public class Cla09 {
	public static void main(String[] args) {
		int a = 20, b = 10;
		// instance 생성 후, instance.멤버를 사용하여야 한다
		Meth09 m1 = new Meth09(); m1.Sum(20, 10);
		Meth09 m2 = new Meth09(); m2.Sum(20, 10);
		
		// class명.멤버로 사용하여야 한다
		Meth09.Sub(20, 10);
	}
}

# static 사용 3 

- 사칙연산 메소드를 static으로 사용하면 좋은 이유!!

package thisisjava;

class Meth10 {
	static int Sum(int x, int y) {
		return x + y;
	}
	
	static void Sub(int x, int y) {
		System.out.println(x - y);
	}
	
	static int Mul(int x, int y) {
		return x * y;
	}
	
	static void Div(int x, int y) {
		System.out.println(x / y);
	}
}

public class Cla10 {
	public static void main(String[] args) {
		int a = 20, b = 10;
		System.out.println(Meth10.Sum(a, b));
		Meth10.Sub(a, b);
		System.out.println(Meth10.Mul(a, b));		
		Meth10.Div(a, b);
	}
}

# static 사용 4

package thisisjava;

class Meth13 {

	static int cnt0 = 0;
	int cnt3 = 0;
	void count01(int cnt1) {
		cnt0++; cnt1++; cnt3++;
		System.out.printf("%d, %d, %d\n", cnt0, cnt1, cnt3);
	}
	
	void count02(int cnt2) {
		cnt0++; cnt2++; cnt3++;
		System.out.printf("%d, %d, %d\n", cnt0, cnt2, cnt3);
	}
}

public class Cla13 {

	public static void main(String[] args) {
		Meth13 m1 = new Meth13(); m1.count01(10); // 1, 11, 1 
		Meth13 m2 = new Meth13(); m2.count02(20); // 2, 21, 1
	}
}

(수요일)

# static / instance / local 변수 비교하기

package thisisjava;

class Meth14 {
	static int staticCnt = 0;
	int instanceCnt = 0;
	void Count() {
		int localCnt = 0;
		staticCnt++; instanceCnt++; localCnt++;
		System.out.printf("%d, %d, %d\n",staticCnt, instanceCnt, localCnt);
	}
}

public class Cla14 {	
	public static void main(String[] args) {
		Meth14 m1 = new Meth14(); 
		m1.Count(); // 1, 1, 1
		m1.Count(); // 2, 2, 1
		m1.Count(); //a3, 3, 1
		
		Meth14 m2 = new Meth14(); 
		m2.Count(); // 4, 1, 1
		m2.Count(); // 5, 2, 1
		m2.Count(); // 6, 3, 1
	}
}

static : 모두의 공용 공간에 존재!! 항상 값이 바뀐다

instance : 내가 같은 객체를 호출할때마다 값이 바뀐다

local : method가 실행할때마다 값이 생기고 없어진다!!

# private를 사용하여 getter, setter 메서드를 우회적으로 사용했을때..

package thisisjava;

class Book16{
	// 필드명이 그대로 노출되는것이 좋지 않아서 private로 처리를 많이 하는데
	// 그때 getter, setter 메서드를 만듦으로써 우회적으로 메서드를 사용하여 만드는것이 좋다
	private String title = "무제"; 
	private String author = "미상";
	
	public String getTitle() { return this.title; }
	public void setTitle(String title) { this.title = title; }
}

public class Cla16 {
	public static void main(String[] args) {
		Book16 b1 = new Book16();
		b1.setTitle("Java"); 
		System.out.println(b1.getTitle());
		
	}
}

# Class의 활용

package thisisjava;

class Point17 {
    int x, y;
    
    Point17() { }; 
    
    Point17(int i, int j) {
        this.x = i;
        this.y = j;
        System.out.println(this.x + ", " + this.y);
    }
    
    void Sum(Point17 p1, Point17 p2) {
        this.x = p1.x + p2.x;
        this.y = p1.y + p2.y;
        System.out.println(this.x + ", " + this.y);
    }
    
    // 강사님 코드
    static Point17 pSum(Point17 i, Point17 j) {
    	int a = i.x + j.x;
    	int b = i.y + j.y;
    	return new Point17(a, b);
    }
    
    // 직사각형 넓이 구하기
    static int pRect(Point17 i, Point17 j) {
//    	int height;
//    	int width;
//    	if(i.x >= j.x) {
//    		width = i.x - j.x;
//    	} else width = j.x - i.x;
//    	
//    	if(j.y >= i.y) {
//    		height = j.y - i.y;
//    	} else height = j.y - i.y;
    	int height = Math.abs(i.x - j.x);
    	int width = Math.abs(i.y - j.y);
    	int res = height * width;
    	return res;
    	
    }
}

public class Cla17 {
    public static void main(String[] args) {
        Point17 p1 = new Point17(20, 10); 
        Point17 p2 = new Point17(35, 25); 
        Point17 p3 = new Point17();
        p3.Sum(p1, p2);      // 55, 35
        
        // 강사님 코드
//        Point17 p4 = Point17.pSum(p1, p2);
        System.out.println(p3.pRect(p1, p2));
    }
}

# 싱글톤 패턴

• 생성자를 private 접근 제한해서 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아서 외부에서 마음대로 객체를 생성하지 못하게 함
• 대신 싱글톤 패턴이 제공하는 정적 메소드를 통해 간접적으로 객체를 얻을 수 있음
• 싱글톤 : 클래스의 인스턴스를 딱 하나만 생성하도록 보

package thisisjava;

class Sing18 {
	// 딱 한번만 실행되어야 하는 애들한테 강제로 하게 한다!! 
    // Sing18 클래스는 자기 자신의 객체를 클래스 내부에서 단 한 번 생성합니다.
	private static Sing18 sing = new Sing18();
    // 생성자를 private으로 선언하여 외부에서 객체를 생성할 수 없도록 제한합니다.
	private Sing18() {}
	
	static Sing18 getInstnace() {
		return sing;
	}
}

public class Cla18 {
	public static void main(String[] args) {
		Sing18 s1 = Sing18.getInstnace();
		Sing18 s2 = Sing18.getInstnace();
		
		System.out.println(s1 == s2);
	}
}

# 상속 (& 메소드 오버라이딩)

package thisisjava;

class Ani20 {
	String name = "이름";
	void cry() { System.out.println("으앙"); }	
}

class Dog20 extends Ani20 {
	String name = "해피";
	@Override
	void cry() { System.out.println("멍멍"); } // Method Overriding
}

class Cat20 extends Ani20 {
	String name = "아치";
	@Override
	void cry() { System.out.println("야옹"); 	}
}

class Duck20 extends Ani20 { 
	String name = "도트";
	@Override
	void cry() { System.out.println("꽤꽥"); 	}
}

public class Cla20 {
	public static void main(String args[]) {
		Dog20 d1 = new Dog20();
		System.out.print(d1.name); d1.cry();
		
		Cat20 c1 = new Cat20();
		System.out.print(c1.name); c1.cry();
		
		Duck20 d2 = new Duck20();
		System.out.print(d2.name); d2.cry();
	}
}

# 상속 ( & final & Override)

package thisisjava;

class Vehicle22{
	static final int a = 1;
	void start() {System.out.println("출발");}
	void move() {System.out.println("이동");}
	void stop()  {System.out.println("멈춤");}
}
class Car22 extends Vehicle22{
	// final이 붙은 경우 오버라이딩 불가능 
//	@Override
//	int a = 2;
	
	// final + 변수 -> 상수같은 느낌
	static final int Normal = 1;
	static final int Accel = 2;
	static final int Slow = 3;
	
	int moveMode = Normal;
	
	void move() {
		if (moveMode == Normal) { super.move(); }
		else if (moveMode == Accel) 
			{System.out.println("빠른 이동");}
		else {System.out.println("천천히 이동");}
	}
}
public class Cla22 {
	public static void main(String[] args) {
		Car22 c1 = new Car22();
		c1.start();
		c1.move();
		c1.moveMode = Car22.Accel;
		c1.move();
		c1.moveMode = Car22.Slow;
		c1.move();
		c1.stop();
	}

}

# 참조형 형변환

- 부모 보다 자식에 더 많은 데이터가 들어있다!!

- 값을 찾을 수 없어서 마지막 4번은 틀린거임

package thisisjava;

class A25 { int a = 200; }
class B25 extends A25{ int b = 100; }


public class Cla25 {
	public static void main(String[] args) {
		// 참조형 형변환
		A25 z1 = new A25();
		B25 z2 = new B25();
		A25 z3 = new B25();
		// B25 z4 = new A25(); 문법적인 에러는 아니지만 메모리적인 에러
		
		short s1 = 10;
		int i1 = s1;
		int i2 = 20;
		short s2 = (short) i2;
	}
}

(목요일)

# 상속

package thisisjava;

class A26 {}
class B26 extends A26 {}
class C26 extends A26 {}
class D26 extends B26 {}
class E26 extends C26 {}

public class Cla26 {

	public static void main(String[] args) {
		B26 b = new B26();
		C26 c = new C26();
		D26 d = new D26();
		E26 e = new E26();
		
		A26 a1 = b; A26 a2 = c;
		A26 a3 = d; A26 a4 = e;
		
		B26 b1 = d; C26 c1 = e;
//		B26 b3 = e; C26 c3 = d;  -> 직계가 아니면 형변환 불가
		
		System.out.println(d instanceof B26);
		System.out.println(d instanceof A26);
		System.out.println(b instanceof D26); // false 
		
		System.out.println(e instanceof C26);
		System.out.println(e instanceof A26);
	}

}

# 다중 상속(인터페이스는 가능) 

- 불가능한 이유 : 필드랑 메서드를 아무리 안 만든다고 하더라도 근본적으로 object에 상속을 받기 때문에 없다고 느껴도 실질적으로 equals()나 toString()같은 메서드가 포함되어 있기 때문에 다중 상속이 불가하다 

- Java는 클래스 간의 다중 상속을 허용하지 않습니다. 그 이유는 다중 상속이 허용될 경우, 두 부모 클래스에서 같은 이름의 메서드나 필드가 정의되었을 때 어떤 것을 사용할지 결정하는 과정에서 혼란스러워질 수 있기 때문입니다(다이아몬드 문제). 또한, Java의 모든 클래스는 기본적으로 Object를 상속받기 때문에, 다중 상속이 허용되면 상속 관계가 지나치게 복잡해지고 충돌 가능성이 높아집니다. 이러한 이유로 Java는 클래스 간의 다중 상속을 금지하고, 대신 인터페이스를 통해 다중 구현을 지원합니다.

- interface는 가능한 이유 : 상태(필드)가 없고 동작(행위)만 정의하기 때문에 다중 구현이 안전합니다.

package thisisjava;


//class A27{}
//class B27{}
//class C27 extends A27,B27 { }

interface A27{ }
interface B27{ }
class C27 implements A27, B27{ }

public class Cla27 {

	public static void main(String[] args) {
		System.out.println("잘 실행됨");
	}
}

# 접근제한자

(public / protected / (default) / private) 

package thisisjava;

class A28 {
	
	int aa1 = 10;				// default (같은 패키지) / 숨겨져 있다 / 공개 범위 3등
	public int aa2 = 100; 		// public (항상 공개) / 공개 범위 1등
	private int aa3 = 1000;		// private(자기 클래스) / 공개 범위 꼴등
	protected int aa4 = 10000;	// protected (상속관계 내 + default) / 공개 범위 2등
}

class B28 extends A28 {
	int bb1 = 20;
}

public class Cla28 {
	public static void main(String[] args) {
		A28 a = new A28(); 
		B28 b = new B28(); 
	}
}

# 상속에서의 접근 범위

- 부모에서 상속받은 멤버는 접근 범위가 작아질 수 없다

- 오버라이딩된 메서드는 부모 클래스의 메서드를 **대체(replace)**하는 역할을 합니다. 따라서 부모 클래스 타입으로 자식 객체를 참조할 때도, 오버라이딩된 메서드에 동일한 접근 수준으로 접근 가능해야 합니다.

package thisisjava;

class A29 {
	void meth01() {}
}

class B29 extends A29 {
	// 부모한테서 상속받은 멤버는 접근범위가 작아질 수 없다
//	@Override
//	private void meth01() {}
}

public class Cla29 {

	public static void main(String[] args) {

	}

}

#  추상 클래스의 활용

- 상속 관계를 유지하면서 다형성을 이용하고자 할때

- 부모는 구현부가 필요하므로 

- abstract를 붙여서 추상클래스로 만들면 된다

package ch07.sec08.exam02;

public abstract class Vehicle {
	//메소드 선언
	public abstract void run(); 
}

# main 메서드가 있는 클래스에서 다른 메서드를 static으로 지정하는 것이 권장되는 이유

1. static 메서드와 non-static 메서드 혼용의 문제

• main() 메서드는 static 메서드입니다. main() 메서드 내부에서 static 메서드와 non-static 메서드가 혼용되면 가독성이 떨어질 수 있습니다.
• 예를 들어, test02()를 호출하기 위해 객체를 생성해야 하는 반면, test01()은 객체 없이 호출됩니다.
  개발자가 코드를 읽을 때 이러한 혼용은 혼란을 초래할 수 있습니다.

2. 객체 생성 오버헤드

• non-static 메서드를 사용하기 위해 객체를 생성해야 하므로, 불필요한 메모리 사용과 처리 비용이 발생할 수 있습니다.
  만약 메서드가 인스턴스 상태를 참조하지 않는다면, static으로 선언하여 객체 생성을 피할 수 있습니다.

3. 코드의 일관성 유지

• main() 메서드가 속한 클래스에서 모든 메서드를 static으로 선언하면, 객체 생성 없이 클래스 이름으로 모든 메서드 호출이 가능합니다.
• 이렇게 하면 일관성 있는 코드 스타일을 유지할 수 있습니다.

4. 유지보수성

• 정적 메서드는 상태를 공유하기 때문에 코드의 흐름을 예측하기 쉽습니다.
• 비정적 메서드가 혼재되면 객체 생성과 관리를 따로 추적해야 하므로 유지보수가 어려워질 수 있습니다.

package thisisjava;

class Cla31 {
	public static void main(String[] args) {
		System.out.println("Cla30-main() 실행");		
	}
	
	static void test01() {
		System.out.println("Cla31-test01() 실행");
	}
	
	void test02() {
		System.out.println("Cla31-test02() 실행");
	}
}

public class Cla30 {

	public static void main(String[] args) {
		System.out.println("Cla30-main() 실행");
		Cla31.test01();
		Cla30.test01();
		test01();
		
		Cla31 c31 = new Cla31();
		c31.test02();
		
		// 권장하지 않는 이유 : main 메서드가 있는 곳에서는 main 메서드를 제외하고 다른 메서드 또한 static을 붙여주는것이 좋다고 권장 (안되는건 아님)
		Cla30 c30 = new Cla30();
		c30.test02();
		
	}
	static void test01() { System.out.println("Cla30-test01() 실행"); }
	void test02() {
		System.out.println("Cla31-test02() 실행");
	}
}

# 봉인된 클래스

- sealed ~ permits : 상속을 허락하는 클래스를 제한할 수 있다

- nonsealed : 누가 상속하든 상관 x

- final : 상속하지 x

package ch07.sec11;

// Person 클래스는 Employee와 Manager에게만 상속을 허락한다
public sealed class Person permits Employee, Manager {
	//필드
	public String name;
	
	//메소드
	public void work() {
		System.out.println("하는 일이 결정되지 않았습니다.");
	}
}


// non-sealed는 누가 상속하든지 상관 없다!
public non-sealed class Manager extends Person {
	@Override
	public void work() {
		System.out.println("생산 관리를 합니다.");
	}
}


// final은 Employee이후 클래슨 더 이상 상속 해주지 않음
public final class Employee extends Person {
	@Override
	public void work() {
		System.out.println("제품을 생산합니다.");
	}
}

# interface 사용!!

- 구현은 필요없고 정의만 하는 경우 interface 사용 

- class가 interface를 사용하여 구현할 때는 extends -> implements로 변경

- 인터페이스의 모든 메서드는 기본적으로 public abstract이므로 interface에서 상속받아서 사용할 때는 접근제한자를 public 보다 같거나 큰 범위인 public 설정 필수

package thisisjava;

// 굳이 쓰지도 않은 구현체가 있을때 interface를 사용!!
interface TV{
	void PowerOn();
	void PowerOff();
}

class LGTV implements TV{
	// 부모 멤버의 접근 제한자보다 범위가 커야해서 public이 필수임
	public void PowerOn() {
		System.out.println("LGTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("LGTV 꺼짐");
	}
}

class SSTV implements TV{
	public void PowerOn() {
		System.out.println("SSTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("SSTV 꺼짐");
	}
}

class KTTV implements TV{
	public void PowerOn() {
		System.out.println("KTTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("KTTV 꺼짐");
	}
}

public class Cla32 {
	public static void main(String[] args) {
		TV[] tvs = { new LGTV(), new SSTV(), new KTTV() };
		for(TV tv : tvs) {
			tv.PowerOn();
			tv.PowerOff();
		}
	}
}

문제 😵‍💫

https://school.programmers.co.kr/learn/courses/30/lessons/42840

내 풀🦷

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        // 수포자들의 패턴 정의
        int[] pattern1 = {1, 2, 3, 4, 5};
        int[] pattern2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] pattern3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        
        // 점수를 계산할 배열
        int[] scores = new int[3];
        
        // 각 문제에 대해 수포자들의 답안을 비교하여 점수 계산
        for(int i = 0; i < answers.length; i++) {
            if(answers[i] == pattern1[i % pattern1.length]) {
                scores[0]++;
            }
            if(answers[i] == pattern2[i % pattern2.length]) {
                scores[1]++;
            }
            if(answers[i] == pattern3[i % pattern3.length]) {
                scores[2]++;
            }
        }
        
        // 제일 높은 점수를 찾음
        int maxScore = Math.max(scores[0], Math.max(scores[1], scores[2]));
        
        // 가장 높은 점수를 받은 수포자를 리스트에 추가
        List<Integer> result = new ArrayList<>();
        for(int i = 0; i < scores.length; i++) {
            if(scores[i] == maxScore) {
                result.add(i+1);
            }
        }
        
        return result.stream().mapToInt(i -> i).toArray();
    }
}

가장 많은 점수를 획득한 사람을 배열로 반환하는 간단한 문제였다!!

담는것 까지는 정말 쉬운데 return 문 작성하는 과정에서 어려움이 있었다!

참고하면 좋을 개념들 ✍️

• .stream()
  • stream : 데이터 컬렉션의 추상화로, 요소들을 차례차례 꺼내 처리할 수 있는 "데이터 흐름" 
  • List<Integer> 객체에서 각 요소에 접근할 수 있는 스트림을 생성한다 
  • 스트림은 데이터 처리 작업을 쉽게 할 수 있도록 도와주는 추상화 도구이다
• .mapToInt(i -> i) 
  • 스트림의 각 요소를 정수로 변환한다
  • i -> i는 람다 표현식으로, 리스트의 각 요소를 i 그대로 변환한다는 의미이다
  • 이 과정에서 객체(Integer)를 원시 타입(int)으로 변환하게 된다
• .toArray() 
  • 스트림의 결과를 배열로 변환한다
  • 최종적으로 List<Integer> 가 int[] 배열로 변환된다

(월요일)

# 최초의 프로그래머

https://namu.wiki/w/%EC%97%90%EC%9D%B4%EB%8B%A4%20%EB%9F%AC%EB%B8%8C%EB%A0%88%EC%9D%B4%EC%8A%A4

# it 언어의 역사

C언어의 탄생

- 직관적 언어

- 변수, 조건문, 반복문, 함수

- H/W, OS 변화시, 다시 컴파일 필요

- 메모리 직접 할당/해제

- 위 2문제점들로 탄생함 => Java (JVM에서 실행됨 / OS에 맞는 JVM 환경 구성)

Java의 시작

- 참조형(데이터가 무질서하게 들어감, 데이터의 주소가 들어감) / 값형(데이터의 값이 들어감)

- Garbage Collection 

- OOP 

JRE(Java Runtime Environment)

- JDK = JRE + development tools

- JRE = JVM + libraries

# jdk 다운로드

https://www.oracle.com/java/technologies/downloads/

환경변수 구성
JAVA_HOME : C:\Program Files\Java\jdk-21
PATH : %JAVA_HOME%\bin

환경변수 구성 확인
java -version

javac -version

# 메모장으로 코딩해서 컴파일 해보기

- java는 객체지향 언어

- class 단위로 메모리에 올라간다

- main메소드만 실행한다

- 함수는 4가지로 구성 : 메서드 이름, 입력값, 처리 구문, 출력값

- 명령어 마침표 : 세미콜론(;)

- public : 접근제한자 공개!!

- static : cpu가 main메소드를 찾기 쉽게 하는것!

- void : 반환값이 없다는 의미(return이 없음)

# 메모장 개발~
class Hello {
	public static void main(String[] args) {
		// 이것은 한줄 주석입니다.
		System.out.println("Hello Seoul");
		/* 이것은
		    여러줄 주석
		    입니다.
		*/
	}
}
// 주석은 제외하고 컴파일한다(날짜, 만든 목적,설명시 주석 사용)

javac Hello.java # cmd에서 컴파일 명령어
java Hello # Hello 메서드 실행

# Java 개발 환경 구성

- Eclipse 구성

• 자바 프로그램을개발할 때 가장 많이 사용하는 통합 개발 환경(IDE)
• JDK 21을 지원하는 Eclipse IDE 2023-12이상 버전 사용 
• [ctrl] + [s] (저장) 을 누르면 바로 컴파일된다!!

https://www.eclipse.org/downloads/

# JVM 메모리 구조

Heap 영역 : 무질서한 공간 / 참조형 친구들(string) 

Method 영역 :  모든 경우에서든 접근 가능하도록..?(1층 화장실은 다 사용 가능/ 내 화장실 못쓴다) 

Stack 영역 : 값형 데이터가 쌓임(책 쌓이듯이 - 사이즈가 명확해야함) / 데이터를 뺄때는 (LIFO) 

Heap 영역: 동적으로 할당되는 메모리로, 무질서하게(즉, 일정한 순서 없이) 데이터가 저장되는 공간이에요. 
           주로 참조형 데이터(예: 객체)가 할당됩니다. 말 그대로 무질서한 공간이라, 
           메모리 관리를 잘 하지 않으면 메모리 누수(메모리를 차지한 채 반환되지 않는 상황)도 발생할 수 있어요.

Method 영역: 프로그램이 실행될 때 로드되는 클래스, 메서드, 정적 변수 등이 저장되는 공간입니다. 
            그래서 어디서든 접근할 수 있게 준비된 공용 공간 같은 느낌이에요. 
            이곳에는 고정된 데이터가 주로 저장되기 때문에 다른 쓰레드에서도 동시에 접근할 수 있습니다.

Stack 영역: 함수 호출 시 할당되는 메모리로, 각 호출마다 메모리가 쌓이고(LIFO - 후입선출 구조) 함수가 
            종료되면 해당 메모리가 해제됩니다. 간단한 값형 데이터(예: int, float)가 여기에 쌓이는데, 
            데이터의 크기가 명확하게 정해져 있어야 하죠.

public class Type01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		short a1 = 10;
		int a2 = 20;
		int a3 = a1;
		short a4 = (short) a2; // 큰거에서 작은걸로 넘어가려면 명시적으로 표기해줘야 error가 나지 않는다
		
		System.out.println(a1); 10
		System.out.println(a2); 20
		System.out.println(a3); 10
		System.out.println(a4); 20
	}
}

(화요일)

# 값형 vs 참조형

package thisisjava;

public class Type02 {

	public static void main(String[] args) {
		// 값형은 초기값을 설정해야 에러가 안남..
		byte a1; a1 = 10;
		short a2 = 20;
		int a3 = 30;
		long a4 = 40;
		char a5 = 'A'; char a6 = '강';  // 여기까지 값형(그릇이 만들어지고 값을 넣음)
		String a7 = "서울"; // 참조형은 데이터가 만들어지고 그릇에 담는다(주소가 스택에 들어가있음)
		
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		System.out.println(a4);
		System.out.println(a5);
		System.out.println((int)a5); // 65
		System.out.println((int)'a'); // 97
		System.out.println(a6);
		System.out.println(a7);
	}
}

# 실수형 & boolean 타입 

package thisisjava;

public class Type03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		float a1 = 3.14f; // float 타입이라고 명시 해줘야 한다!! / 4byte
		double a2 = 3.14; // 8byte
		System.out.println(a1);
		System.out.println(a2);
		
		boolean b1 = true;
		boolean b2 = 3 > 4;
		System.out.println(b1);
		System.out.println(b2);
	}
}

# 2진수, 10진수, 16진수 비교하기

package thisisjava;

public class Type04 {
	public static void main(String[] args) {
		char a1 = 'A';
		System.out.println(a1); 
		System.out.println((int)a1); // 65
		System.out.println(Integer.toBinaryString(a1));
		System.out.println(Integer.toOctalString(a1));
		System.out.println(Integer.toHexString(a1));
		
		char a2 = 65;
		System.out.println(a2); // A
		
		char a3 = 0101;
		System.out.println(a3); // A
		
		char a4 = 0x0041;
		System.out.println(a4); // A
	}
}

# string의 주소 변환 & \ 사용법

package thisisjava;

public class Type05 {

	public static void main(String[] args) {
		String s1 = null;
		System.out.println(s1);
		s1 = "서울";
		System.out.println(s1); // garbage collector가 데이터를 치워줌..
		s1 = null;
		System.out.println(s1);
		
		String s2 = "사랑";
		System.out.println(s2); 
		s2 = "썰렁"; // 데이터의 값이 아니라 주소가 바뀜!! / 사랑에 대한 데이터는 gc가 치워줌
		System.out.println(s2);
		
		String s3 = "'사랑'합니다.";
		s3 = "\"사랑\"합니다."; // 큰따옴표 안에 큰따옴표 넣고 싶으면 \ 사용!!
		s3 = "2024년 11월 12일. \n"
				+ "날씨가 좋아요 \n그래서, "
				+ "맛있는 점심을 먹고싶어요";
		System.out.println(s3);
		
		System.out.print("안녕");  
		System.out.print("하세요");  
		
	}
}

# 값형 -> 참조형 데이터 변환

package thisisjava;

public class Type06 {

	public static void main(String[] args) {
		// 값형 안에서의 형변환은 사이즈 변환만 가능!(스택 안에서의 위아래만 변환)
		short a1 = 10;
		int a2 = a1; // 자동 형변환
		System.out.println(a2);
		
		short a3 = (short) a2; // 강제 형변환
		System.out.println(a3);
		
		// 값형에서 참조형으로 바꿔줄때는 자바 문법이 필요하다
		int a4 = 20;
		String s4 = String.valueOf(a4); // 데이터만 이전하고 주소만 a4로 넘김
		System.out.println(a4);
		
		// 참조형에서 값형으로 
		String s5 = "30";
		int a5 = Integer.parseInt(s5);
		System.out.println(a5);
	}
}

# 출력 방식에 따라 println vs printf()

• println(내용) : 괄호 안의 내용을 출력하고 행을 바꿔라
• print(내용) : 괄호 안의 내용을 출력하고 행은 바꾸지 마라
• printf("형식문자열", 값1, 값2....) : 형식에 맞춰서 출력해라(행은 바꾸지 않음)

package thisisjava;

public class Type07 {

    public static void main(String[] args) {
        // 동일한 데이터 타입으로 변수를 나열할때는 쉼표로 연결할 수 있다
        String s1 = "apple", s2 = "포도"; 
        int a1 = 500, a2 = 700;

        System.out.println(s1 + " 가격은 " + a1 + "원이다.");
        System.out.printf("%s 가격은 %d원이다.\n", s1, a1); 
        
        System.out.println(s2 + " 가격은 " + a2 + "원이다.");
        System.out.printf("%s 가격은 %d원이다.\n", s2, a2);  

        String s3 = "딸기", s4 = "수박";
        float a3 = 900.99f;
        double a4 = 3333.33;

        System.out.printf("%s 가격은 %.2f원이다.\n", s3, a3);  
        System.out.printf("%s 가격은 %.2f원이다.\n", s4, a4); 
        
        System.out.printf("%s 가격은 %d원이다.\n", "과일", 45678); 
        System.out.printf("%s 가격은 %10d원이다.\n", "과일", 45678); 
        System.out.printf("%s 가격은 %-10d원이다.\n", "과일", 45678); 
 
        System.out.printf("%s 가격은 %f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %5f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %.2f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %5.2f원이다.\n", "과일", 123.45); 

        System.out.printf("%s는 과일이다.\n", "사과"); 
        System.out.printf("%5s는 과일이다.\n", "사과"); // 5칸에서 우측부터 채움
        System.out.printf("%-5s는 과일이다.\n", "사과"); // 5칸에서 좌측부터 채움
    }
}

# Scanner(키보드 입력)

package thisisjava;

import java.util.Scanner;

public class Type08 {

	public static void main(String[] args) {
		System.out.println("이름 입력=>");
		Scanner sc = new Scanner(System.in);
		// 빨간줄 Click(import ~)
		// 직접 작성(import 문장)
		// Ctrl + Shift + o(영문)
		String name = sc.next();
		System.out.print(name + "님, 안녕하세요");
		sc.close();
	}
}

# 산술 연산자

- 오버플로우 : 타입이 허용하는 최대값을 벗어나는 것(예를 들어, short의 최댓값이 127에 1을 더하면 128이 되어 오버플로우가 발생하므로 연산결과는 최소값인 -128이 된다!!)

- 언더플로우 : 타입이 허용하는 최소값을 벗어나는 것

package thisisjava;

public class Op01 {

	public static void main(String[] args) {
		
		int i1 = 20, i2 = 10;
		
		System.out.println(i1+i2); // 산술연산자
		System.out.println(i1-i2);
		System.out.println(i1*i2);
		System.out.println(i1/i2);
		System.out.println(i1%i2);
		
		String s1 = "30", s2 = "40"; 
		System.out.println(s1+s2); // 연결연산자
		
		int i3 = Integer.parseInt(s1) + Integer.parseInt(s2); // Quiz
		
		System.out.println(i3); // 70
		
		int i4 = 100;
		i4 = i4 + 2; 
		System.out.println(i4);
		
		i4 += 2; 
		System.out.println(i4);
		
		i4 *= 2; 
		System.out.println(i4);
		
		i4 /= 2; 
		System.out.println(i4);
		
		byte b1 = 127;
		//b1 = b1 + 1;
		System.out.println(b1+1); // 128
		b1 += 1;
		System.out.println(b1); // -128(오버 플로우)
		System.out.println(b1+1);
		
	}

}

< 진법의 음수 & 양수 / 제일 앞자리 : 부호 비트(0이면 양수, 1이면 음수) >

# 나눗셈연산에서 예외 방지하기

• 나눗셈(/) 또는 나머지(%)연사에서 좌측 피연산자가 정수이고 우측 피연산자가 0일 경우 ArithmeticException발생
• 좌측 피연산자가 실수이거나 으측 피연산자가 0.0또는 0.0f이면 예외가 발생하지 않는다

System.out.println(5/0.0); // Infinity
System.out.println(5%0.0); // NaN

# 증감연산자

- 전치증감연산자 : ++a

- 후치증감연산자 : a--

package thisisjava;

public class Op02 {

	public static void main(String[] args) {
		// ++ , --
		int a = 10;
		int b = --a;
		System.out.println(a); // 9
		System.out.println(b); // 9
		
		int c = a--;
		System.out.println(a); // 8
		System.out.println(c); // 9

		int d = ++a;
		System.out.println(a); // 9
		System.out.println(d); // 9
		
		int e = a++;
		System.out.println(a); // 10
		System.out.println(e); // 9
	}

}

# 논리 연산자 && 비트논리연산자

package thisisjava;

public class Op03 {

	public static void main(String[] args) {
		int i = 4, j = 3;
		System.out.println(i==j); // 비교연산자
		System.out.println(i>j);
		System.out.println(i!=j);
		
		System.out.println(true&&true);
		System.out.println(true&&false);
		System.out.println(true&true);
		System.out.println(true&false);
		
		System.out.println(false&&true);
		System.out.println(false&&false);
		System.out.println(false&true);
		System.out.println(false&false);
		
		System.out.println(true||true);
		System.out.println(true||false);
		System.out.println(false||true);
		System.out.println(false||false);
		
		System.out.println("------");
//		System.out.println(6&&4);//논리연산자 (불리언 타입으로만 와야함)
		System.out.println(6&4);//비트논리연산자 (이진수로 바꾸고 비교!)
//		System.out.println(6||3);//논리연산자
		System.out.println(6|3);//비트논리연산자	
		
		int k = 8; // 1000(2)
		System.out.println(k >> 1); // 100(2) 
		System.out.println(k << 1); // 100000(2)
	}
}




package thisisjava;
public class Op04 {
	public static void main(String[] args) {
		int a = 7, b = 3;
		System.out.println((a==b)&&(a>b++));//false
		System.out.println(b);//3
		
		System.out.println((a==b)&(a>b++));//false
		System.out.println(b);;//4
		
		System.out.println((a!=b)||(a>b++));//true
		System.out.println(b);;//4
		
		System.out.println((a!=b)|(a>b++));//true
		System.out.println(b);;//5

	}

}

(수요일)

# 삼항 연산자

- 총 3개의 피연산자를가짐

- ? 앞의 피연산자는 boolean 변수 또는 조건식이 참이면 : 뒤에 앞에 것을 선택하고 거짓이면 뒤에 것을 선택 

package ch03.sec11;

import java.util.Scanner;

public class ConditionalOperationExample {
	public static void main(String[] args) {
//		int score = 85;
//		char grade = (score > 90) ? 'A' : ( (score > 80) ? 'B' : 'C' );
//		System.out.println(score + "점은 " + grade + "등급입니다.");
		
		/* 90점이상이면, 우수
		 * 80점이상이면, 보통
		 * 80점미만이면, 부족
		*/
		System.out.print("자신의 점수를 입력하시오 => ");
		Scanner sc = new Scanner(System.in);
		int score = sc.nextInt();
		
		String grade = ((score >= 90) ? "우수" :
			((score >= 80) ? "보통" :
				((score >= 70) ? "부족" : "낙제")));
		System.out.printf("Score는 %d점, %s", score, grade);
		sc.close();
	}
}




package ch03.sec11;

public class ConditionalOperationExample {
	public static void main(String[] args) {
		int score = 85;
		char grade = (score > 90) ? 'A' : ( (score > 80) ? 'B' : 'C' );
		System.out.println(score + "점은 " + grade + "등급입니다.");
	}
}

# if - else (조건문)

package thisisjava;

import java.util.Scanner;

public class if01 {

	public static void main(String[] args) {
		// 조건식 ? true : false
		System.out.print("숫자를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String ans = null;
		
		if((n % 2) == 0) {
			ans = "짝수"; 
		} else {			
			ans = "홀수"; 
		}
		
		System.out.println(ans);
		sc.close();
	}
}


package thisisjava;

import java.util.Scanner;

public class if02 {

	public static void main(String[] args) {
		System.out.print("점수를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String score = null;
		
		if(n >= 90) { score = "우수"; }
		else if(n >= 80) { score = "보통"; }
		else if(n >= 70) { score = "부족"; }
		else { score = "낙제"; }
		
		System.out.printf("제점수는 %d이고, %s입니다", n, score);
		sc.close();

	}
}

# switch - case 문

package thisisjava;

import java.util.Scanner;

public class switch01 {

	private static final int case1 = 0;

	public static void main(String[] args) {
		// 조건식 ? true : false
		System.out.print("숫자를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = (sc.nextInt() % 2);
		sc.close();
		
		String ans = null;
		
		switch (n) {
			case 0: ans = "짝수";
				break; // 빠져 나가주지 않으면 다 기타로 빠짐....
			case 1: ans = "홀수";
				break;
			default: ans = "기타";
		}
		
		System.out.println(ans);
	}

}

#  ==과 .equals()의 차이

package thisisjava;

import java.util.Scanner;

public class str01 {

	public static void main(String[] args) {
		int i1 = 20, i2 = 10, i3 = 20;
		System.out.println(i1 == i2);
		System.out.println(i1 == i3);
		
		// s1 : KR을 먼저 만들고 주소 할당하고 / s2 : 이미 KR이 있으므로 같은 주소가 들어감
		String s1 = "KR", s2 = "KR";
//		String s3 = new String("KR");
		System.out.println(s1 == s2);
//		System.out.println(s1 == s3);
		System.out.println(s1.equals(s2));
		
		// 외부에서 입력받았을 경우..
		// 어떤 데이터가 올지 몰라서 일단 주소를 넣고 KR이 들어감!! 그래서 키보드로 입력받은것은 
		// 이미 heap에 저장되어 있는 값이더라도 주소가 다를 수 밖에 없다 
		System.out.println("KR 입력 =>");
		Scanner sc = new Scanner(System.in);
		String s3 = sc.next();
		sc.close();
		
		System.out.println(s1 == s3);
		System.out.println(s1.equals(s3));
	}
}

# 화살표 처리 (jdk12버전 부터 있었당)

package thisisjava;

import java.util.Scanner;

public class switch03 {

	public static void main(String[] args) {
		System.out.println("영어를 알려줘 👇👇👇👇");
		Scanner sc = new Scanner(System.in);
		String direction = sc.next();
		String eng;
		sc.close();
		
		switch(direction) {
			case "동" -> eng = "East";
			case "서" -> eng = "West"; 
			case "남" -> eng = "South"; 
			case "북" -> eng = "North"; 
			default -> eng = "기타"; 
		}
		
		System.out.printf("%s에 대한 영어 단어는 %s입니다 :)", direction, eng);
	}
}


package thisisjava;

import java.util.Scanner;

public class switch04 {

	public static void main(String[] args) {
		System.out.println("영어를 알려줘 👇👇👇👇");
		Scanner sc = new Scanner(System.in);
		String direction = sc.next();
		sc.close();
		
		String eng = switch(direction) {
			case "동", "동쪽", "동녁" -> "East";
			case "서" -> "West"; 
			case "남" -> {
				String result = "South" + "방향";
				yield result;  // switch 표현식의 반환 값을 지정할 때 사용
			}
			case "북" -> "North"; 
			default -> "기타"; 
		};
		
		System.out.printf("%s에 대한 영어 단어는 %s입니다 :)", direction, eng);
	}
}

(목요일)

# 가위바위보 게임!!

package thisisjava;

import java.util.Scanner;

public class if07 {

	public static void main(String[] args) {

		int num = (int)(Math.random()*3); // 상대 랜덤

		String sRan; // 상대꺼 저장
		if(num== 0) { sRan= "가위"; }
		else if (num == 1) { sRan= "바위"; }
		else { sRan= "보"; }		
		
		System.out.println("가위/바위/보 입력 => ");
		Scanner sc = new Scanner(System.in);  // 내꺼 입력
		String sMe= sc.next(); // 내꺼 저장
		
		// 비기는 경우 (가위-가위, 바위-바위, 보-보)
		if(sMe.equals("가위") || sMe.equals("바위") || sMe.equals("보")) {
//			while(sMe.equals("가위") || sMe.equals("바위") || sMe.equals("보")) {
			System.out.printf("나 : %s, 상대 : %s \n",sMe,sRan);
			if(sMe.equals(sRan)) { System.out.println("비김");}
			// 이기는 경우 (가위-보 || 바위-가위 || 보-바위)
			else if(    (sMe.equals("가위") && sRan.equals("보"))
					|| (sMe.equals("바위") && sRan.equals("가위"))
					|| (sMe.equals("보") && sRan.equals("바위"))
					){
				System.out.println("이김");
			}
			// 지는 경우
			else { System.out.println("졌음"); }			
		}
		else {
			System.out.println("잘못입력하였습니다 (TㅡT)");
		}
	}
}

# 강사님 문제

package thisisjava;

import java.util.Scanner;

public class if08 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("국어 점수 입력 => ");
		int iKr = sc.nextInt();
		System.out.println("영어 점수 입력 => ");
		int iEn = sc.nextInt();
		sc.close();
		
		int iTotal = iKr + iEn;
		double dAvg = iTotal / 2.0; // int로 계산한뒤 저장하기 때문에 2를 double인 2.0으로 바꿔줌
		System.out.printf("총점 : %d, 평균 : %.2f \n", iTotal, dAvg);
		
		if(iKr < 60 || iEn < 60) {
			System.out.println("과목낙제 입니다 FFF");
		}
		else {
			if(dAvg >= 90) {
				System.out.println("우수");
			} else if(dAvg >= 80) {
				System.out.println("보통");
			} else if(dAvg >= 70) {
				System.out.println("부족");
			} else {
				System.out.println("평균낙제");
			}
		}
	}

}

https://www.w3schools.com/

공부하기 좋은 url

# 반복문 3가지!! (for / while / do-while)

package thisisjava;

public class for01 {

	public static void main(String[] args) {
		// 1 ~ 5 까지 가로방향 출력
		// 시작점 : int i = 1 / 끝점 : i <= 5 / 스텝 : 1씩 증가 : i++ / 처리 : 가로 방향 출력 (syout) 
		
		/*
		 for문의 구조
		 for(시작점; 끝점; 스텝;) {
		 	처리;
		 }
		 */
		
		for(int i = 5; i >= 1; i--) {
			System.out.print(i + " ");
		}
		
		
		/*
		 while문의 구조
		 시작점;
		 while(끝점) {
		 	처리;
		 	스텝;
		 }
		 */
		int z = 5;
		while(z >= 1) {
			System.out.print(z + " ");
			z--;
		}
		
		
		/*
		 do - while문의 구조
		 시작점;
		 do {
		 	처리;
		 	스탭;
		 }while (끝점);
		 */
		
		int y = 5;
		do {
			System.out.print(y + " ");
			y--;
		}
		while(y >= 1);
		
	}
}

# 예외처리

package thisisjava;

import java.util.InputMismatchException;
import java.util.Scanner;

public class try01 {

	public static void main(String[] args) {
		System.out.print("숫자 하나 입력 => ");
		Scanner sc = new Scanner(System.in);
		
		try {
			int i1 = sc.nextInt();
			int i2 = 100/i1;
			System.out.println(i2);			
		} catch(ArithmeticException e) {
			System.out.println("0은 안되요");
			System.out.println(e);
		} catch(InputMismatchException e) {
			System.out.println("문자는 안되요");
			System.out.println(e);
		}
		sc.close();
	}
}

(금요일)

# array 기초

package thisisjava;

public class arr01 {

	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		int i3 = 30;
		int i4 = 40;
	
		int[] iArr1 = {10, 20, 30, 40};
		
		
		for(int i = 0; i < iArr1.length; i++) {
			System.out.println(iArr1[i]);
		}
		System.out.println();
		
		// sArr1 세로방향 출력
		String[] sArr1 = {"사과", "배", "바나나"};
		for(int i = 0; i < sArr1.length; i++) {
			System.out.println(sArr1[i]);
		}
	}
}

package thisisjava;

import java.util.Arrays;

public class arr02 {

	public static void main(String[] args) {
		int i1 = 100, i2 = 200;
		
		int[] iArr1 = {10, 20, 30, 40};
		// 다른 메모리를 쓰는 이유 : 구조를 만들고 데이터를 넣는 것이므로 같은 값이더라도 주소값이 다르다
        /*
        새로운 메모리 공간에 구조(배열 객체)를 할당하고 그 안에 데이터를 넣는 방식으로 동작하므로, 
         같은 데이터가 들어가더라도 객체마다 별개의 메모리 주소를 가지게 됩니다. 
         */
		int iArr2[] = {10, 20, 30, 40}; 
		if(Arrays.equals(iArr1, iArr2)) {
			System.out.println("g");
		}
		
		// new를 보면 heap 공간에 데이터를 넣기 위해 확보한다는 의미
		int[] iArr3 = new int[4]; 
		
		iArr3[0] = 11; iArr3[1] = 22; 
		iArr3[2] = 33; iArr3[3] = 44; 
		
		for(int i = 0; i < iArr3.length; i++) {
			System.out.println(iArr3[i]);
		}
	}
}

# 향상된 for 문

package thisisjava;

public class arr04 {

	public static void main(String[] args) {
		int[] iArr1 = {10, 20, 30, 40, 50};
		
		// 방번호 붙여서 가지고 올래
		for(int i = 0; i < iArr1.length; i++) {
			 System.out.print(iArr1[i] + " ");
		}
		
		System.out.println();
		
		// 방값 복사해서 가지고 올래..
		for(int iA : iArr1) {
			System.out.print(iA + " ");
		}
	}
}

# String과 String[]의 메모리 구조 이해!!!

#  null & nullPointerException

package thisisjava;

public class arr06 {

	public static void main(String[] args) {
		// 사과, 배, 바나나가 들어가는 빈 STring 배열 3칸 구성
		String[] fruits =  new String[3];
		
		for(int i = 0; i < fruits.length; i++) {
			System.out.print(fruits[i] + " "); // null : 연결할 주소 없음
		}
		
		fruits[0] = "사과";
		fruits[1] = "배";
		fruits[2] = "바나나";
		
	}
}


package thisisjava;

public class NullPointerExceptionExample {
	public static void main(String[] args) {
		int[] intArray = null;
//		intArray[0] = 10;	 //NullPointerException

		// eclipse도 실행을 해봐야 에러가 나온다! 문법적인 에러가 따로 없어서 실행은 되는데 막상 실행해보면 안됨;;
		String str = null;
		System.out.println("총 문자수: " + str.length() );	  //NullPointerException
	}
}

(화요일)

- github 이슈 생성해서 jira랑 연동 실습하기(?)

- README.md 파일에서 md란...? markdown 파일이라는 뜻 (웹 페이지 글올릴 때 쓰임) 

Todo : 이슈 진행 전 상태

In Progress : 담당자가 이슈를 확인하고 진행중인 상태

In Review : 검토를 요청/진행 중인 상태(중간에 검토 단계를 넣는게 요즘 근황)  

Done : 완료 및 종료된 상태

프로젝트 목표 : 정해진 비용과 기간내에서 어떻게 하면 품질을 높이면서 마무리할 수 있을건지...

- R&R : Role & Responsibility (pm이라면 프로젝트 관리를 위한 책임)

- wbs 실습은 내일!!

- 위험과 이슈의 차이 : 위험(potential problem)은 아직 잠재적 문제로 아직 일어나지 않은 것이고 이슈는 일어난 문제로 실제로 일어날 이슈를 방지하기 위해 위험을 방지해야한다!

- 위험과 관련된용어 : 발생 가능성과 발생했을때의 심각도(위험도)를 곱한것이 위험도.. 높은것이 우선순위로 정해지고 이를 대비하기 위해 철저하게 계획을 세워야한다

(수요일)

- wbs 만들기 

베이스 라인 : 특정 시점에서 필요한 파일들을정확히 사용할 수 있게 해주는 작업..

 - 어떤 요구사항 명세서를 반영하는 소스코드인건지를 알기 애매하므로 어떤 산출물을 기준으로 개발한건지를 알기 위해 적어 놓은것이 baseline..

- 어떤 요구사항 명세서와 설계서를 기준으로 개발할건지를 확인하고 개발해야한다!

- 소프트웨어 형상 통제 : 형상통제위원회에서 변경 요청을 수용할 것인지 평가하고 협의하는 과정(CCB한테 통과 받아야 업데이트 가능)

요구사항 명세서(SW Requirement Specification) : 무엇을 개발할건지에 초점을 맞춘다! (어떤 기능을 제공할것인지, 어떤 품질로 / 어떻게는 설계서에 들어갑니다..)

- 시스템(SYSRS)

- 소프트웨어(SWRS)

- 하드웨어(HWRS)

기능 vs 비기능 

- 기능 :  찐 기능

- 비기능 : 품질, 성능, 제약사항

비기능 요구사항 예시

기능 요구사항 어떻게 분석하고 작성하는지... (도출, 분석, 명세, 확인...)

- 좋은 요구사항 명세서라면 요구사항 명세서를 가지고 테스트를 만들어서 다 잘 돌아가는지...(테스트가 가능하다면 요구사항이 굉장히 디테일 하다는것!! / 아니라면 요구사항 명세서 더 자세하게 해달라고 부탁하기!!)

- 추적성 : 우리의 소스코드가 어떤 설계서, 아키텍처 설계서, 요구사항 명세서를 만족시키기 위해 나왔는지 추적이 가능한지... / 우리의 요구사항은 언제든지 변경될 수 있기 때문에 어떤걸 수정해야할지 찾는데 시간이 오래걸림, 누락 가능하다

- 변경 용이성 : 다른것과 최대한 독립성을 띄우는것이 좋다(의존적이면 변경하기 힘듦) 

-  uml 그리기 실습은 내일..

<목요일)

- UML : 시스템 설계를 표현하는데 사용하는 통합된 모델링언어

MBD : MODEL BASED DEVELOPMENT / 모델링만 하면 자동으로 개발해줌... / 개발자는 없어져도... 설계자는 안 없어진다

USECASE DIAGRAM 구성요소

- user actor :  시스템의 외부에 있으면서 시스템과 상호작용하는 것들... 일반적으로 사용자 혹은 외부 시스템

- system actor : 해당 프로젝트의 개발 범위에는 속하지 않지만 데이터를주고받는 등 서로 연동되는 다른 시스템 
                          ex) 우리 시스템에 데이터를 주는 기상청 시스템   

- usecase : 시스템이 액터에게 제공해야 하는 기능의 집합 / 동사+명사 형식으로 작성(성적등록, 성적조회)

- relationship : 액터와 유스케이스 / 유스케이스와 유스케이스 사이의 연관 관계!!! (관계 종류.....)

# USECASE DIAGRAM 그리기

https://app.diagrams.net/

# 설계

- 관점 : HOW(어떻게)

- 특징 : 사용 환경을 반영해 구체적

- 상위 설계서, 상세 설계서 두가지로 나뉨

(금요일)

https://velog.io/@hongjunland/Clean-Architecture

클린 아키텍처 필독서...

# 설계!!!

## 추상화 : 상위 레벨에서 제품의 구현을 생각해봄!!

https://wealthymindset.tistory.com/entry/%EC%82%AC%EC%97%85%EC%B6%94%EC%A7%84-%ED%98%95%ED%83%9C%EC%9D%98-%EB%91%90%EA%B0%80%EC%A7%80-%EB%B0%A9%EB%B2%95-%ED%83%91%EB%8B%A4%EC%9A%B4Top-down%ED%95%98%ED%96%A5%EC%8B%9D-%EB%B0%94%ED%85%80%EC%97%85Bottom-up%EC%83%81%ED%96%A5%EC%8B%9D-%EB%B0%A9%EC%8B%9D

Top-down(하향식)과 Bottom-up(상향식)의 차이..

comfile 과정 : .java 파일을 컴퓨터가 해석할 수 있도록 컴파일러를 거쳐서 .class 파일로 바꿔주는 과정

## 분할과 정복(Divide Conquer)

- Component : 소프트웨어를 구성하는 요소들의 집합 / 클 수도 작을 수도 어떻게 쪼개지는지는 때마다 다르다  

- Unit : 더이상 나눌 수 없는 atomic한 요소

분할과 정복의 의미...

- 하나로 하지 말고 여러 개로 쪼개고 하나하나 작은 단위부터 개발하고 합쳐서 상향식으로 개발해 나가라는 의미

- 모듈화랑 같은 의미(= unit과도 같음)

- 한 화면에 보기 좋은 50-80줄 사이로 함수를 작성하는 것이 좋음

## 모듈화(Modularity)

- 의미 : 소프트웨어 구조를 이루는 기본 단위

- 특징

• 독립적인 기능을 수행하는 단위
• 유일한 이름을 가짐
• 모듈에서 또 다른 모듈을 호출(call)할 수 있음 -> interaction의 한 종류 / interface : interaction을 하는데 손쉽게 하는 수단(화면) / 호출을 하는경우... 데이터를 요청하고 응답 받을  
• 다른 프로그램에서도 모듈을 호출할 수 있음

- 모듈의 크기 : 시스템의 규모, 유형, 특성에 따라 작음 / 작은 시스템이라면 모듈의 크기는 함수 / 큰 시스템이라면...

- 응집도는 강하게(모듈 구성 요소간에는 강하게) / 결합도는 약하게(의존성이 약해야한다)

- 결합도를 느슨하게 하라는 말이... 모든 관계가 안좋다는 말이 아니라 A,B가 서로 호출하여 에러의 무한루프를 돌지 말라는 소리  

- 결합도가 높을수록 복잡해짐 / 낮을수록 단순해지도 유지보수, 재사용성이 좋다

C언어 절차지향형 언어...

- 다른 언어들도 다 순서대로 코드가 실행되는데 왜 절차지향이라고 하는지 ???? 특히나 순서에 집중해서?? 함수를 어디서나 쓰려고 하면 전역변수로 선언해야 한다 / 유지보수 어려움

JAVA 객체지향 언어...

- 사람이 이해한것처럼 코드를 짜보자 해서 나온 언어

- interaction이 이루어지기 때문에 loose coupling, strong cohension을 꼭 하자

# 객체지향방법론의 특징

- 캡슐화 : 정보은닉의 개념이 포함된 개념 / 나의 정보를 감싸서 다른 사람들에게 정보를 숨기는 효과 

- 상속 : 다른클래스의 속성을 물러받아 내 것처럼 쓰는 것 

- 다형성 : 하나 이상의 형태를 갖는 것

• 오버로딩 : 같은 함수 이름이어도 매개변수의 개수나 타입이 다르면 중복 정의하여 사용 가능
• 오버라이딩 : 상속 관계에서 부모의 가져온 메소드를 자식 클래스가 재정의 하여 사용 가능
  • 오버라이딩은 부모 클래스의 메소드를 자식 클래스에서 동일한 이름과 매개변수로 재정의하여, 자식 클래스에서 메소드를 호출할 때 부모 클래스의 메소드가 아닌 자식 클래스의 메소드가 실행되도록 하는 것입니다. 오버라이딩은 메소드에서만 이루어집니다.
  • 쉐도잉은 자식 클래스에서 부모 클래스와 동일한 이름의 변수를 선언하여 부모 클래스의 변수를 덮어쓰는 것입니다. 이 경우 자식 클래스의 인스턴스는 부모 클래스의 변수 대신 자식 클래스의 변수를 참조하게 됩니다. 하지만 부모 클래스의 변수 자체가 변경되는 것은 아닙니다