[SK shieldus 지능형 애플리케이션 개발 트랙 2기] 6 (Java)

# 개요
- Java 언어
    - 과정 내 배우는 언어 : JavaScript, Java, Python
    - 특징
        - 객체 지향 프로그래밍 언어
            - 클레스 단위로 개발
        - 기반 C/`C++`
        - 1995년 개발됨, Sun 마이크로시스템즈 (http://www.java.com)
            - 2008~9 Oracle 인수되었음
        - 철학
            - 모든 기기를 연결하는 `네트워크`상에 언어
                - 초기 : J2SE(PC유저), J2ME(모바일), J2EE(엔터프라이즈, 웹)
                - 현재 : 
                    - 엔터프라이즈 시장!! 집중 -> `웹 서비스`
                        -Servlet/JSP -> EJB -> Spring -> `Spring Boot (현재)`
                    - 모바일(피처폰(midp)->안드로이드:자바->코틀린)
                        -점점 비중이 사라짐
                - 정리
                    - 자바 => Spring Boot
- 개발 환경
    - 개발 PC에는 JDK(JRE(런타임 환경) + JVM(가상머신)):개발자툴킷 설치되어 있어야함
        - 17 이상 버전 권장 , 스프링부트 3.x 버전 이상
        - Windows x64 Installer
            - https://download.oracle.com/java/17/archive/jdk-17.0.12_windows-x64_bin.exe 

    - IDE
        - 개발 통합 환경
        - 레거시 방식 
            - eclipse (이클립스) 
            - STS (https://spring.io/tools)
            
        - 최근 3-4년  
            - IntelliJ (인텔리J)
                - Ultimate (유로, 대학생/교육용 무료료)
                    - https://www.jetbrains.com/ko-kr/idea/download/?section=windows (30일 평가판 설치)
                    - 현역 대학생
                        - https://www.jetbrains.com/community/education/#students : 신청하여 교육용 라이센스 발급
                        - 발급 절차 참고 : https://goddaehee.tistory.com/215
                    - 졸업생등 비현역
                        - 교육 라이센스 제공 (별도로 제공)
            - 젯브레인 : 안드로이드 스튜디오, 파이참, ... 코틀린,,  

- 환경 구축 절차
    - JDK 설치
        - path 부분 주의깊게 체크 (않나오면 생략)
        - 설치간 특이 사항 없음
        - 설치 완료후 확인 -> path 확인
            - 터미널 오픈
            - 아래 명령어 실행 
                ```
                    $> java
                    $> java -version
                ```
    - IDE 설치
        - 설치간 특이점
        - 연결 파일등.. 메뉴
        - 활성화 문의 -> "30 평가판"으로 진행
        - 설정 
            - File > Settings
                - Appre... > thema 조정
                - Editor > font 조정
                - auto 검색 > auto import > 체크박스 2개 체크 (최적 import 처리됨)
                - Editor > General > Mouse > Change Font...     체크

# 프로젝트
    - Java 프로젝트 생성
        - 프로젝트 유형 Java 선택
        - 적절한 이름 JavaBasic
        - 프로젝트 위치 적절하게 구성
    
    - 프로젝트 구조 
        - src/*.java 만 체크

# Java 문법
    - 기본 구동 구조 이해 - PC 기반에서
    - 타입
        - 자바의 타입 = 원시(primitive) 타입:8 + 참조(reference) 타입:무한대

        - 원시(primitive) 타입 -> 값의종류, 그릇의 크기(메모리 공간간)
            - byte, short, (*)int, long : 정수형
            - (*)float, double : 부동소수형
            - (*)boolean : 참/거짓
            - char : 문자
        - 원시타입-메모리크기로 비교 (그릇의 크기가 다음)
            - byte   : 1 byte (8bit)    : -2^7 ~ 2^7   <= 값의 표현 범위
                - -128 ~ 127
            - short  : 2 byte (16bit)   : -2^15 ~ 2^15
            - (*)int : 4 byte (32bit)   : -2^31 ~ 2^31 <= 가장많이 사용(주로)
                - 일반 계산
            - long   : 8 byte (64bit)   : -2^63 ~ 2^63
                - 시간!!            
            -  float  : 4 byte
            -  double : 8 byte
            - boolean : 1 bit
            - char    : 2 byte
        - 참조형
            - 객체 이후 등장!!
            - ex) String, 배열, 객체, 컬렉션, ...
    
    - 연산자
        - JS와 거의 동일하다!!
        - 생략
        - +, -, /, *, %, &, |, ^, !, ....
        - >=, <=, ==, !=, >, <, ...
        - 다른 코드 진행하면서 체크

    - 흐름제어
        - if문, for 문, while문, switch문 : 모두 동일함, 

    - 자료구조 
        - 배열 
        - 컬렉션

모디파이어(Modifier)

---

1. 접근 제한자 (Access Modifiers)

접근 제한자는 클래스, 메서드(함수), 필드(변수), 생성자 등에 대한 접근 범위를 정의합니다.

접근 제한자 같은 클래스 같은 패키지 하위 클래스 다른 패키지

(*)public	O	O	O	O	모든곳사용가능
protected	O	O	O	X	상속관계에서만 사용
default	O	O	X	X	표시 x
(*)private	O	X	X	X	나만 사용, 해당클레스만 사용

접근 제한자 설명

1. public
   • 모든 클래스에서 접근 가능.
   • 클래스, 메서드, 필드에 적용 가능.
2. protected
   • 같은 패키지와 다른 패키지의 하위 클래스에서 접근 가능.
   • 상속을 통해 접근 허용.
3. default (패키지 전용)
   • 접근 제한자를 생략하면 기본값으로 default가 적용됩니다.
   • 같은 패키지에서만 접근 가능.
4. private
   • 같은 클래스 내에서만 접근 가능.
   • 캡슐화를 위해 주로 사용.

---

2. 기타 (일반) 모디파이어 (Non-Access Modifiers)

기능적 동작을 정의하는 모디파이어입니다.

클래스에 사용 가능한 모디파이어

모디파이어 설명

final	클래스 상속 금지.
abstract	클래스에 추상 메서드가 포함될 수 있으며, 객체를 생성할 수 없음.
strictfp	부동소수점 연산이 플랫폼 독립적으로 수행되도록 보장.

---

메서드에 사용 가능한 모디파이어

모디파이어 설명

final	메서드를 오버라이딩할 수 없음.
abstract	메서드의 구현을 제공하지 않음. (선언만 가능, 추상 클래스에서 사용.)
static	객체를 생성하지 않고 클래스 이름으로 호출 가능.
synchronized	메서드를 스레드 안전하게 동기화 처리.
native	메서드가 네이티브 코드(C/C++)에서 구현되었음을 나타냄.
strictfp	메서드 내 부동소수점 연산을 플랫폼 독립적으로 수행.

---

변수에 사용 가능한 모디파이어

모디파이어 설명

final	변수 값을 한 번만 할당 가능. (상수로 사용됨.)
static	클래스에 속하는 변수로, 모든 인스턴스에서 공유됨.
transient	직렬화 대상에서 제외.
volatile	멀티스레드 환경에서 변수를 메모리에 항상 최신 값으로 유지.

---

• static
  • 메모리상 최고 레벨(탑 레벨)로 할당됨 (정적)
    • 메모리 공간을 최우선으로 배정받는다!!
    • 우선 대우
    • 접근 자유롭다!!

    - 기본 문법
        - 변수
        - 메소드
    
    - 패키지
        - 향후 작성되는 *.java들을 특정 목적에 맞게 소속시키는 관점
            - 유틸리티
            - UI 모음
            - 네트워크 모음
            - ... 
            - 용도별로 그룹화할수 있다 => 관리상 잇점!!
            - 스프링부트의 대표적인 패키지 구성
                - 엔티티 -> 테이블과 1대 1일대응
                - 레포지트리 -> SQL을 대한 객체로 대응하여 구성
                - 컨트롤러 -> 라우팅 화면처리 담당
                - 서비스 -> 비즈니스 로직 담당
                - DTO
                - ...

        - *.java가 많아지면 분류해서 관리가 필요!! => 패키지
        - 물리적으로는 디렉토리가 계층적으로 구성됨
        - 오타등 존재할경우
            - 대상 선택 > 우클릭 > `refactor` > rename 진행 : 모두 자동 반영됨

 

Test1.java

package com.example.demo.basic;

/**
 * 자바 프로그램 구조
 *      - 클레스 단위 개발 (통상)
 *      - main 함수가 엔트리 포인트(진입로, 가장 먼저 호출되는 메소드)
 *          - A.java 파일을 실행
 *          - 1. 컴파일
 *              - javac A.java
 *              - 컴파일의 결과물 => A.class (생성됨)
 *              - 자바는 컴파일 언어 (소스코드->컴파일->실행)
 *              - 자바스크립트는 인터프린터 언어 (소스코드->실행)
 *          - 2. 실행
 *              - java A.class
 *          - 3. 가장 먼저 main() 함수를 찾는다!! -> 호출하면 실행됨
 */
public class Test1 {
    public static void main(String[] args) {
        // 여기서 자바 코드 작성 !!
        // 1. 변수, 타입 !!
        //    변수 이름 규칙 : 카멜표기법
        //    타입 변수명;
        //    타입 변수명 = 값;
        int a = 10;
        // int(그룻, 정수만 담을수 있다)
        // 정수값을 담을수 잇는 그릇(변수) a를 선언 및 초기화한것임

        // 그릇의 종류 -> 타입
        // 자바의 타입 = 원시(primitive) 타입:8 + 참조(reference) 타입:무한대
        // 8 + 무한대

        // 정수형
        byte i1  = 1;
        short i2 = 1;
        int i3   = 1; // 정수값을 담을 그릇은 정수 타입으로 지정하면 됨
        long i4  = System.currentTimeMillis(); // 현재시간, 시간등 큰값을 담을때 사용
        // 1970년 1월 1일 00시00분00초 부터 현재까지 도래한시간(런던,기준시) + 9시간
        // 출력
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        // 블린
        boolean b1 = true; // true or false
        System.out.println(b1);
        // 문자(1개) , 문자열 X
        char c1 = 'a'; // 홀따움표만 사용 <-> 문자열 : ""만 사용
        System.out.println(c1);
        // 부동소수형
        float f1 = 1.1f;
        // float f2 = 1.1; // float는 반드시 f를 붙어야 한다
        double d1 = 1.1d;
        double d2 = 1.1;
        System.out.println(f1);
        System.out.println(d1);
        System.out.println(d2);

    }
}

 

 

Test2.java

package com.example.demo.basic;

/**
 * 자바의 타입
 *  - 참조형 -> 객체타입
 *      - 대표적인 종류 : 문자열 (String), 정수형|문자열|... 배열
 *      - 참조형은 모두다 객체이다!!
 */
public class Test2 {
    public static void main(String[] args) {
        // 문자열 테스트
        // 타입 변수 = 값;
        String news = "크리스마스"; // 문자열 => "값"
        System.out.println(news);
        
        // 배열 => 아파트 :대표변수명 [위치정보:인덱스]
        // 정수형 배열이라고 표현, 맴버는 정수만 가질수 있다
        // 자바틑 타입을 강력하게 제한한다!!
        int[] numbers = {1,2,3,4,5,6,7,8,9,10}; // 배열 numbers의 구성원은 무조건 int타입만
        System.out.println( numbers[ 0 ]  ); // JS와 동일하게 값 추출
        System.out.println( numbers[ 5 ]  );

        // 문자열 배열
        String[] langs = {"Java","JS","Python"}; // 맴버는 무조건 문자열만 추가!!
        System.out.println( langs[ 0 ]  );
        System.out.println( langs[ 1 ]  );
        // JS의 배열과 문법적으로는 생성을 제외하고는 유사하다!!
    }
}

 

 

Test3.java

package com.example.demo.basic;

import java.util.Scanner;

/**
 * 흐름제어
 *  - 조건문 : if ~ else if ~ else ~
 *      - 콘솔 입력 사용
 *  - 반복문 : for ~,  do ~ while, while ~ , continue, break
 *  - 게임 제작(간단하게) - 스킵
 *      - 콘솔 입력 사용
 */
public class Test3 {
    public static void main(String[] args) {
        // 조건문 연습
        flowcontrol1();
        // 반복문-for 연습 : 지정된 횟수 반복
        //flowcontrol2();
        // 반복문-while 연습 : 무한루프(종료 시점 알수 없다)
        //flowcontrol3();
    }

    private static void flowcontrol3() {
        int i=1;
        // 0 ~ 무한대 반복
        while( true ) {
            System.out.println(i);
            // i 업데이트 필요
            i++;
            if( i > 5 ) break; // 나를 감싸고 있는 가장 가까운 반복문 탈출
        }
        // 출력값 : 1, 2, ....

        // 1 ~ 무한대 반복
        System.out.println("-----");
        i = 1;
        do{
            if( i % 2 == 1 ) continue; // 나머지는 0 or 1 만약 1이면(홀수면)
            System.out.println(i);
            i++;
            if( i > 5 ) break; // 탈출 조건
        }while( true );
        // 출력값 : ... 혹은 무한루프 (학습 정리 시간에 고민)
    }

    private static void flowcontrol2() {
        // for 문의 문법 => JS와 유사함
        // 기본 for문
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
        }
        // 응용
        // 1 ~ 100까지 총합계 구하시오 => 기본 for문 사용
        int sum = 0; // 합계값을 담을 그릇(정수형)
        for (int i = 1; i <= 100; i++) {
            // 누적합
            sum += i;
            //sum = sum + i;
        }
        System.out.println("누적합 : " + sum);

        // 역순 출력
        // 값 업데이트 파트  => i++, i--, i+=2, ... 여러 표현 가능(요구사항에 맞게)
        for (int i = 3; i > 0; i--) {
            System.out.println(i);
        }

        // 배열 순환 for
        int[] arr = {3, 7, 4, 10};
        // arr.length : 배열의 길이, 현재 데이터 기준 4번 반복
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // 중첩 for문 => 구구단 => 5~7단, 3~6까지만 출력
        // 출력값 : 5 x 3 = 15, .... 7 x 6 = 42
        // 15, .... 42 <= 곱의 결과만 나오게 출력
        for (int i = 5; i <=7; i++) {     // i : 5, 6, 7
            for (int j = 3; j < 7; j++) { // j : 3, 4, 6
                // print() 줄바꿈 없는 출력
                System.out.print( i*j + "\t" );
            }
        }
        // 피라미드 출력 연습
        // 오후 학습 정리때 시도 !! => 2중(중첩) for문 처리
        /*
            순열식 값 시뮬레이션 쉽게
            for : 전체는 5번반복
                for
                    - : 4, 3, 2, 1, 0
                for
                    * : 1, 3, 5, 7, 9
           ----*
           ---***
           --*****
           -*******
           *********
         */

        // for-each 반복 처리 => 배열, 컬렉션 계열 데이터를 대상
        System.out.println();
        int[] data = {10, 12, 15, 40, 50};
        for(int i: data) { // JS의 for ~ of
            // 인덱스에 상관없이 값을 뽑아서(순서대로) 출력
            System.out.println(i);
        }


    }

    private static void flowcontrol1() {
        // 1. 콘솔 입력
        Scanner sc = new Scanner(System.in); // 콘솔에서 사용자 입력 대기하는 코드
        while(true)
        {
            try {
                System.out.println("Enter number: ");
                // 2. 사용자 입력후 엔터 => 값이 반환
                int userInputValue = sc.nextInt(); // 입력 대기
                System.out.println("Enter number: ");
                // 3. 만약 100을 입렷했다면, 종료 혹은 반복문 탈출
                if (userInputValue == 100) break;
                // 4. 조건식 사용, JS 조건문 동일, 조건이 2개? 3개?
                if (userInputValue > 10) {
                    System.out.println("10보다 초과한다");
                } else {
                    System.out.println("10보다 작거나 같다");
                }
            }catch (Exception e) {
                System.out.println("오류 : " + e.getLocalizedMessage() );
            }
        }
        // 입력 닫기
        sc.close();
    }
}

 

 

Test4.java

 

package com.example.demo.basic;

/**
 * 배열
 *  - 자바의 기본 타입 이외에 n개의 데이터를 다루는 자료구조
 *      - (*)배열 -> 아파트형태, 각 호실에 데이터가 존재!!
 *          - 순서가 존재한다 : 0, 1, 2, ...
 *          - 동일한 타입만 맴버로 가질수 있다!!
 *              - 정수 배열 => 정수만
 *              - 문자열 배열 => 문자열
 *              - 배열이 한번 만들어지면 맴버를 추가/삭제등 행위 x
 *              - 고정크기!!, 최초 세팅된 크기가 최종
 *      - 컬렉션 계열 : 가변형
 *          - List => 게시판 데이터 가져와서 받을 때 주로 사용됨
 *          - Map
 *          - Set
 *          - ...
 */
public class Test4 {
    public static void main(String[] args) {
        // 1. 배열 선언 및 초기화
        {
            // 크기 5개짜리 정수형 배열 생성 => 아파트 공사해라
            int[] nums = new int[5]; // 배열 껍대기만 존재, 데이터 x
            for (int i: nums) {
                // 0으로 기본 세팅
                System.out.println(i);
            }

            // 배열에 데이터 세팅 <- 입주
            nums[0] = 1;
            nums[1] = 2;
            nums[2] = 30;
            nums[3] = 4;
            nums[4] = 5;

            // 출력 for - each
            for (int i: nums) {
                System.out.println(i);
            }
        }
        // 2. 자주 사용하는 유형, 배열 선언과 초기화
        {
            // 배열 선언과 동시에 초기화
            int[] nums = {10, 5, 6, 8, 29};
            for (int i: nums) {
                System.out.println(i);
            }
        }
        // 3. 배열 요소 찾기(검색)
        {
            int[] nums = {10, 5, 6, 8, 29};
            int target = 6; // 검색을 통해서 찾고자 하는 데이터(가정)
            // 검색 데이터를 찾으면(if), 반복문 중단(탐색 중단)
            for (int i: nums) {
                if (i == target) {
                    // 데이터를 찾았다
                    System.out.println("탐색 완료 : "+i);
                    break; // 목적을 달성했으므로, 탐색 종료(반복문 종료)
                }
            }
        }
        // 4. 배열 카피
        {
            int[] nums = {10, 5, 6, 8, 29};
            // 복사한 데이터를 담을 배열 준비
            int[] nums_copy = new int[nums.length]; // 배열의 크기만큰 공간 준비
            // api 지원
            // ( 원본배열, 복사할 시작위치, 타겟 배열, 타겟배열의 시작위치, 복사될양)
            System.arraycopy(nums, 0, nums_copy, 0, nums.length);
            // for-each
            for (int value: nums_copy) {
                System.out.println(value);
            }

        }
    }
}

 

Test5.java

package com.example.demo.basic;

import java.util.*;

/**
 * 컬렉션(*) API
 *      - 데이터베이스 연동후 가져오는 데이터는 => 컬렉션 으로 처리됨!!
 *      - 맴버를 언제든지 추가 삭제 가능함
 *      - List
 *          - 순서가 있다
 *          - (*)ArrayList, LinkedList, ...
 *      - Set
 *          - 중복 데이터가 없다(중복제거)
 *          - HashSet, TreeSet
 *      - Map
 *          - 키와 값 형태로 보관 -> JSON, JS 객체 , python dict
 *          - HashMap, TreeMap
 */
public class Test5 {
    public static void main(String[] args) {
        // 1.  (중요)List, 순서(*) 존재->인덱스(0, 1, ..) 존재!!, 중복 가능함
        {
            // 저장 공간 준비
            // <유형> =>  제네릭 표현 (범용성등 목적)
            // ArrayList : 자식, List: 부모
            // 크기 지정 한적 없다!!
            // 제네릭, 다형성, 컬렉션 적용
            // 제네릭을 통해서 컬렉션에서 담을 데이터의 타입 제약 -> 문자열만 받을수 있다
            // 다형성을 통해서 부모 List 가 자식객체  ArrayList를 받을 수 있게 정의
            List<String> temp = new ArrayList<>();    // new 클레스명() => 객체 생성
            System.out.println(temp); // []

            // 더미데이터 사용 <- 가변크기, 언제든지 맴버를 추가할수 있다!!
            temp.add("a");
            temp.add("b");
            temp.add("c");

            System.out.println(temp); // [a, b, c]

            // List 언제든지 가변적으로 맴버 추가 혹은 삭제 가능
            // 값 출력하기
            System.out.println( temp.get( 1 ) ); // 참고 배열은 변수[ 1 ]
            // 크기 확인 -> for문과 자주 사용
            System.out.println( temp.size() ); // 데이터 전체 크기
            // 요소 삭제
            System.out.println( temp.remove(1) ); // 삭제된 내용이 출력
            // 초기화 -> 데이터 모두 버림 -> 버퍼를 비운다, 모두 삭제
            temp.clear();
            System.out.println( temp.size() );
            System.out.println( temp );
        }

        // 2. Set - 중복 제거(허용 x)
        //    동일한 값 넣어서 확인, 순서는 X(보장되지 않음)
        {

            // 컬렉스 스타일의 그릇 생성
            Set<String> temp = new HashSet<>();

            // 요소추가
            temp.add("서울");
            temp.add("부산");
            temp.add("대전");
            temp.add("대구");
            temp.add("인천");
            temp.add("서울"); // 중복 추가

            // 중복이 제거 되었는가?
            System.out.println(temp);
            // 중복 제거 OK, 검사과정에서 순서가 바꼈음
            // 순서가 중요하지 않는 데이터 를 사용하여 중복 제거 혹은 이후 정렬
            System.out.println( temp.size() );
            // Set은 조연임, 특정 과정속에서 데이터 전처리에 사용됨
        }

        // 3. (중요)Map, 키와 값의 쌍으로 구성
        //    키는 고유값, 값은 중복 가능
        {
            // Integer는 int을 대변하는 클레스 (레퍼클레스) -> int
            Map<String, Integer> persons = new HashMap<>();

            // 컬렉션의 이름 => 복수형으로 구성
            // 요구사항 사람의 이름과 나이를 관리하는 자료구조 구성
            // 키는 이름, 값은 나이
            // 키-값 추가 (이름, 나이) <= 의미 부여
            persons.put("JJ", 40);
            persons.put("Kim", 30);
            persons.put("Park", 20);

            // 값 출력 : {JJ=40, Kim=30, Park=20}
            System.out.println(persons);
            // 개별값 : JJ의 나이는? 40
            System.out.println("JJ의 나이는? "+ persons.get("JJ"));

            // 크기
            System.out.println( persons.size() );
            // 새로 추가하는  내용의 키가 기존에 존재하는 키라면? (키 중복)
            persons.put("JJ", 41); // 추가 x,  수정 ok(키는 고유함)
            System.out.println(persons);

            // TODO Map for문을 이용하여 모든값 출력하기 -> 나중에 체크 Generic.java

            // 삭제
            persons.remove("JJ"); // JJ 제거
            System.out.println(persons); // {Kim=30, Park=20}
            // 초기화 -> 내용 비워라
            persons.clear();
            System.out.println(persons); // {}
        }
    }
}

 

 

 

Test6_Syntax.java

// 본 파일의 소속을 표현한것, 패키지 묘사
package com.example.demo.basic;

/**
 * 변수 문법
 * - [Modifiers] Type 변수
 *      - [] 생략가능
 * - Modifiers => 사용 목적이 존재할때만 사용
 *      - access Modifiers : 접근제어자
 *      - non-access|gerneral Modifiers :일반
 *      - 2가지는 혼용 사용가능, 서열 x
 * - Type
 *      - 원시타입 (8개)
 *      - 참조타입
 * - 변수명
 *      - 카멜표기법
 *          - 소문자로 시작, 이어지는 글자 대문자, 다시 소문자..
 *          - 알파벳시작, _ 시작가능 , 두번쩨문자부터 숫자 가능
 *          - 알파벳만 사용!! (간단)
 */
public class Test6_Syntax {
    // 전역 변수 자리 (범위 기준)
    // public : 모든 다른 클레스, 내부등등 다 접근 가능하다
    // static : 메모리 탑레벨, static 메소드에서만 사용 가능
    // 정수형 그릇에 100이라는 값이 세팅되었다 => 힙에 메모리 존재한다(참고)
    public static int score = 100;
    static public int score1 = 100;
    public int score2 = 100;
    static int score3 = 100;

    // 최소, 가장 기본형
    int age = 100; // js => let age = 100;

    // 메소드
    public static void main(String[] args) {
        // 지역 변수 자리(범위 기준)
        // 가장 많이 사용하는 유형
        int level = 5;// static 아닌데 가능한데? -> 지역이니까 사용가능!!
        System.out.println(level);
        System.out.println(score);
        System.out.println(score1);
        System.out.println(score3);
        // 메소드가 satic 이라서
        //System.out.println(score2); // non-static 사용 불가, 에러

        // 메소드 호출(호출해야 의미를 가진다)
        sum(100, 5); // 105
    }


    // 메소드(JS의 함수) 문법
    /**
     *  [Modifiers] 리턴타입 메소드명 ( parameters(매개변수) ) {
     *      statements(수행문);
     *      [return [값]];
     *  }
     *
     *  - Modifiers : 변수와 동일규칙, 종류(일반 모디파이어)만 다름
     *  - 리턴타입(3개유형) : 원시타입(8개), 참조형(무한대), void <- 추가됨:반환값 없다
     *  - 메소드명 : 카멜표기법
     *  - parameters : 매개변수 특이점 없음
     *  - statements : 수행문, 특이점 없음
     *  - return : 생략 가능함, return 이 없거나, return만 존재하면 -> 리턴타입 void 사용
     *
     */
    // 풀버전
    public static // Modifiers
    void // 리턴타입
    sum ( int a, int b ) // 메소드명 ( parameters )
    {
        int c = a + b; // statements
        System.out.println(c); // statements
        // return 생략
    }
    // 최소버전 : JS와 유사
    // Modifiers 사용 않하면 간단하다!!
    int add(int a, int b){
        return a + b;
    }


}

 

 

ClassInfo.java

-ClassInfo

-Person

-Person2

-Person3

-Person4

// 패키지 내부에서 클레스 생성 -> 무조건 패키지 표식 자동추가됨
package com.example.demo.basic;

/**
 * 클레스 정의
 * - 클레스 (class)
 *      - 코드로 존재
 *      - 객체를 생성(구현)하기 위한 설계도면(청사진, 붕어빵기계,..., 틀)
 *      - 변수(필드), 메소드(함수), 생성자 로 구성
 *
 * - 객체 (Object)
 *      - 메모리상에 존재
 *      - 클레스를 기반으로 생성 (클레스와 유사하게 생겼음)
 *      - 클레스의 인스턴스가 객체이다 (붕어빵)
 *
 *  - 클레스 문법
 *  [모디파이어] class 클레스명(첫글자 대문자)
 *  [extends 부모클레스명(상속표현)]
 *  [implements 인터페이스명(다중상속표현)] <- 클레스 선언부
 *  {   <- 클레스 코드블럭
 *      [맴버 변수]
 *      [맴버 메소드]
 *      [생성자]
 *      [inner class(내부 클레스)] - 생략 !!
 *  }
 */
// 1. 클레스 정의 (간단하게)
//    자바에서 클레스는 코드 작성 단위 -> 클레스 단위로 개발!!
class Person {}
// 2. 맴버 추가
class Person2 {
    // 맴버(클레스 내부에서 정의),  변수(변수 구성 문법 고려), 범위:전역변수
    String name;
    int age;
    // 맴버 메소드
    void info () {
        System.out.println("Person2 info " + name + " " + age);
    }
}
// 3. 생성자(constructor) 사용
//    문법 : 클레스명과 동일, 메소드 형식, 리턴타입 x, 객체를 생성 역활, 맴버변수 초기화
//    종류 : 기본생성자(default constructor), 생성자 재정의(overroading), 생략가능
//          생략한다면 -> 컴파일러(javac) 자동 삽입해줌, 필요시 개발자가 커스텀 생성!!
//          기본생성자(default constructor) : 파라미터 없는 생성자 (빈 껍대기)<->파라미터 존재
class Person3 {
    String name;
    int age;
    // 생성자
    // 기본 생성자
    public Person3() {
        // 커스텀 가능
    }
    // 생성자 오보로딩
    // 맴버변수 초기화에 집중한 생성자
    public Person3(String name, int age) {
        // this => 클레스 내에서 자기자신을 가르키는 키워드
        this.name = name; // 맴버변수 = 매개변수;
        this.age = age;
    }
}
// 객체 지향 프로그램(OOP)의 3대 특징 : 상속성, 다형성, 은닉성
// 4. 데이터 은닉(객체 지향 프로그램의 3대 특징중 한개), 클레스 내부 데이터는 외부에서 직접  접근 x
//    제공되는 메소드를 통해서 접근해라(설계 기법) -> 메소드 : getter, setter
//    데이터 종류가 너무 많다면 => get/setter 언데 다 만들지? => 라이브러리 => lombok(롬복)
//    스프링부트 개발시 필수 라이브러리 : 롬복
class Person4 {
    // 외부에서 직접  접근 x 설정 필요 => private 추가 : 데이터가 은닉(숨겨짐)됨 => 설계개념
    private String name;
    private int age;
    // Getter, Setter
    // public 지정해서 누구나 사용 가능하게 접근 제어를 조정
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    // setter 생성
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}


// 1개의 자바 파일안에 여러개의 class가 존재할수 있다!!
// 파일명과 일치하는 클레스, 그안에 main 함수가 존재하면 문제 없다!!
public class ClassInfo {
    // 메인 메소드
    // J2SE(PC 기반 유저 대상 자바 개발시 사용하는 버전)
    // 반드시 main 메소드가 존재해야 한다 (규칙)
    // 가장 먼저 메모리에 상주, 호출되야 한다(규칙)
    // args : 자바 구동시 전달할 매개 변수가 있다면 받는다
    // 통상적으로는 전달 X
    // main 시작점, 엔트리포인트!!
    public static void main(String[] args) {
        // 클레스는 객체의 틀(청사진, ...) -> 메모리에 객체를 띠우는게 목표 -> 프로그램 작동
        // 객체 생성법(문법) => new 클레스명([ 매개변수 ]);

        // 객체 생성 -> 인텔리J 해석 -> 코드 가이드 : AI로 처리하는 패턴
        // Person p <- 참조형(타입) 변수!!, 클레스명=>내가만든 참조형 타입이 된다
        // 참조형 변수 = 객체!!
        Person p = new Person();
        Person2 p2 = new Person2();
        // p2는 맴버 존재 => 접근 => 객체명.맴버 : 도트(.) 연산자로 접근
        p2.name = "게스트";
        p2.age  = 30;
        // 맴버 메소드 사용
        p2.info();

        // Person3 객체 생성, 매개변수를 세팅해서 생성
        Person3 p3 = new Person3("게스트2", 10);
        System.out.println(p3.name+" "+p3.age); // 맴버 변수 출력

        // Person4 객체 생성
        Person4 p4 = new Person4();
        p4.setName("게스트3"); // p4.name="..."; <- 에러, 접근제어 오류
        System.out.println( p4.getName() );
    }
}

 

 

Inheritance.java

-Animal

-Cat

-Dog

-Inheritance

-XMan

-매그니토

-울버린

package com.example.demo.basic;

// 코드 [모두] 접기 : ctrl + [shift] + -
// 코드 [모두] 펼치기 : ctrl + [shift] + +

/**
 * 상속성 과 다형성 문법 체크 -> 클레스 마무리
 * - 상속
 *  - 부모 클레스의 모든 유산(맴버 변수/메소드/생성자)을 그대로 상속받고
 *  - 자식이 재정의(업그레이드)
 *  - 데이터(변수), 기능(메소드) 추가
 *  - 용도
 *      - 버전업!!(안드로이드 2009년 -> 현재 계속 상속받으면서 확장)
 *      - s/w 업그레이드 관리
 *      - 빠른 개발(생산성 높아짐)
 */
// 1. 상속 (Inheritance)
// 부모 클레스
class Animal {
    // 부모의 유산 맴버 변수/메소드 준비
    String name;
    void eat() {
        // this.은 생략 가능함 => 컴파일러 자동 삽입해줌
        System.out.println( this.name + " eat");
    }
}
// 자식 클레스
class Cat extends Animal {}
class Dog extends Animal {
    // 부모의 유산을 재정의(업그레이드) 할수 있다
    // 재정의(오버라이드),
    @Override // 어노테이션,
    void eat() {
        // super : 부모 객체를 지칭하는 이름, this: 자기자신
        //super.eat(); // 부모의 원래 유산(맴버 매소드)호출
        System.out.println( this.name + " 잘 먹는다");// 업그레이드
    }
    // 어노테이션
    // "자바에 메타데이터를 제공하는 기법"
    // 컴파일러 | 런타임관리자등 어노테이션 확인후에
    // 코드를 삽입, 기능을 부가 등등 처리!!
    // 스프링부트에서 진행시 엄청 많이 사용!! -> 사용시 체크 !!

    // 자식이 맴버 추가할수 있다!! (
    String kind; // 품종
    void info() {
        System.out.println( this.name + " 의 품종은 " + this.kind );
    }
}
/**
 * Cat은 Animal 이다 - OK : 자식 is a 부모
 * Animal은 Cat 이다 - Fail
 * Animal은 Cat을 자식으로 가진다 - 부모 has a 자식
 */

/**
 * 다형성 (Polymorphism)
 * 하나의 객체가 여러 형태를 가질수 있다!
 */
class XMan {
    void attack(){
        System.out.println("공격 능력");
    }
}
class 울버린 extends XMan {
    // XMan의 유산을 받아서 자식은 업그레이드
    @Override
    void attack() {
        System.out.println("갈고리 공격 능력");
    }
}
class 매그니토 extends XMan {
    @Override
    void attack() {
        System.out.println("금속/자기장 공격 능력");
    }
}

public class Inheritance {
    public static void main(String[] args) {
        // 상속
        Cat cat = new Cat();
        // 부모로 상속받은 유산(맴버..) 사용
        cat.name = "고양이";
        cat.eat();

        Dog dog = new Dog();
        dog.name = "강아지";
        dog.eat(); // 자식 세대에서 업그레이드된 메소드
        // 기능 추가
        dog.kind = "진돗개";
        dog.info();

        // 다형성 : 자식 객체를 부모가 받을 수 있다
        // 부모는 여러 모습을 띨수 있다 => 다형성
        // 부모형 변수 = 자식 객체; 자식 객체를 부모형 변수가 받을 수 있다
        XMan xman; // 참조형 변수
        xman = new 울버린();
        xman.attack();

        xman = new 매그니토();
        xman.attack();


    }
}

 

Interface.java

-A

-B

-C

-Cal

-Car

-Interface

-MyCalculator

-P

-Truck

-Vehicle

package com.example.demo.basic;

/**
 * 인터페이스
 *  - 자바는 단일 상속 지원!!
 *  - 다중 상속 이슈 -> 인터페이스가 제공
 *  - 구현한다!! (implements)
 *  - 구성원
 *      - 상수
 *      - 추상(abstract) 메소드 : 메소드 문법중 {}:코드블럭  x => 메소드 선언만 존재
 *      - java 8에서 추가 : 기본 메소드
 *  - 문법
 *    interface 인터페이스명 {
 *        [상수]
 *        [추상 메소드]
 *        [기본 메소드]
 *    }
 */

/**
 * final : 최종이라는 의미를 가진 키워드
 *  - 변수에서 사용 : 상수
 *  - 메소드에서 사용 : 재정의 x
 *  - 클레스에서 사용 : 상속을 해주는것 불가
 */
interface Vehicle {
    // 상수 => final
    public static final int MAX_VEHICLES = 5;
    String NAME = "내연"; // public static final 생략된 표현, 컴파일러 자동 삽입
    // 인터페이스에서는 생략 가능 : public static final
    // 메소드 선언 => 코드 블럭 생략!!
    void start();
    void stop();
}
// 인터페이스 사용
class Car implements Vehicle {
    // 인터페이스를 구현 => 선언된 함수를 구현해랴 한다!! 의무!!
    // ctrl + i , code -> implements ...
    @Override
    public void start() {
        // 적당한 메세지 각자 작성 => 콘솔 출력
        System.out.println("Car start");
    }
    @Override
    public void stop() {
        System.out.println("Car stop");
    }
}
class Truck implements Vehicle {
    @Override
    public void start() {
        System.out.println("Truck start");
    }
    @Override
    public void stop() {
        System.out.println("Truck stop");
    }
}

// 2. 멀티의 인터페이스 구현
interface A{
    void a();
}
interface B{
    void b();
}
class P{}
// 클레스 C는 P이고, A이면서 B이기도 하다 => 다중상속
class C extends P implements A,B{
    @Override
    public void a() {
    }
    @Override
    public void b() {
    }
}

// 3. 자바 8에 추가, 기본 함수
interface Cal {
    // 메소드 선언
    int add(int a, int b);
    // (*)기본 메소드 -> 구현되어 있음, 완전한 메소드 형태
    default int sub(int a, int b) {
        return a - b;
    }
    // (*)정적 메소드 -> 구현되어 있음, 완전한 메소드 형태
    static int mul(int a, int b) {
        return a * b;
    }
}
class MyCalculator implements Cal{
    @Override
    public int add(int a, int b) {
        return a+b;
    }
}

public class Interface {
    public static void main(String[] args) {
        // 인터페이스를 이용한 다형성  처리
        Vehicle vehicle;
        vehicle = new Car(); // 인터페이스 변수에 구현한 객체를 받아서 객체처럼 사용 가능
        vehicle.start(); 
        vehicle.stop();
        vehicle = new Truck();
        vehicle.start();
        vehicle.stop();

        // 멀티 인터페이스 구현, 단일 상속 => 다중 상속 구현
        C c = new C();
        c.a();

        // MyCalculator 구현
        MyCalculator myCalculator = new MyCalculator();
        System.out.println( "더하기 => " + myCalculator.add(1,2) );
        System.out.println( "빼기 => " + myCalculator.sub(1,2) );
        // static 사용법 : (클레스|인터페이스)명.static(메소드|변수)
        // 객체명.... X : 불가
        System.out.println( "곱하기 => " + Cal.mul(1,2) );
    }
}

 

 

Generic.java

-Generic

-Multi

package com.example.demo.basic;

import java.util.HashMap;
import java.util.Map;

/**
 * 제네릭(Generic)
 *  - <>
 *  - 컬렉션에 자주 등장!!
 *  - 클레스, 메소드, 인터페이스, 변수 사용가능
 *  - 범용성 대변하기 위해 생성된 문법
 *  - 메소드 1개 -> 정수 처리 OK, 부동소수 처리 OK, 문자열 처리 OK
 *      - 만능의 기능을 가진 메소드
 *      - 개념이 없다면, 각가 개별 메소드를 만들어야 한다!!
 *          - 목표:1개만 만들어서 모든 상황에 대응할수 잇다면 !!
 *          - 제네릭을 이용하여 이 개념(요구사항) 구현
 *  - 범용표현
 *      - <T>
 *  - 제약표현
 *      - <String>, <Integer> ....
 */
// 제네릭 표현을 클레스에 적용
// T : 모든 타입이 올수 있다!!
class Multi<T> {
    private T t;
    // getter/setter 자동 생성 : alt + insert -> getter and setter 선택
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

public class Generic {
    public static void main(String[] args) {
        // 1. 클레스 적용, 변수 적용
        {
            // 범용 타입으로 정의된 Multi 클레스 사용
            Multi<String> m = new Multi<String>();
            m.setT("Hello");
            System.out.println(m.getT());
            // 정수형을 다루는 Multi  생성
            Multi<Integer> m2 = new Multi<Integer>();
            m2.setT(1);
            System.out.println(m2.getT());
            // 정리 <T>를 도입함으로써 1개의 클레스로 개별 타입의 클레스 대응할수 있었음
        }

        // 2. 변수 적용
        {
            // 컬렉션 하고 자주 사용된다 => Test5.java 체크
            Map<String, Integer> persons = new HashMap<>();
            persons.put("JJ", 40);
            persons.put("Kim", 30);
            persons.put("Park", 20);
            // for문에서 데이터 추출 -> for each
            for (String key : persons.keySet()) { // 키만 획득
                System.out.println(key + " " + persons.get(key)); // 키, 키를 이용하여 값 획득
            }
            // 제네릭을 이용하여 처리
            for (Map.Entry<String, Integer> entry : persons.entrySet()) {
                // 개별 데이터로부터 키와 값 획득
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }

        // 3. 메소드 적용
        {
            print(1);
            print(1.1);
            //print("hi"); // 수치형이 아닌데? 오류
            // 나중에 실습 수치, 문자도 모드 처리되는 제네릭 메소드 만들어보기  print2
        }
    }
    // T는 Number(수치) 유형을 확장한 타입만 허용 => 수치형만 가능!!
    public static <T extends Number> void print( T number ) {
        System.out.println(number);
    }
}

 

 

EnumTest.java

-EnumTest

-Level

-TrafficSignal

package com.example.demo.basic;

/**
 * 열거형
 *  - 상수로 정의되는 여러 변수들을 묶어서 클레스처럼 관리하는 타입
 *  - 여러 상수를 그룹으로 묶어서 관리!!
 *  - 내부적인 변수들은 모두 public static final  적용됨
 */
// 1. 기본형
enum Level {
    VVIP, VIP, GOLD, SILVER, BRONZE // 고객 등급
}
// 2. 클레스 같은 유형 가미
enum TrafficSignal { // 교통신호
    // 열거형 변수에 값 부여 구조
    GREEN("출발신호"),
    YELLOW("정지대기"),
    RED("정지신호"),
    ARROW("반향전환신호");

    // 열거형 변수를 대변하는 변수 지정(값의 타입 고려)
    private final String signal;
    // 열거형 생성자에서 데이터 세팅 구조
    TrafficSignal(String signal) {
        this.signal = signal;
    }
    // 값 출력
    public String getSignal() {
        return signal;
    }
}
public class EnumTest {
    public static void main(String[] args) {
        // 1. 기본 사용
        {
            // 열거형 타입의 변수
            Level level = Level.VVIP; // 값은 5개중에 한개만 가능
            // 등급값에 따라 동적으로 처리가 가능한 구조!!
            switch (level) {
                case VVIP:
                    System.out.println("VVIP");
                    break;
                case VIP:
                    System.out.println("VIP");
                    break;
                default:
                    System.out.println("기타 등급");
                    break;
            }
        }
        // 2. 열거형의 값 활용-> 출력
        //  열거형 확장 사용
        {
            // TrafficSignal.values() => 배열로 자료구조 전환
            for (TrafficSignal signal : TrafficSignal.values()) {
                System.out.println(signal +" : "+signal.getSignal());
            }
        }
    }
}

 

 

Lambda.java

package com.example.demo.basic;

import java.util.Arrays;
import java.util.List;

/**
 * 자바의 람다 표현식
 *      - 자바 8에서 도입
 *      - 익명함수 형태로 간결하게 표현
 *      - JS의 화살표 함수와 유사함
 *          - JS : ()=>{}
 *          - Java : ->
 *      - 함수형 프로로그래밍 패러타임 지원
 */
public class Lambda {
    public static void main(String[] args) {
        // 순수한 코드 => 람다 처리
        // 1. 쓰레드에서 사용 -> 비동기!!
        {
            // 쓰레드(Thread) : 자바의 작업 단위, 프로세스 =  쓰레드 + 쓰레드 + ...
            // 용도 : 멀티 작업을 구현 하기 위해서 도입 (멀티 쓰레드 기본)
            // 쓰레드 가동법
            // 1. Runnable 인터페이스를 객체처럼 생성 -> 쓰레드객체에 넣어서 가동, run() 메소드
            //    실제 일하는 요소 : run()
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    // 실제 일하는 내용 작성
                    System.out.println("T - Hello World");
                }
            };
            // 2. 쓰레드 가동
            new Thread(r).start();
            // 스프링부트에서는 미사용됨

            // 람다로 수정
            Runnable r2 = ()->System.out.println("T2 - Hello World");
            new Thread(r2).start();

            // 더줄임
            new Thread( ()->System.out.println("T3 - Hello World") ).start();
        }
        // 2. 컬렉션 + for문 람다 처리
        {
            // 데이터를 세팅하면서 컬렉션 바로 생성
            List<String> temp = Arrays.asList("A", "B", "C");
            // for-each
            for(String s : temp){
                System.out.println(s);
            }
            // 람다 수정
            // 하나씩 데이터를 꺼내서 출력
            temp.forEach(s->System.out.println(s));
        }
        // 3. 예외처리 -> s/w 셧다운 x
        //    처리방식 : 잡는다(try~ catch ~ finally):내가해결, 던진다(throws 예외):상위에서 해결
        {
            try{
                System.out.println(1);
                int a = 1 / 0;
                System.out.println(2);
            } catch (Exception e) {
                System.out.println(3 + " "+e.getMessage());
                // 차후 로그 처리 -> 로깅 필요
            } finally {
                System.out.println(4);
            }
            // 1->3->4

        }
    }
}