Java · SQL · 웹 백엔드 학습 노트

package hk.edu20260803.day01; //파일의 폴더 구조(경로), 최상단에 위치

//명명법
//클래스명: 파스칼
public class HelloJava {
    // …(생략: main 메서드 각 단어 설명 주석)
    // 메서드명: 카멜방식 (첫글자 소문자, 뒤 글자마다 대문자)
    // 변수명: 카멜방식 (첫글자 소문자, 뒤 글자마다 대문자)
    // 상수명: 스네이크 방식(모두 대문자)

    public static final int NUMBER = 10000;
    public int number = 10;

    public static void main(String[] args) {
        System.out.println("Hello Java");

        testMethod();
    }

    // 메서드 선언: 카멜
    public static void testMethod() {
        // 변수명: 카멜
        boolean isS = true;
        int i = 100;
        i = 200;
        final int TEST = 10; // final: 상수로 선언됨. 변경 불가능

        System.out.println("메서드 실행결과: " + i);
    }
}

byte b = 1;
b = 127; // byte 표현범위는 -128 ~ 127
b = -128;

short sh = 128; // 2byte 크기
int i = 100000; // 4byte 크기
long l = 1000000000000000000L; // 리터럴 정수는 기본 int 형으로 인식함 (long타입 정수는 L을 붙여줘야함)
System.out.println("long타입 표현범위: " + l);

byte bb = (byte) i; // int -> byte 다운캐스팅, 원본값 손실됨   ← 원본 주석의 방향을 바로잡음
int ii = 126;
byte bbb = (byte) ii; // int -> byte 다운캐스팅, 원본값이 손실되지 않음
System.out.println("바이트 타입 표현범위: " + bbb);

// 2.실수타입
// 기본형은 double(8byte)
double d = 15.7;
float f = 15.77f;
float ff = (float) (d + f); // 큰값을 작은 상자에 담는다 (down casting)

// 3. 다른 타입끼리 연산
int iii = (int) (i + d); // int+double -> double, 연산결과가 double이므로 강제형변환 필요

// 4.정수끼리 연산
byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // …(생략: 왜 오류인지 설명하는 원본 주석)
byte b3 = (byte) (b1 + b2); // 연산의 결과값은 int로 반환되므로 강제형변환이 필요
byte b4 = 10 + 20; // 리터럴 정수는 기본 int 타입으로 인식하기 때문에 오류가 나지 않는다.
System.out.println("바이트 타입 연산 결과: " + b4);

// 윤년을 판단하는 조건을 확인
// -년도가 4의 배수이면서, 100으로 나누어떨어지지 않는 수
// -또는 400으로 나누어 떨어지는 수

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("년도를 입력해주세요 : ");
    int year = sc.nextInt();
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
        System.out.println(year + "는 윤년입니다");
    } else {
        System.out.println(year + "는 평년입니다");
    }
    // …(생략: 2000~2030 윤년 출력 — 4장에서)
}

public static boolean isLeapYear(int year) {
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
        return true;
    } else {
        return false;
    }
}

case 1:
    System.out.println("예금액 : ");
    int saveTemp = Integer.parseInt(sc.nextLine());
    savemoney += saveTemp;
    break;
case 2:
    System.out.println("출금액 : ");
    int outTemp = Integer.parseInt(sc.nextLine());
    if (outTemp > savemoney) {
        System.out.println("잔고가 부족합니다");
    } else {
        savemoney -= outTemp;
    }
    break;

public void divisor(int a) {
    for (int i = 1; i < a + 1; i++) {
        if (a % i == 0) {
            System.out.print((i == a) ? i : i + ",");
        }
    }
    System.out.println();
}

for (int i = 2000; i < 2031; i++) {
    if ((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) {
        System.out.println(i + "는 윤년입니다");
    }
}

Scanner sc = new Scanner(System.in);
boolean start = true;
int savemoney = 0;

while (start) {
    System.out.println("옵션을 선택하세요");
    System.out.println("---------------------");
    System.out.println("1.예금 2.출금 3.잔고 4.종료");
    System.out.print("선택 >> ");
    int select = Integer.parseInt(sc.nextLine());
    switch (select) {
        case 1:
            // …(생략: 예금 — 3장 예제 참고)
            break;
        case 2:
            // …(생략: 출금)
            break;
        case 3:
            System.out.println("잔고 : " + savemoney);
            break;
        case 4:
            System.out.println("종료합니다");
            start = false;
            break;
        default:
            System.out.println("잘못된 입력입니다");
            break;
    }
}

for (int i = 0; i < 6; i++) {
    for (int j = 0; j < i; j++) {
        System.out.print("*");
    }
    System.out.println();
}
// …(생략: 다른 모양들)
int line = 5;
for (int i = 0; i < line; i++) {
    for (int j = 0; j < line - 1 - i; j++) {
        System.out.print(" ");
    }
    for (int k = 0; k < i * 2 + 1; k++) {
        System.out.print("*");
    }
    System.out.println();
}

System.out.print("========2단==========\n");
// 2단
for (int i = 1; i <= 9; i++) {
    System.out.printf("\"2X%d=%d\"", i, 2 * i);
    System.out.println();
}

System.out.print("=========2~9단==========\n");
// 2~9단
for (int i = 2; i <= 9; i++) {
    for (int j = 1; j <= 9; j++) {
        System.out.printf("%dx%d=%d", i, j, i * j);
        System.out.print("\t");
    }
    System.out.println();
}

import java.util.Scanner;
// …(생략)
Scanner sc = new Scanner(System.in);
System.out.print("년도를 입력해주세요 : ");
int year = sc.nextInt();

Scanner sc = new Scanner(System.in);
// …(생략)
System.out.print("선택 >> ");
int select = Integer.parseInt(sc.nextLine());
// …(생략)
System.out.println("예금액 : ");
int saveTemp = Integer.parseInt(sc.nextLine());

public static void main(String[] args) {
    // static 메서드 사용: 클래스명.메서드() 호출해서 사용
    D2_MethodTest.test01();

    // non-static 메서드 사용: 객체생성후 메서드 호출
    D2_MethodTest methodTest = new D2_MethodTest();
    methodTest.test02();
}

public static void test01() {
    System.out.println("static 메서드");
    // …(생략: "메모리에 올라가 있지 않음" 주석 — 위 바로잡기 참고)
    D2_MethodTest methodTest = new D2_MethodTest();
    methodTest.test02();
}

// non-static 메서드 -> 객체생성해야지만 사용 가능
public void test02() {
    System.out.println("non-static 메서드");
}

public int test03() {          // 매개변수 X, 반환값 O
    return 0;// 반환타입을 설정했다면 반드시 해당 타입을 반환
}

public void test04() {         // 매개변수 X, 반환값 X
}

// 3. 파라미터 O/X : 외부로부터 값을 받아서 뭔가 실행하려고
public int test05(int a, int b) {   // 매개변수 O, 반환값 O
    int res = 0;
    if (a > b) {
        res = a;
    } else {
        res = b;
    }
    return res;
}

public static void main(String[] args) {
    D1_divisor d = new D1_divisor();
    d.divisor(12);
    System.out.println("최대공약수1:" + getGcd1(12, 18));
    System.out.println("최대공약수2:" + getGcd2(12, 18));
    lowestMultiple(12, 18);

    // amicable은 non-static메서드이기떄문에 객체생성해서 객체명.메서드로 호출한다.
    d.amicable(1, 1000);
    d.perfectnum(1, 1000);
}

// 유클리드 호제법 재귀호출
public static int getGcd2(int a, int b) {
    if (b == 0) {
        return a;
    }
    return getGcd2(b, a % b);
}

// 최소공배수
public static void lowestMultiple(int a, int b) {
    int gcd = getGcd1(a, b);
    int lowestMultiple = (a * b) / gcd;
    System.out.println("최소공배수:" + lowestMultiple);
}

// 진약수 합
public static int sumDivisor(int a) {
    int sum = 0;
    for (int i = 1; i < a; i++) {
        if (a % i == 0) {
            sum += i;
        }
    }
    return sum;
}

// 친화수
public void amicable(int s, int e) {
    for (int i = s; i <= e; i++) {
        if (i != sumDivisor(i) && i == sumDivisor(sumDivisor(i))) {
            System.out.printf("%d와 %d는 친화수 관계입니다.\n", i, sumDivisor(i));
        }
    }
}

// 완전수
public void perfectnum(int s, int e) {
    for (int i = s; i <= e; i++) {
        if (i == sumDivisor(i)) {
            System.out.println(i + "는 완전수입니다.");
        }
    }
}

public class D2_ClassTest {
    public int number; // 인스턴스 멤버필드 (변수)
    public static int staticNumber; // 클래스 변수

    // …(생략: 기본 생성자 설명 주석)
    public D2_ClassTest() {
        this(10);   // 자기 자신의 (다른) 생성자 호출
    }

    // 생성자 오버로딩: 파라미터의 개수와 타입을 다르게 해서 생성자나 메서드 이름을 같게 사용
    public D2_ClassTest(int number) {
        this.number = number; // this->이 객체 자신을 의미. 멤버필드 number를 지칭
    }

    public void methodTest() {
        System.out.println("인스턴스에 관련된 기능을 정의한다");
    }

    public static void stmethodTest() {
        System.out.println("메서드영역 메모리에 생성되어 공통기능을 정의한다.");
    }
}

D2_ClassTest classTest = new D2_ClassTest(); // Heap 메모리에 생성
classTest.methodTest(); // 객체명.메서드로 호출 -> 인스턴스 메서드
classTest.number = 20; // 객체명.멤버필드로 호출 -> 인스턴스 변수

D2_ClassTest.stmethodTest();// 클래스명.메서드로 호출 -> 정적 메서드

D2_ClassTest classTest2 = new D2_ClassTest(30);
classTest2.number = 40;

System.out.println("classTest.number:" + classTest.number);
System.out.println("classTest2.number:" + classTest2.number);

// static 변수는 클래스 전체에서 공유됨
D2_ClassTest.staticNumber = 50;
System.out.println("classTest.staticNumber:" + classTest.staticNumber);
System.out.println("classTest2.staticNumber:" + classTest2.staticNumber);

public class D4_Constructor {
    private int size = 0; // 중요한 데이터 -->private 선언
    public String color = "검정석"; // 색상   ← 원본 오타 그대로

    // default 생성자: 단독으로 사용한다면 생략 가능 -> 오버로딩을 하면 생략 못함
    public D4_Constructor() {
        this(24, "검정색"); // 생성자 호출은 반드시 첫줄에 작성
    }

    // 생성자 오버로딩
    public D4_Constructor(int size) {
        this.size = size;
    }

    public D4_Constructor(int size, String color) {
        this.size = size;
        this.color = color;
    }
    // …(생략: getSize / setSize — 8장에서)
}

D4_Constructor tv = new D4_Constructor();
D4_Constructor tv2 = new D4_Constructor(70);
D4_Constructor tv3 = new D4_Constructor(60, "노랑색");
// 생성자 이용 안하고, 직접 멤버필드에 접근해서 초기화 할경우 불편하다
D4_Constructor tv4 = new D4_Constructor();
tv4.color = "파란색";
tv4.setSize(24); // private이라 메서드 통해 값 추가

String str = new String("Object");
String str2 = "ObjectLit"; // 주로 사용되는 방식
System.out.println(str.getClass());
System.out.println(str2.getClass());

D3_ObjectTest ot = new D3_ObjectTest();
System.out.println(ot.getClass());

// toString(): 문자열로 반환한다
// target 객체에 "위치@hashcode(16진수)" 반환
System.out.println(ot.toString());
System.out.println(str.toString());

// hashcode(): 객체의 hashcode를 반환한다. -> 10진수로 표현
System.out.println(ot.hashCode());
// …(생략: equals·hashCode 관계 주석 — 위 바로잡기 참고)
System.out.println(ot.equals(str2));

// 리터럴 방식 선언(String)
String s = "a";
String s2 = "a";
System.out.println(s == s2); // 비교연산자: 객체에 주소로 비교
System.out.println(s.equals(s2)); // String.equals: 글자 내용 비교 (원본 주석 "hashcode로 비교"를 바로잡음)

// 객체 생성으로 선언(new String())
String s3 = new String("a");
System.out.println(s == s3); // false //메모리 주소가 달라서
System.out.println(s.equals(s3)); // true --> 내용물이 같은지 봐서

// private은 클래스 내부에서만 접근 가능
private int size = 0; // 중요한 데이터 -->private 선언
public String color = "검정석"; // 색상
// …(생략: 생성자 — 7장)

// private으로 선언한 맴버필드는 어떻게 접근할까?->getter, setter메서드를 사용한다
public int getSize(int pw) {
    // 조건에 따라 값을 반환한다. ex: 비밀번호를 알고 있다면 반환
    if (pw == 1234) {
        return size;
    } else {
        System.out.println("잘못된 비밀번호");
        return -1;
    }
}

public void setSize(int size) {
    this.size = size;
}

// 참조타입끼리 형변환
D3_Singleton sm = new D3_Singleton();
sm.test();
Object obj = sm; // Object 부모 객체(더 큰 개념) -> 자동 형변환
// obj.test(); //형변환되면 설계도가 바뀌기 때문에 test()를 못찾음
D3_Singleton afterSm = (D3_Singleton) obj; // b=(byte)200 같은거임
afterSm.test();// 이제 설계도에 test()가 보이므로 호출 가능
// 주의사항: 객체간에 관계가 없는 것끼리는 형변환X

public class D1_ImmutableTest {
    public static void main(String[] args) {
        int a = 5;
        change01(a);
        System.out.println("원본 a변수의 값은?" + a);

        D1_ImmutableTest imTest = new D1_ImmutableTest();
        change02(imTest);
        System.out.println("원본 bb변수의 값은?" + imTest.bb);
    }

    public static void change01(int a) {
        a = 10; // 받은 쪽에서 10으로 값을 변경
    }

    public int bb = 5; // 멤버필드

    public static void change02(D1_ImmutableTest imTest) {
        int aa = imTest.bb; // 실제 값을 꺼내서 저장한뒤 사용
        aa = 15;
        imTest.bb = 10; // 직접 주소로 접근해서 값을 변경하는 경우 ->원본이 저장됨
    }
}

// 참조타입 상수 선언: 값변경 금지(X), 주소변경 금지(O)
public static final int[] arrayNum = { 1, 2, 3, 4 };

// 멤버필드에 static을 사용해서 상수를 정의하자
public static final int num = 100;

// 생성자를 통해서 값을 초기화하는 코드를 작성한다면 초기값 정의 안해도됨
public final int num2;

public D2_FinalTest(int num2) {
    this.num2 = num2;
}

public static void main(String[] args) {
    final int b = 5; // 값이 변경되지 않음 -> 상수(상수는 대문자로 선언)
    // b = 15; // 에러발생 -> final로 선언된 변수는 값을 변경할 수 없다
    // …(생략)
    D2_FinalTest ft1 = new D2_FinalTest(100);
    D2_FinalTest ft2 = new D2_FinalTest(200);

    arrayNum[0] = 10;
    System.out.println(Arrays.toString(arrayNum));
    int[] test = { 1, 2, 3, 4, 5 };
    // arrayNum = test; // 에러발생 참조타입의 주소를 변경하려고 했다.
}

// 기본타입과 참조타입 변환
int a = 10;
Object obj2 = a; // 참조타입 <--- 기본타입

Integer ii = a;// 중간 진행 과정
// Integer iii = new Integer(a);
Object obj3 = ii;

System.out.println(obj3.toString());
int b = (int) obj3; // 언박싱해서 정수형으로 다시 사용한다.

List<Integer> list = new ArrayList<>();
list.add(10);
// list.add("가"); // List<Integer>에는 String을 넣을 수 없어 컴파일 에러 (원본 주석을 바로잡음)

// 싱글턴 패턴-------------------
// D3_SingletomTest st = new D3_SingletomTest(); //x
D3_SingletomTest st = D3_SingletomTest.getInstance();
D3_SingletomTest st2 = D3_SingletomTest.getInstance();

public class D3_SingletomTest {
    // static을 붙인 이유는 getInstance메서드가 static이라서
    private static D3_SingletomTest st;

    private D3_SingletomTest() {// 외부에서 접근 못함 --> new를 못함

    }

    public static D3_SingletomTest getInstance() {
        if (st == null) { // 객체가 생성되지 않았을때만 생성하자
            st = new D3_SingletomTest();
        }

        return st;
    }
}

// 리터럴과 리터럴 비교
String s1 = "java";
String s2 = "java";
System.out.println((s1 == s2) + ":" + (s1.equals(s2)));

// 객체와 객체 비교
String obj1 = new String("java");
String obj2 = new String("java");
System.out.println((obj1 == obj2) + ":" + (obj1.equals(obj2)));

// 객체와 리터럴
System.out.println((s1 == obj1) + ":" + (s1.equals(obj1)));
// …(생략: += 반복과 StringBuilder 비교)

// String 특징: immutable -> 값을 변경할 수 없다.
String s = "java";// 원본
String sss = s;// 복사본
sss = "자바";// 값을 변경
System.out.println(s); // 원본은 그대로
String s4 = s.replace("j", "o");// 원본이 바뀌지 않는다
System.out.println(s4); // 바뀐 내용을 사용하려면 재할당받아야 한다
System.out.println(s);

int count = 0;
int searchIndex = 0; // 검색 시작 위치

while (true) {
    int index = s.indexOf(str, searchIndex);
    if (index == -1) {
        break; // 더 이상 검색어가 없으면 반복 종료
    }
    System.out.println("검색어 인덱스: " + index);
    System.out.println("추출된 검색어: " + s.substring(index, index + str.length()));
    count++;
    searchIndex = index + str.length(); // 다음 검색 시작 인덱스 업데이트
}
System.out.println("검색된 개수: " + count + "개");
System.out.println(s.replace(str, "###"));

public void paramInt(String s, String cal) {
    // s-> "5+10" -> "5"만 추출해서 정수형으로 변환하여 num1에 저장
    if (s.indexOf(cal) != -1) {
        num1 = Integer.parseInt(s.substring(0, s.indexOf(cal)));
        // s-> "5+10" -> "10"만 추출해서 정수형으로 변환하여 num2에 저장
        // s.length()가 아니라 연산자 길이(cal.length())를 더해야 함!
        num2 = Integer.parseInt(s.substring(s.indexOf(cal) + cal.length()));
    }
}

// 1. 리터럴방식: 기본타입처럼 선언
int[] a = { 1, 2, 3, 4, 5, 6 }; // 바로 선언과 동시에 초기화를 해야 함
int[] b = null;

b = a;// 주소복사(얕은 복사)   ← 정확히는 '참조 복사'
b[0] = 10;
System.out.println(Arrays.toString(a));

// 2. new를 사용하는 정의
int[] b2;
b2 = new int[] { 1, 2, 3, 4, 5 };

// 선언과 정의(자릿수) -> 자동초기화 지원(int면 0으로 초기화됨)
int[] b3 = new int[5];
for (int i = 0; i < b3.length; i++) {
    b3[i] = i + 1;
}
// …(생략: sort, String replace 비교)

// 깊은복사   ← 원소를 하나씩 옮기기
int[] e = new int[] { 1, 2, 3, 4, 5, 6 };
for (int i = 0; i < b3.length; i++) {
    e[i] = b3[i];
}

// 깊은복사 기능 : System.arraycopy() 단, 값의 타입이 기본타입일 경우
int[] f = new int[5];
// (원본대상배열,복사할 시작위치, 복사받을 배열, 시작위치, 복사할 길이)
System.arraycopy(e, 0, f, 0, f.length);

int[][] bb = new int[][] { { 1, 2, 3 }, { 4, 5, 6 } }; // 2행 3열
// …(생략)

// 2차원 배열 --> 1차원 배열 변환
int[] dd = new int[bb.length * bb[0].length];
for (int i = 0; i < bb.length; i++) {
    for (int j = 0; j < bb[i].length; j++) {
        dd[i * bb[0].length + j] = bb[i][j];
    }
}
System.out.println(Arrays.toString(dd));

// 1차원배열 --> 2차원배열
// 공식: [i/col][i%col]
int[][] ee = new int[2][3];
int col = ee[0].length;
for (int i = 0; i < dd.length; i++) {
    ee[i / col][i % col] = dd[i];
}
for (int i = 0; i < ee.length; i++) {
    System.out.println(Arrays.toString(ee[i]));
}

int count = 1;
for (int i = 0; i < total; i++) {
    String next = "";
    ant = ant + " ";   // 끝에 공백 하나: 마지막 묶음도 '다른 글자'를 만나게
    for (int j = 0; j < ant.length() - 1; j++) {
        if (ant.charAt(j) == ant.charAt(j + 1)) {
            count++;
        } else {
            next = next + ant.charAt(j) + count;   // "숫자 + 개수"
            count = 1;
        }
    }
    ant = next;
    System.out.println(ant);
}

public class D1_CalculatorA {
    public int num1;
    public int num2;
    // 계산 결과는 중요한 값이기 때문에 외부에서 쉽게 접근하지 못하게 하자
    private int result;

    public D1_CalculatorA() {
        this(10, 5);
    }

    public D1_CalculatorA(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public void a() {
        this.result = this.num1 + this.num2;
    }

    // getter 메서드:private 필드에 접근하여 값을 가져오기 위해 선언
    public int getResult() {
        return result;
    }
}

private int result; // 연산결과

public void calculator(int num1, int num2, String cal) {
    if (cal.equals("+")) {
        D1_CalculatorA calA = new D1_CalculatorA(num1, num2);
        calA.a(); // 덧셈연산 실행
        this.result = calA.getResult(); // 은닉화: getter메서드 통해 결과 가져오기
    } else if (cal.equals("-")) {
        // …(생략: B·D·C도 같은 모양)
    } else {
        System.out.println("잘못된 연산자입니다.");
    }
}

public class D2_Parent {
    public int a;

    public D2_Parent() {
        System.out.println("부모생성자(default)");
    }

    public D2_Parent(int a) {
        System.out.println("부모생성자(오버로딩)");
    }

    public void parentMethod() {
        System.out.println("부모의 메서드:" + getClass());
    }
    // …(생략: toString 오버라이딩)
}

public class D2_Child extends D2_Parent {
    public String s = "나는 자식의 맴버필드 값이야";

    public D2_Child() {
        this(5);
        System.out.println("자식생성자(default)");
    }

    public D2_Child(int a) {
        super(a);// 부모가 먼저 생성된후 자식이 생성된다.
        System.out.println("자식생성자(오버로딩)");
    }

    public void childMethod() {
        parentMethod();// 부모메서드를 자식의메서드처럼 사용가능
        System.out.println("자식클래스에서 정의된 메서드:" + getClass());
    }

    // 부모의 메서드를 자식이 재정의하는 기능
    @Override
    public void parentMethod() {
        System.out.println("부모메서드를 자식이 재정의한 메서드");
    }

    @Override
    public String toString() {
        return s;
    }
}

// private은 상속을 해줄 수 없어서 자식에서 사용하기 불편함
// -> protected로 선언하면 상속이 가능, 같은 패키지 안에서는 사용가능
protected int customerID; // 고객ID
protected String customerName;// 고객이름
protected String customerGrade;// 고객등급
protected int bonusPoint; // 보너스포인트
protected double bonusRatio; // 보너스 적립률

// …(생략: 생성자 2개 — 등급 "SILVER", 적립률 0.01로 시작)

// 보너스 적립률 계산해서 보너스 포인트 추가
public int calcPrice(int price) {
    bonusPoint += price * bonusRatio; // 보너스점수 누적
    return price; // 일단 그대로 리턴
}

public class D1_VIPCustomer extends D1_Customer {
    private int agentID; // 담당 상담원 ID
    private double saleRatio; // 할인율

    // …(생략: 기본 생성자)

    public D1_VIPCustomer(int customerID, String customerName, int agentID) {
        super.customerID = customerID;
        super.customerName = customerName;
        super.customerGrade = "VIP";
        super.bonusRatio = 0.05;
        this.saleRatio = 0.1;
        this.agentID = agentID;
    }

    // -> 자식에서는 할인률도 계산하는 기능이 추가
    @Override
    public int calcPrice(int price) {
        super.bonusPoint += price * super.bonusRatio;
        return (int) (price - (price * saleRatio)); // int로 강제 형변환
    }
    // …(생략: toString 오버라이딩)
}

// 부모의 타입으로 자식을 생성
D1_Animal human = new D1_Human();
human.move(); // 자식에서 구현한 메서드가 실행(오버라이딩)
// human.eat(); //설계도에 공개된 메서드만 사용가능

// 자식에서 단독으로 구현한 메서드를 사용하려면 자식타입으로 형변환해야 된다.
D1_Human humanEat = (D1_Human) human;
humanEat.eat(); // 자식에서 단독으로 구현한 메서드
// …(생략)

// 1.부모의 타입으로 자식을 생성한다.
D1_Animal animalH = new D1_Human();
D1_Animal animalT = new D1_Tiger();
D1_Animal animalE = new D1_Eagle();
moveAnimal(animalH);
moveAnimal(animalT);
moveAnimal(animalE);
// …

public static void moveAnimal(D1_Animal animal) {
    animal.move(); // 하나의 타입으로 여러 형태를 나타낼 수 있다.(다형성)
}

// 다형성을 활용하지 않았을 경우
public static void moveAnimal(D1_Human human) { human.move(); }
public static void moveAnimal(D1_Tiger tiger) { tiger.move(); }
public static void moveAnimal(D1_Eagle eagle) { eagle.move(); }
// …(생략: Object 매개변수 + instanceof 버전)

public abstract class D2_Computer {
    public void turnOn() {
        System.out.println("전원을 켭니다");
    }
    // …(생략: turnOff)
    public abstract void display(); // 추상메서드
    public abstract void typing(); // 추상메서드
}

public abstract class D2_NoteBook extends D2_Computer {
    @Override
    public void display() {
        System.out.println("노트북 화면 출력");
    }
    // notebook마다 키보드 유형이 다르기때문에 여기서 명확하게 구현할 수 없다.
    @Override
    public abstract void typing();
}

public class D2_MyNoteBook extends D2_NoteBook {
    @Override
    public void typing() {
        System.out.println("MyNoteBook typing기능입니다.");
    }
}

// D2_ComputerMain
// D2_Computer com = new D2_Computer(); //불가능
D2_Computer MynoteBook = new D2_MyNoteBook();
MynoteBook.turnOn();
MynoteBook.display();
MynoteBook.typing();
MynoteBook.turnOff();

public interface D1_InterfaceTest {
    // 맴버필드 선언 -> 자동으로 상수가 됨
    public int b = 50;
    public static final int A = 30;

    // 추상메서드: 그냥 작성해도 자동 추상메서드가 된다.
    public void test1();
    public abstract int test2();
    public int test3();

    // default 메서드
    public default void test5() {
        System.out.println("인터페이스에서 기능을 구현할 수 있는 메서드");
    }

    // private 메서드: 현재 Interface 내부에서 기능을 구현 -> 내부에서만 접근
    private void test6() {
        System.out.println("인터페이스 내부에서만 사용가능한 메서드.");
    }

    // static 메서드: 독립적인 기능을 제공할 떄
    static void test7() {
        System.out.println("인터페이스에서 독립적인 기능을 제공하는 메서드.");
    }
}

D1_InterfaceChild it = new D1_InterfaceChild();
it.test1();
it.test2();
it.test5();
D1_InterfaceTest.test7(); // static 메서드

// 익명 클래스 -> 이름이 없는 클래스 정의 -> 재활용X
// interface는 자체적으로 객체 생성X
D1_InterfaceTest it2 = new D1_InterfaceTest() {
    @Override
    public void test1() {
        System.out.println("인라인 익명클래스에서 구현한 test1");
    }
    // …(생략: test2, test3, test5도 구현)
};

public class D1_NestedClassTest {
    public int a = 5;
    public int b = 10;
    public static int aa = 7;
    public static int bb = 3;

    // 정적 내부 클래스: 독립적으로 사용 가능
    static class StaticInnerClass {
        // …(생략: message 필드, 생성자)
        public int getResult() {
            int result = aa + bb; // static 필드만 접근 가능하다.
            return result;
        }
    }

    // 인스턴스 내부 클래스
    class InnerClass {
        // …(생략)
        public int getResult() {
            int result = a + b;
            return result;
        }
    }

    public void nestedMethod() {
        int c = 5;
        class LocalInnerClass {   // 지역 내부 클래스
            // …(생략)
            public int getLic() {
                int ss = c;
                return ss;
            }
        }
        // c=50; 값이 변경되는 코드가 있다면 오류발생 -> 번경여지가 없는 변수여야 한다.
        // …
    }

    public static void main(String[] args) {
        StaticInnerClass sic = new StaticInnerClass("정적내부클래스");
        System.out.println(sic.getResult());

        // 인스턴스 내부 클래스: 외부클래스를 먼저 객체 생성하고, 내부클래스를 생성해야 사용할 수 있다.
        InnerClass inner = new D1_NestedClassTest().new InnerClass("내부클래스");
        System.out.println(inner.getResult());

        // 익명클래스
        MagicSquare magic = new MagicSquare() {
            @Override
            public void make() { }
            @Override
            public void magicPrint() { }
        };
        magic.make();
        magic.magicPrint();
    }
}

public class D3_GBox<T> {
    private T item;

    public void set(T item) {
        this.item = item;
    }

    public T get() {
        return item;
    }

    public static void main(String[] args) {
        D3_GBox<String> strBox = new D3_GBox<>();
        strBox.set("Hello~~~");
        System.out.println(strBox.get());

        D3_GBox<Integer> intBox = new D3_GBox<>();
        intBox.set(1000);
        System.out.println(intBox.get());

        // 와일드카드: <? extends T> T와 T의 하위타입들: 읽기전용
        List<? extends Number> numbers = new ArrayList<Integer>();
        // numbers.add(100);// 추가,수정작업 X
        // …(생략: num 리스트에 100, 101, 102 추가, numbers = num)
        // printList2(num);
        printList1(num);
    }

    // List에 저장되면 타입간에 계층구조가 깨짐 -> 와일드 카드로 처리하면 계층구조 유지
    public static void printList1(List<? extends Number> list) {
        Integer i = (Integer) list.get(0);
        System.out.println(i);
    }

    public static void printList2(List<Number> list) {
    }
}

public class D2_MagicFactory {
    // singleton pattern 적용
    private static D2_MagicFactory magicFactory;

    private D2_MagicFactory() {
    }

    public static D2_MagicFactory getInstance() {
        if (magicFactory == null) {
            magicFactory = new D2_MagicFactory();
        }
        return magicFactory;
    }

    // Factory pattern
    public Interface_Magic factory() {
        Interface_Magic magic = null;
        // …(생략: Scanner로 num 입력받기)
        if (num < 3) {
            System.out.println("3이상 숫자를 입력하세요");
        } else if (num % 2 == 1) {
            magic = new OddMagicSquare(num);
        } else if (num % 4 == 0) {
            magic = new EvenMagicSquare(num);
        } else if (num % 4 == 2) {
            magic = new D1_SixMagicSquare(num);
        }
        scan.close();
        return magic;
    }
}

public class D1_MagicUtil {
    public static void magicRun(Interface_Magic magic) {
        magic.make();
        magic.magicPrint();
    }
}

// D3_MagicSquareMain.main
// 메서드를 통해 객체 얻어옴: new 사용 못함
D2_MagicFactory fac = D2_MagicFactory.getInstance();
Interface_Magic magic = fac.factory();
if (magic == null) {
    System.out.println("다시입력하세요");
} else {
    D1_MagicUtil.magicRun(magic);
}

// i인덱스의 n/4이 되는 위치에서 j+1을 해서 3을 채우자
private void makeA() {
    int n = magic.length;

    for (int i = 0; i < n / 2; i++) {
        for (int j = 0; j < n / 4; j++) {
            if (i == 2) {          // ← n=10에서만 맞음. if (i == n / 4) 로 고쳐야 한다
                magic[i][j + 1] = 3;
            } else {
                magic[i][j] = 3;
            }
        }
    }
}

Set<String> set = new HashSet<>();
set.add("한");
set.add("국");
set.add("경");
set.add("제");
set.add("제");          // 두 번 넣어도 하나만 남는다

// Iterator
Iterator<String> iter = set.iterator(); // Set -> Iterator 객체로 변환
while (iter.hasNext()) { // 값을 확인한다
    String str = iter.next(); // 값을 꺼낸다
    System.out.println(str);
}

// 꺼내는 다른 방법: List로 변환 -> 원하는값만 가져올 수 있다.
List<String> list = new ArrayList<>(set);
System.out.println(list.get(2));

Map<String, String> map = new HashMap<>();
map.put("하나", "한경");
map.put("둘", "닷컴");
map.put("셋", "교육센터");
map.put("셋", "교육센터"); // key는 중복할 수 없다.
System.out.println(map.get("하나") + "," + map.get("둘"));

// Map에서 일괄적으로 데이터를 가져오려면
Set<String> setKeyMap = map.keySet(); // key들만 Set에 담아 반환
for (String s : setKeyMap) {
    System.out.println(map.get(s));
}

public class D2_Card {
    public static final String[] DECK = { "◆", "♥", "♣", "♠" };
    public static final String[] STECK = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };

    private String card; // "♦2"
    // …(생략: 생성자, init()에서 무작위 그림+숫자 조합, getCard(), toString())

    // Card객체 내부에 멤버필드인 card끼리 비교하는 기능으로 재정의
    @Override
    public boolean equals(Object obj) {
        boolean isS = false;
        D2_Card ca = (D2_Card) obj;
        if (this.card.equals(ca.getCard())) {
            isS = true;
        }
        return isS;
    }

    // equals()를 오버라이딩하면 hashcode()도 오버라이딩해야 됨
    @Override
    public int hashCode() {
        return card.hashCode() + 137;
    }
}

private List<D2_Card> cards;
private static final int NUMOFCARDS = D2_Card.DECK.length * D2_Card.STECK.length; // 4 × 13 = 52

public void shuffle() {
    int i = 0;
    while (true) {
        D2_Card cc = new D2_Card(); // 카드 한장 생성
        if (!cards.contains(cc)) {  // 내부에서 cc.equals(이미 있는 카드)로 하나씩 비교
            cards.add(cc);
            i++;
        }
        if (i == NUMOFCARDS) {
            break;
        }
    }
}

public static void exTest2(String s) {
    int i = 0;
    String ss = "스트링";
    int[] array = { 1, 2, 3, 4, 5 };
    try {
        i = Integer.parseInt(s);   // ① "오"를 넣으면 여기서 사고
        ss = ss.substring(0, 2);
        int a = array[5];          // ② 숫자를 넣으면 여기서 사고(인덱스는 0~4)
    } catch (NumberFormatException e) {
        System.out.println("문자가 숫자형태로 변환되지 않았습니다.");
        e.printStackTrace();
    } catch (StringIndexOutOfBoundsException e) {
        System.out.println("문자열의 범위를 벗어났습니다.");
        e.printStackTrace();
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("배열의 범위를 벗어났습니다.");
        e.printStackTrace();
    } catch (Exception e) {        // 부모는 맨 마지막
        System.out.println("나머지 모든 예외를 처리한다");
        e.printStackTrace();
    } finally {
        ss = ss.substring(0, 2);
        System.out.println(ss);
    }

    System.out.println("오류발생해도 프로그램은 종료되지 않는다.");
}

//내가 필요한 Exception 클래스를 만들때는 Exception을 상속받아 생성
public class D1_UserException extends Exception {
    public D1_UserException() {
        this("UserException 오류 입니다.");
    }

    public D1_UserException(String msg) {
        super(msg);   // 부모(Exception)에 메시지 전달 → getMessage()로 꺼낼 수 있다
    }
}

public static void main(String[] args) {
    try {
        UserExceptionTest(12);
    } catch (D1_UserException e) {
        System.out.println("예외가 발생했습니다");
        e.printStackTrace();
    }
}

public static void UserExceptionTest(int a) throws D1_UserException {
    // 숫자를 받아서 1~10까지의 숫자를 받을 수 있다
    if (!(a > 0 && a < 11)) { // 1~10의 범위를 벗어난 숫자를 받는다면
        throw new D1_UserException("1부터 10까지의 숫자만 입력가능");
    }
}

public interface D1_ILambda {
    // 메서드를 하나만 선언해서 사용한다.
    public int add(int a, int b); // 추상메서드
}

// 익명클래스방식
D1_ILambda lam = new D1_ILambda() {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
};
System.out.println(lam.add(1, 2));

// 람다식 방식
D1_ILambda lam2 = (a, b) -> {
    return a + b;
};
System.out.println(lam2.add(1, 2));

// 람다식 방식 간략하게
D1_ILambda lam3 = (a, b) -> a + b;
System.out.println(lam3.add(1, 2));

List<String> list = Arrays.asList("김태경", "김상원", "임종서");

Stream<String> streamList = list.stream();
streamList.filter(s -> s.contains("김")).sorted()
        .forEach(s -> System.out.println(s));
// Stream객체는 한번 사용하면 끝남 -> 다시 못씀

list.stream().filter(s -> s.startsWith("임")).sorted()
        .forEach(System.out::println);   // 메서드 참조

// Stream을 사용하지 않고 구현한다면?
List<String> list2 = new ArrayList<>();
for (String s : list) {
    if (s.contains("김")) {
        list2.add(s);
    }
}
Collections.sort(list2);
for (String s : list2) {
    System.out.println(s);
}

// map(): 값을 편집해서 새로운 값으로 반환 (원본 데이터를 변경하지 않는다)
List<Integer> listNum = list.stream()
        .map(String::length)
        .collect(Collectors.toList()); // 반환한 값을 list에 담아서 반환
System.out.println(listNum.toString()); // [3,3,3]
// …(생략: List.of()와 parallelStream() 비교)

// try with resource 문법 사용으로 finally 생략가능
try (
        InputStream in = new FileInputStream("C:\\Antigravity26_06\\…\\temp\\test.txt");   // 경로 일부 생략
        OutputStream out = new FileOutputStream("C:\\Antigravity26_06\\…\\temp\\test2.txt");) {
    int i = 0;
    while ((i = in.read()) != -1) {   // 읽을게 없으면 -1을 리턴
        System.out.println(i);
        out.write(i);                 // 파일출력(byte단위로)
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}
// …(생략: catch (Exception e))

try (
        InputStream in = new FileInputStream("C:\\Antigravity26_06\\…\\temp\\images.jpg");   // 경로 일부 생략
        OutputStream out = new FileOutputStream("C:\\Antigravity26_06\\…\\temp\\copy.jpg");
) { // 10바이트 단위로 읽기
    byte[] b = new byte[10];
    int i = 0;
    while ((i = in.read(b)) != -1) { // i에 저장되는 값은 읽은 개수
        // out.write(b); //그전에 읽었던 배열의 데이터가 남아있을수있음
        out.write(b, 0, i); // 읽은 개수만큼만 출력 -> 안정적(권장)
    }
} catch (IOException e) {
    e.printStackTrace();
}
// …(생략: FileNotFoundException·Exception catch)

try (
        // 키보드 입력: InputStreamReader -> BufferedReader (한 줄씩 읽기용)
        InputStreamReader in = new InputStreamReader(System.in, "MS949");
        BufferedReader br = new BufferedReader(in);

        // 파일 출력: FileOutputStream(..., true) -> OutputStreamWriter -> BufferedWriter
        FileOutputStream out = new FileOutputStream(
                "C:\\Antigravity26_06\\…\\temp\\test5.txt",   // 경로 일부 생략
                true); // true: 기존 내용 뒤에 이어쓰기
        OutputStreamWriter ow = new OutputStreamWriter(out, "utf-8");
        BufferedWriter bw = new BufferedWriter(ow);) {
    System.out.println("입력시작. (exit 입력 시 종료)");

    String msg = "";
    while ((msg = br.readLine()) != null) {   // 한 줄씩 입력받기
        if (msg.equals("exit")) {
            System.out.println("종료합니다.");
            break;
        }
        bw.write(msg);
        bw.newLine();
        bw.flush(); // 버퍼 비우기(파일에 즉시 기록)
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 작업단위1
Thread t1 = new Thread() { // 익명클래스 방식으로...
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.print("안");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};
// …(생략: t2도 같은 모양으로 "녕"을 출력)

// 주의 : .run()을 직접 호출하면 쓰레드가 생성되지 않는다!
t1.start();
t2.start();

public class D1_RunableTest implements Runnable {      // 방법 1: 할 일만 정의
    @Override
    public void run() { /* …(생략: "나는 Runnable을 구현한 스레드다" 50번, 0.5초 간격) */ }
}

public class D1_ThreadInheriTest extends Thread {      // 방법 2: 스레드 자체를 상속
    @Override
    public void run() { /* …(생략: "나는 Thread를 상속받은 스레드다" 50번) */ }
}

// D1_ThreadMain.main()
Runnable runObj = new D1_RunableTest();
Thread tr1 = new Thread(runObj);      // Runnable은 Thread에 넘겨서 실행
tr1.start();
tr1.setPriority(Thread.MAX_PRIORITY); // 우선순위범위: 1~10까지

Thread tr2 = new D1_ThreadInheriTest();
tr2.start();
tr2.setPriority(Thread.MIN_PRIORITY);

public static StringBuilder sb = new StringBuilder();
public static StringBuffer sf = new StringBuffer();

public void sbTest(String s) {
    for (int i = 0; i < 1000; i++) {
        sf.append(s);
    }
    // …(생략: 2초 sleep)
    System.out.println(sf.length());
}

// main 안
ShareObject so = new D2_ThreadSync().new ShareObject();
Thread trA = new Thread() {
    @Override
    public void run() {
        synchronized (so) {   // so의 열쇠를 가진 스레드만 들어온다
            so.print("공");   // print(): 0.5초 간격으로 10번 출력
        }
    }
};
// …(생략: trB는 so.print("유"). 수업에서는 trA·trB 실행 줄을 주석 처리하고,
//      아래처럼 tr1·tr2가 각각 sbTest("A")·sbTest("B")를 부르게 해서 실행)

public class D3_CakePlate {
    private int breadCount = 0;

    public synchronized void eatBread() {
        if (breadCount < 1) {          // ⚠️ 정석은 while (breadCount < 1)
            System.out.println("빵이 모자라서 기다려야 함");
            try {
                wait();// 스레드를 일시정지
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        breadCount--;
        System.out.println("빵을 1개 먹음. 총 " + breadCount + "개 남음");
        notifyAll();// 모든 스레드를 실행대기로 설정
    }

    public synchronized void makeBread() {
        if (breadCount >= 10) {        // ⚠️ 정석은 while (breadCount >= 10)
            System.out.println("빵이 남아요!");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        breadCount++;
        System.out.println("빵을 1개 더 만듦. 총 " + breadCount + "개");
        notifyAll();
    }
}

D3_CakePlate cake = new D3_CakePlate();        // 스레드들이 공유할 객체
D3_CakeEater eater = new D3_CakeEater(cake);   // run(): eatBread() 30번
D3_CakeMaker maker = new D3_CakeMaker(cake);   // run(): makeBread() 30번

Thread t1 = new Thread(eater);
Thread t2 = new Thread(maker);
t2.setPriority(10);
t1.setPriority(1);
t1.start();
t2.start();

serverSocket = new ServerSocket(9595);
System.out.println("서버가 클라이언트의 접속을 기다립니다...");
while (true) {
    clientSocket = serverSocket.accept();   // 손님이 올 때까지 멈춤
    System.out.println("클라이언트 연결됨:" + clientSocket.getInetAddress().getHostName());

    out = new PrintWriter(clientSocket.getOutputStream(), true);
    in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

    String inputLine;
    while ((inputLine = in.readLine()) != null) {   // 이 손님이 나갈 때까지 여기 갇힘
        System.out.println("클라이언트 메시지:" + inputLine);
        out.println("메시지를 잘 전달받았습니다.");
    }
}
// …(생략: catch, finally에서 out·in·clientSocket·serverSocket 차례로 close)

try (ServerSocket serverSocket = new ServerSocket(9595);) {
    System.out.println("server is running now...");
    while (true) {
        Socket clientSocket = serverSocket.accept();
        System.out.println("클라이언트 연결됨:" + clientSocket.getInetAddress().getHostName());
        new ServerThread(clientSocket).start();   // 대화는 전담 스레드에게, main은 다시 accept로
    }
} catch (Exception e) {
    e.printStackTrace();
}

static class ServerThread extends Thread {
    Socket clientSocket = null;
    public ServerThread(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }
    @Override
    public void run() {
        try (
                Socket autoCloseSocket = clientSocket;   // close() 자동 처리용으로 등록
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));) {
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("클라이언트로부터 전달받은 메시지:" + inputLine);
                out.println("보낸 메시지:" + inputLine);
            }
        } catch (IOException e) {
        }
    }
}

try (DatagramSocket socket = new DatagramSocket(5000);) {
    byte[] buffer = new byte[512];
    // 수신용 패킷 생성
    DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    System.out.println("server is listening on port 5000");
    while (true) {
        socket.receive(packet);   // 패킷이 올 때까지 멈춤
        String received = new String(packet.getData(), 0, packet.getLength());   // ✔ 받은 길이만큼
        System.out.println("받은 메시지:" + received);

        InetAddress address = packet.getAddress();   // 보낸 사람 주소
        int port = packet.getPort();                 // 보낸 사람 포트
        System.out.println("address:" + address + ",port:" + port);
        packet = new DatagramPacket(buffer, buffer.length, address, port);   // ⚠️ buffer.length(512) → packet.getLength()로 고쳐야 함
        socket.send(packet);// 클라이언트로 보냄
    }
}
// …(생략: catch)

// 여러 스레드가 동시에 접속자 명단에 추가/삭제하므로 동기화(synchronizedSet) 필수!
private static Set<PrintWriter> clientWriters = Collections.synchronizedSet(new HashSet<>());

public static void broadcast(String message) {
    // 여러 스레드가 동시에 명단을 읽는 도중 오류가 나지 않도록 동기화 블록 설정
    synchronized (clientWriters) {
        for (PrintWriter writer : clientWriters) {
            writer.println(message);// 각 클라이언트의 스피커로 메시지 전송
        }
    }
}

// ClientHandler.run() — 손님 1명 전담 스레드
in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
out = new PrintWriter(socket.getOutputStream(), true);
clientWriters.add(out);                 // 2.전체 명단에 내 마이크 등록
nickname = in.readLine();               // 3.맨 처음 한 줄은 닉네임
broadcast(nickname + "님이 입장하셨습니다.");
String message;
while ((message = in.readLine()) != null) {
    broadcast("[" + nickname + "]" + message);
}
// …(생략: catch, finally에서 clientWriters.remove(out), 퇴장 방송, socket.close())

// 6. 서버에서 오는 메시지를 실시간으로 수신하여 출력하는 별도 스레드 시작
Thread receiveThread = new Thread(() -> {
    try {
        String serverMessage;
        while ((serverMessage = in.readLine()) != null) {
            System.out.println(serverMessage);
        }
    } catch (IOException e) {
        System.out.println("서버와의 연결이 끊어졌습니다.");
    }
});
receiveThread.start();

// 7. 메인 스레드는 키보드 입력을 계속 읽어서 서버로 전송 (송신 전용)
String userInput;
while ((userInput = keyboard.readLine()) != null) {
    out.println(userInput);
}

SELECT *
FROM usertbl
WHERE NAME = '김경호';

SELECT userid, name
FROM usertbl
WHERE birthyear >= 1970 AND height >= 182;   -- 2명: 이승기, 성시경

SELECT userid, name
FROM usertbl
WHERE birthyear >= 1970 OR height >= 182;    -- 7명 (AND보다 훨씬 넓다)

SELECT NAME, height
FROM usertbl
WHERE height BETWEEN 180 AND 183;              -- 이승기 182, 임재범 182

SELECT NAME, addr
FROM usertbl
WHERE addr IN ('경남','전남','경북');           -- 김범수, 김경호, 윤종신, 은지원

SELECT NAME, height
FROM usertbl
WHERE NAME LIKE '_종신';                        -- 윤종신 (_ 는 딱 한 글자)

USE scott;
-- Q3) 사원 테이블에서 사원의 이름과 연봉을 출력하자.
SELECT ENAME, SAL*12 AS sal_year
FROM EMP;

-- (2. WHERE) Q4) 1980년도에서 1982년도 사이에 입사한 사원의 이름과 입사일
SELECT ENAME, HIREDATE
FROM emp
WHERE HIREDATE BETWEEN '1980-01-01' AND '1982-12-31';   -- 12명 (1987년 입사 SCOTT·ADAMS 제외)

-- Q9) "OO님이 0000-00-00에 입사를 하고 OO의 월급을 받습니다." 한 컬럼으로
SELECT CONCAT(ENAME, '님이 ', HIREDATE, '에 입사를 하고 ', SAL, '의 월급을 받습니다.') AS 사원정보
FROM EMP
ORDER BY '급여지급현황';    -- ⚠️ 아래 바로잡기 참고

-- 정렬하기
USE sqldb;
SELECT NAME, height
FROM usertbl
ORDER BY height DESC, NAME ASC;   -- 성시경 186, 이승기 182, 임재범 182, 김경호 177 …

USE sqldb;
-- group by 절
SELECT userid, SUM(amount) AS '총 구매 개수'
FROM buytbl
GROUP BY userid;

SELECT userid AS '사용자 아이디' ,SUM(price * amount) AS '총 구매액'
FROM buytbl
GROUP BY userid;
-- BBK 1920 · EJW 95 · JYP 200 · KBS 1210 · SSK 75  (12행 → 5행)

USE scott;
-- 7. Q6) 사원 테이블에서 평균 커미션(COMM)을 출력하자.
SELECT AVG(comm)
FROM emp;                      -- 550.0000 (NULL 10명은 빼고 4명으로 나눔)

-- 8. Q3) 커미션이 책정된 사원은 모두 몇 명인지
SELECT count(comm)
FROM emp
WHERE comm IS NOT NULL;        -- 4

-- 8. Q8) 직업별 총 월급, MANAGER 제외, 총 월급이 5000보다 큰 직업만
SELECT job, sum(sal)
FROM emp
WHERE job != 'manager'         -- 행 조건 → WHERE
GROUP BY job
HAVING SUM(sal)>5000;          -- 그룹 조건 → HAVING  : SALESMAN 5600, ANALYST 6000

-- 11) 부서별 평균 월급, 커미션이 책정된 사원만, 평균 1000 이상, 높은 순
SELECT deptno, AVG(sal)
FROM emp
WHERE comm IS NOT NULL
GROUP BY deptno
HAVING AVG(sal) >= 1000
ORDER BY AVG(sal) DESC;        -- 30번 부서 1400 한 줄

-- 8. Q4) 직업이 SALESMAN이고 월급이 1000 이상인 사원의 이름과 월급 (수업 답안)
SELECT ename, sal
FROM emp
WHERE job = 'salesman'
GROUP BY ename
HAVING sal >= 1000;

-- 부서별 평균 급여 (첫 시도)
USE scott;
SELECT ename, deptno,ROUND( AVG(sal), 2) AS "avg_sal"
FROM emp
GROUP BY deptno, ename;        -- 이름까지 묶으면 묶음마다 1명 → 평균 = 자기 월급

-- 윈도우 함수 사용: 집계 대상 데이터외에 다른 데이터도 표현
SELECT ename, deptno,
ROUND( AVG(sal) OVER(PARTITION BY deptno), 2) AS "avg_sal"
FROM emp
GROUP BY deptno, ename;        -- 10번 2916.67 · 20번 2175.00 · 30번 1566.67

USE sqldb;
SELECT ROW_NUMBER() OVER(ORDER BY height DESC) `키큰순위`,
NAME, addr, height
FROM usertbl;

-- rank() 사용하기
SELECT rank() OVER(ORDER BY height DESC) `키큰순위`,
NAME, addr, height
FROM usertbl;

-- dense_rank() 사용하기
SELECT dense_rank() OVER(ORDER BY height DESC) `키큰순위`,
NAME, addr, height
FROM usertbl;

USE sqldb;

SELECT b.userid, NAME, prodname, addr,
CONCAT(mobile1, mobile2) AS "연락처"
FROM buytbl b
JOIN usertbl u
ON b.userid = u.userid
WHERE b.userid = 'jyp';        -- 조용필 · 모니터 · 경기 · 01144444444

-- 기준테이블 usertbl일 경우
SELECT u.userid,u.name,b.prodName, u.addr,
      CONCAT(u.mobile1, u.mobile2) AS "연락처"
FROM usertbl u
    LEFT OUTER JOIN buytbl b
    ON u.userID = b.userID
ORDER BY u.userID;             -- 17행 = 구매 12행 + 안 산 회원 5명

-- 구매이력이 없는 회원 조회할 경우
SELECT u.userid,u.name,b.prodName, u.addr,
      CONCAT(u.mobile1, u.mobile2) AS "연락처"
FROM usertbl u
    LEFT OUTER JOIN buytbl b
    ON u.userID = b.userID
WHERE b.prodName IS NULL
ORDER BY u.userID;             -- JKW 조관우, KKH 김경호, LJB 임재범, LSG 이승기, YJS 윤종신

USE scott;
-- Q9) 사원번호·사원이름 + 그 사원을 관리하는 관리자의 사원번호·사원이름
SELECT e1.empno, e1.ename, e2.empno, e2.ename
FROM emp e1                    -- e1 = 사원
JOIN emp e2                    -- e2 = 관리자 (같은 표를 한 번 더)
ON e1.mgr = e2.empno;          -- 13행 : KING은 mgr이 NULL이라 짝이 없어 빠진다

-- Q10) 부서이름, 위치, 사원 수, 평균 급여
SELECT d.dname "DNAME", d.loc "LOC",
       COUNT(*) "NUMBER OF PEOPLE", round(AVG(sal)) "SALARY"
FROM emp e  JOIN dept d
ON e.deptno = d.deptno
GROUP BY d.dname;              -- 3개 부서만 (OPERATIONS가 사라짐)

SELECT d.dname "DNAME", d.loc "LOC",
       COUNT(e.EName) "NUMBER OF PEOPLE", round(AVG(sal)) "SALARY"
FROM emp e RIGHT OUTER  JOIN dept d
ON e.deptno = d.deptno
GROUP BY d.dname;              -- 4개 부서

USE scott;
-- 4-03. 'BLAKE'가 근무하는 부서의 위치(LOC) — 단일행(=)
SELECT loc
FROM dept
WHERE deptno = (SELECT deptno FROM emp WHERE ename = 'blake');   -- CHICAGO

-- 3-04. 부하직원이 있는 사원 — 다중행(IN)
SELECT empno, ename
FROM emp
WHERE empno IN (SELECT mgr FROM emp);          -- JONES, BLAKE, CLARK, SCOTT, KING, FORD

-- 3-05. 부하직원이 없는 사원
-- NVL(컬럼,지정값): 해당 컬럼의 값들 중에 null을 찾아서 지정한 값으로 대체
SELECT empno, ename
FROM emp
WHERE empno NOT IN (
    SELECT NVL(mgr, 0)
    FROM emp
);                                             -- 8명 (NVL을 빼면 0행!)

-- 인라인 뷰 사용 -> 반드시 별칭을 정의해야 함
SELECT empno, ename, sal
FROM
(SELECT empno, ename, sal
FROM emp
WHERE deptno IN (SELECT deptno FROM emp WHERE ename LIKE '%S%')
) AS a
WHERE sal > (SELECT AVG(sal) FROM emp);       -- JONES, BLAKE, SCOTT, FORD

-- CTE 사용하기
USE sqldb;
WITH abc(userid, total)
AS
(SELECT userid, SUM(price*amount)
FROM buytbl
GROUP BY userid)
SELECT * FROM abc ORDER BY total DESC; -- 하나의 묶음으로 실행

SELECT * FROM abc ORDER BY total DESC; -- 재실행은 안됨

CREATE TABLE userTbl -- 회원 테이블
( userID    CHAR(8) NOT NULL PRIMARY KEY, -- 사용자 아이디(PK)
  name      VARCHAR(10) NOT NULL, -- 이름
  birthYear INT NOT NULL,  -- 출생년도
  addr      CHAR(2) NOT NULL, -- 지역(경기,서울,경남 식으로 2글자만입력)
  mobile1   CHAR(3), -- 휴대폰의 국번(011, 016, 017, 018, 019, 010 등)
  mobile2   CHAR(8), -- 휴대폰의 나머지 전화번호(하이픈제외)
  height    SMALLINT,  -- 키
  mDate     DATE  -- 회원 가입일
);
CREATE TABLE buyTbl -- 회원 구매 테이블
(  num       INT AUTO_INCREMENT NOT NULL PRIMARY KEY, -- 순번(PK)
   userID    CHAR(8) NOT NULL, -- 아이디(FK)
   prodName  CHAR(6) NOT NULL, --  물품명
   groupName CHAR(4)  , -- 분류
   price     INT  NOT NULL, -- 단가
   amount    SMALLINT  NOT NULL, -- 수량
   FOREIGN KEY (userID) REFERENCES userTbl(userID) -- 외래키 지정
);

INSERT INTO userTbl VALUES('LSG', N'이승기', 1987, N'서울', '011', '11111111', 182, '2008-8-8');
-- …(생략: 회원 9명 더)
INSERT INTO buyTbl VALUES(NULL, 'KBS', N'운동화', NULL   , 30,   2);
INSERT INTO buyTbl VALUES(NULL, 'KBS', N'노트북', N'전자', 1000, 1);
-- …(생략: 구매 10건 더)

USE TABLEdb;
-- …(생략: 제약조건 없이 usertbl·buytbl 생성, 데이터 입력 — buytbl에는 usertbl에 없는 'bbk'의 구매가 있다)
ALTER TABLE usertbl
ADD CONSTRAINT pk_usertbl_userid
PRIMARY KEY (userid);

DELETE FROM buytbl WHERE userid = 'bbk';   -- 부모에 없는 값을 먼저 치워야 FK가 붙는다

ALTER TABLE buytbl
ADD CONSTRAINT fk_usertbl_buytbl
FOREIGN KEY (userid)
REFERENCES usertbl (userid);

-- …(생략: foreign_key_checks·CHECK 실습, 회원 입력)
ALTER TABLE buytbl
DROP FOREIGN KEY fk_usertbl_buytbl;

ALTER TABLE buytbl
ADD CONSTRAINT fk_usertbl_buytbl
FOREIGN KEY(userid)
REFERENCES usertbl (userid)
ON UPDATE CASCADE
ON DELETE CASCADE;

UPDATE usertbl SET userid = 'vvk' WHERE userid = 'bbk';   -- buytbl의 bbk 구매도 vvk로 바뀐다
-- …(생략: 조인으로 확인)
DELETE FROM usertbl WHERE userid = 'vvk';                 -- buytbl의 vvk 구매도 함께 지워진다

USE sqldb;
CREATE TABLE buytbl3 (SELECT * FROM buytbl);   -- 원본 대신 복사본으로 연습 (제약조건은 복사 안 됨)

ALTER TABLE buytbl3
ADD CONSTRAINT pk_buytbl3_num PRIMARY KEY (num);

START TRANSACTION;                             -- ★추가: 여기부터 한 묶음
UPDATE buytbl3 SET price = 90, amount = 60, prodname = '노트북'
WHERE num = 6;

SELECT * FROM buytbl3;

DELETE FROM buytbl3 WHERE num = 2;
SELECT * FROM buytbl3;                         -- ★추가: 6번이 바뀌고 2번이 사라진 모습
ROLLBACK;                                      -- ★추가: 둘 다 취소 → 원래대로

-- 연습문제 9) 1. 직업이 'SALESMAN'인 사원 급여(SAL)에 400 더하는 UPDATE
USE scott;
CREATE TABLE emp2 AS SELECT * FROM emp;
UPDATE emp2
SET sal = sal - 400
WHERE job = 'SALESMAN';

CREATE TABLE tbl1 (a INT PRIMARY KEY, b INT, c INT);
SHOW INDEX from tbl1;          -- PRIMARY(a) 하나

CREATE TABLE tbl2 (a INT PRIMARY KEY, b INT UNIQUE, c INT UNIQUE , d INT);
SHOW INDEX FROM tbl2;          -- PRIMARY(a) = 클러스터형, b · c = 보조

-- unique와 not null을 설정하면 클러스터형 인덱스가 됨
CREATE TABLE tbl4(a INT UNIQUE NOT NULL , b INT UNIQUE, c INT UNIQUE, d INT);
SHOW INDEX FROM tbl4;          -- PK가 없으니 a가 클러스터형 역할

CREATE TABLE tbl5(a INT UNIQUE NOT NULL , b INT UNIQUE, c INT UNIQUE, d INT PRIMARY KEY );
SHOW INDEX FROM tbl5;          -- PK(d)가 있으니 d가 클러스터형, a는 보조

-- 클러스터형 인덱스로 지정한 열을 기준으로 정렬된다.
CREATE TABLE usertbl3(SELECT * FROM usertbl ORDER BY RAND());
ALTER TABLE usertbl3
ADD PRIMARY KEY (userid);
-- 조회해보니 userid 값들이 오름차순 정렬되어 조회됨
SELECT * FROM usertbl3;

USE indexdb;
CREATE TABLE emp SELECT * FROM employees.employees
ORDER BY RAND();               -- 인덱스 없음
CREATE TABLE emp_c SELECT * FROM employees.employees
ORDER BY RAND();               -- 클러스터형(PK)을 붙일 표
CREATE TABLE emp_se SELECT * FROM employees.employees
ORDER BY RAND();               -- 보조 인덱스를 붙일 표

ALTER TABLE emp_c
ADD PRIMARY KEY (emp_no);
SELECT * FROM emp_c LIMIT 20; -- 데이터가 정렬된다

ALTER TABLE emp_se
ADD INDEX idx_emp_se_em_no (emp_no);
SELECT * FROM emp_se LIMIT 20; -- 데이터가 정렬 안된다

-- 생성한 인덱스의 실제 적용을 하려면
ANALYZE TABLE emp, emp_c, emp_se;

-- 조회해서 성능 확인하기
EXPLAIN SELECT * FROM emp WHERE emp_no < 11000;
EXPLAIN SELECT * FROM emp_c WHERE emp_no < 11000;
EXPLAIN SELECT * FROM emp_se WHERE emp_no < 11000;

-- 쿼리문에 조건을 잘못 만들 경우
EXPLAIN SELECT * FROM emp_c WHERE emp_no = 100000;
EXPLAIN SELECT * FROM emp_c WHERE emp_no*1 = 100000; -- (x)
EXPLAIN SELECT * FROM emp_c WHERE emp_no = 100000/1; -- (o)

DROP PROCEDURE IF EXISTS getDept_emp;

delimiter $
CREATE PROCEDURE getDept_emp(IN p_deptno INT)
BEGIN
    -- 부서 존재 여부를 체크할 변수 선언
    DECLARE v_cnt INT DEFAULT 0;

    -- dept 테이블에 전달받은 부서번호가 있는지 확인
    SELECT COUNT(*) INTO v_cnt
    FROM dept
    WHERE deptno = p_deptno;

    -- 조건 분기
    IF v_cnt > 0 THEN
        -- 부서가 존재할 경우: 사원 정보 출력
        SELECT ename, job, sal
        FROM emp
        WHERE deptno = p_deptno;
    ELSE
        -- 부서가 존재하지 않을 경우: 메시지 출력
        SELECT '해당 부서가 없습니다.' AS '메시지';
    END IF;
END $
delimiter ;

CALL getDept_emp(10);   -- (실행 예) CLARK · KING · MILLER
CALL getDept_emp(99);   -- (실행 예) 해당 부서가 없습니다.

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee" … version="6.0">   <!-- 스키마 속성 …(생략) -->
  <display-name>01_userboard_sepa</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <!-- …(index.xhtml · default.* 생략) -->
  </welcome-file-list>
</web-app>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
…(생략)
<body>
<h1>고객관리시스템</h1>
<p><a href="userList.jsp">(1)회원 조회(조회 후 수정/삭제 가능)</a></p>
<p><a href="userInsertFrom.jsp">(2)신규회원등록</a></p>
<h1>구매목록관리</h1>
<p><a href="buyList.jsp">구매목록조회</a></p>
<p><a href="buyInsertForm.jsp">구매상품등록</a></p>
</body>

String url = "jdbc:mariadb://localhost:3306/hk"; // 내 컴퓨터(localhost)의 3306 포트에 있는 'hk' 데이터베이스
String user = System.getenv().getOrDefault("STUDY_DB_USER", "study");
// 공개 저장소에 올리면서 실제 값을 뺐다. 내 환경의 비밀번호를 넣고 쓸 것.
// 원래는 소스에 직접 적지 않고 WEB-INF 안의 설정 파일로 빼는 것이 맞다.
String password = System.getenv("STUDY_DB_PASSWORD");

public UserDao() {
	try {
		Class.forName("org.mariadb.jdbc.Driver");                  // [1단계] 드라이버 로딩
		System.out.println("1단계: 드라이버 로딩 성공 (MariaDB 통역사 준비 완료)");
	} catch (ClassNotFoundException e) {
		System.out.println("1단계: 드라이버 로딩 실패 (라이브러리 jar 파일이 누락되었는지 확인하세요)");
		e.printStackTrace();
	}
}

public List<userDto> getAllUser() {
	List<userDto> list = new ArrayList<>();
	// …(url · user · password 생략 — 26장 예제)
	String sql = " SELECT "
			+ " USERID, NAME, BIRTHYEAR, ADDR, MOBILE1, MOBILE2, HEIGHT, "
			+ " MDATE FROM USERTBL "
			+ " ORDER BY MDATE DESC ";

	Connection conn = null;
	PreparedStatement psmt = null;
	ResultSet rs = null;
	try {
		conn = DriverManager.getConnection(url, user, password);   // [2단계] 연결
		System.out.println("2단계: DB연결 성공");
		psmt = conn.prepareStatement(sql);                         // [3단계] 쿼리 준비
		System.out.println("3단계: 쿼리준비 성공");
		rs = psmt.executeQuery();                                  // [4단계] 실행(SELECT)
		System.out.println("4단계: 쿼리실행 성공");
		while (rs.next()) {                                        // [5단계] 한 줄씩 DTO에 담기
			userDto dto = new userDto();
			dto.setUserId(rs.getString(1));   // 1번째 열: USERID (문자열)
			dto.setName(rs.getString(2));     // 2번째 열: NAME (문자열)
			// …(3~8번째 열 생략)
			list.add(dto);
		}
		System.out.println("5단계: 쿼리결과 받기 성공 (총 " + list.size() + "명 포장 완료)");
	} catch (SQLException e) {
		System.out.println("SQL 실행 중 문제가 발생했습니다.");
		e.printStackTrace();
	} finally {
		try {                                                      // [6단계] 연 순서의 반대로 닫기
			if (rs != null) rs.close();
			if (psmt != null) psmt.close();
			if (conn != null) conn.close();
			System.out.println("6단계: DB 연결 안전하게 닫기 완료");
		} catch (SQLException e) { /* …(생략) */ }
	}
	return list;
}

public boolean insertUser(userDto dto) {
	int count = 0; // DB에서 영향을 받은 행(줄)의 개수를 셀 변수
	// …(url · user · password 생략)
	String sql = " INSERT INTO USERTBL VALUES(?,?,?,?,?,?,?,SYSDATE()) ";

	try (Connection conn = DriverManager.getConnection(url, user, password);
		 PreparedStatement psmt = conn.prepareStatement(sql)) {

		psmt.setString(1, dto.getUserId());    // 1번째 ?: 회원 아이디
		psmt.setString(2, dto.getName());      // 2번째 ?: 이름
		psmt.setInt(3, dto.getBirthYear());    // 3번째 ?: 출생년도
		// …(4~7번째 ? 생략)
		count = psmt.executeUpdate();          // 등록·수정·삭제는 executeUpdate → 바뀐 행 수

	} catch (SQLException e) {
		System.out.println("회원 등록 실패 (아이디 중복 등)");
		e.printStackTrace();
	}
	return count > 0 ? true : false;
}

<%@page import="com.hk.board.dao.UserDao"%>
<%@page import="com.hk.board.dto.userDto"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
…(생략)
<% //JSP 구성요소중 jsp tag: scriptlet(실행부)
	UserDao dao = new UserDao();
	List<userDto> list = dao.getAllUser();
%>
<body>
<h1>고객 조회 결과</h1>
<table border = "1">
	<tr>
		<th>아이디</th><th>이름</th><th>가입일</th><th>삭제</th>
	</tr>
		<%
			for(userDto dto:list){
				%>
				<tr>
					<td><%=dto.getUserId()%></td>
					<td><a href="userDetail.jsp?userid=<%=dto.getUserId()%>"><%=dto.getName()%></a></td>
					<td><%=dto.getmDate()%></td>
					<td><a href="#" onClick="delUser('<%=dto.getUserId()%>')">삭제</a></td>
				</tr>
				<%
			}
		%>
…(생략)
<script type="text/javascript">
	function delUser(userId) {
		if(confirm("정말 삭제하겠습니까?")){
			location.href="userDel.jsp?userid="+userId;
		}
	}
</script>

<%
	request.setCharacterEncoding("UTF-8");              // [1] 한글: 값을 꺼내기 전에

	String userId = request.getParameter("userid");    // [2] 전부 String으로 온다
	String addr = request.getParameter("addr");
	String mobile1 = request.getParameter("mobile1");
	String mobile2 = request.getParameter("mobile2");
	String sHeight = request.getParameter("height"); // 문자로 넘어온 키 (예: "178")
	int height = Integer.parseInt(sHeight);

	UserDao dao = new UserDao();                        // [3] DAO에 맡기기
	boolean isS = dao.updateUser(new userDto(userId, addr, mobile1, mobile2, height));

	if (isS) {
		%>
		<script type="text/javascript">
			alert("회원정보를 수정했습니다.!!");
			location.href="userDetail.jsp?userid=<%=userId%>";
		</script>
		<%
	} else{
		response.sendRedirect("error.jsp");
	}
%>

// JDBC 1단계와 2단계(DB 연결 통로 만들기)를 전담하는 부모 클래스입니다.
public class DataBase {

	public DataBase() {                                   // [1단계: DB 드라이버 로딩]
		try {
			Class.forName("org.mariadb.jdbc.Driver");
			System.out.println("1단계: 드라이버 로딩 성공 (MariaDB 통역사 준비 완료)");
		} catch (ClassNotFoundException e) { /* …(생략) */ }
	}

	public Connection getConnection() throws SQLException {   // [2단계: 연결 통로 개설]
		Connection conn = null;
		String url = "jdbc:mariadb://localhost:3306/hk";
		String user = System.getenv().getOrDefault("STUDY_DB_USER", "study");
		String password = System.getenv("STUDY_DB_PASSWORD");
		conn = DriverManager.getConnection(url, user, password);
		return conn; // 연결된 통로 객체를 호출한 곳(DAO)으로 전달
	}
}

public class HkDao extends DataBase{

	public List<HkDto> getAllList(){
		List<HkDto> list = new ArrayList<>();
		String sql = "SELECT SEQ, ID, TITLE, CONTENT, REGDATE FROM HKBOARD ORDER BY REGDATE DESC ";

		try(Connection conn = getConnection(); // 2단계: 부모 클래스에서 연결 통로(conn)를 얻어옴
			PreparedStatement psmt = conn.prepareStatement(sql); // 3단계: DB에 보낼 쿼리문 준비
			){
			try(ResultSet rs = psmt.executeQuery()){
				while(rs.next()) {
					HkDto dto = new HkDto();
					dto.setSeq(rs.getInt(1));          // SEQ 컬럼의 정수값
					// …(2~5번째 열 생략)
					list.add(dto);
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return list;
	}

<%
	//1단계: command값 받기 -> 어떤 요청인지 확인하기 위한 값을 받는다
	String command = request.getParameter("command");
	if (command == null) command = "";

	//2단계: DAO 객체 생성
	HkDao dao = new HkDao();

	//3단계: 요청분기(요청확인하기)
	if(command.equalsIgnoreCase("boardlist")){//글목록요청확인
		//4단계: 파라미터 받기 생략
		//5단계: dao메서드 실행
		List<HkDto>list=dao.getAllList();
		//6단계:Scope객체에 담기
		request.setAttribute("list", list);
		//7단계: 페이지 이동
		pageContext.forward("boardlist.jsp");

	}else if(command.equalsIgnoreCase("boardInsert")){
		String id = request.getParameter("id");
		String title = request.getParameter("title");
		String content = request.getParameter("content");

		boolean isS=dao.insertBoard(new HkDto(id,title,content));
		if(isS){
			//그냥 boardlist.jsp페이지로 가면 안되고,
			//반드시 컨트롤러를 거쳐서 가야 한다 --> list객체가 필요하기 때문
			response.sendRedirect("boardController.jsp?command=boardlist");
		}else{
			response.sendRedirect("error.jsp");
		}
	}
	// …(boardinsertform · boardDetail · boardUpdate · boardDelete · muldel 분기 생략)
%>

<%
	//boardController.jsp에서 전달된 scope객체로부터 list객체를 가져온다.
	List<HkDto> list =(List<HkDto>)request.getAttribute("list");//저장된 객체의 타입은 Object임
%>

public boolean mulDel(String[] seqs) {
	boolean isS = true;
	int[] count= null;// 쿼리 실행 개수 저장
	String sql = "DELETE FROM HKBOARD WHERE SEQ = ?";

	try(Connection conn=getConnection();){
		// 자동 commit 해제 --> rollback할 수 있음
		conn.setAutoCommit(false);

		try(PreparedStatement psmt=conn.prepareStatement(sql)){
			for (int i = 0; i < seqs.length; i++) {
				psmt.setString(1, seqs[i]);//쿼리 하나 완성
				psmt.addBatch();//완성된 쿼리를 준비시켜줌
			}
			count = psmt.executeBatch();//batch 실행 후 결과는 배열반환
			conn.commit();//DB에 반영
		}catch (SQLException e) {
			conn.rollback();// 오류가 나면 성공한 작업 되돌리기
			e.printStackTrace();
		}finally {
			//원래 설정으로 되돌리기
			conn.setAutoCommit(true);
		}
		// count[1,1,1,1,1] 각각의 쿼리가 성공하면 1
		// …(count 배열 검사 생략)
	} catch (SQLException e) {
		e.printStackTrace();
		isS=false;
	}
	return isS;
}

//url-mapping 어노테이션 방식: tomcat7.0부터 지원
@WebServlet(
		 urlPatterns = {"/HelloServlet.do"},
		 initParams = {
				 @WebInitParam(name="name",value="한경닷컴")
		 }
		)
public class HelloServlet extends HttpServlet{

	//init(): 서블릿 객체가 생성될때 최초 한번 실행되는 메서드
	@Override
	public void init() throws ServletException {
		System.out.println("init():최초 한번 실행");
	}

	@Override
	public void init(ServletConfig config) throws ServletException {
		//서블릿에 정의된 초기값 가져오기
		String name=config.getInitParameter("name");
		System.out.println("서블릿 초기값:"+name);

		//ServletContext객체 얻어오기(JSP: application객체)
		ServletContext application=config.getServletContext();
		application.setAttribute("id", "hk");//객체 저장
		System.out.println((String)application.getAttribute("id"));

		//web.xml에 정의하고 가져올 경우
		System.out.println((String)application.getInitParameter("driver"));
	}

	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse respose) throws ServletException, IOException {
		System.out.println("요청주소:"+request.getRequestURL());
		String param = request.getParameter("param");

		PrintWriter out=respose.getWriter();
		out.print("<h1 style='color:blue;'>서블릿개념</h1>");
		out.print("<h2>서블릿에서 받은 파라미터:"+param+"</h2>");
		// …(생략)
		HttpSession session = request.getSession();
		session.setAttribute("id", "hk");
	}

	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		doGet(req, resp);
	}

	@Override
	public void destroy() {
		System.out.println("요청이 더이상 없으면 자동으로 서블릿 객체를 소멸시킨다.");
	}
}