$$config title: 미래융합 자바 keywords: - IT - ... $$ [블로그](https://blog.naver.com/iadslba) # 2/22 ``` package javabasic; //패키지 이름 // 자바는 패키지를 기본으로 하고, 클래스가 기본이다. // public은 접근 지정자 // 변수 앞에는 데이터타입이 있어야 함 // class는 사용자정의 데이터타입(기본 데이터타입을 이용해서 사용자가 정의한 데이터타입) public class a_00_test { // public / protected / private // 프로그램 진입점 -> 시작하는 클래스 // 함수 : 접근 지정자 -> 데이터를 보호하기 위해서 // 함수는 리턴해야 함 -> void는 리턴하지 않는다. // 함수는 괄호와 함께 함 // String은 문자열을 지정할 때, []는 배열을 받을 때 public static void main(String[] args) { // static은 정적함수 // 데이터입력 -> 처리 -> 출력 int a = 100; // ;은 문장종료점 int b = 200; int c = a+b; // 처리 System.out.println(c); // 출력 } } ``` ``` package javabasic; public class a_01_variables { public static void main(String[] args) { System.out.println("대한민국"); //오버로딩 //System.out. System.out.println("천 안 시"); String str = "대전시"; // ' 싱글 쿼테이션: 문자, " 더블 쿼테이션:문자열인 경우 // 변수는 물리적 주소 위치를 가리킴 String str2 = "공주시"; str = "만세"; System.out.println(str+ "에 살아요 "); System.out.println(str2 + "에 살아요 "); int korea = 90; korea = 97; int english = 100; int result = korea + english; float average = result / 2.0f; // float타입의 데이터는 값에 f를 붙여준다., 정수 나누기 정수도 결과가 부동소수점이 될 수 있음. System.out.println("평균은 "+average); // Math는 클래스, static함수들로 구성되어있음. // 클래스는 인스턴스를 해야함.->Math는 인스턴스하지 않고 사용하고 있음(static함수로 구성되어있어서) System.out.println("평균은 "+Math.round(average)); // 문제 // 3.141592를 변수에 대입하고 출력해보세요. final float pi = 3.141592f; // final을 넣으면 상수가 됨. System.out.println(pi); // 소수점 4째자리에서 반올림해주세요. float shortpi = Math.round(pi*1000)/1000f; System.out.println(shortpi); System.out.println(); // 증감연산자 int i =5; i++; // i=i+1 후위 증가연산자 System.out.println(i++); System.out.println(i); i=5; ++i; // 전위 증가연산자 System.out.println(i); //6 System.out.println(i++); //6->7 6출력 System.out.println(++i); //7->8 8출력 System.out.println("십의 삼승 "+Math.pow(10, 3)); // power System.out.println(); // 데이터 변환 -> 데이터가 송수신 될 때는 문자로 변환 // 데이터 타입과 데이터가 불일치하면 입력이 안됨. int num = 200; // 변수는 사용 // String은 문자열을 다루는 class, new없이 특이하게 인스턴스화 된거.(valueOf 함수 때문에) String s = String.valueOf(num); // valueOf 함수로 숫자에서 문자열로 데이터타입 변환 System.out.println(i+100); System.out.println(s+100); // Integer는 Wrapper class int num1 = Integer.parseInt(s); // parseInt함수로 문자열에서 숫자로 데이터타입 변환 System.out.println(num1); // class는 인스턴스 되어야 함 -> class는 사용자정의 데이터타입 boolean isExisted = false; // true/false 예약 System.out.println(isExisted); double d1 = 123456.56; System.out.println(d1); } } ``` ``` package javabasic; public class a_02_binary { public static void main(String[] args) { System.out.println(Integer.toBinaryString(8)); // 128, 64, 32, 16, 8, 4, 2, 1 // 0 0 0 0 1 0 0 0 System.out.println(Integer.toBinaryString(10)); // 128, 64, 32, 16, 8, 4, 2, 1 // 0 0 0 0 1 0 1 0 System.out.println(Integer.toBinaryString(-8)); // 보수를 취함 // 128, 64, 32, 16, 8, 4, 2, 1 // 1 1 1 1 0 1 1 1 -> 2의 보수 +1 // 1 1 1 1 1 0 0 0 // int형이 4byte니까 32비트 그래서 11111111/11111111/11111111/11111000 나옴 // 문제 // 48을 이진수로 만들어보고 toBinaryString을 이용해서 확인해보시오. System.out.println(Integer.toBinaryString(48)); // 128, 64, 32, 16, 8, 4, 2, 1 // 0 0 1 1 0 0 0 0 System.out.println(Integer.toBinaryString(-48)); // 128, 64, 32, 16, 8, 4, 2, 1 // 1 1 0 0 1 1 1 1 +1 // 1 1 0 1 0 0 0 0 System.out.println(); int temp = 8 >> 1; // bit shift 하시요 // 1 0 0 0 -> 0 1 0 0 옆으로 한칸 이동해서 8에서 4됨. int temp1 = 8 << 1; System.out.println(temp); System.out.println(temp1); System.out.println(); // &:and연산자, |:or연산자 int x = 123; int y = 205; System.out.println(Integer.toBinaryString(x)); // 01111011 System.out.println(Integer.toBinaryString(y)); // 11001101 // and 01001001 ->73 // or 11111111 ->255 // xor 10110110 ->or연산자의 반대(false+false->false, true+true->false) int z = x^y; // 송신자, ^ -> xor System.out.println(z); System.out.println(Integer.toBinaryString(z)); int t = z^y; // 수신자 System.out.println(Integer.toBinaryString(t)); System.out.println(); // 비교 : 관계연산자 ( >, >=, < , <=, ==) -> 결과값 : true/false // 숫자 -> 큰수 // 문자 -> ascii code 순 (8비트->256가지, unicode UTF-8로 통일: 2바이트 문자열) // A:65, a:97 x= 10; y =-10; int absX = (x>=0) ? x:-x; int absY = (y>=0) ? y:-y; System.out.println("x= " +absX); System.out.println("y= " +absY); } } ``` ``` package javabasic; public class a_03_math { public static void main(String[] args) { System.out.println(Math.max(5, 10)); System.out.println(Math.min(5, 10)); System.out.println(Math.abs(-4.1)); // 절대값(absolute) System.out.println(Math.random()); // 의사난수(난수는 아닌데 난수처럼 만들어졌다?):0~1사이의 임의의 부동소수점을 리턴 // 1은 포함이 안됨 System.out.println(Math.sqrt(64)); // root System.out.println(Math.pow(10, 3)); // 승수 10의 3제곱 System.out.println(Math.log(28)); System.out.println(Math.log10(28)); System.out.println(Math.exp(3)); System.out.println(); // 삼각함수 : 회전하거나 두 벡터의 사이각을 구할 때 사용 // 컴퓨터에서는 각도 개념으로 사용하지 않고 radian 개념으로 사용 // sin(30) 30도 대신에 라디안을 사용 // toDegrees // 원의 지름을 1로 한 경우에 그 각도에 해당되어지는 호의 길이가 라디안이다. double b = Math.toRadians(10); // 각도 -> 라디안 System.out.println(Math.sin(b)); System.out.println(); // 문제 // random을 이용해서 0~100 사이의 정수형 값을 만들어 보세요. int randomNum1 = (int)(Math.random()*101); // 숫자에서 타입의 변환 double->int System.out.println(randomNum1); System.out.println(); // 문제 // cos 30도의 값을 계산한 다음 그 결과를 다시 각도로 변환해보시오. double angle = Math.toRadians(30); System.out.println(Math.toDegrees(angle)); //cos은 길이의 비(반지름이 1인 상태에서의 길이의 비) double cosvalue = Math.cos(angle); // 밑변은 0.866 System.out.println(cosvalue); // 길이의 비로부터 호의 길이로 변경해주는 것이 acos // 0.00000000000000000002812-> 0으로 본다. System.out.println(Math.toDegrees(Math.acos(cosvalue))); //29.999->30 System.out.println(); // 문제 // 32는 자연대수의 몇 승인가? 자연대수는 e // 32는 밑수 10의 몇 승인가? System.out.println(Math.log(32)); System.out.println(Math.log10(32)); // 문제 // 두 변의 사이각이 45도일 때 대각선의 길이가 28이라면 이때 밑변의 길이는 얼마인가? double angle45 = Math.toRadians(45); System.out.println(28*Math.cos(angle45)); System.out.println(); // 밑변이 8, 높이가 4라면 각도는 얼마인가? double tanheta = 4/8.0; System.out.println(Math.toDegrees(Math.atan(tanheta))); } } ``` ``` package javabasic; public class a_04_casting { public static void main(String[] args) { int myInt = 9; //int는 4byte double myDouble = myInt; // 암묵적 캐스팅, double은 8byte System.out.println(myInt); System.out.println(myDouble); // 작은 사이즈에서 큰 사이즈로 변경되는 암묵적 캐스팅이 자동으로 실행 double myDouble1 = 9.78d; int myInt1 = (int)myDouble1; // 큰 것에서 작은 것으로 갈 때는 명시적 캐스팅을 해야함.(int)이렇게 System.out.println(myDouble1); System.out.println(myInt1); System.out.println(myInt1 + myDouble1); // 연산:int+double 연산가능, 묵시적으로 사이즈 큰 것으로 캐스팅 됨. } } ``` # 2/23 ``` package javacontrol; public class b_01_condition { public static void main(String[] args) { int x = 10; // 데이터입력 : 초기화 System.out.println(x++);//10 -> 11 10출력 System.out.println(++x);//12 System.out.println(x--);//12 -> 11 12출력 System.out.println(--x);//10 int a = 10; int b = 10; System.out.println(a++ + ++a);//10+12 = 22 System.out.println(b++ + b++);//10+11 = 21 System.out.println(b);//12 System.out.println(); boolean c = true; // 1과 의미가 같음 c =! c; // !는 논리연산자 -> 단항연산자 System.out.println(c);//false c =! c; System.out.println(c);//true System.out.println(); a = 10; // 값 수정 b = 5; int d = 20; // 초기화 System.out.println(a < b && a < d);//false && true => false System.out.println(a < b & a < d);//false(0) & true(1) => 0(false) System.out.println(a < b || a < d);//false || true => true a+=1; // a = a+1 a/=100; // a = a/100 System.out.println(a);//0 System.out.println(); int number = -13; if(number > 0) { System.out.println("긍정(POSITIVE)"); }else if(number<0) { System.out.println("부정(NEGATIVE)"); }else { System.out.println("ZERO"); } // 단일명령일 경우에는 block 생략 가능, block은 처리명령의 집합이다. if(number>0) System.out.println("긍정(POSITIVE)"); else if(number<0) System.out.println("부정(NEGATIVE)"); else System.out.println("ZERO"); } } ``` ``` package javacontrol; import java.util.Scanner; // 임력용 public class b_02_if_test { // 입력된 월을 계절로 매핑하는 프로그램 public static void main(String[] args) { // class는 instance를 실행 // new가 동적메모리 할당 명령 -> Heap에 저장 -> 변수는 Stack에 생성 // 메모리를 분할:Heap(작은 메모리로 대량의 데이터처리)/Stack(함수호출의 복귀주소) // 장치를 사용하거나, 네트워크를 사용하거나, db를 사용할 때는 반드시 명시적으로 close 해줘야 한다. // Scanner input은 Stack에, new Scanner(System.in)은 Heap에 Scanner input = new Scanner(System.in); // 클래스 초기화 매개변수(장치)->키보드 System.out.print("월을 입력하시요"); // 설명 int month = input.nextInt(); // 입력을 받으시요 String season = null; // Stack에 String season 만들어짐. if(month==12||month==1||month==2) { season = "겨울"; }else if(month ==3||month==4||month==5) { season = "봄"; }else if(month==6||month==7||month==8) { season = "여름"; }else if(month==9||month==10||month==11) { season = "가을"; }else { season = "없는 계절"; } System.out.println(month + "월은 " + season + "입니다."); //switch case문:변수에 따라서 분기 시키고 싶은 경우 System.out.print("월을 입력하시요"); month = input.nextInt(); season=null; switch(month) { // 변수의 경우의 수에 대하여 분기 case 12: case 1: case 2: season="겨울"; break; case 3: case 4: case 5: season="봄"; break; case 6: case 7: case 8: season="여름"; break; case 9: case 10: case 11: season="가을"; break; default: season="없는 계절"; } System.out.printf("%d월은 %s입니다",month,season); // format문자열(digit,string) input.close(); } } ``` ``` package javacontrol; // 키보드 입력 -> 버퍼(숫자 + enter 입력) import java.util.Scanner; public class b_03_if_problem { public static void main(String[] args) { // 문제 // 나이는 성년(18), 체중은 50이상인 사람만 헌혈이 가능하다. // age=25, weight=48인 사람의 헌혈여부를 결정하는 프로그램을 작성하시요. // 경우의 수는 4가지가 발생 // age>=18, weight>=50 // age>=18, weight<50 // age<18, weight>=50 // age<18, weight<50 Scanner input = new Scanner(System.in); System.out.print("나이를 입력하시오>>"); int age = input.nextInt(); System.out.print("체중을 입력하시오>>"); int weight = input.nextInt(); if(age>=18) { if(weight>=50) { System.out.println("헌혈이 가능합니다."); }else { System.out.println("헌혈이 불가능합니다."); } }else { System.out.println("헌혈이 불가능합니다."); } if(age>=18 && weight>=50) { System.out.println("헌혈 가능"); }else if(age>=18&& weight<50){ System.out.println("체중미달로 헌혈 불가능"); }else if(age<18 && weight >=50) { System.out.println("나이제한으로 헌혈 불가능"); }else { System.out.println("체중미달과 나이제한으로 헌혈 불가능"); } // 문제 // 숫자 하나를 입력 받아서 홀수, 짝수인지 판정해 출력하는 프로그램을 작성하시오. System.out.print("숫자를 입력하시오>>"); int num = input.nextInt(); // enter가 남아있음 if(num%2==0) { // / 나누기, % 나머지 연산자 System.out.println("짝수"); }else { System.out.println("홓수"); } // 문제 // 주급 40시간까지는 시간당 100,000원으로 계산하고 40시간 이상이면 초과인 시간에 대하여 150,000원으로 계산한다. // 주 작업시간을 입력받아서 위의 계산조건으로 계산한 결과를 출력하세요. // 입력되어질 변수 // 작업시간 : hours // 주급여 : pay // 기본시간 : basictime // 시간당 급여 : paypertime // 초과시간당 급여 : payperovertime int hours; int pay; final int basictime = 40; final int paypertime = 100000; final int payperovertime = 150000; System.out.print("작업시간 입력>>"); hours = input.nextInt(); if(hours > basictime) { pay = basictime + paypertime; pay += (hours - basictime) * payperovertime; } else { pay = hours * paypertime; } System.out.printf("당신의 주급은 %d %s %s입니다.\n",pay,"원","정"); // optimization 최적화 => 저장공간을 효휼적으로 사용하고 처리속도를 높일 수 있는 방법을 찾아야한다. // 문제 // 점수를 입력받아서 학점으로 매핑하는 프로그램을 작성하시오(switch case) input.nextLine(); // enter를 제거 System.out.print("점수입력>> "); String imsi = input.nextLine(); int score = Integer.parseInt(imsi); char grade =' '; switch(score/10){ case 10: case 9: grade = 'A'; break; case 8: grade = 'B'; break; case 7: grade = 'C'; break; case 6: grade = 'D'; break; default: grade = 'F'; break; } System.out.println(grade); input.close(); } } ``` ``` package javacontrol; import java.util.Scanner; public class b_04_switch { public static void main(String[] args) { // 문제 // 2월달 윤달을 고려해서 말일을 결정하는 프로그램의 작성 // 1:31 2 3:31 4:30 5:31 6:30 7:31 8:31 9:30 10:31 11:30 12:31 // 연도를 4로 나누어서 떨어지는 해이면서, 100으로 나누어서 떨어지지 않으면 윤년이고 // 400으로 나누어서 떨어지면 윤년입니다. // 위를 고려해서 연도와 달을 입력하면 말일을 출력하는 프로그램을 작성하세요.(switch case) // 경우의 수 : 31일, 30일, 변동이 있는 경우(3가지) Scanner input = new Scanner(System.in); System.out.print("년도:"); int year = input.nextInt(); System.out.print("월:"); int month = input.nextInt(); if (month>12)month = month%12 +1; // 1~12월을 만들기 위해 나머지에 1을 더해줌 input.nextLine(); // enter를 제거 int numDays = 0; switch(month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31; break; case 4: case 6: case 9: case 11: numDays = 30; case 2: // 논리연산자도 연산의 우선순위가 있음. 단항연산자(!)->&&->|| if(((year % 4 ==0)&& !(year % 100 ==0))||(year %400 ==0)) numDays = 29; else numDays = 28; break; default: System.out.println("해당 월이 없습니다."); break; } System.out.println("해당 월의 말일은 = "+numDays); input.close(); } } ``` ``` package javacontrol; public class b_05_for { public static void main(String[] args) { for(int i = 1;i <= 10; i++) { if(i==5) { continue; // 5는 출력하지 않고 다음꺼 실행 } if(i==7) { break; // 7부터 찍히지 않음 } System.out.print(i+" "); } int hab = 0; for(int i =1;i <= 10; i++) { hab+=i; System.out.print(" "+hab); } System.out.println("\n1부터 10까지의 합="+hab); System.out.println(); // 2중 for문 // for문을 벗어난 초기화된 변수는 증가한 값으로 남아있음 // 2중 for문에서 break문은 해당하는 for문에만 영향을 미침 for(int i = 1;i<=3;i++) { for(int j =1;j<=3;j++) { System.out.println(i+" "+j); } } System.out.println(); // 문제 // 위의 2중 for문에서 i=2, j=2인 경우에 중지시키시오. for(int i = 1;i<=3;i++) { for(int j =1;j<=3;j++) { if(i==2 && j==2) { break; } System.out.println(i+" "+j); } } } } ``` ``` package javacontrol; // 프로그래밍은 처리 순서가 중요 import java.util.Scanner; public class b_06_while { public static void main(String[] args) { int i=1; while(i<=10) { //i++; 순서를 바꾸면 처음값이 2가 되고 11이 마지막 값 System.out.print(i); i++; //1부터 10이 찍힘 } System.out.println(); i=1; do { System.out.print(i); i++; }while(i<=10); System.out.println(); // 문제 // 유저는 숫자를 입력받아서 컴퓨터가 생성한 숫자를 맞추는 게임입니다. // 컴퓨터는 난수를 이용해서 1부터 100까지의 숫자를 선택합니다. // 유저는 숫자를 입력해서 컴퓨터가 선정한 숫자를 맞춥니다. // 게임이 종료되면 몇번 입력했는지 입력횟수를 출력하세요. //필요한 데이터 : 컴퓨터가 선택한 수(int), 입력한 값(int), 입력횟수를 카운트할 변수(int) // 추가 문제 // 게임이 끝나면 ?전 ?승 ?패를 출력하도록 여러번 게임이 가능하도록 수정해보세요. // 증감에 -1이 입력되거나 번데이터가 들어오면 중지하도록 수정해보세요. // 입력된 내용이 없는 확인하고자 할 때는 문자열로 입력받아서 isEmpty()함수 사용 // 문자열비교는 equals("-1") // input.isEmpty(), input.equals("-1") int answer = 0; int input = 0; int count = 0; Scanner sc = new Scanner(System.in); int battle = 0; int win = 0; String temp = ""; // 게임여부를 받을 변수 while(true) { System.out.println("게임을 시작합니다.(시작은 y, 종료는 -1)"); temp = sc.nextLine(); if(temp.isEmpty() || temp.equals("-1")) { break; } battle += 1; answer = (int)(Math.random()*100)+1; do { count++; //input = sc.nextInt(); input = Integer.parseInt(sc.nextLine()); // 한줄 입력이 가능 if(answer > input) { System.out.println("숫자가 너무 작습니다."); }else if(answer < input) { System.out.println("숫자가 너무 큽니다."); }else { System.out.println("정답입니다."); System.out.println("입력하신 횟수는 "+count+"입니다."); win += 1; break; } }while(true); }System.out.printf(" %d전 %d승 %d패 입니다.",battle,win,battle-win); sc.close(); } } ``` ``` package javacontrol; public class b_07_star_pattern { public static void main(String[] args) { int row = 10; for( int i =0; i < row;i++) { for(int j = 0; j < row;j++) { System.out.print("* "); } System.out.println(); } System.out.println(); for( int i =0; i < row;i++) { for(int j = 0; j < i;j++) { System.out.print("* "); } System.out.println(); } System.out.println(); for(int i = 1;i < row;i++) { for(int j = row; j > i;j--) { System.out.print("* "); } System.out.println(); } System.out.println(); for(int i = 1;i < row;i++) { for(int j = row-1 ; j >= i;j--) { System.out.print(" "); } for(int j = 1; j <= i;j++) { System.out.print("* "); } System.out.println(); } System.out.println(); for(int i = 1;i < row;i++) { for(int j = row-1 ; j > i;j--) { System.out.print(" "); } for(int j = 1; j <= i;j++) { System.out.print("* "); } System.out.println(); } System.out.println(); // 구구단 for(int i =1;i<=9;i++) { for(int j = 2;j<=9;j++ ) { System.out.printf("%d x %d = %d\t",j,i,j*i); } System.out.println(); } } } ``` # 2/24 ``` package javadarray; // 만약에 stack구조가 없다면 : 작은 코드로 대량의 데이터 처리가 가능 // Heap이 없다면 데이터만큼의 메모리가 있어야 함. public class c_01_array { public static void main(String[] args) { // enhanced for문 // 배열 초기화는 new를 사용하거나 {}를 이용해서 초기화 int arr[] = {2, 11, 45, 9}; // arr은 배열 인스턴스 변수 -> 주소가 저장 for(int num : arr) { // num에 입력되는 것은 데이터 자체임 (인덱스가 아닙) System.out.println(num); } System.out.println(); int a[] = new int[4]; // new는 동적 메모리 할당에 사용 -> Heap // a변수 주소에 가면 배열의 주소를 입력하는 데이터를 저장 // 포인터(주소)를 저장하는 공간을 만듬: Stack // Heap에 4byte int형 데이터를 저장하는 공간을 만들고 그 선두 주소를 a가 가리키는 주소에 저장 // 주소에 있는 주소를 참조하여 데이터를 처리하는 것을 reference변수라고 한다. a[0] = 100; a[1] = 200; a[2] = 300; a[3] = 400; int sum = 0; sum = a[0] + a[1] + a[2] + a[3]; System.out.printf("배열의 총합은 %d입니다.\n",sum); sum = 0; // 배열의 length 속성을 이용해서 개수 파악 가능 for (int i =0;i < a.length;i++) { int temp = a[i]; sum += temp; System.out.println(temp); } System.out.printf("배열의 총합은 %d입니다.\n",sum); System.out.println(); // 문제 // 한 학생의 과목별 점수는 {100, 88, 99, 99, 98}을 배열에 저장하고 // 합계를 계산하고 평균을 계산한 결과를 출력하세요. // 평균에 따라서 학점을 부여하시오. int score[]={100, 88, 99, 99, 98}; sum = 0; float average = 0f; for(int x : score) { sum += x; } average = sum/score.length; System.out.println("합계 = "+sum); System.out.println("평균 = "+average); // 소수점 이하 자리수 조절 // 연산에서 조절된 수치를 사용할 때는 round처리 (올림(ceil), 반올림(round), 내림(floor) ) System.out.printf("합계는 %d, 평균은 %4.2f 입니다.",sum,average); char grade = ' '; int ave =(int) average/10; switch(ave) { case 10: case 9: grade = 'A'; break; case 8: grade = 'B'; break; case 7: grade = 'C'; break; case 6: grade = 'D'; break; default : grade = 'F'; } System.out.println("학점 = "+grade); } } ``` ``` package javadarray; public class c_02_array { public static void main(String[] args) { int a[][] = new int[3][2]; // 행렬 = 배열 + 선형대수 : 공간만 확보 a[0][0] = 10; a[0][1] = 20; a[1][0] = 30; a[1][1] = 40; a[2][0] = 50; a[2][1] = 60; for(int i = 0; i < a.length; i++) { // 행 : 더디게 진행 for(int j = 0; j < a[i].length; j++) { // 열 : 빠르게 진행 : 2차원 배열에서 행을 의미하는 단일 대괄호 System.out.print(a[i][j] + " "); } System.out.println(); } System.out.println(); int b[][] = {{10,20}, {30,40}, {50,60}}; for(int i = 0; i < b.length; i++) { for(int j = 0; j < a[i].length; j++) { System.out.print(b[i][j] + " "); } System.out.println(); } System.out.println(); // 비정방형 배열 만들기 int arr3[][] = new int [3][]; // 행만 3개로 결정 arr3[0] = new int[3]; // 첫번째 행에는 3개 열을 arr3[1] = new int[4]; // 두번째 행에는 4개 열을 arr3[2] = new int[2]; // 세번째 행에는 2개 열을 생성 int count = 1; for(int i =0;i < arr3.length; i++) { for(int j = 0;j< arr3[i].length; j++) { arr3[i][j] = count++; } System.out.println(count); } System.out.println(); // 문제 // 위의 입력된 데이터를 출력해보시오. for(int i =0;i < arr3.length; i++) { for(int j = 0;j< arr3[i].length; j++) { System.out.print(arr3[i][j] + " "); } System.out.println(); } System.out.println(); } } ``` ``` package javadarray; public class c_03_sort { public static void main(String[] args) { // CRUD (create, read, update, delete) // 비교 int score[] = {79, 88, 91, 33, 100, 55, 95}; int max = score[0]; // 별도의 공간확보(초기화 시킨다) int min = score[0]; // 초기화 과정 int maxcount = 0; int mincount = 0; for(int i = 1; i < score.length; i++) { if(score[i] > max) { max = score[i]; // 대입을 통해 수정 // 79 -> 88 -> 91 -> 91 -> 100 -> 100 -> 100 maxcount += 1; } if(score[i] < min) { min = score[i]; // 79 -> 79 -> 79 -> 33 -> 33 -> 33 -> 33 mincount += 1; } } System.out.println("최대값 : " + max+"\t바뀐회수 : "+maxcount); System.out.println("최대값 : " + min+"\t바뀐회수 : "+mincount); System.out.println(); // 정렬 int number[] = new int[10]; for(int i = 0; i < number.length; i++) { number[i]=i; System.out.print(number[i]+ " "); } System.out.println(); // shuffling // 메모리의 특성(두 개의 변수 간의 데이터를 직접 교환하는 것이 불가능) for(int i =0; i <100; i++) { int n = (int)(Math.random()*10); // 인덱스를 랜덤하게 int temp = number[0]; number[0] = number [n]; number[n] = temp; } for(int i = 0; i < number.length; i++) { System.out.print(number[i]+ " "); } System.out.println(); // 버블 정렬 // 오름차순 ascending : asc // 내림차순 descending : des // 내림차순으로 바꿔보세요. // 최적화 - 한 회전에서 변화가 없으면 정렬된 상태입니다. 최적화시켜보세요. // 변화여부를 감지하는 변수 changed : boolean for(int i = 0; i < number.length; i++) { // 행 수만큼 회전 boolean changed = false; // 행마다 초기화가 되어야 하기 때문에 for(int j=0; j < number.length-i -1; j++) { // 열 수만큼 회전 if(number[j] > number[j+1]) { // 인접한 데이터 2개를 비교 // 부등호 < 로 바꾸면 내림차순으로 됨 int temp = number[j]; number[j] = number[j+1]; number[j+1] = temp; changed = true; } } if(!changed) break; System.out.print(number[i]+" "); } System.out.println(); } } ``` ``` package javadarray; public class c_04_string_compare { public static void main(String[] args) { String str1 = "Hello"; String str2 = "World"; String str3 = "Hello"; // equals -> 문자열 동일여부 System.out.println("str1.equals(str2) : "+str1.equals(str2)); System.out.println("str2.equals(str1) : "+str2.equals(str1)); System.out.println("str1.equals(str3) : "+str1.equals(str3)); // compareTo -> 문자열 비교한 다음에 앞이 크면 정수, 같으면 0, 앞이 작으면 음수를 출력 System.out.println("str1.compareTo(str2) : "+str1.compareTo(str2)); System.out.println("str1.compareTo(str3) : "+str1.compareTo(str3)); System.out.println("str2.compareTo(str3) : "+str2.compareTo(str3)); // IgnoreCase -> 대소문자를 불문하고 System.out.println("str1.compareToIgnoreCase(str3) : "+str1.compareToIgnoreCase(str3)); System.out.println(); // 문제 // 다음을 배열에 입력하고 {"대한","민국","만세","한국","대전"} 정렬하는 프로그램을 작성해보세요. String str[] = {"대한","민국","만세","한국","대전"}; for(int i=0; i < str.length; i++) { for(int j=0; j < str.length-i -1; j++) { if(str[j].compareTo(str[j+1])>0) { // 오름차순 String temp = str[j]; str[j]=str[j+1]; str[j+1]= temp; temp = str[j]; } } } for(int i = 0; i < str.length;i++) { System.out.print(str[i]+" "); } System.out.println(); } } ``` ``` package javadarray; public class c_05_sungjuk { public static void main(String[] args) { // 문제 // 배열을 이용해서 점수를 입력하고 합계와 평균을 계산한 다음 출력하시오. // 배열은 동질적 데이터만 처리 가능 // 데이터 타입은 이름:string, 점수:int, 평균:double // 배열 3개가 필요 // 입력 -> 처리 -> 출력 // 변수와 데이터타입 결정 : 이름:string 1차원 배열, 성적:int 2차원 배열, 평균:double 배열 // 3가지를 통일 시키는 것 -> 인덱스에 의해 구분 // 입력 String name[] = {"대한","민국","만세"}; int sungjuk[][] = {{90,90,90,0},{89,89,89,0},{90,99,99,0}}; double avg[] = new double[3]; // 처리 for(int i = 0; i < avg.length;i++) { int tot =0; for(int j = 0; j < avg.length;j++) { tot += sungjuk[i][j]; } sungjuk[i][3] = tot; avg[i] = tot/3.0; } // 출력 System.out.println("----< 성적 계산표 >----"); System.out.println("이름 국어 영어 수학 합계 평균"); for(int i =0; i < name.length;i++) { System.out.print(name[i]+" "); for(int j = 0; j < sungjuk[i].length; j++) { System.out.print(sungjuk[i][j]+" "); } System.out.print(avg[i]); System.out.println(); } } } ``` // 팀별과제 // 1.홀짝게임을 만들어보세요(경우의 수 2가지) 컴퓨터는 random, 유저는 입력 // 2.가위바위보게임을 만들어보세요(경우의 수 9가지,컴3가지,컴퓨터3가지) 컴퓨터는 random, 유저는 입력 ``` package javadarray; import java.util.Scanner; public class c_06_홀짝 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while(true) { int com = (int)(Math.random()*2); System.out.println("컴퓨터:"+com); System.out.print("홓(1),짝(0) >> "); int user = sc.nextInt(); if(user == com) { System.out.println("정답"); break; }else { System.out.println("땡"); } } sc.close(); } } ``` ``` package javadarray; // 입력(컴,사람) 처리(if) 출력(print) import java.util.Scanner; public class c_07_가위바위보 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while(true) { int computer = (int)(Math.random()*3); String com = ""; if (computer == 0) { com = "가위"; }else if(computer == 1) { com = "바위"; }else if(computer ==2) { com ="보"; } System.out.println("컴퓨터:"+com); System.out.println("가위(0),바위(1),보(2) 입력>>"); int user = sc.nextInt(); if(user == computer) { System.out.println("비겼습니다."); }else if(user==0) { if(computer==1) { System.out.println("졌습니다."); }else if(computer==2){ System.out.println("이겼습니다."); break; } }else if(user==1) { if(computer==2) { System.out.println("졌습니다."); }else if(computer==0){ System.out.println("이겼습니다."); break; } }else if(user==2) { if(computer==0) { System.out.println("졌습니다."); }else if(computer==1){ System.out.println("이겼습니다."); break; } }else { System.out.println("다시 입력해주세요."); } } // 선생님 풀이 Scanner input = new Scanner(System.in); int count = 0; int win = 0; int draw = 0; int lose = 0; String judge[] = {"비겼습니다","이겼습니다","졌습니다"}; sc.nextLine(); // sc에서 남아있던 enter 제거해야함. while(true) { System.out.println("가위(0)/바위(1)/보(2)중에 하나를 선택하시요(9는 종료)"); int person = Integer.parseInt(input.nextLine()); if(person == 9) { // 무한루프 방지를 위한 종료 break; } int com = (int)(Math.random()*3); person %= 3; com %= 3; count += 1; int result = 0; if(person == 0) { if(com == 0) { result = 0; }else if(com == 1) {result = 2; }else if(com == 2) result = 1; }else if(person == 1) { if(com == 0) { result = 1; }else if(com ==1) {result = 0; }else if(com ==2) result = 2; }else if(person == 2){ if(com == 0) {result = 2; }else if(com == 1) {result = 1; }else if(com == 2) result = 0; } switch(result) { case 0 : draw+=1; break; case 1 : win+=1; break; case 2 : lose+=1; break; } System.out.println("게임결과:"+judge[result]); } System.out.println("------ 게임결과 : "+ count + "전 "+ win + "승 "+ draw +"무 "+ lose + "패--\n"); sc.close(); input.close(); } } ``` # 2/27 ``` package kfunction_pkg; public class d_01_method { // class 자체가 사용자 정의 데이터 타입 -> 메모리를 확보 -> 인스턴스 public static void main(String[] args) { int num1 = 100; int num2 = 200; int result = num1 + num2; System.out.println(result); float output = add(num1,num2); output = add(300,400); output = add(500,600); System.out.println("덧셈결과:"+output); float output1 = multiply(200,300); float output2 = divide(200,300); float output3 = substract(200,300); System.out.println("200*300="+output1); System.out.println("100/300="+output2); System.out.println("200-300="+output3); } // 코드 중복의 방지, 1번을 실행하더라도 함수로 생성하는 것이 유리 - 수정, 유지보수가 편리함 // 오버로딩(overloading):함수 이름은 같되 매개변수 타입이 다르거나 매개변수 개수가 다르면 다른 함수로 인식하자. public static float add(int num1, int num2) { // 매개변수를 입력으로 float result = num1 + num2; return result; } // 문제 // * multiply, / divide, - subtract : 두 수를 입력받아서 곱셈, 나눗셈, 빼기 연산을 하는 함수를 작성하시고 // 입력으로 100, 200를 전달해 함수호출결과를 출력하시오. public static float multiply(int a, int b){ float result = a * b; return result; } public static float divide(float a, float b){ float result = a / b; return result; } public static float substract(int a, int b){ float result = a - b; return result; } } ``` ``` package kfunction_pkg; // 프로그램은 순차적으로 실행 // 분기 : if, for, 함수분기, 클래스 영역 분기 public class d_02_method_order { int b; // 멤버변수 int c; static String name; // static 변수 : 한번만 만들어지는 변수, 클래스 공유변수 public static void main(String[] args) { System.out.println("프로그램 시작 첫 함수 호출 "); staticMethod1(); // 함수 영역으로 분기 System.out.println("첫번째 함수 호출 종료"); staticMethod1(); System.out.println("첫번째 함수 호출 종료"); staticMethod2(); System.out.println("두번째 함수 호출 종료"); System.out.println("메인으로 복귀"); System.out.println("종료합니다"); System.out.println(); // cal(3); } public static void staticMethod1(){ // stack영역에 생성 -> 함수화 생명을 같이 함 // 함수처리에 필요한 모든 데이터는 stack에 저장되어야 함 -> 주소로 참조하는 것도 가능(이때는 참조변수가 stack에 만들어져야 함) int a = 10; // 지역변수(local variables) System.out.println("- 첫 함수 진입"); System.out.println(a); staticMethod2(); System.out.println("두번째 함수 호출 종료"); } public static void staticMethod2(){ System.out.println("= 두번째 함수 진입 "); System.out.println("두번째 함수 종료 "); } // 문제 // y = ax^2 + bx + x일 때 이를 함수로 구현하고 a=2, b=4, c=1일 때 // x가 2라면 어떤값이 리턴하는지 확인해 출력하시오. public static int cal(int x){ int a = 2; int b = 4; int c = 1; // casting에 필요한 함수(pow) -> double써야함 int result = a*(int)Math.pow((double)x, 2) + b*x + c; System.out.println("y = "+result); return result; // 함수 return type(void자리)이 정해져 있으니까 꼭 return을 해줘야함. void면 return 안 씀. } } ``` ``` package kfunction_pkg; public class d_03_return_array { static int[] makeArray() { // 주소값을 리턴 int temp[] = new int [4]; // heap에 정수형 데이터 4개를 저장하는 영역을 만들고 그 주소를 대입 for(int i=1;i < temp.length+1;i++) { temp[i-1] = i*100;} // 100,200,300,400 return temp; } // Garbage Collection은 참조가 0이 되면 메모리를 해제 public static void main(String[] args) { int returnArray[]; // 주소값:reference, 데이터를 참조 returnArray = makeArray(); for(int i=0;i < returnArray.length;i++) { System.out.println(returnArray[i]); } System.out.println(); //1 returnArray = Array(); int sum = 0; for(int i=0;i < returnArray.length;i++){ sum+=returnArray[i]; } System.out.println("합계 = "+sum); System.out.println(); //2 int data[]= {10,20,30,40}; System.out.println("합계 = "+makehab(data)); int temp[]= new int[4]; for(int i=0;i < temp.length;i++) { temp[i]=(i+1)*10; //temp배열에 1부터 100까지 집어넣은거 } System.out.println("합 = "+makehab(temp)); System.out.println(); //3 temp=makeArray2(4,10); System.out.println(makehab(temp)); } // 문제 // main함수에서 10,20,30,40 배열을 만들어서 함수를 만들어 배열을 전달받고 전달받은 배열의 모든 데이터를 // 합계를 내서 리턴 받은 다음 메인에서 출력하시오. //1 static int[] Array() { int a[] = new int [4]; for(int i=0;i < a.length;i++) { a[i] = (i+1)*10; } return a; } //2 // call by reference라고 함 -> 데이터가 여러개를 담고 있는 변수 - 배열,class static int makehab(int data[]) { // 추상화 int hab = 0; for(int i=0; i < data.length;i++) { hab += data[i]; } return hab; } //3 // call by value static int[] makeArray2(int count, int basic) { int temp[]=new int[count]; for(int i = 1; i < temp.length+1;i++) { temp[i-1] = i*basic; } return temp; } } ``` ``` package kfunction_pkg; public class d_04_swap { public static void main(String[] args) { int a1 = 30; int b1 = 45; System.out.println("교환 전, a1 = "+a1+" b1 = "+b1); swapFunction(a1,b1); // 값이 바뀌지 않은 이유는 값으로 전달되었기 때문에 System.out.println("교환 후, a1 = "+a1+" b1 = "+b1); System.out.println(); //1 int x[] = {20,10,40,80,100}; printarray(x); System.out.println(); //2 // 배열교환 // call by reference int a[] = {4,1,2}; int b[] = {2,1,6}; printarray(a); printarray(b); swap(a,b); // 호출한 곳에 데이터 교환효과가 미침 printarray(a); printarray(b); } // 사용자 정의 함수 public static void swapFunction(int a, int b) { // 호출한 곳으로 영향을 미치지 않는다. System.out.println("교환 전, a = "+a+" b = "+b); int c = a; a = b; b = c; System.out.println("교환 후, a = "+a+" b = "+b); } // 문제 // 배열을 입력받아서 배열에 있는 데이터를 출력하는 함수를 작성하시오. //1 public static void printarray(int x[]) { for(int i =0;i < x.length;i++) { System.out.print(x[i]+" "); } System.out.println(); } //2 // 배열에 의한 데이터 전달은 주소에 의한 전달이라 호출한 곳에도 영향을 미침 // 배열에 지정값이 또다른 주소이기 때문에 일일이 교환해 주는 작업을 하지 않으면 교환이 안됨 public static void swap(int x[], int y[]) { // 함수 안에서 데이터를 교환 int temp[] = {x[0],x[1],x[2]}; x[0]=y[0]; x[1]=y[1]; x[2]=y[2]; y[0]=temp[0]; y[1]=temp[1]; y[2]=temp[2]; } } ``` ``` package kfunction_pkg; // 함수 이름은 같되 매개변수 타입과 매개변수 숫자가 다르면 다른 함수로 인식하는 것 : 오버로딩(overloading) // 함수 이름을 데이터 타입마다 기억해야하는 번거로움을 덜어주는 방법 public class d_05_overloading { public static void f(char c) {System.out.println("문자(char)입니다. ");} public static void f(int i) {System.out.println("int형입니다. ");} public static void f(long i) {System.out.println("long형입니다. ");} // public이 없으면 클래스 내부에서만 사용 static void m() {} static void m(int i) { i = 99; } static void m(Integer i) { i = 99; } static void m(int arr[]) { arr[0] = 99; } public static void main(String[] args) { f('a'); f(2); f(2L); // 데이터 타입마다 함수를 만들어서 사용해야 함 m(); int i = 10; m(i); System.out.println(i); //10 바뀌지 않음 Integer val = 10; // 정수 wrapper class라고 함( parseInt() ) m(val); System.out.println(val); //10 얘도 바뀌지 않음 int arr[] = {10,20,30}; m(arr); // reference는 배열, class instance인 경우 : new를 사용하는 경우에 reference가 됨 System.out.println(arr[0]); //99 애는 바뀜:reference로 전달되었을 때는 수정시 원본에 영향을 미침 System.out.println(arr.length); } } ``` ``` package kfunction_pkg; // static이 생략된 경우에는 반드시 인스턴스를 해야함. public class d_06_instance { public long sum(int... temp) {// 변동 매개변수, 배열을 만들어서 데이터를 입력 long sum = 0; for(int i = 0; i < temp.length; i++) { sum+=temp[i]; } return sum; } public static void main(String[] args) { d_06_instance v1 = new d_06_instance(); // class 인스턴스화(class의 데이터를 저장하기 위해서 메모리를 확보) long s1 = v1.sum(1,2); System.out.println(s1); long s2 = v1.sum(1,2,3,4); System.out.println(s2); } } ``` ``` package kfunction_pkg; import java.util.Scanner; public class d_07_가위바위보1 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while(true) { int computer = (int)(Math.random()*3); String com = ""; if (computer == 0) { com = "가위"; }else if(computer == 1) { com = "바위"; }else if(computer ==2) { com ="보"; } System.out.println("컴퓨터:"+com); System.out.println("가위(0),바위(1),보(2) 입력>>"); int user = sc.nextInt(); System.out.println(game(computer,user)); String result = game(computer,user); if(result=="이겼습니다.") { break; } } sc.close(); } public static String game(int computer, int user) { String ret=""; if(user == computer) { ret="비겼습니다."; }else if(user==0) { if(computer==1) { ret="졌습니다."; }else if(computer==2){ ret="이겼습니다."; } }else if(user==1) { if(computer==2) { ret="졌습니다."; }else if(computer==0){ ret="이겼습니다."; } }else if(user==2) { if(computer==0) { ret="졌습니다."; }else if(computer==1){ ret="이겼습니다."; } } return ret; } } ``` 선생님 풀이↓ 가위바위보 // 매개변수, 배열, +1해서 하는거 ``` package kfunction_pkg; // 가위:0,바위:1,보:2 // 결과: 비김:0,승리:1,패배:2 // 객체:user,com,judge // 판단 테이블 // 0 1 2 (유저) //0 0 1 2 //1 2 0 1 //2 1 2 0 import java.util.Scanner; public class d_07_가위바위보_정답 { public static void main(String[] args) { String judge[] = {"비겼습니다","이겼습니다","졌습니다"}; Scanner person = new Scanner(System.in); int input; int count=0; int victory=0; int lose=0; int draw=0; while(true) { System.out.println("가위[0], 바위[1], 보[2] 중 하나를 입력하세요."); input = Integer.parseInt(person.nextLine()); int answer = (int)(Math.random()*100); if(input==3) { System.out.println("\n===게임결과 :"+count+"전 "+victory+"승"+draw+"무"+lose+"패. ==="); break; } count++; if(!(input==0 || input==1 || input==2 || input==3)) { System.out.println("잘못 입력하였습니다."); count--; }else { int result = doif(answer%3,input); if(result==0)draw++; else if(result == 1)victory++; else lose++; System.out.println("당신은 "+judge[result]); } } person.close(); } //1 public static int doif(int com, int person) { if(person == 0) { if(com == 0) {return 0; }else if(com == 1) {return 2; }else return 1; }else if(person == 1) { if(com == 0) {return 1; }else if(com == 1) {return 0; }else return 2; }else { if(com == 2) {return 2; }else if(com == 1) {return 1; }else return 0; } } //2 public static int doarray(int com, int person) { int judge[][] = {{0,1,2},{2,0,1},{1,2,0}}; return judge[com][person]; } //3 public static int docalc(int com, int person) { if(com == (person%3)) { return 0; }else if((com+1)%3 == (person%3)) { return 1; }else { return 2; } } } ``` // 과제:홀짝을 함수화하시요 ``` package kfunction_pkg; import java.util.Scanner; public class d_08_홀짝 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while(true) { int computer = (int)(Math.random()*3); String com = ""; if(computer == 0) { com = "짝"; }else { com = "홀"; } System.out.println("컴퓨터:"+com); System.out.println("홀(1),짝(0)>>"); int user = sc.nextInt(); System.out.println(game(user,computer)); if(game(user,computer)=="이겼습니다!") { break; } } sc.close(); } public static String game(int user, int computer) { String ret = ""; if (user==computer) { ret="이겼습니다!"; }else { ret="떙!!!! 다시!!"; } return ret; } } ``` # 2/28 ``` package lclass; // class의 기본개념 // 캡슐화:데이터보호 // 추상화 // 상속성 // 다형성 class test_class{ // 내부클래스 (외부에서 접근이 안됨) int data; int change(int data) { data = data + 100; return data; } } public class e_01_class { int data= 50; // 멤버변수 // 파이썬으로부터 자바측이 받아들인 것(public을 안써주더라도 기본이 됨) int change(int data) { // static을 안붙인 경우 // 멤버함수 // 함수의 지역변수가 우선함 data = data + 100; return data; } // 프로그램 진입점 public static void main(String[] args) { // 변수는 메인함수 stack에 저장, 데이터는 heap에 저장 e_01_class op = new e_01_class(); // class는 동적메모리 할당으로 메모리 확보 System.out.println(op.data); int ret = op.change(500); System.out.println(ret); System.out.println(op.data); test_class tc = new test_class(); ret = tc.change(1000); System.out.println(ret); } } ``` ``` package lclass; // 생성자를 안만들면 디폴트생성자가 기본으로 생성이 됨. class Student99{ // 클래스 = 멤버변수(데이터) + 멤버함수(메소드:처리) int studentId; // 변수만 선언 String studentName; int grade; String address; Student99(){} // 이게 디폴트생성자 public void showStudentInfo(){ System.out.println("학생의 이름은 "+studentName+", 주소는 "+address+"입니다."); } String getStudentName() { return studentName; } void printGreeting(String name) { System.out.println(name+"님 안녕하세요^^"); return; } } public class e_02_inner_class { public static void main(String[] args) { Student99 student1 = new Student99(); // 공간확보 student1.studentName = "홍길동"; String name = student1.getStudentName(); System.out.println(name); // 주소에 대전시 탄방동으로 초기화하고 출력해보시오. student1.address = "대전시 탄방동"; student1.showStudentInfo(); // 원래는 데이터 없으면 에러났는데 // null값 나옴. // printGreeting 함수를 이용해서 대한이에게 인사해보시오. student1.printGreeting("대한"); // 강하늘. 서울시로 데이터를 입력해ㅐ보시오. Student99 student2 = new Student99(); student2.studentName = "강하늘"; student2.address = "서울시"; student2.showStudentInfo(); // 함수는 선언할 때 한번만 만들어짐, 인스턴스할 때는 멤버변수 공간만 힙에 할당 } } ``` --------- --------- ~ Student 클래스 ``` package lclass; public class Student { String name; // 인스턴스할 때 공간만 확보하기 때문에 데이터를 초기화하는 것이 필요 int kor; int mat; int eng; // 인스턴스 될 때 초기화시키기 위해서 딱 한번만 사용됨. // ↓강제호출이 불가능 - 초기화될 때 자동으로 한번만 실행 // 리턴값을 붙이지 않음 // 이름은 클래스이름과 동일 // 생성자 overloading public Student(String name, int kor, int mat, int eng) { // 생성자 this.name = name; // this -> 클래스가 인스턴스 되었을 경우 자기자신을 가리키는 지시자 (this.멤버변수=지역변수) this.kor = kor; this.mat = mat; this.eng = eng; } public Student(String name, int kor, int mat) { this.name = name; this.kor = kor; this.mat = mat; } public Student(String name, int kor) { this.name = name; this.kor = kor; } public void setStudentName(String name) { // 데이터 바꾸려할 때 함수이름에 보통 set을 붙이고 this.name = name; } public String getStudentName() { // 데이터를 그냥 가져올 때 함수이름에 보통 get을 붙임 return name; } public void print() { System.out.println("이름:"+name+" 국어:"+kor+" 수학:"+mat+" 영어:"+eng); } } ``` => 실행 ``` package lclass; public class e_03_Student_test { public static void main(String[] args) { Student st = new Student("대한이",100,90,95); // 인스턴스하면서 데이터 초기화 st.print(); // 멤버변수가 초기화되지 않으면 0으로 자동 초기화 됨. Student st2 = new Student("민국이",100,90); // 영어:0 st2.print(); System.out.println(); // 문제 //1 // 만세를 저장하는 생성자를 오버로딩하는데 국어만 100점으로 입력하도록 생성자를 만들고 인스턴스해보시오. Student st3 = new Student("만세",100); st3.print(); System.out.println(); //2 // 만세이름을 만세야로 바꾸고 이름만 출력해보시오. st3.setStudentName("만세야"); System.out.println(st2.getStudentName()); //민국이 System.out.println(st3.getStudentName()); //만세야 System.out.println(); } } ``` -------- --------- ~ Person 클래스 ``` package lclass; public class Person { public String name; // public 그냥 명시적으로 써준거 public int age; public Person() {} // 디폴트생성자는 생성자가 없으면 자동으로 만들어줌, 배열처리 때문에 public Person(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { if(age > 200) age = 200; // 데이터 보호가능 this.age = age; } public int getAge() { return age; } public void print() { System.out.print(name+":"+age+"살 "); } } ``` => 실행 ``` package lclass; public class e_04_Person_test { public static void main(String[] args) { //3 // name과 age를 저장하는 Person class를 만들고 // 멤버함수는 데이터를 초기화하는 생성자를 만들고 각 데이터를 get, set하는 함수를 작성하시오. // 만들어진 Person class를 인스턴스하여 대한이:13살, 민국이:14살, 만세:15살인 데이터를 저장하시오. Person ps1 = new Person("대한이",13); Person ps2 = new Person("민국이",14); Person ps3 = new Person("만세",15); ps1.print(); // 출력 ps2.print(); ps3.print(); System.out.println(); System.out.println(); Person pe_dim[] = new Person[3]; // 생성자(배열에는 디폴트생성자가 있어야 함) pe_dim[0] = new Person("대한이",13); pe_dim[1] = new Person("민국이",14); pe_dim[2] = new Person("만세",15); for(Person pe : pe_dim) { pe.print(); } System.out.println(); System.out.println(); String st_arr[] = {"대한이","민국이","만세"}; int age_arr[] = {10,11,12}; Person pe_arr[] = new Person[st_arr.length]; for(int i=0;i < st_arr.length;i++) { pe_arr[i] = new Person(st_arr[i], age_arr[i]); } for(Person pe : pe_arr) { pe.print(); } } } ``` ---- ----- ~ Point 클래스 ``` package lclass; public class Point { public double x; public double y; public Point() {} public Point(double x, double y) { this.x = x; this.y = y; } public void setX(double x) { this.x = x; } public double getX() { return this.x; } public void setY(double y) { this.y = y; } public double getY() { return this.y; } public double distance() { // 대각선의 길이 - 원점으로부터의 거리값 return Math.sqrt(x*x+y*y); } public double theta() { double radian_result = Math.atan2(x,y); // 길이의 비를 라디안 return Math.toDegrees(radian_result); // 라디안을 각도로 변환 } public double distanceTo(Point po){ double dx = this.x - po.x; // 두 점간의 거리값 double dy = this.y - po.y; return Math.sqrt(dx*dx+dy*dy); } } ``` => 실행 ``` package lclass; public class e_05_Point_test { public static void main(String[] args) { Point po = new Point(5,3); System.out.println(po.getX()); System.out.println(po.getY()); System.out.println("원점으로부터의 거리 "+po.distance()); System.out.println("각도는 "+po.theta()); Point po2 = new Point(10,20); System.out.println("두 포인트간의 거리는 "+po.distanceTo(po2)); } } ``` ---- ----- ~ Circle 클래스 ``` package lclass; public class Circle { // 문제 // Circle class를 생성해보세요 // 중심점(Point), 둘레(perimeter):2*pi*r, 면적(area):pi*r*r // 두 circle간의 거리는 이미 point에서 구해져있음 // 두 원은 충돌하는가 Point po; double radius; double perimeter; // 계산 double area; public Circle(Point po, double radius) { this.po = po; this.radius = radius; calcPerimeter(); calcArea(); } public void setRadius(double radius) { this.radius = radius; calcPerimeter(); calcArea(); } public double getRadius() { return this.radius; } public void calcPerimeter() { this.perimeter = 2 * Math.PI * radius; } public void calcArea() { this.area = Math.PI * radius * radius; } public boolean getCollision( Circle cir2 ) { double tot_radius = this.radius + cir2.radius; double dist = this.po.distanceTo(cir2.po); if (dist < tot_radius) return true; else return false; } public void display() { System.out.println("원의 반지름:"+getRadius()); System.out.println("원의 둘레:"+this.perimeter); System.out.println("원의 면적:"+this.area); } } ``` => 실행 ``` package lclass; public class e_06_Circle_test { public static void main(String[] args) { Point po = new Point(5,6); Circle cl = new Circle(po,100); // 생성자가 자동으로 호출: 둘레,면적이 계산 되어있음 cl.display(); cl.setRadius(50); cl.display(); System.out.println(); Point po2 = new Point(10,8); Circle cl2 = new Circle(po2,100); if(cl.getColleision(cl2)) { System.out.println("두 원은 충돌했습니다."); }else { System.out.println("두 원은 충돌하지 않습니다."); } cl2.display(); } } ``` ----- ------ ~ Student90 클래스 ``` package lclass; import java.util.Scanner; public class Student90 { public int no; public String name; public int kor; public int mat; public int eng; public int total; public float average; public char grade; public int ranking; public Student90(){ Scanner sc = new Scanner(System.in); System.out.println("이름을 입력하시요"); this.name = sc.nextLine(); System.out.println("국어점수:"); this.kor = Integer.parseInt(sc.nextLine()); System.out.println("수학점수:"); this.mat = Integer.parseInt(sc.nextLine()); System.out.println("영어점수:"); this.eng = Integer.parseInt(sc.nextLine()); total = total_fun(); average = avr_fun(); grade = grade_check(); } public int total_fun() { return this.kor + this.mat + this.eng; } public float avr_fun() { return average = Math.round((double)this.total/3); } public char grade_check() { char hakjum; switch((int)average/10) { case 10: case 9: hakjum = 'A'; break; case 8: hakjum = 'B'; break; case 7: hakjum = 'C'; break; case 6: hakjum = 'D'; break; default: hakjum = 'F'; } return hakjum; } public Student90(String name, int kor, int mat, int eng) { this.name = name; this.kor = kor; this.mat = mat; this.eng = eng; total_clac(); } public void total_clac() { total = total_fun(); average = avr_fun(); grade = grade_check(); } // set함수를 생성 public void setName( String name ) { this.name = name; } // 문제 // 국어 별도로, 수학 별도로, 영어 별도로 값을 set하는 함수를 작성해보시오. // 꼭 검산을 반드시 실행하시오. public void setKor( int kor ) { this.kor = kor; total_clac(); } public void setMat( int mat ) { this.mat = mat; total_clac(); } public void setEng( int eng ) { this.eng = eng; total_clac(); } // 기본적으로 자바는 모든 클래스가 Object를 상속받음 // 입출력하는 데이터는 모두 문자열이어야 함 // 문자열을 요구하는 함수에 클래스가 전달되면 자동으로 작동한다. public String toString() { // 오버라이딩(재정의)의 예 // 상속:코드 중복을 방지하기 위해서 공통부분을 부모로 정의하고 자식이 상속받아서 기능을 구현 // (함수명만 정의하고 바디부분은 정의 않는 부분이 있음) // 이 부분을 자식이 재정의해서 구현하면 자식마다 다른 기능을 구현할 수 있습니다. return kor + "," + mat + "," + eng; } public String lasttoString() { return no + "\t" + name + "\t" + kor + "\t" + mat + "\t"+ eng + "\t" + total + "\t" + average + "\t" + grade + "\t" + ranking; } public String printhead() { return "번호" + "\t" + "이름" + "\t" + "국어" + "\t" + "수학" + "\t" + "영어" + "\t" + "합계" + "\t" + " 평균" + "\t" + "학점" + "\t" + "등수"; } } ``` => 실행 ``` package lclass; import java.util.Scanner; public class e_07_student90_test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("몇 명을 입력하시겠습니까"); int studentnum = Integer.parseInt(sc.nextLine()); Student90 school[] = new Student90[studentnum]; // 2인분 for(int i = 0; i < school.length; i++) { school[i] = new Student90(); // default 생성자가 동작 school[i].no = i+1; } System.out.println(school[0].printhead()); for(int i = 0; i school[j + 1].no) { // 부등호 <로 바꾸면 내림차순으로 정렬 Student90 temp; temp = school[j]; school[j] = school[j+1]; school[j+1] = temp; changed = true; } } if(!changed) break; } } } public static void menuOpen(Student90 school[]) { int inputNum = 0; boolean re = false; Scanner sc = new Scanner(System.in); while(!re) { re = true; System.out.println("========== 성적 관리 프로그램 =========="); System.out.println("1.검색 2.출력 3.수정 8.과목별합계출력 9.종료"); // 총점으로 정렬을 해서 등수를 입력하고 다시 번호로 정렬 System.out.println("메뉴선택"); inputNum = Integer.parseInt(sc.nextLine()); switch(inputNum) { case 1: System.out.println("1.검색내용"); System.out.println("검색할 이름을 입력하시요"); String inputname = sc.nextLine(); for(int i =0; i < school.length; i++) { if(school[i].name.equals(inputname)) { System.out.println(school[i].lasttoString()); } } break; case 2: System.out.println("2.출력내용"); // 등수를 부여하기 위해 점수로 정렬 후 출력 sort(school,1); for(int i = 0;i < school.length; i++) { school[i].ranking = i+1; } // 시각화하기 위해서 번호를 중심으로 재정렬 sort(school,2); System.out.println(school[0].printhead()); for(int i =0; i < school.length; i++) { System.out.println(school[i].lasttoString()); } break; case 3: System.out.println("3. 수정"); System.out.println("수정할 이름을 입력하시요"); inputname = sc.nextLine(); for (int i = 0; i < school.length; i++) { if(school[i].name.equals(inputname)) { System.out.println("이름을 변경해주세요"); inputname = sc.nextLine(); school[i].setName(inputname); System.out.println(school[i].lasttoString()); } } break; case 8: System.out.println("8.과목별합계출력"); int kor_hab=0; int mat_hab=0; int eng_hab=0; for(int i=0;i < school.length;i++) { kor_hab += school[i].kor; mat_hab += school[i].mat; eng_hab += school[i].eng; } System.out.println("국어합계:"+kor_hab+"점 수학합계:"+mat_hab+"점 영어합계:"+eng_hab+"점"); break; case 9: re = true; break; default: System.out.println("다시 입력해주세요"); re = false; break; } } sc.close(); } } ``` // 과제 게임(가위바위보를 클래스로 작성(computer,user,judge class를 만들어서 구현하시요) ``` ``` # 3/2 ``` package m_inheritance; // 상속 // 모든 클래스는 보이지는 않지만 extends Object class Super_class{ //부모(Super,Parent) int num = 20; public void display() { System.out.println("슈퍼클래스에서 출력 "); } } public class f_01_inheritance extends Super_class{ //자식(Child) // 인스턴스를 해야 사용가능 int num = 10; // 재정의 함. public void display() { System.out.println("서브클래스에서 출력 "); } public void my_method() { // 자식에서 추가된 메쏘드 f_01_inheritance sub = new f_01_inheritance(); // 메쏘드 내 인스턴스 sub.display(); // 자식 실행 super.display(); // 부모의 메쏘드 실행 // 문법적으로 부모는 프로그램 내에서 super로 정의됨. // 자기 자신은 this(메모리에서 실행이 될 때 부모의 주소값이나 자식의 주소값을 가지고 있는 포인터) display(); // 자식의 메쏘드 실행 System.out.println("자식의 변수 : "+sub.num); // 메모리에서 부모의 영역과 자식의 영역은 별도로 존재한다. System.out.println("부모의 변수 : "+super.num); // 부모의 값도 자식에서 출력이 가능하다. System.out.println("자식의 변수 : "+num); } public static void main(String[] args) { f_01_inheritance obj = new f_01_inheritance(); obj.display(); // 재정의 없으면 부모 것이 출력 obj.my_method(); } } ``` ``` package m_inheritance; class Parent{ int x = 100; public void setvalue(int x) { this.x = x; } void method() { System.out.println("부모함수"); } } class Child extends Parent{ int x = 200; // 재정의 Child(){ x = 1000; } // 자식 생성자 public void setvalue(int x) { this.x = x; } // 부모 함수 오버라이딩 void method() { System.out.println("자식 1-1함수 : "+x); } void method2() { // 부모에는 없는걸 자식에서 추가된 함수 System.out.println("자식 1-2함수 : "+x); } } class Child2 extends Parent{ int x = 300; Child2(){ x = 2000; } public void setvalue(int x) { this.x = x; } void method() { System.out.println("자식 2-1함수 : "+x); } void method3() { System.out.println("자식 2-2함수 : "+x); } } public class f_02_Parent_Child { public static void main(String[] args) { Child c = new Child(); c.method(); // upCasting은 자동으로 벌어짐. Parent p = new Child(); // 부모는 자식을 가리킬 수 있다. p.method(); // 자식의 메쏘드가 출력 c.method2(); //p.method2(); // 컴파일 타임에 에러가 남(부모가 가리킬 수는 있지만 추가된 자식 메쏘드를 호출 불가) // downCasting으로 처리한 다음 호출 Child d = (Child) p; d.method2(); // 배열을 이용한 처리 - 같은 크래스인 경우는 크래스 배열을 만들어서 처리 Child ch[] = new Child[3]; // 배열의 형태를 지정 for(int i = 0; i < 3;i++) { ch[i] = new Child(); // 실제 메모리를 확보하는 것 } ch[0].setvalue(100); ch[1].setvalue(20); ch[2].setvalue(10); for(int i = 0; i < 3;i++) { ch[i].method(); } // Child 3개, Child2 3개가 필요한 경우 // 부모의 이름으로 Child3, Child2 3개를 동시에 호출 Parent chp[] = new Parent[6]; for(int i = 0; i < 3;i++) { // 0,1,2 chp[i] = new Child(); } for(int i = 3; i < 6;i++) { // 3,4,5 chp[i] = new Child2(); } for(int i = 0; i < 6;i++) { chp[i].method(); } // 추가된 메쏘드는 부모가 알 수가 없다. 그래서 downCasting한 다음 호출 Child ch1[] = new Child[3]; // 0,1,2 Child2 ch2[] = new Child2[3]; // 0,1,2 for(int i = 0; i < 3; i++) { ch1[i] = (Child) chp[i]; // (Child)다움캐스팅 후 호출 ch1[i].method2(); } for(int i = 3; i < 6; i++) { ch2[i-3] = (Child2) chp[i]; ch2[i-3].method3(); } } } ``` ``` package m_inheritance; // 면적, 출력함수, 계산함수 => 부모 // Rectangle, Circle, Triangle // 가로, 세로, 반지름, 밑변높이 // 계산방법만 다른 경우 -> 함수 이름은 같되 다른 일을 하는 재정의를 이용 class Shape{ // 3번 적용되어야 하는 코드를 한번으로 줄임. public double area; // 공통 public void display() { // 공통 System.out.println("면적은" + this.area + "입니다."); } // 함수명도 하나만 알고 있으면 객체마다 다른 계산을 호출 public void calcArea(){ } // 오버라이딩 대상 } class Circle extends Shape{ public double radius; // 원에 추가된 변수 public Circle(double radius) { this.radius = radius; calcArea(); } public void calcArea() { // 재정의 area = Math.PI * radius * radius; } } class Rectangle extends Shape{ public double width; // 추가 public double height; // 추가 public Rectangle(double width, double height) { this.width = width; this.height = height; calcArea(); } public void clacArea() { area = width * height; } // 재정의 } class Triangle extends Shape{ public double width; public double height; public Triangle(double width, double height) { this.width = width; this.height = height; calcArea(); } public void clacArea() { area = width * height /2; } } public class f_03_shape { public static void main(String[] args) { Circle cl = new Circle(10); cl.display(); Rectangle re = new Rectangle(10,20); re.display(); Triangle tr = new Triangle(10,5); tr.display(); // 부모의 배열을 이용해서 일시에 처리 Shape parent[] = new Shape[3]; parent[0] = cl; // 자식을 부모의 배열에 대입 parent[1] = re; parent[2] = tr; for(int i = 0;i < 3;i++) { parent[i].display(); } } } ``` ``` package m_inheritance; // Point class도 사용을 하면서 GUI프로그램에서 사용하기 위해서 // point에 color값을 지정해야 하는 경우 => 상속으로 해결 class Point2 { public double x; public double y; public Point2() {} public Point2(double x, double y) { this.x = x; this.y = y; } public void setX(double x) { this.x = x; } public double getX() { return this.x; } public void setY(double y) { this.y = y; } public double getY() { return this.y; } public double distance() { // 대각선의 길이 - 원점으로부터의 거리값 return Math.sqrt(x*x+y*y); } public double theta() { double radian_result = Math.atan2(x,y); // 길이의 비를 라디안 return Math.toDegrees(radian_result); // 라디안을 각도로 변환 } public double distanceTo(Point2 po){ double dx = this.x - po.x; // 두 점간의 거리값 double dy = this.y - po.y; return Math.sqrt(dx*dx+dy*dy); } public void display() { System.out.println("x의 위치:"+x+" y의 위치:"+y); } } class Colorpoint extends Point2{ String color; public Colorpoint() { color = "검정"; } public Colorpoint(String color) { // 부모의 생성자는 처음부터 호출되어야 함 super(10,100); // 부모의 생성자 호출을 자식의 생성자에서 호출하는 것이 가능 this.color = color; } public Colorpoint(String color, int x, int y) { super(x,y); this.color = color; } public void display() { System.out.println("x의 위치:"+x+" y의 위치:"+y+" 컬러값:"+this.color); } } class Circle2 { // 클래스 이름만 변경 Point2 po; double radius; double perimeter; // 계산 double area; public Circle2(Point2 po,double radius) { this.po = po; this.radius = radius; calcPerimeter(); calcArea(); } public void setRadius(double radius) { this.radius = radius; calcPerimeter(); calcArea(); } public double getRadius() { return this.radius; } public void calcPerimeter() { this.perimeter = 2 * Math.PI * radius; } public void calcArea() { this.area = Math.PI * radius * radius; } public boolean getCollision( Circle2 cir2 ) { double tot_radius = this.radius + cir2.radius; double dist = this.po.distanceTo(cir2.po); if (dist < tot_radius) return true; else return false; } public void display() { System.out.println("원의 반지름:"+getRadius()); System.out.println("원의 둘레:"+this.perimeter); System.out.println("원의 면적:"+this.area); } } // 유지보수가 편리함 -> 상속을 사용하면(부모가 자식을 가리킬 수 있다는 점) public class f_04_Colorprint_test { public static void main(String[] args) { Colorpoint cp1 = new Colorpoint("노랑",100,200); Colorpoint cp2 = new Colorpoint("파랑",5,6); cp1.display(); cp2.display(); System.out.println(); // Colorpoint가 Point에 들어갈 수 있는 이유는 부모가 자식을 가리킬 수 있기 때문에 가능 // Point = ColorPoint가 대입된 것 // 부모가 자식을 가리키는 것(추가된 것은 못 가리킴) Circle2 cl1 = new Circle2(cp1,100); // 원래 Circle2는 Point가 매개변수 Circle2 cl2 = new Circle2(cp2,100); cl1.po.display(); cl2.po.display(); System.out.println(); System.out.println("두 점 사이의 거리는 "+cl1.po.distanceTo(cl2.po)); if(cl1.getCollision(cl2)) { System.out.println("두 점은 충돌합니다."); }else { System.out.println("두 점은 충돌하지 않습니다."); } } } ``` ----- ----- ~ Employee2 클래스 ``` package m_inheritance; // 100사람을 처리할 때 1사람을 기준으로 class를 만듬 // 이질적인 데이터 public class Employee2 {// 이룸,나이,성별,주소,급여 String name; int age; String sex; String address; long salary;// 메모리에 인스턴스 될 때 확보하는 메모리양 // 생성자 public Employee2() {} // 디폴트 생성자 public Employee2(String name, int age, String sex, String address, long salary) { this.name = name; this.age = age; this.sex = sex; this.address = address; this.salary = salary; } // 오버로딩 public Employee2(String name, int age, String sex) { this.name = name; this.age = age; this.sex = sex; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public long getSalalry() { return salary; } public void setSalalry(long salary) { this.salary = salary; } public double bonus() { return salary * 1.5; } // 출력 void display() { System.out.println(name+", "+age+", "+sex+", "+address+", "+salary+", "+bonus()); } public String toString() {// 문자열을 요구하는 함수의 매개변수로 클래스 인스턴스 변수가 전달되면 작동해서 자동으로 실행 return "이름:"+name+" 나이:"+age; } } ``` ~ Manager 클래스 ``` package m_inheritance; public class Manager extends Employee2{ public String department; public Employee2 sub[]; // 직원 정보 입력 public Manager() {} public Manager(String name, int age, String sex, String address, long salary, String department) { super(name, age, sex, address, salary); // 상속시 부모의 생성자를 명시적으로 호출 this.department = department; this.sub = new Employee2[2]; // 배열에 주소 데이터가 입력될 공간을 확보 } public void displayEmployee2() { for(int i = 0;i < sub.length;i++) { sub[i].display(); } } public void display() { // 오버라이딩 System.out.println("담당부서:"+this.department); System.out.println("부하직원수:"+this.sub.length); System.out.println("부서장"); super.display(); System.out.println("부서직원:"); displayEmployee2(); } } ``` => 실행 ``` package m_inheritance; //회사의 상황 //직원이 6명이 있음 (3명, 3명) //매니저가 직원이면서 관리자가 2명이 있음 //Employee class //출력, 보너스함수는 1.5배를 곱해서 계산하는 함수를 가지고 있음 //Manager class가 있어야 함(상속구조로 클래스를 작성해보시요) //매니저는 직원 명단을 가지고 있어야 함 //매니저는 자기부서와 직원을 출력할 수 있어야 함 //name, age, sex, address, salary, department //"대한이", 23, "남", "서울시 강북구", 1500000 //"민국이", 35, "남", "대전시 쌍용동", 2500000 //"김관리", 40, "여", "서울시 강남구", 5000000, "개발부" //"희망이", 23, "남", "대전시 쌍용동", 1500000 //"하면됨", 35, "남", "대전시 쌍용동", 2500000 //"이소정", 40, "여", "대전시 쌍용동", 2500000, "연구부" public class Company2 { public static void main(String[] args) { Employee2 el1 = new Employee2("대한이",23,"남","서울시 강북구",150000); Employee2 el2 = new Employee2("민국이", 35, "남", "대전시 쌍용동", 2500000); Employee2 el4 = new Employee2("희망이", 23, "남", "대전시 쌍용동", 1500000); Employee2 el5 = new Employee2("하면됨", 35, "남", "대전시 쌍용동", 2500000); Manager co[] = new Manager[2]; Manager ma1 = new Manager("김관리", 40, "여", "서울시 강남구", 5000000,"개발부"); ma1.sub[0] = el1; // 부서직원 등록 ma1.sub[1] = el2; Manager ma2 = new Manager("이소정", 40, "여", "대전시 쌍용동", 2500000,"연구부"); ma2.sub[0] = el4; ma2.sub[1] = el5; co[0] = ma1; co[1] = ma2; System.out.println("전체 직원현황"); for(int i = 0; i< co.length; i++) { co[i].display(); } // 클래스 인스턴스 변수 출력 System.out.println(el1); // toString이 오버라이딩 되어있음 System.out.println(ma1); // toString이 오버라이딩 되어있지 않음에도 부모를 상속받아서:주소가 출력되지 않고 값이 뜸 } } ``` -------- --------- ``` package m_inheritance; // 추상클래스:추상함수가 하나라도 있으면 추상클래스 // 추상클래스는 인스턴스하면 안됨 - 안되는 이유:정의 안된 함수는 실행하면 에러발생 abstract class Weapon{ public void prepare() { System.out.println("무기 작동을 준비합니다."); } public abstract void attack(); // 추상함수 } // 추상클래스를 상속받는 이유 // 1)추상함수는 반드시 오버라이딩해야 함 - 프로그래머가 잊지 않고 같은 이름으로 구현해주길 바랄 때 -> 약속(plug in에서) // 2)인스턴스하지 않지만 부모로서 상속받은 자식을 가리킬 수가 있음 class MyWeapon extends Weapon{ @Override // annotation(자바)-파이썬에서는 장식자라고 함 -> 특수한 기능 public void attack() { System.out.println("김구라를 공격해요"); } } class YourWeapon extends Weapon{ @Override public void attack() { System.out.println("원숭이를 공격해요!"); } } public class g_01_abstract { public static void main(String[] args) { MyWeapon w1 = new MyWeapon(); w1.prepare(); w1.attack(); YourWeapon w2 = new YourWeapon(); w2.prepare(); w2.attack(); useWeapon(w1); useWeapon(w2); } public static void useWeapon(Weapon w) { // 부모를 매개변수로 사용한다. w.prepare(); w.attack(); } } ``` ``` package m_inheritance; // 추상클래스는 추상함수가 하나라도 있으면 만들어짐(abstract) // 클래스의 함수가 모두가 추상함수이면 순수추상클래스라고 하고, 이를 자바에서는 interface라고 함. // 인터페이스에서는 멤버변수를 사용하지 마라 -> 사용하면 멤버변수는 public, static(인스턴스하지 않고 사용) // final은 수정이 안된다. // 인터페이스는 인스턴스하면 암됨:부모로는 사용이 가능 interface MyInterface{ public String hello = "인터페이스 변수는 기본으로 public static final 접근이 가능"; public void sayHello(); } // 인터페이스는 상속(extends)이라고 하지 않고 구현(implements)이라고 함. // 클래스가 인터페이스를 구현 // 인터페이스가 인터페이스 상속이라고 함(인터페이스 간에도 상속이 됨) class MyInterfaceImp1 implements MyInterface{ public void sayHello() { // 반드시 오버라이딩해야 함 System.out.println(MyInterface.hello); } } public class g_02_interface { public static void main(String[] args) { System.out.println(MyInterface.hello); // 직접호출이 가능 MyInterface myinterface = new MyInterfaceImp1(); // 인스턴스에서 사용 myinterface.sayHello(); MyInterface mydim[] = new MyInterface[3]; // 인터페이스 배열 - 부모배열과 마찬가지 mydim[0] = new MyInterfaceImp1(); // 구현클래스만 인스턴스가 가능하다. mydim[1] = new MyInterfaceImp1(); } } ``` ``` package m_inheritance; // Cloneable 인터페이스 -> 객체 복사가 가능하도록 해줌 // 어떤 클래스던지 이 인터페이스를 구현하면 객체 복사가 가능해짐 // 이렇게 공통기능을 자바측에서 만들어서 제공해줌:어떤 객체든지 Cloneable을 implements하면 clone이 가능 // Cloneable 인터페이스 public class g_03_interface_clonable implements Cloneable{ int rollno; String name; g_03_interface_clonable(int rollno, String name){ this.rollno = rollno; this.name = name; } // clone()을 구현 public Object clone() throws CloneNotSupportedException{ // 구현해줌 return super.clone(); // Object를 상속받음 } public static void main(String[] args) { try{ // 예외처리 g_03_interface_clonable s1 = new g_03_interface_clonable(101, "대한민국"); // Cloneable를 구형하면 clone함수를 사용하는 것이 가능 // 클래스 대입은 // g_03_interface_clonable s2 = s1; 이런 경우는 복사가 아니라 주소를 전달해서 // s2나 s1이나 같은 주소를 가리키게 됨 : 하나를 바꾸면 다른 변수에도 영향을 줌 g_03_interface_clonable s2 = (g_03_interface_clonable) s1.clone(); // 위와 같이 clone을 하면 힙에 별도의 공간을 만들어서 데이터를 복사하기 때문에 // 두 변수가 가리키는 위치는 다르다. System.out.println(s1.rollno +" "+s1.name); System.out.println(s2.rollno +" "+s2.name); } catch(CloneNotSupportedException cnse){ cnse.printStackTrace(); } } } ``` ``` package m_inheritance; // 예외처리 // 프로그램은 기본적으로 파일공간이 넉넉하고, 네트워크가 작동하고, 서버가 작동한다는 전제조건에서 진행 // 예외적으로 파일공간이 부족하거나 네트워크가 물리적으로 끊어져 있거나 서버가 죽어잇는 경우 // 프로그램이 중지될 때 예외를 처리하고 프로그램이 지속적으로 동작하도록 하는 것을 예외처리라고 함 // try catch finally public class g_04_exception { public static void main(String[] args) { try { int a[] = new int[5]; // 배열은 공간을 확보하고 값을 대입해야 함 //a[5] = 30/0; // 0으로 나누면 예외가 발생 a[5] = 30; a[4] = 30; } // Exception은 클래스 생성이 되어있음 // 예외는 Exception을 상속받아서 구현:하위들은 문법적 에러가 발생함 //catch(Exception e) {System.out.println(e);} // 부모는 자식을 받을 수 있음 // 예외의 부모 클래스는 자식 예외의 뒤에 있어야 함 // toString을 오버라이딩 해놓음. catch(ArithmeticException e) {System.out.println(e);} // 연산에러 catch(ArrayIndexOutOfBoundsException e) { // 문지방 // 클래스를 선언:변수로 System.out.println("인덱스가 없습니다."); } catch(Exception e) {System.out.println(e);} // 최상위 예외 finally {System.out.println("마지막은 항상 실행");} // 예외가 발생하더라도 마지막은 반드시 실행 } } ``` ``` package m_inheritance; // throw 강제로 명시적으로 예외를 프로그래머가 발생 public class g_05_thread { static void validate(int age) { if(age<18) throw new ArithmeticException("정당하지 않습니다."); // 수치 에러 발생 else System.out.println("투표 권한 있음"); } public static void main(String[] args) { try { validate(13); } catch(Exception m) {System.out.println("Exception 발생");} } } ``` ``` package m_inheritance; //toString을 사용해서 해결하는 문제 //Student25 class에 번호와 이름을 저장하도록 클래스를 구성하고 //문자열을 요구하는 함수에 매개변수로 던져지면 이름과 번호가 출력이 되도록 클래스를 작성해서 //데이터 101, "대한민국 만세"로 초기화한 다음 출력해보세요 class Student{ private int rno; private String name; public Student(int r, String n){ rno = r; name = n; } public String toString() { // 문자열을 리턴 return rno+", "+name; } // 오버라이딩 } public class g_06_toString { public static void main(String[] args) { Student s = new Student(101,"대한민국만세"); System.out.println("학생정보:"); System.out.println(s); } } ``` ``` package m_inheritance; import java.io.*; // Stream 저장을 하기 위해서 Serializable을 구현해줌 class Employee24 implements java.io.Serializable{ public String name; public String address; public int number; } public class g_07_FileStream { public static void main(String[] args) { Employee24 e = new Employee24(); e.name = "korea"; e.address = "Seoul"; e.number = 101; try { // 파일 처리는 예외처리해야 함 // 파일 오픈 // 파일이나 네트워크, DB접속은 os 자원을 사용 FileOutputStream fileOut = new FileOutputStream("c:\\\\work\\test.txt"); // 객체를 스트림으로 -> 저장할 때는 순서적으로 Serial하게 ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(e); // 객체 저장하시요 out.close(); // 파일, 네트워크, DB객체 등은 반드시 닫아주어야 함(차원 누수 방지) fileOut.close(); System.out.printf("Serialized 된 클래스의 데이터가 c:\\test.txt에 저장"); }catch(IOException i) { i.printStackTrace(); } } } ``` ``` package m_inheritance; import java.io.*; class Employee24 implements java.io.Serializable{ public String name; public String address; public int number; } public class g_08_FileStreamInput { public static void main(String[] args)throws Throwable { ObjectInputStream ois = null; try {// \\->드라이브를 의미, \->폴더를 의미: 프로그램에서 eclipse는 리눅스 os문제 // 윈도우에서 폴더지정은 "c:\\work\test.txt" 리눅스에서는 한번씩 더 \ 그어줘야함. FileInputStream fn = new FileInputStream("c:\\\\work\\test.txt"); ois = new ObjectInputStream(fn); Employee24 data = (Employee24) ois.readObject(); System.out.println("이름:"+data.name); System.out.println("번호:"+data.number); System.out.println("메일:"+data.address); }catch(IOException e){ System.out.println("입력오류"); } } } ``` # 3/3 ``` package n_generic; class Box< T >{ // 대표데이터 타입 - 실제 사용하는 타입으로 변화 private T t; public void add(T t) { this.t = t; } public T get() { return t; } } // 상속도 아닌데 다양한 데이터타입을 받아서 처리하는 함수 public class h_01_box { public static < E > void printArray( E[] inputArray ) { // 함수에 대표타입 지정 for(E element : inputArray) { System.out.printf("%s ",element); } System.out.println(); } public static void main(String[] args) { // generic에서는 class만 가능, interface 등 만 가능 Integer[] intArray = {1,2,3,4,5}; // 정수형 배열 Double[] doubleArray = {1.1, 2.2, 3.3, 4.4}; Character[] charArray = {'H','E','L','L','O'}; printArray(intArray); printArray(doubleArray); printArray(charArray); System.out.println(); Box integerBox = new Box(); // 클래스는 구체적인 데이터타입을 인스턴스할 때 지정 Box stringBox = new Box(); integerBox.add(Integer.valueOf(10)); // 추가 stringBox.add(new String("안녕 일반화 프로그램")); System.out.printf("정수형 :%d\n\n", integerBox.get()); System.out.printf("문자형 :%s\n", stringBox.get()); } } ``` ``` package n_generic; import java.util.*; public class h_02_ArrayList { public static void main(String[] args) { // 부모 자녀 지간 // 클래스로 만들어진 자료구조 // 배열(dim) // List는 인터페이스 -> 인스턴스가 불가능 -> 부모로서 자식의 포인터를 가리킬 수 있음 // 부모는 자식을 가리킬 수 있다. // 알고리즘을 인터페이스에서 정의해놓고 클래스에서 오버라이딩 하고있음 List a1 = new ArrayList(); // ArrayList = 배열이면서 리스트 -> 배열 대신에 사용 // CRUD함수가 정의되어 있음 a1.add("자라"); a1.add("고래"); a1.add("송어"); System.out.println("ArrayList 출력 "); System.out.println("\t "+a1); List l1 = new LinkedList(); l1.add("자라"); l1.add("고래"); l1.add("송어"); System.out.println("\t "+l1); Set s1 = new HashSet(); // Iterable -> Collection -> Set s1.add("자라"); s1.add("고래"); s1.add("송어"); System.out.println("\t "+s1); // 키 데이터 형식으로 입력 // 자바 자체에서도 사용하는 함수인 hash함수 -> Map m1 = new HashMap(); // hash함수(키 주소값으로 변환)를 사용 -> hashtable에 저장 m1.put("자라", "피"); m1.put("고래", "고기"); m1.put("송어", "어장"); System.out.println("\t "+m1); } } ``` ``` package n_generic; import java.util.*; class MemberDto{ public int num; public String name; public String addr; public MemberDto() {} public MemberDto(int num, String name, String addr) { this.num = num; this.name = name; this.addr = addr; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAddr() { return addr; } public void setAddr(String addr) { this.addr = addr; } public String toString() { // Object에서 상속받아 문자열을 요구하는 함수의 매개변수로 던져지면 문자열을 출력 return "번호:"+num+" 이름:"+name+" 주소:"+addr; } } public class h_03_ArrayList2 { public static void main(String[] args) { List names = new ArrayList(); names.add("김구라"); names.add("해골"); names.add("원숭이"); for(int i=0; i < names.size(); i++) { // size()함수를 이용해서 인덱싱 String tmp = names.get(i); // 인덱스로 출력 System.out.println(tmp); } System.out.println("--- 확장 for문 사용 ---"); for(String tmp:names) { // 객체로 출력 System.out.println(tmp); } MemberDto dto1 = new MemberDto(1, "김일", "노량진"); MemberDto dto2 = new MemberDto(2, "해골", "행신동"); MemberDto dto3 = new MemberDto(3, "", "상도동"); List members = new ArrayList(); members.add(dto1); members.add(dto2); members.add(dto3); System.out.println("ArrayList 출력"); System.out.println("\t "+members); for(int i=0; i < members.size(); i++) { System.out.println(members.get(i)); } System.out.println(); // iterator 반복자:데이터를 순서적으로 가리키는 reference ListIterator listIterator2 = members.listIterator(); // 시작점의 데이터 위치 // 처음 데이터가 있으면 while(listIterator2.hasNext()) { // 데이터 여부를 확인 System.out.println(listIterator2.next()); // 포인터가 한칸씩 이동(다음 데이터가 있으면) } System.out.println(); while(listIterator2.hasNext()) { // 반복자가 마지막을 가리키고 있기 때문에 출력이 안됨. System.out.println(listIterator2.next()); } System.out.println(); while(listIterator2.hasPrevious()) { // 반대 순서로 출력 System.out.println(listIterator2.previous()); } System.out.println(); while(listIterator2.hasNext()) { System.out.println(listIterator2.next()); } System.out.println(); listIterator2 = members.listIterator(); while(listIterator2.hasNext()) { System.out.println(listIterator2.next()); } System.out.println(); // 함수형 프로그래밍(for문을 생략) // 람다함수 -> 자바에서는 함수 하나를 만들려고 해도 class를 사용해야 함 // (무명함수):함수가 요구되는 곳에 함수를 즉시 정의해서 사용 // 다음에는 사용하지 않을 함수 // forEach문은 매개변수로 함수를 요구하는 함수 members.forEach(a->{System.out.println(a.num+" "+a.name+" "+a.addr);}); System.out.println(); // 문제 // members에 들어있는 번호들의 합을 출력하시요 // for문 사용 // while문 사용 // forEach문 사용 : 람다함수:지역변수, static변수, int sum =0; for(int i=0; i < members.size(); i++) { //MemberDto dt = members.get(i); //sum += dt.num; 이렇게 할 수도 있다 sum += members.get(i).num; } System.out.println(sum); System.out.println(); listIterator2 = members.listIterator(); sum = 0; while(listIterator2.hasNext()) { sum += listIterator2.next().num; } System.out.println(sum); System.out.println(); } } ``` ``` package n_generic; import java.util.*; public class h_04_ArrayList3 { public static void main(String[] args) { ArrayList arraylist = new ArrayList(); System.out.println("데이터 한계를 입력하시요"); Scanner scan = new Scanner(System.in); arraylist.add(scan.nextLine()); arraylist.add("충주"); arraylist.add("천안"); arraylist.add("아산"); arraylist.add("오리"); arraylist.add("서울"); System.out.println(arraylist.get(1)); // 데이터 출력 // 데이터 정렬 // Collections 객체에 정렬 함수 Collections.sort(arraylist); System.out.println(arraylist.get(1)); System.out.println(Collections.frequency(arraylist,"천안")); // 도수:도수분포표 // 이진 검색 : 정렬된 데이터에 대하여 실행 System.out.println("검색"+Collections.binarySearch(arraylist, "오리")); System.out.println(arraylist); arraylist.remove("천안"); // 삭제 System.out.println(arraylist); arraylist.set(1,"대전"); // 수정 System.out.println(arraylist); scan.close(); } } ``` ``` package n_generic; import java.util.*; class Domain{ // 클래스 private int id; // primitive 데이터 타입 private String url; public Domain(int id, String url) { this.id = id; this.url = url; } public Integer getId() {return Integer.valueOf(id);} // generic에서는 class를 사용 } // 클래스는 사용자 정의 데이터타입 -> 클래스를 비교하는 방법이 없으면 안됨 public class h_05_binarysearch { public static void main(String[] args) { List l = new ArrayList(); l.add(new Domain(10,"http://naver.com")); l.add(new Domain(20,"민국")); l.add(new Domain(30,"만세")); l.add(new Domain(40,"오라")); Comparator c = new Comparator() { public int compare(Domain u1, Domain u2) // 구현해주어야 함 { return u1.getId().compareTo(u2.getId()); // ID로 비교하시오. } }; // 클래스인 경우에는 비교방법을 지정해주어야 함 int index = Collections.binarySearch(l, new Domain(20,null),c); System.out.println("다음 위치에서 발견됨:"+index); //1 index = Collections.binarySearch(l, new Domain(5,null),c); // 없으면 -1이 나옴 System.out.println(index); index = Collections.binarySearch(l, new Domain(30,"오라"),c); //2 System.out.println(index); } } ``` ``` package n_generic; import java.util.*; // 클래스는 사용자정의 데이터타입 -> 멤버변수가 다양하게 구성 -> 기준점을 선정하기가 어려움 // 인터페이스 구현을 통해 기준점을 생성 class Student77 implements Comparable{ // 인스턴스 구현을 통해 클래스 비교가 가능하도록 해줌 int rollno; String name; int age; Student77(int rollno, String name, int age){ this.rollno = rollno; this.name = name; this.age = age; } public int compareTo(Student77 st) { // 오버라이딩 if(age==st.age) return 0; else if(age>st.age) return 1; else return -1; } } public class h_06_class_sort { public static void main(String[] args) { ArrayList a1 = new ArrayList(); a1.add(new Student77(101, "대한", 23)); a1.add(new Student77(106, "민국", 27)); a1.add(new Student77(105, "만세", 21)); Collections.sort(a1); // 클래스 정렬 -> 나이로 정렬 for(Student77 st:a1) { System.out.println(st.rollno + " "+st.name+" "+st.age); } } } ``` ``` package n_generic; import java.util.*; //문제 //Dept 클래스를 생성(부서번호, 부서명, 회사위치) : 생성자 만들고, get/set함수 만들고, 출력함수 //다음과 같이 데이터를 입력하고 //10, "회계부", "서울" //20, "연구부", "대전" //30, "영업부", "대구" //40, "생산부", "천안" //50, "개발부", "전주" //ArrayList에 입력하고 출력하시요(출력방법은 3가지를 다 사용해보시오) //50번 부서를 삭제해보시오 //정렬하고(sort) 2진 검색을(binarysearch) 수행해서 30번을 검색해보시오. -> 검색기준에 Comparator를 구현해서 적용 class Dept{ public int deptno; public String dname; public String loc; public Dept() {} public Dept(int deptno, String dname, String loc) { this.deptno = deptno; this.dname = dname; this.loc = loc; } public Integer getDeptno() { return Integer.valueOf(deptno); } public void setDeptno(int deptno) { this.deptno = deptno; } public String getDname() { return dname; } public void setDname(String dname) { this.dname = dname; } public String getLoc() { return loc; } public void setLoc(String loc) { this.loc = loc; } public String toString() { return deptno+" "+dname+" "+loc; } } public class h_07_Dept { public static void main(String[] args) { Dept s1 = new Dept(10, "회계부", "서울"); Dept s2 = new Dept(20, "연구부", "대전"); Dept s3 = new Dept(30, "영업부", "대구"); Dept s4 = new Dept(40, "생산부", "천안"); Dept s5 = new Dept(50, "개발부", "전주"); List al = new ArrayList(); al.add(s1); al.add(s2); al.add(s3); al.add(s4); al.add(s5); for(int i=0; i < al.size(); i++) { System.out.println(al.get(i)); } System.out.println(); Iterator itr = al.iterator(); while(itr.hasNext()) { Dept st = (Dept) itr.next(); System.out.println(st); } System.out.println(); itr = al.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } al.forEach(a->{System.out.println(a.deptno+" "+a.dname+" "+a.loc);}); // ramda 함수 System.out.println(); itr = al.iterator(); while(itr.hasNext()) { Dept st = (Dept) itr.next(); if(st.deptno == 50) { al.remove(st); // 데이터를 통째로 넘겨줌 break; } } // 겁색 : generic에서는 Wrapper class만 가능 Comparator comp = new Comparator() { public int compare(Dept u1, Dept u2) { return u1.getDeptno().compareTo(u2.getDeptno()); } }; Collections.sort(al, comp); // 정렬 int index = Collections.binarySearch(al,new Dept(30,null,null),comp); System.out.println("이진검색으로 찾은 인덱스 "+index); // 번호 System.out.println("이진검색으로 찾은 데이터 "+al.get(index)); // class al.get(index).setLoc("개발부"); int index2 = Collections.binarySearch(al, new Dept(40,null,null),comp); al.remove(index2); // 삽입삭제가 용이 LinkedList ll = new LinkedList(); ll.add(s1); ll.add(s2); ll.add(s3); ll.add(s4); ll.add(s5); Iterator itr2 = ll.iterator(); while(itr2.hasNext()) { Dept dept = (Dept) itr2.next(); System.out.println(dept); } LinkedList ll2 = new LinkedList(); ll2.add(s1); ll2.add(s2); // 링크드 리스트를 다른 링크드 리스트에 추가 ll.addAll(ll2); ll.remove(0); // 하나의 링크드 리스트를 다른 링크드 리스트에서 삭제 ll.removeAll(ll2); // 삽입삭제 ll.addFirst(s1); // 선두추가 ll.addLast(s2); // 후미추가 ll.removeFirst(); // 선두삭제 ll.removeLast(); // 후미삭제 ll.removeFirstOccurrence(s1); // 처음 발생하는 것 ll.removeLastOccurrence(s2); // 마지막에 발견되는 것 ll.clear(); // 모두 지우기 // 역순으로 순회 System.out.println("역순으로 출력하기"); Iterator reverse_iter = ll.descendingIterator(); while(reverse_iter.hasNext()) { Dept dept = (Dept)reverse_iter.next(); System.out.println(dept); } } } ``` ``` package n_generic; import java.util.*; // Map은 Iterator가 없음(순서적으로 접근) -> Map은 계산된 위치에 저장 // Map은 순서가 없음 public class h_08_Map { public static void main(String[] args) { // Map은 기본적으로 정렬이 되지 않는데 정렬이 필요한 경우는 SortedMap을 사용 -> TreeMap // HashTable(동기화를 보장), HashMap(동기화를 보장하지 않지만 처리가 빠름)이 있음 // 동기화를 보장하는 것을 rock시킨다고 함 HashMap hm = new HashMap(); // 키(hash함수를 이용해 주소값으로 변환) + 데이터로 저장 hm.put("소독", Double.valueOf(1234.12)); hm.put("체중", Double.valueOf(48.2)); hm.put("체중", 8.2); // 키값이 동일하면 이전 데이터를 대체함. hm.put("저축", 123123123); Set set = hm.entrySet(); // 키(set) : Map의 키는 set // Set : 범주형데이터를 생성(중복을 허용하지 않는 종류) Iterator i = set.iterator(); // Collections를 상속받음 while(i.hasNext()) { Map.Entry me = (Map.Entry)i.next(); // 키와 데이터의 조합을 Entry System.out.println(me.getKey()+":"); // 키값 System.out.println(me.getValue()); // 값을 가지고 옴 } double balance = (Double) hm.get("소독"); hm.put("소독", 2000); // 데이터를 수정 System.out.println(set); System.out.println(hm); } } ``` ``` package n_generic; import java.util.*; import java.io.*; public class h_09_properties { public static void main(String[] args) throws Exception{ Properties prop = new Properties(); // 프로젝트의 옵션을 관리 prop.setProperty("timeout", "30"); // 입력 prop.setProperty("language", "kr"); prop.setProperty("size", "10"); prop.setProperty("capacity", "10"); // Enumeration은 순차적으로 접근하는 반복자 - 초창기 Enumeration e = prop.propertyNames(); // Properties의 반복자 while(e.hasMoreElements()) { String element = (String)e.nextElement(); System.out.println(element+" = "+prop.getProperty(element)); } prop.setProperty("size", "20"); // 입력과 같은 함수인데 수정 System.out.println("size="+prop.getProperty("size")); prop.store(new FileWriter("info.properties"), "test"); // 파일을 오픈한 다음 테스트 후 저장 try { prop.load(new FileInputStream("info.properties")); }catch(IOException e1) { System.out.println("지정된 파일을 찾을 수 없습니다."); System.exit(0); } System.out.println("size="+prop.getProperty("size")); Properties sysProp = System.getProperties(); System.out.println("java.version:"+sysProp.getProperty("java.version")); System.out.println("user.lanuage:"+sysProp.getProperty("user.language")); sysProp.list(System.out); } } ``` package n_generic; // 1)sungjuk88 클래스를 작성 // 번호, 이름, 국어, 영어, 수학, 합계, 평균데이터를 가지고 있음 // sungjuk88은 비교가 가능하고, 파일 저장이 가능하도록 Comparable, Serializable을 implement합니다. // 2)별도의 class에서 ArrayList에 데이터를 저장하고 CRUD를 구현합니다. // 입력은 Scanner를 이용해서 입력합니다. // 출력, 검색 후 삭제, 이름수정, 검색 후 출력, 정렬, 파일저장, 파일로딩 // 메뉴 관리 함수를 작성해서 메뉴로 구동하도록 하고 9일 때는 프로그램 중지하도록 합니다. // 3)main이 담긴 클래스에서 위의 클래스들을 이용해서 작동하도록 프로그램하시오. # 3/6 ~ Student60 클래스 ``` package n_generic; import java.util.*; import java.io.*; // 비교와 저장을 위해서 interface 구현(implements) public class Student60 implements Comparator, Comparable,Serializable{ // 데이터를 결정 String name = ""; int ban; int no; int kor; int math; int eng; int total; // 데이터를 입력 Student60(){} // 디폴트생성자 Student60(String name, int ban, int no, int kor, int math, int eng){ this.name = name; this.ban = ban; this.no = no; this.kor = kor; this.math = math; this.eng = eng; total = kor+math+eng; } // 데이터를 처리(get/set) public void setName(String name) { this.name = name; } // 데이터를 출력 public void showtitle() { System.out.println("이름\t반\t번호\t국어\t수학\t영어\t합계"); } public String toString() { // Object를 통해 상속해 오버라이딩하고 있음 return name+"\t"+ban+"\t"+no+"\t"+kor+"\t"+math+"\t"+eng+"\t"+total; } // 비교해야 될 일이 있어 인터페이스를 오버라이딩 public int compareTo(Student60 sampleStu1) { // 문자열 비교 return name.compareTo(sampleStu1.name); } public int compare(Student60 samplestud1, Student60 sampleStu2) { // 숫자 비교 return sampleStu2.total - samplestud1.total; } } ``` ~ Tables 테이블 ``` package n_generic; import java.util.*; import java.io.*; public class Tables { ArrayList al = new ArrayList(); // 자료구조 선언(개수를 지정하지 않아도 됨) Scanner in = new Scanner(System.in); Iterator itr; //CRUD public void inputInfo() throws IOException{ // 1인분의 데이터 채우기 Student60 st1 = new Student60(); // Student60 st1->stack에 변수가 만들어짐, new Student60()->heap영역에 데이터 저장공간이 만들어짐 boolean re = false; // while문을 참으로 실행하기 위해서 System.out.print("이름 입력>>"); st1.name = in.nextLine(); System.out.print("반 입력>>"); st1.ban = Integer.parseInt(in.nextLine()); // Integer.paseInt 사용이유:버퍼에 엔터가 남는 것을 방지 System.out.print("번호 입력>>"); st1.no = Integer.parseInt(in.nextLine()); while(!re) { // 참인 경우 re = true; do { try { System.out.print("국어점수 입력(0~100)>>"); st1.kor = Integer.parseInt(in.nextLine()); }catch(NumberFormatException e) { System.out.print("숫자로 입력>>"); re = false; } }while(st1.kor<0 || st1.kor>100); } System.out.print("수학점수 입력(0~100)>>"); st1.math = Integer.parseInt(in.nextLine()); System.out.print("영어점수 입력(0~100)>>"); st1.eng = Integer.parseInt(in.nextLine()); st1.total = (st1.kor+st1.math+st1.eng); al.add(st1); // ArrayList에 1명 추가한 거 } public void display() { System.out.println("*****입력된 값들을 출력합니다*****"); itr = al.iterator(); // 위치만 가리키는 반복자 - 데이터의 최선두를 가리킴 while(itr.hasNext()) { Student60 s = (Student60) itr.next(); // 그래서 캐스팅이 필요 System.out.println(s); //toString을 오버라이딩했기 때문에 문자열 출력 } } public void delete() throws IOException{ System.out.print("**삭제하고자 하는 이름을 입력>>"); String inputValue = in.nextLine(); itr = al.iterator(); while(itr.hasNext()) { Student60 s = (Student60) itr.next(); if(s.name.equals(inputValue)) { itr.remove(); } } System.out.println("**삭제완료**"); } // 여러 학생을 다루기 위한 기능을 기능별로 함수화(CRUD와 처리에 대한 함수들) public void edit() throws IOException{ System.out.print("**수정하고자 하는 이름을 입력>>"); String inputValue = in.nextLine(); itr = al.iterator(); // 반복자 초기화 while(itr.hasNext()) { Student60 s = (Student60) itr.next(); if(s.name.equals(inputValue)) { System.out.print("**변경할 이름을 입력>>"); String ChangeValue = in.nextLine(); s.setName(ChangeValue); // 이름 수정 } } System.out.println("**수정완료**"); }// 삭제, 수정, 검색 기능별로 함수를 작성: 설계->구현->호출 public void searchAndShow() { System.out.print("**검색하고자 하는 이름을 입력>>"); String inputValue = in.nextLine(); itr = al.iterator(); while(itr.hasNext()) { Student60 s = (Student60) itr.next(); if(s.name.equals(inputValue)) { System.out.println(s); break; } } } // Collections/Map // Collections -> list(ArrayList, LinkedList, Stack), queue, set(HashedSet, TreeSet) // Map : HashMap, TreeMap public void sort() throws IOException{ Collections.sort(al); // 상속관계에 있는 상위 부모인 Collections의 함수를 사용 display(); } // 파일 저장로딩 public void objectDataWrite() { try { // 예외처리가 필요 FileOutputStream fos = new FileOutputStream("sungjuk"); // 바이트 단위처리 ObjectOutputStream oos = new ObjectOutputStream(fos); // 객체 단위로 처리하는 클래스 oos.writeObject(al); oos.close(); // 반드시 close 해주어야 함 fos.close(); }catch(IOException ioe) { ioe.printStackTrace(); } } public void objectDataRead() { try { FileInputStream fis = new FileInputStream("sungjuk"); ObjectInputStream ois = new ObjectInputStream(fis); al = (ArrayList) ois.readObject(); ois.close(); fis.close(); }catch(IOException ioe) { ioe.printStackTrace(); return; }catch(ClassNotFoundException c) { System.out.println("클래스를 발견할 수 없습니다."); c.printStackTrace(); return; } } // 메뉴함수 public int windowFor() throws IOException{ System.out.println("======성적 관리 시스템======"); System.out.println("----------------------"); System.out.println("1입력 2출력 3편집 4조회 5정렬 6삭제 7저장 8로딩 9종료"); System.out.println("----------------------"); System.out.println("메뉴를 선택하세요"); int ch=0; try { ch = Integer.parseInt(in.nextLine()); }catch(NumberFormatException e) { } switch(ch) { case 1: inputInfo(); return 1; case 2: display(); return 1; case 3: edit(); return 1; case 4: searchAndShow(); return 1; case 5: sort(); return 1; case 6: delete(); return 1; case 7: objectDataWrite(); return 1; case 8: objectDataRead(); return 1; case 9: System.out.println("종료합니다."); in.close(); return 0; // 0이면 종료해라 default: System.out.println("잘못입력하셨습니다."); return 1; } } } ``` =>실행 ``` package n_generic; import java.util.*; // generic 자료구조 import java.io.*; // 파일 public class h_10_sungjuk_general_menu { public static void main(String[] args) throws Exception{ // 예외처리 Tables tb = new Tables(); int i = 0; while(true) { i = tb.windowFor(); // 입출력 if(i==0) { break; } } } } ``` ----------- ------------ mariadb 설치 - 비번:acorn1234 ### mariadb - 쿼리1 ``` INSERT INTO member(num, NAME, addr) VALUES(1,'대한','서울'); -- 민국이를 2번에 대전으로 해서 입력해보세요. INSERT INTO member(num, NAME, addr) VALUES(2,'민국','대전'); INSERT INTO member(num, NAME) VALUES(3,'민국'); SELECT * FROM member; ``` - 쿼리2 ``` # 부서를 관리하는 테이블 # 데이터베이스 명령어 # DML (Data Manipulation Language) : select, insert into, update set, delete from # DDL (Data Definition Language) : create, drop(테이블 자체를 삭제), alter # DCL (Data Control Language) : grant(권한 부여), revoke(권한 회수) # TCL (Transaction Control Language) : commit, rollback # Transaction 대상 # -> insert into, update set, delete FROM은 테이블에 영향을 미침 # 여러 명령어를 그룹으로 처리하고자 할 때 # SELECT은 영향을 미치지 않음 CREATE TABLE dept( # 부서 정보 DEPTNO TINYINT PRIMARY KEY, # 1바이트 : 256가지 경우의수 DNAME VARCHAR(14), LOC VARCHAR(13) ); # KEY를 이용하여 두개의 테이블을 연결 # 데이터베이스는 검색이 우선 (중복 데이터가 있으면 안된다) # 데이터를 유일하게 구분할 수 있는 데이터 : 키(KEY) # Foreign key는 참조하는 곳에 있는 데이터 범위 내의 것이어야 한다 CREATE TABLE EMP( # Employee 직원 정보 ENPNO SMALLINT PRIMARY KEY, # 2바이트(-32768 ~ 32767) ENAME VARCHAR(10), JOB VARCHAR(9), MGR SMALLINT, HIREDATE DATE, # 입사일 : 날짜(숫자, 문자, 날짜) - 입출력할때는 문자열, 입력된 문자열은 날짜형으로 변환되어야 한다, 이후 숫자연산이 필요 SAL FLOAT, COMM FLOAT, # Commission DEPTNO TINYINT, foreign key(DEPTNO) references DEPT(DEPTNO) # DEPT 테이블의 DEPTNO를 참조한다. ); CREATE TABLE bonus( ENAME VARCHAR(10), JOB VARCHAR(9), SAL INT, COMM INT ); CREATE TABLE SALGRADE( GRADE TINYINT, LOSAL SMALLINT, HISAL SMALLINT ); INSERT INTO DEPT VALUES (10, 'ACCOUNTING', 'NEW YORK'); INSERT INTO DEPT VALUES (20, 'RESEARCH', 'DALLAS'); INSERT INTO DEPT VALUES (30, 'SALES', 'CHICAGO'); INSERT INTO DEPT VALUES (40, 'OPERATIONS', 'BOSTON'); # 포맷(Format) 문자열(ex. %s, %i) INSERT INTO EMP VALUES (7369,'SMITH','CLERK',7902,STR_TO_DATE('17-12-1980','%d-%m-%Y'),800,NULL,20); INSERT INTO EMP VALUES (7499,'ALLEN','SALESMAN',7698,STR_TO_DATE('20-2-1981','%d-%m-%Y'),1600,300,30); INSERT INTO EMP VALUES (7521,'WARD','SALESMAN',7698,STR_TO_DATE('22-2-1981','%d-%m-%Y'),1250,500,30); INSERT INTO EMP VALUES (7566,'JONES','MANAGER',7839,STR_TO_DATE('2-4-1981','%d-%m-%Y'),2975,NULL,20); INSERT INTO EMP VALUES (7654,'MARTIN','SALESMAN',7698,STR_TO_DATE('28-9-1981','%d-%m-%Y'),1250,1400,30); INSERT INTO EMP VALUES (7698,'BLAKE','MANAGER',7839,STR_TO_DATE('1-5-1981','%d-%m-%Y'),2850,NULL,30); INSERT INTO EMP VALUES (7782,'CLARK','MANAGER',7839,STR_TO_DATE('9-6-1981','%d-%m-%Y'),2450,NULL,10); INSERT INTO EMP VALUES (7788,'SCOTT','ANALYST',7566,STR_TO_DATE('1-3-1981','%d-%m-%Y'),3000,NULL,20); INSERT INTO EMP VALUES (7839,'KING','PRESIDENT',NULL,STR_TO_DATE('17-11-1981','%d-%m-%Y'),5000,NULL,10); INSERT INTO EMP VALUES (7844,'TURNER','SALESMAN',7698,STR_TO_DATE('8-9-1981','%d-%m-%Y'),1500,0,30); INSERT INTO EMP VALUES (7876,'ADAMS','CLERK',7788,STR_TO_DATE('1-5-1981','%d-%m-%Y'),1100,NULL,20); INSERT INTO EMP VALUES (7900,'JAMES','CLERK',7698,STR_TO_DATE('3-12-1981','%d-%m-%Y'),950,NULL,30); INSERT INTO EMP VALUES (7902,'FORD','ANALYST',7566,STR_TO_DATE('3-12-1981','%d-%m-%Y'),3000,NULL,20); INSERT INTO EMP VALUES (7934,'MILLER','CLERK',7782,STR_TO_DATE('23-1-1982','%d-%m-%Y'),1300,NULL,10); INSERT INTO EMP VALUES (7935,'SUNG','CLERK',7782,STR_TO_DATE('14-11-1981','%d-%m-%Y'),1500,NULL,40); -- 급여 등급 INSERT INTO SALGRADE values (1,700,1200); INSERT INTO SALGRADE VALUES (2,1201,1400); INSERT INTO SALGRADE VALUES (3,1401,2000); INSERT INTO SALGRADE VALUES (4,2001,3000); INSERT INTO SALGRADE VALUES (5,3001,9999); SELECT * FROM dept; SELECT * FROM emp; SELECT * FROM salgrade; -- SELECT 필드 FROM 테이블 WHERE 조건 -- group by 그룹으로 묶어서 처리 - excel에 있는 기능 -- order by 정렬 -- limit 개수 제한 -- emp테이블에서 사원번호, 사원이름, 직업을 출력 SELECT enpno, ename, job FROM emp; -- emp테이블에서 사원번호, 급여, 부서번호를 출력하시오. 단, 급여가 많은 순서대로 출력 SELECT enpno, sal, deptno FROM emp ORDER BY sal DESC; -- descending, 디폴트 값이 ASC -- 위의 정렬순서를 급여가 작은 것이 먼저 출력되도록 하시오. SELECT enpno, sal, deptno FROM emp ORDER BY sal ASC; -- emp테이블에서 직업, 급여를 출력해보시오. 단, 직업명으로 오름차순, 급여로 내림차순 SELECT job AS '직업', sal AS '급여' FROM emp ORDER BY job ASC, sal DESC; -- 산술연산자(+,-,*,/) -- emp테이블에서 부서번호가 10번인 사원들의 급여를 출력하되 10%인상된 금액으로 출력 SELECT sal*1.1 FROM emp WHERE deptno=10; -- 관계연산자(>,>=,<,<=,=) -- emp테이블에서 급여가 3000이상인 사원들의 모든 정보를 출력하시오. SELECT * FROM emp WHERE sal >= 3000; -- 문제 -- 부서번호가 30번이 아닌 사람들의(!=) 이름과 부서번호를 출력하시오. SELECT ename, deptno FROM emp WHERE deptno != 30; -- 논리연산자(AND, OR, NOT) -- emp테이블에서 부서번호가 10번이고 급여가 3000이상인 사원들의 이름과 급여를 출력해보시오. SELECT ename, sal FROM emp WHERE deptno =10 AND sal >= 3000; -- 문제 -- emp테이블에서 직업이 salesman이거나 manager인 사원의 사원번호와 부서번호를 출력해보시오. SELECT enpno, deptno FROM emp WHERE job = 'SALESMAN' OR job = 'MANAGER'; -- 연산(in, between, like, is null, is not null) -- in 연산자 -- 부서번호가 10번이거나 20번인 사원의 사원번호와 이름, 부서번호를 출력하시오. SELECT enpno, ename, deptno FROM emp WHERE deptno = 10 OR deptno = 20; SELECT enpno, ename, deptno FROM emp WHERE deptno IN(10,20); -- OR을 대신 -- berween -- 급여가 1000과 2000 사이인 사원들의 사원번호, 이름, 급여를 출력하시오. SELECT enpno, ename, sal FROM emp WHERE sal > 1000 AND sal <2000; SELECT enpno, ename, sal FROM emp where sal BETWEEN 1000 AND 2000; -- 사원이름이 'FORD'와 'SCOTT'사이의 사원들의 사원번호와 이름을 출력해보시오. SELECT enpno, ename FROM emp WHERE ename BETWEEN 'FORD' AND 'SCOTT'; -- like 문자열 비교 -- 사원이름이 'J'로 시작하는 사원의 사원이름과 부서번호 출력 SELECT ename, deptno FROM emp WHERE ename LIKE 'J%'; -- 사원의 이름이 'J'를 포함하는 사원의 사원이름과 부서번호 출력 SELECT ename, deptno FROM emp WHERE ename LIKE '%J%'; -- 사원이름의 두번째 글자가 'A'인 사원의 이름, 급여, 입사일을 출려하시오. SELECT ename, sal, hiredate FROM emp WHERE ename LIKE '_A%'; -- '_'는 한글자에 대응 -- 사원의 이름이 'ES'로 끝나는 사원의 이름, 급여, 입사일을 출력해보시오. SELECT ename, sal, hiredate FROM emp WHERE ename LIKE '%ES'; -- 입사년도가 81년인 사원들의 입사일과 사원번호를 출력해보시오. SELECT hiredate FROM emp; SELECT hiredate, enpno FROM emp WHERE hiredate LIKE '1981%'; -- if문 -- is null, is not null -- 커미션이 null인 사원의 사원이름과 커미션을 출력해보시오. SELECT ename, comm FROM emp WHERE comm IS NULL; -- concat함수 SELECT CONCAT(ename, '의 직업은 ', job, '입니다.') FROM emp; -- select는 for문이 없고 규칙을 모든 데이터에 적용해서 결과를 출력 SELECT CHR(65); SELECT CHR(97); SELECT LOWER('HELLO!'); SELECT UPPER('hello!'); SELECT LPAD('HI',10,'*'); -- left paddint(충전재) SELECT LENGTH('국어'); -- 출력:6 -> 데이터베이스에서는 문자당 3바이트 문자를 사용 SELECT LEFT('abcde',3); -- 왼쪽으로부터 3개 SELECT right('abcde',3); -- 오른쪽으로부터 3개 SELECT SUBSTRING('abcde',2,2); -- 두번째부터 2개 SELECT FORMAT(12345.23456789, 1); -- 소수점 첫째자리까지 SELECT ename, NVL(comm, 0) FROM emp; -- null인 경우에 0으로 출력 SELECT ABS(-10); -- 절대값(absolute) SELECT CEIL(3.1234); -- 올림 SELECT FLOOR(3.2241); -- 내림 SELECT ROUND(3.22645,2); -- 소수점 둘째자리에 반올림 SELECT MOD(10,3); -- 나머지 SELECT TRUNCATE(11111.23456789,3); -- 잘라내서 출력하기 -- 날짜 관련 함수 SELECT CURDATE(); -- 현재 날짜 출력(current date) SELECT DATE(CURDATE()); SELECT CURTIME(); -- 날짜 빼기 연산 SELECT DATE_SUB('2016-02-08', INTERVAL 60 DAY); SELECT DATEDIFF('2016-01-01 23:59:59','2016-01-03'); -- 날짜로 2일 차이 남 SELECT DATE_ADD('2016-01-04 23:59:59', INTERVAL 22 SECOND); SELECT EXTRACT(YEAR FROM '2016-01-08'); SELECT NOW(); SELECT DATE_FORMAT('2016-01-09 20:20:00','%W %M %Y'); -- 두 데이터의 주어진 단위시간 차 SELECT TIMESTAMPDIFF(HOUR, '2018-03-01', '2018-03-28'); SELECT COUNT(ename) form emp;-- 행수 카운트 SELECT SUM(sal) FROM emp; SELECT AVG(sal) FROM emp; SELECT AVG(NVL(comm,0))FROM emp; SELECT MAX(sal) FROM emp; SELECT MIN(sal) FROM emp; -- group by 부서별:집계대상이 되는 필드나 집계함수가 사용 SELECT deptno, SUM(sal) FROM emp GROUP BY deptno; -- 부서별로 집계 SELECT deptno, SUM(sal), MAX(sal), MIN(sal) FROM emp GROUP BY deptno; -- 문제 -- 1.부서별로 평균 급여를 출력해보시오.(반올림해서 소수접 1째자리까지만 출력) SELECT deptno, round(AVG(sal),1) FROM emp GROUP BY deptno; -- 2.직업별로 최대급여를 출력해보시오. SELECT job, MAX(sal) FROM emp GROUP BY job; -- job이 중복 - 범주형데이터 -- 3.급여가 1000이상인 사원들의 부서별 평균급여의 반올림값을 부서번호로 내림차순 정렬해서 출력 SELECT deptno, ROUND(AVG(sal),1) FROM emp WHERE sal >= 1000 GROUP BY deptno order by deptno DESC; -- 위를 평균급여로 오름차순으로 정렬하시오 SELECT deptno, ROUND(AVG(sal),1) FROM emp WHERE sal >= 1000 GROUP BY deptno order by ROUND(AVG(sal),1) ASC; -- 4.각 부서별로 같은 업무를 하는 사람의 인원수를 구해서 부서번호, 업무, 인원수를 -- 부서번호에 대해서 오름차순으로 정렬해서 출력하시오. SELECT deptno, job, COUNT(*) FROM emp GROUP BY deptno, job ORDER BY deptno ASC; -- having절을 이용한 그룹 제한 - group by를 한 결과에 대한 조건 -- 급여가 1000이상인 사원들의 부서별 평균 급여를 출력해보시오. -- 단, 부서별 평균 급여가 2000이상인 부서만 출력하시오. SELECT deptno, AVG(sal) FROM emp WHERE sal>1000 GROUP BY deptno HAVING AVG(sal)>=2000; -- join SELECT * FROM emp; -- emp테이블의 모든 사원들의 이름, 부서번호, 부서명을 출력해보시오. SELECT ename, emp.deptno, dname FROM emp, dept WHERE emp.deptno = dept.deptno; -- 별칭으로 처리하면 SELECT e.ename, e.deptno, d.dname FROM emp e, dept d WHERE e.DEPTNO = d.deptno; SELECT e.ename, e.deptno, d.dname FROM emp e JOIN dept d ON e.deptno = d.deptno; -- 문제 -- 1.급여가 3000에서 5000사이의 사원이름과 부서명을 출력해보시오. SELECT e.ename, d.dname FROM emp e, dept d WHERE sal>=3000 AND sal<=5000; -- 2.부서명이 'ACCOUNTING'인 사원의 이름, 입사일, 부서번호, 부서명을 출력하시오. SELECT e.ename, e.hiredate, e.deptno, d.dname FROM emp e, dept d WHERE d.dname = 'ACCOUNTING'; -- 3.커미션이 null이 아닌 사원의 이름, 입사일, 부서명을 출력해보시오. SELECT e.ename, e.hiredate, d.dname FROM emp e, dept d WHERE e.comm IS NOT NULL; ``` # 3/7 ``` -- mariadb가 동작중임을 확인(service program으로 작성:상시대기) SELECT * FROM emp; -- 문제 -- 1.급여가 3000에서 5000사이의 사원이름과 부서명을 출력해보시오. SELECT e.ename, d.dname FROM emp e, dept d WHERE e.deptno = d.deptno AND (sal >=3000 AND sal<=5000); -- 2.부서명이 'ACCOUNTING'인 사원의 이름, 입사일, 부서번호, 부서명을 출력하시오. SELECT e.ename, e.hiredate, e.deptno, d.dname FROM emp e, dept d WHERE e.deptno = d.deptno and d.dname = 'ACCOUNTING'; -- 3.커미션이 null이 아닌 사원의 이름, 입사일, 부서명을 출력해보시오. SELECT e.ename, e.hiredate, d.dname FROM emp e, dept d WHERE e.deptno = d.deptno and e.comm IS NOT NULL; -- emp테이블과 dept테이블을 조인하여 부서번호, 부서명, 이름, 급여를 출력해보시오. SELECT d.deptno, d.dname, e.ename, e.sal FROM emp e, dept d WHERE e.deptno = d.deptno; SELECT e.deptno, d.dname, e.ename, e.sal FROM emp e JOIN dept d ON e.deptno = d.deptno; -- 사원의 이름이 'ALLEN'인 사원의 부서명을 출력해보시오. -- inner join -> 두 테이블에 모두 일치하는 데이터가 있어야 함 SELECT e.ename, d.dname FROM emp e JOIN dept d ON e.deptno = d.deptno WHERE e.ename = 'ALLEN'; -- 모든 사원의 이름, 부서번호, 부서명, 급여를 출력하시오.단,dept테이블에 없는 부서도 출력해보시오. -- 두 개의 테이블을 조인할 때 좌측의 데이터를 기준으로 출력하라(Left join) -- 두 개의 테이블을 조인할 때 오른쪽의 데이터를 기준으로 출력(Right join) SELECT e.ename, d.deptno, d.dname, e.sal FROM emp e LEFT JOIN dept d ON e.deptno = d.deptno; -- 사원의 이름과 급여, 급여의 등급을 출력해보시오. SELECT * FROM salgrade; SELECT ename, sal, grade FROM emp, salgrade WHERE sal BETWEEN losal AND hisal; -- 사원의 이름과 부서명, 급여의 등급을 출력해보시오. SELECT e.ename, d.dname, s.grade FROM emp e, dept d, salgrade s where e.deptno = d.deptno AND e.sal BETWEEN s.losal AND s.hisal; -- subquery: -- select문 안에 select문 -- 결과가 하나인 것:단일행 서브쿼리 -- 결과가 복수행인 것:복수행 서브쿼리(in,all,any,exist):다중행 연산sungjuksungjuk자를 이용 -- 'SMITH'가 근무하는 부서명을 서브쿼리를 이용해서 출력하시오. SELECT dname FROM dept WHERE deptno = (SELECT deptno FROM emp WHERE ename = 'SMITH'); -- 'ALLEN'과 같은 부서에 근무하는 사원의 이름과 부서의 번호를 출력해보시오. SELECT ename, deptno FROM emp WHERE deptno = (SELECT deptno FROM emp WHERE ename = 'ALLEN'); -- 'ALLEN'과 동일한 직책을 가진 사원의 사번과 이름, 직책을 출력해보시오. SELECT enpno, ename, job FROM emp WHERE job = (SELECT job FROM emp WHERE ename = 'ALLEN'); -- 'ALLEN'의 급여와 동일하거나 더 많이 받는 사원의 이름과 급여를 출력해보시오. SELECT ename, sal FROM emp WHERE sal >= (SELECT sal FROM emp WHERE ename = 'ALLEN'); -- 'DALLAS'에서 근무하는 사원의 이름, 부서번호를 출력해보시오. SELECT ename, deptno FROM emp WHERE deptno = (SELECT deptno FROM dept WHERE loc = 'DALLAS'); -- 자신의 직속상관이 'KING'인 사원의 이름과 급여를 출력해보시오. SELECT ename, sal FROM emp WHERE mgr = (SELECT enpno FROM emp WHERE ename = 'KING'); -- 다중행 서브쿼리 -- 급여를 3000이상받는 사원이 소속된 부서와 동일한 부서에서 근무하는 사원들의 이름과 급여, -- 부서번호를 출력해보시오 SELECT ename, sal, deptno FROM emp WHERE deptno IN (SELECT deptno FROM emp WHERE sal>=3000); -- 직책이 MANAGER인 사원이 속한 부서의 부서번호와 부서명과 부서의 위치를 출력하시오. SELECT deptno, dname, loc FROM dept WHERE deptno IN (SELECT deptno FROM emp WHERE job = 'MANAGER'); -- 직책이 SALESMAN보다 급여를 많이 받는 사원들의 이름과 급여를 출력하시오. SELECT ename, sal FROM emp WHERE sal > ANY(SELECT sal FROM emp WHERE job = 'SALESMAN'); -- 부서별로 가장 급여(max(sal))를 많이 받는 사원의 사원번호, 급여, 부서번호를 출력해보시오. -- group by - 동일한 경우도 있을 수 있음 SELECT MAX(sal) FROM emp GROUP BY deptno; -- 숫자만 출력되어서 같이 출력하는 문제가 발생 -- 다중행 쿼리에서의 문제 SELECT enpno, sal, deptno FROM emp WHERE sal IN (SELECT MAX(sal) FROM emp GROUP BY deptno); ``` ### sungjuk 데이터베이스 생성 ``` INSERT INTO school(schoolname, address, schoolcode, studentcount) VALUES('충주여자고등학교', '충주시', 'CH00000001', 360); INSERT INTO school(schoolname, address, schoolcode, studentcount) VALUES('서울여자고등학교', '서울시', 'SE00000001', 1200); INSERT INTO school(schoolname, address, schoolcode, studentcount) VALUES('대전고등학교', '대전시', 'IC00000001', 560); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('김만덕', 100, 99, 99, 'CH00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('고려인', 100, 99, 99, 'CH00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('전공인', 81, 81, 81, 'SE00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('전공이', 81, 81, 81, 'SE00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('전공삼', 91, 100, 100, 'CH00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('전공사', 100, 100, 100, 'CH00000001'); INSERT INTO student(NAME, kor, mat, eng, schoolcode) VALUES('종로구', 100, 81, 71, 'IC00000001'); SELECT * FROM school; SELECT * FROM student; -- 김만덕을 검색해서 이름 국어 영어 수학 학교코드를 별칭으로 출력하시오. SELECT NAME AS '이름',kor AS '국어', mat '수학', eng '영어', schoolcode '학교코드'FROM student WHERE NAME='김만덕'; -- 이름에 전이 들어있는 사람을 모두 출력하시오. SELECT * FROM student WHERE NAME LIKE '전%'; SELECT * FROM student WHERE NAME LIKE '%전%'; -- 이름이 3자이면서 가운데 공이 들어간 사람을 출력하시오. SELECT * FROM student WHERE NAME LIKE '_전_'; -- 국어, 영어, 수학 점수가 모두 90점 이상인 사람의 국어 영어 수학점수를 출력하시오. SELECT NAME, kor, mat, eng FROM student WHERE kor>=90 AND mat>=90 AND eng>=90; -- 국어, 영어, 수학 점수 중 하나라도 90점 이상인 사람의 이름, 국어, 영어, 수학점수를 출력하시오. SELECT NAME, kor, mat, eng FROM student WHERE kor>=90 OR mat>=90 OR eng>=90; -- 국어점수가 60점에서 80점 사이인 사람 중 2사람만 출력하시오. SELECT kor FROM student WHERE kor BETWEEN 60 AND 80 LIMIT 2; -- 학생들의 이름 중 중복되는 것을 제외하고 이름만 출력하시오. SELECT district NAME FROM student; SELECT COUNT(*) AS '학생수' FROM student; -- 학생들의 이름 뒤에 님자를 붙여서 출력하시오. SELECT CONCAT(NAME,'님') FROM student; -- 학생들의 이름 뒤에 님자를 붙이고 각 점수는 10자리의 공간을 확보하고 숫자가 없는 부분은 * 붙여서 출력하시오. SELECT CONCAT(NAME, '님'),LPAD(kor, 10,'*'),LPAD(mat, 10,'*'),LPAD(eng, 10,'*') FROM student; -- 학생들의 이름 중 성을 빼고 출력하시오. SELECT SUBSTRING(NAME,2,2) FROM student; -- 학생들을 이름(오름차순)과 국어점수(내림차순)로 정렬해서 출력하시오. SELECT * FROM student ORDER BY NAME ASC, kor DESC; -- 학생의 이름, 평균, 그리고 학교이름을 출력하시오. SELECT NAME, (kor+mat+eng)/3, sc.schoolname FROM student st, school sc WHERE st.schoolcode = sc.schoolcode; -- 학교별로 총점의 합계를 구하시오. SELECT sum(kor+mat+eng) AS '학교별총점' FROM student GROUP BY schoolcode; -- 변수를 사용하는 방법 -- 데이터베이스에서 변수는 @를 붙여줌, @@가 붙으면 시스템에서 만든 변수 SET @abc = 0; SELECT schoolcode INTO @abc FROM school WHERE schoolname = '충주여자고등학교'; SELECT NAME, kor, mat, eng FROM student WHERE schoolcode = @abc; SELECT @abc; -- 데이터 백업 CREATE TABLE if NOT EXISTS student_backup AS SELECT * FROM student; SELECT * FROM student_backup; -- 문제 -- 서울여자고등학교 학생들만 se_backup 테이블로 백업하시오. CREATE TABLE if not exists se_backup as SELECT * from student where schoolcode = (SELECT schoolcode FROM school WHERE schoolname = '서울여자고등학교') ; -- SELECT * FROM student; -- 3항연산자가 연속 사용됨 -- if(kor>=90, 'A', 'B'); SELECT NAME,(if(kor>=90,'A', if(kor>=80,'B',if(kor>=70,'C',if(kor>=60,'D','F'))))) FROM student; -- 문제 -- 김만덕의 합계와 평균을 구해서 입력해보시오.(update set문) UPDATE student SET total = kor+mat+eng, average = round(total/3, 2) WHERE NAME = '김만덕'; SELECT * FROM student WHERE NAME = '김만덕'; -- 김만덕의 grade를 결정해서 입력하시오. UPDATE student SET grade = if(average>=90, 'A', if(average>=80, 'B', if(average>=70, 'C', if(average>=60, 'D', 'F')))) WHERE NAME = '김만덕'; -- 김만덕의 grade를 결정해서 입력하시오.(case end문) UPDATE student SET grade = (case when average>='90' then 'A' when (average>='80' AND average<'90') then 'B' when (average>='70' AND average<'80') then 'C' when (average>='60' AND average<'70') then 'D' ELSE 'F' END) WHERE NAME = '김만덕'; -- 나머지 계산이 안된 학생들의 총점, 평균, 학점을 계산해서 입력하시오. UPDATE student SET total = kor+mat+eng, average = round(total/3, 2), grade = if(average>=90, 'A', if(average>=80, 'B', if(average>=70, 'C', if(average>=60, 'D', 'F')))); SELECT * FROM student; -- 문제 -- 김만덕의 국어:80, 영어:60 으로 수정하시오. UPDATE student SET kor = 80, eng = 60 WHERE NAME = '김만덕'; UPDATE student SET total = kor+mat+eng, average = round(total/3, 2), grade = if(average>=90, 'A', if(average>=80, 'B', if(average>=70, 'C', if(average>=60, 'D', 'F')))) WHERE NAME = '김만덕'; SELECT * FROM student; -- ↓트리거 생성이후 -- 전공인을 국어:100 영어:100 으로 수정하시오 UPDATE student SET kor = 100, eng = 100 WHERE NAME = '전공인'; SELECT * FROM student; -- 문제 -- 만세야 국어:99, 수학:99, 영어:99 으로 입력하시오(학교코드는 CH00000001) INSERT INTO student(NAME, kor, mat, eng, schoolcode)VALUES('만세야',80,80,80,'CH00000001'); -- delete form student where name = '만세야'; -- 코드 중복이 발생하면 예외가 발생 SET @result = 0; CALL school_insert("대전여상","대전시","DE00000001",2000, @result); SELECT @result; -- 데이터입력이 잘 됨 SELECT * FROM school WHERE schoolname = '대전여상'; -- 사용자 정의 함수 호출 SELECT calc_add(10,20); SELECT calc_functino(200); -- 다음은 stored procedure를 이용해서 해결합니다. 그리고 결과를 확인해보시오. -- 문제 -- 학교이름을 대전여상을 대전여자상업고등학교로 변경하시오. UPDATE student SET schoolname = '대전여자상업고등학교' WHERE schoolname = '대전여상'; SET @result = 0; CALL school_update('대전여상','대전여자상업고등학교',@result); SELECT @result; -- 학교코드가 CH00000001번인 학교정보를 출력하시오. SELECT * FROM schoolcode = 'CH00000001'; CALL school_select2('CH00000001'); -- 이름이 CH00000001 schoolcode를 삭제하시오. SET @result = 0; CALL school_delete('CH00000001',@result); SELECT @result; -- 뷰는 자주 사용되는 select문을 테이블로 정의해서 사용하는 것 -- CH00000001에 해당되는 학교의 학생들만 별도의 테이블로 생성하시오. -- 이름 국어 영어 수학 합계 평균 학교이름 학교주소 SELECT NAME, st.kor, st.mat, st.eng, st.total, st.average, sc.schoolname, sc.address FROM student st, school sc WHERE st.schoolcode = sc.schoolcode AND sc.schoolcode = 'CH00000001'; SELECT * FROM student_view; ```