내 코드

import java.util.Scanner;

public class miniBank {

    public static void main(String[] args) {
        int money=0; // 사용자의 자산 


        System.out.println("원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료");
        Scanner sc = new Scanner(System.in); 


        for(int i=0;i<100;i++) {// 사용자가 원하는 만큼 횟수를 반복해야 하므로 반복문 사용
            int choice=sc.nextInt(); // 사용자로부터 번호를 입력받기 위한 choice 변수

            // 입금하기
            if(choice==1) {
                System.out.println("입금하기 입니다.얼마를 입금하시겠습니까?");
                int insertMoney=sc.nextInt(); // 사용자가 입금할 금액 
                money+=insertMoney;
                System.out.println(money);
            }

            // 출금하기  
            if(choice==2) {
                System.out.println("출금하기 입니다.얼마를 출금하시겠습니까?");
                int withdrawMoney=sc.nextInt(); // 사용자가 출금할 금액 
                money-=withdrawMoney; 
                System.out.println(money);


            }
            // 잔액조회 
            if(choice==3) {
                System.out.println("잔액조회입니다.현재 잔액은 "+money+"원 입니다");
            }

            // 종료 
            if(choice==4) {
                System.out.println("프로그램이 종료됩니다.다음에 다시 이용해주세요");
                break;
            } 

            System.out.println("원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료");
        }
    }

}

실행 결과

원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료
1
입금하기 입니다.얼마를 입금하시겠습니까?
5000
5000
원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료
2
출금하기 입니다.얼마를 출금하시겠습니까?
500
4500
원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료
3
잔액조회입니다.현재 잔액은 4500원 입니다
원하시는 거래를 선택해주세요 (1)입금 (2)출금 (3)잔액조회 (4)종료
4
프로그램이 종료됩니다.다음에 다시 이용해주세요

총평

어찌저찌 Scanner과 if문을 활용하여 입/출금,잔액확인 로직은 구현하였다. 그런데 통장 관리 프로그램은 생각보다 구현해야 할 부분이 많았다(if 잔액이 부족하다면 출금이 불가능한 경우 등등)

현재는 내 수준에서 구현한 코드라 많은 기능과 다양한 문법을 이용하여 구현하지는 못했지만, 훗날에 좀 더 정교화된 코드를 이용하여 구현하고자 한다. 말 그대로 정말 miniBank 였다.

1. 1~45 숫자 중에서 무작위로 6개의 수를 추출한다.
2. 6개의 숫자를 추출하되, 중복되는 수가 있으면 안된다.
3. 무작위(랜덤)+중복제거된 6개의 숫자를 추출하여 사용자에게 보여준다.

코드 수정 전

public class lottoRepeat {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int lottoNumber[]=new int[7]; 

        for(int i=0;i<45;i++) {
            // for문 돌리고 배열에 숫자 저장(45개) 
            lottoNumber[i]=(int)(Math.random()*45)+1;
        }

        // 중복숫자 제거 
            for(int j=0;j<45;j++) {
                if(lottoNumber[i]==lottoNumber[j]) {

                }

        // 사용자에게 6개 숫자 노출 
        System.out.println(lotto[i]);
            }
    }

}

코드 수정 후

public class RandomRottoNumber {

    public static void main(String[] args) {
        // 랜덤 로또번호 추첨 프로그램 
        // 1~45까지의 번호가 있으며 랜덤으로 6개의 번호를 추출한다(같은 번호 중복X) 

        // 로또 번호를 저장할 lottoNumber 배열 생성 
        int[] lottoNumber=new int[7];


        // 45개의 숫자 중에서 랜덤으로 6개의 숫자 추출 
        for(int i=0;i<6;i++) {
            lottoNumber[i]=(int)(Math.random()*45)+1;

            // 중복 번호 제거 
            for(int j=0;j<i;j++) {
                if(lottoNumber[i]==lottoNumber[j]) {
                    i--;
                    break;
                }
            }
        }
        System.out.println("로또 번호:");

        // 6개 숫자 사용자에게 노출 
        for(int i=0;i<6;i++) {
            System.out.println(lottoNumber[i]+"");
        }

    }

}

고쳐야할 점

1. 배열 선언 시 왜 크기 할당을 해주지 않았나?
2. for문을 먼저 돌리고 나서 배열 안에 랜덤으로 추출된 숫자를 저장하는 것이다. i가 인덱스 번호이므로 i만큼 돌려서 그 수를 저장한다.
3. random() 함수에서 +1을 해주는 이유도 몰랐다. +1을 해주지 않으면 내가 곱해준 숫자에서 '미만'의 수에서 랜덤으로 값이 추출되는 것이기 때문에 +1을 꼭 해주어야 그 숫자의 이하의 범위에서 값이 랜덤으로 추출되는 것이다.
4. 전반적으로 접근법은 크게 틀리지 않은 것 같으나 자잘한 부분에서 오류가 많았던 것 같다. 앞으로 유의하자

수정 전 코드

package AlgorithmPkg;
import java.util.Arrays;
import java.util.Scanner; 

public class b2750 {

    public static void main(String[] args) {
        // 내 사고과: 배열 안에서 사용자가 입력한 수 만큼의 값이 나오고 그 뒤에 오름차순 

        int[] size = new int[1000];

        //배열을 선언하고 Scanner로 사용자로부터 값을 입력받는다..? 
        Scanner sc = new Scanner(System.in);
        int num =sc.nextInt();

        Arrays.sort(); // 값들 오름차순 정렬, sort()는 int가 아닌 배열에만 적용된다. 
                       // num으로 할 때는 오류가 발생하는데 배열 size로 하면 오류가 발생하지 않는다.

        for(int i:num) {
            System.out.println("[+i+]");
        }

        // 중복 제거 (if문 활용) 
    }
}

[ 내가 구현하지 못했던 점 ]

1. 정확히 배열과 Scanner을 어느 때에 적재적소에 배치해야 하는지 잘 모르는 듯 했다.
2. sort() 메소드도 java.util.sort()에 있는 것임을 까먹고 있었다.
3. 중복을 제거한다고 하는데 어떤 식으로 중복을 제거해야 하는지 구현 방법을 알지 못했다.

수정 후 코드

package AlgorithmPkg;
import java.util.Arrays;
import java.util.Scanner; 

public class b2750 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] arr = new int[N]; // 사용자가 입력한 값을 배열의 크기로 설정 

        for(int i=0; i<N; i++) {
            arr[i]=sc.nextInt();
        }

        Arrays.sort(arr);

        for(int i : arr)    
            System.out.println(i);
    }
}

1. 구글링하여 답 코드를 참고해보니 중복되는 숫자에 대한 코드는 따로 없었다. 아마도 백준 문제에서 '수는 중복되지 않는다'라고 명시를 했는데, 이 부분이 애초에 사용자로부터 중복되는 숫자를 적지 말라는 뜻이었던 것 같다.
2. 전반적인 맥락은 크게 다르지 않다. 향상된 for문을 썼는데 향상된 for문은 왼쪽에 for문 변수명을 적어주고 오른쪽에는 배열명을 적어준다. arr 배열에 대한 값들이 출력된다.
3. 결국 모든 값을 사용자한테 입력을 받는 것이다. 5 > 숫자의 개수 1 2 3 4 5 > 5개에 대한 숫자 값들 5개 1 2 3 4 5 이런식으로 오름차순이 출력되는 것이다.

괜히 꼬아서 생각한 문제가 아닌가 싶었다. 그리고 Array() 말고도 다른 버블정렬이나 삽입정렬 등 사용해서 정렬하는 예제를 많이 봤는데 나중에 기회가 된다면 한 번 도전해봐야 겠다.

수정 전 코드

import java.util.Scanner;


public class b10872 {

    public static void main(String[] args) {
        int sum=0;

        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();

         for(int i=0;i<num.length;i--) {
             sum*=num[i];
         } 
    }

}

일단 이 문제의 카테고리가 '재귀'였는데 나는 재귀를 구현하지 못했다.

수정 후 코드

import java.util.Scanner;


public class b10872 {

    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);

        int n = sc.nextInt();
        sc.close();

        int sum=factorial(n); // factorial 재귀함수 호출. 매개변수로 n 갖는다. 
        System.out.println(sum);
         } 

    public static int factorial(int n) { // factorial 함수 호출 시 매개변수가 n이었으므로 int n으로 값을 담는다. 
        if(n==0){ // 0!=0
            return 1;
        }
        if(n==1) { // 1!=1
            return 1;
        }
        return n*factorial(n-1); // 5!=5*4!, 4!=4x3!.. 같은 식으로 진행된다. 
    }

}

1. factorial(n)이라는 재귀함수를 따로 선언해주었다. 매개변수로 n을 갖는다. main함수에서 factorial 함수를 호출해준다.
2. n x n! 팩토리얼 형태로 구현하였다. 결국 5!=5x4!, 7!=7x6! .. 와 같은 형식으로 구하고자 하는 팩토리얼(n!)의 n은 그대로 곱해주고 n-1은 (n-1)!의 형태로 존재하기 때문이다.

사고과정 : 사용자로부터 입력값을 받고 그 값을 아스키 코드로 변환해서 리턴을 해줘야 할 것 같은데 아스키코드로 변환하는 방법을 모르겠다..

수정 전 코드

import java.util.Scanner;

public class b11654 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(); // Scanner로 사용자로부터 알파벳 소문자,대문자,숫자 0-9 중 입력받기 
        String s = sc.next(); // 사용자가 입력한 값 string형으로 s 변수에 저장하기 

        // 아스키로 변환 
        s.ascii();


    }

}

수정 후 코드

import java.util.Scanner;

public class b11654 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // Scanner로 사용자로부터 알파벳 소문자,대문자,숫자 0-9 중 입력받기 
        int s = sc.next().charAt(0); // String에서 char로. 문자열을 잘라 문자로 변환한다. 
                                     // int 타입 변수에 저장함으로써 문자에 대응되는 값. 즉 아스키 코드값을 저장한다. 

        System.out.println(s);


    }

}

1.Scanner에서 System.in은 왜 또 안쓴거지.. 2.그리고 string형으로 sc.next()를 하는 건 맞았지만 우리가 원하는 것은 아스키 코드가 반환되는 '정수값'이므로 int형으로 바꿔주어야 한다. 3.charAt()은 문자열을 잘라 문자로 변환하는데 sc.next().charAt(0)의 의미는 sc.next() 문자열에서 0번째에 있는 문자를 가리키는 것이다. 그리고 그것을 int형으로 바꿔 s 변수에 넣는 것이다.

참고 ) Java는 String을 처리할 때 내부(메모리 상)에서는 UTF-16 BE 인코딩으로 문자열을 저장하고, 송수신에서는 직렬화가 필요한 경우 변형된 UTF-8을 사용하여 문자열을 입/출력할때만 사용자가 지정한 인코딩 값 또는 운영체제의 기본 인코딩 값으로 문자열을 인코딩한다.

만약에 Ecplise의 File 인코딩이 UTF-8이라면 입력(UTF-8) > 송수신(변형된 UTF-8) > 자바 메모리(UTF-16) > 송수신(변형된 UTF-8) > 출력(UTF-8)

출처 : https://st-lab.tistory.com/41?category=830901

[문제] 2학년 학생들이 전공수업으로 JAVA와 DB를 수강하고 있다. 같은 과목, 같은 강의실에서 구두시험 치룸. 교단에 두 분의 교수님이 각각 앉아 있고 교수님 앞에는 구두시험 볼 학생 의자가 '하나씩' 놓여있다 . 구두시험 순서는 정해지지 X 의자에 먼저 앉는 학생이 구두시험을 볼 수 있다. 각 교수님과는 한 번에 한 학생만 시험을 볼 수 있다. JAVA와 DB 구두시험은 서로 다른학생들이 동시에 볼 수 있다.

수정 전 코드

class Students extends Thread { 

    Student(String n){ 

        number=no; 
    } 
    public void run(){ 
        javaTest.javaTellTest(number);
        Students.dbTellTest(number); 

} 
}
class javaTest { 
    synchronized void javaTellTest("JAVA 구두시험본다");

} 

class DBProfessor { 
    synchronized void dbTellTest("DB 구두시험본다"); 
} 

class JavaTest2 { 
    public static void main(String[] args){ 

        int number=Integer.parseInt(args[0]);
        javaTest j = new javaTest();
        DBProfessor = new DBProfessor(); 
        Students s[] = new Students[number]; 
        for(int i=0; i<s.length; i++){
            s[i]=new Students(i+1,j);
            s[i].start(); 
    }
}

수정 후 코드 (해당 코드 실행 안되는 중. 일단 느낌만이라도 보자)

class Student extends Thread { // 학생 쓰레드 클래스 

    String hakbun,name;
    Professor javaPf,dbPf;

    Student(String h, String n, Professor jp, Professor dbp){ 
        hakbun=h; 
        name=n;
        javaPf=jp;
        dbPf=dbp;
    } 

    public void run(){ 
        javaPf.javaOralTest(hakbun,name);
        dbPf.dbOralTest(hakbun,name);

   } 
}

class Professor { // 공유자원 교수 클래스 

    int javaNo,dbNo;

    synchronized void javaOralTest(String hakbun, String name) { 
        try { 
            long time = System.currentTimeMillis();
            System.out.println(hakbun+name+"학생이 java 구두시험을"+time+"밀리 초에"+ ++javaNo + "번째로 본다");
            Thread.sleep(1);
        } catch(InterruptedException e) { } 
    }

    synchronized void dbOralTest(String hakbun, String name) { 
        try { 
            long time = System.currentTimeMillis();
            System.out.println(hakbun+name+"학생이 db 구두시험을"+time+"밀리 초에" ++dbNo + "번째로 본다");
            Thread.sleep(1);
        } catch(InterruptedException e) { } 
    } 
} 

public class OralTest { 
    public static void main(String[] args){ 

        Professor javaP = new Professor();
        Professor dbP = new Professor();

        Student st[] = new Student[args.length/2];

        for(int i=0; i<st.length; i++)
            st[i]=new Student(args[i*2],args[i*2+1],javaP,dbP);

        for(int i=0; i<st.length; i++) 
            st[i].start(); // 쓰레드 객체가 여러개일 때 start() 주는 법 
    }
}

헷갈렸던 내용, 기억해야 할 내용

1. args[i2],args[i2+1]에서 첫번째는 hakbun이고 두번째는 name인데 왜 i*2+1을 해주는지 모르겠다. args[] 배열에 hakbun이 먼저 들어가고 그 다음 칸에 name이 들어가서 그런건가?
2. sleep() 메소드가 나오면 무조건 try~catch()로 예외처리!
3. 위에는 쓰레드 객체가 여러개이다( 다 같은 학생들) 그 여러 쓰레드 객체들에게 start()를 주어야 하는데 일일이 하나하나 줄 수 없다. 그래서 for문을 돌려 학생 객체 배열의 i 번째만큼? 길이만큼 해서 start()를 주어야 학생 쓰레드가 일을 한다.
4. currentTimeMillis()는 int형으로는 값을 담기에 범위가 커서 long형으로 선언하였다
5. run() 메소드는 학생 한 명이 하는 일들을 정의해놓았다. 결국 자바시험과 db시험을 보는 것이므로 학생 한 명이 자바시험과 db시험을 보는 것이다.
6. 나는 왜 공유자원 객체는 학생으로만 정의하면 됐는데 교수 클래스 2개로 만든건가..

수정 전 코드

class Car extends Thread { 
    private Road road; // 공유자원인 도로 객체 

    public Car(Road r,String a) { 
        road = r; 
        super(name) // 객체로부터 받아온 이름에서 생성자는 생성자 주기에만 동작한다. 그래서 멤버변수에 값을 따로 저장해준다 > 이건 어느 경우에.. 


    } 
public void run() { 
    for(int i=0;i<3;i++){
        road.runcar(i); } 
} 
} 

class Bicycle extends Thread { 
    Road road; // 공유자원인 도로 객체 

    public Bicycle(Road r,string b){
        road = r;
        b=super(name);
    } 

public void run() { 
    for(int i=0;i<3;i++){ 
        road.runBicycle(i); } 
} 

} 

class Human extends Thread { 
    Road road; // 공유자원인 도로 객체 

    public Human(Road r,String c){ 
        road = r; 
        c=super(name);
    } 

public void run() { 
    for(int i=0;i<3;i++){ 
        road.walkHuman(i); } 
} 

}

class Road { 
    int signal = 1; // 자동차 신호 
    int signal = 2; // 자전거 신호 
    int signal = 3; // 보행자 신호 

    public synchronized void runCar() { 
        while(signal!=1) { // 자동차의 신호가 1번이 아닐 때 
            try{ 
                wait(); // 자동차는 기다린다. 
            } catch (InterruptedException e) { } 
        } 
        System.out.println(a+ "가 주행한다"); // 자동차 신호가 1번이 맞으므로 차가 주행한다. 근데 왜 a값이 안넘어왔지? 
        // 자동차 신호가 자신의 일을 끝내기 전에 나머지 객체가 일할 수 있도록 신호 바꿔주기 
        if(signal==2 && signal==3){
            notifyAll(); 
        } else { } 

    }



    public synchronized void runBicycle() { 
        while(signal!=2){ 
            try{ 
                wait();  //자전거는 기다린다
            } catch (InterruptedException e) { } 
        }
        System.out.println( b + "가 달린다"); // 자전거 신호가 2번이 맞으므로 자전거가 달린다. 
        // 자전거 신호가 자신의 일을 끝내기 전에 나머지 객체가 일할 수 있도록 신호 바꿔주기
        if(signal==1 && signal==3){ 
            notifyAll(); 
        } else { }
    }


    public synchronized void walkHuman() { 
        while(signal!=3){ 
            try{ 
                wait(); // 보행자는 기다린다
            } catch(InterruptedException e) { } 
        } 
        System.out.println( c + "가 길을 건넌다");
        // 보행자 신호가 자신의 일을 끝내기 전에 나머지 객체가 일할 수 있도록 신호 바꿔주기
            if(signal==1 && signal==2){
                notifyAll(); 
            } else { }
    }

}


class ThreeSignal {
    public static void main(String[] args) { 

    Road rd = new Road(); // 공유자원인 도로 객체 
    Car car = new Car("자동차",rd); // 자동차 쓰레드 객체 , 공유자원인 도로 객체 공유 
    Bicycle bc = new Bicycle("자전거",rd); // 자전거 쓰레드 객체 
    Human hm = new Human("보행자",rd); // 보행자 쓰레드 객체 

    car.start();
    bc.start();
    hm.start();

} 

} 

수정 후 코드

class Car extends Thread { 
    private Road road; // 공유자원인 도로 객체 

    public Car(Road r) { 
        road = r; 
        } 
    public void run() { 
        for(int i=0;i<3;i++){
            road.drive();
    } 
       } 
} 

class Bike extends Thread { 
    Road road; // 공유자원인 도로 객체 

    public Bike(Road r){
        road = r;
        } 

    public void run() { 
        for(int i=0;i<3;i++){ 
            road.biking();     
    }
    } 
} 

class Man extends Thread { 
    Road road; // 공유자원인 도로 객체 

    public Man(Road r){ 
        road = r; 
        } 

    public void run() { 
        for(int i=0;i<3;i++){ 
            road.walk(); 
    } 
   } 

}

class Road { 
    private String signal = "green"; 

    public synchronized void drive() { 
        while(signal!="green") { // 자동차의 신호가 green이 아닐 때 
            try{ 
                wait(); // 자동차는 기다린다. 
            } catch (InterruptedException e) { } 
        } 
        System.out.println("차가 주행한다");
        signal = "yellow"; // 자전거 신호 바꿔주기 
        notifyAll();
        } 

    public synchronized void biking() { 
        while(signal!="yellow"){ 
            try{ 
                wait();  //자전거는 기다린다
            } catch (InterruptedException e) { } 
        }
        System.out.println("자전거가 달린다"); // 자전거 신호가 yellow가 맞으므로 자전거가 달린다. 
        // 자전거 신호가 자신의 일을 끝내기 전에 나머지 객체가 일할 수 있도록 신호 바꿔주기
        signal = "red";
        notifyAll();
        } 


    public synchronized void walk() { 
        while(signal!="red"){ 
            try{ 
                wait(); // 보행자는 기다린다
            } catch(InterruptedException e) { } 
        } 
        System.out.println("보행자가 길을 건넌다");
        signal = "green"; // 자동차 신호로 바꿔주기
        notifyAll();
            } 
    }




class ThreeSignal2 {
    public static void main(String[] args) { 

    Road rd = new Road(); // 공유자원인 도로 객체 
    Car car = new Car(rd); // 자동차 쓰레드 객체 , 공유자원인 도로 객체 공유 
    Bike bike = new Bike(rd); // 자전거 쓰레드 객체 
    Man man = new Man(rd); // 보행자 쓰레드 객체 

    car.start();
    bike.start();
    man.start();

} 

} 

놓쳤던 부분, 헷갈렸던 부분

1. 서로 하는 일이 다르면 각각의 쓰레드 클래스로 만들어주자.
2. private Road road; 처럼 road형의 매개변수는 private형이 좋다. 캡슐화를 할 수록 좋은 프로그램이다. 그러나 꼭 private로 선언할 필요는 없다.
3. car의 road와 bike의 road Man의 road는 서로 다르다. 각각의 클래스의 멤버변수이다.
4. main 클래스에서 road 객체를 만들 때 초기값이 없었다. 그러므로 공유자원 클래스 Road에서도 생성자를 만들 필요가 없다.
5. wait()는 안 깨어날 수도 있기 때문에 try~catch로 예외처리를 꼭 해주어야 한다.
6. main 클래스에서 객체 선언&생성시 초기값으로 그들이 공유하는 공유자원 객체와 쓰레드 클래스에 넘겨주어야 하는 값들을 초기값으로 지정하는 것을 명심하자.

15596번 Java: long sum(int[] a); (클래스 이름: Test) a: 합을 구해야 하는 정수 n개가 저장되어 있는 배열 (0 ≤ a[i] ≤ 1,000,000, 1 ≤ n ≤ 3,000,000) 리턴값: a에 포함되어 있는 정수 n개의 합

사고과정 : 일단은 long sum(int[] a) 라는 문장이 잘 와닿지가 않았다. 함수를 구현해야 하는 건 알고 있었고 for문으로 sum만 구하면 되겠지? 라고만 생각했던 것 같다.

그저 long type형의 함수였다. 큰 문제는 아니였던 것 같다. 답과 유사하게 코드를 짠 것 같았지만 문제에 대한 이해가 정확하게 되지는 않았던 것 같다.

public class Test1 {

    public static void main(String[] args) {
        int[] a = new int[]; // int형 a 배열 선언

        long sum(int[] a) {
            for(int i=0;i<a.length;i++) {
                sum+=a[i]; //sum에다가 a[i]번째들을 더해나가며 누적합을 구한다. 
            }
        }
        System.out.println("sum"+sum);


    }

}

정답 코드

public class Test1 {

        long sum(int[] a) {
            long sum=0; // sum안에 a 배열 원소의 합을 넣는다.

            for(int i=0;i<a.length;i++) {
                sum+=a[i]; //sum에다가 a[i]번째들을 더해나가며 누적합을 구한다. 
            }

        return sum; // long형으로 sum이 return 된다. 


    }

}

1. 만약에 long sum=0; 부분을 int로 주게 되면 return 값이 int 범위에 있다면 자동 형변환이 일어나서 문제 없이 실행된다. 그러나 문제의 조건에서 배열 길이가 a: 합을 구해야 하는 정수 n개가 저장되어 있는 배열 (0 ≤ a[i] ≤ 1,000,000, 1 ≤ n ≤ 3,000,000) 이었으므로 long형으로 선언해주어야 하는 것이다.

2. 근데, eclipse에서 출력을 해보니 main 메소드가 없다고 자꾸 오류를 출력한다. Error: Main method not found in class Test1, please define the main method as: public static void main(String[] args) or a JavaFX application class must extend javafx.application.Application

3. 함수명은 sum인데, 매개변수로 (int[] a)로 배열을 받아 객체를 처리한다.

4. 내 코드는 System.out.println(sum)으로 출력하고자 하였는데, 문제에서 함수를 구현하라고 했으므로 함수의 return값으로 값을 반환해주어야 한다.

수정 전 코드

package p1;

class firstException extends Exception
class secondException extends Exception

class firstException { 
    throw new firstException(); // 예외 발생 
    // firstException 예외 전파 

} 

class secondException { 
    throw new secondException(); // 예외 발생 
    // firstException 예외 처리 
    // secondException 예외 전파
} 

public class p1 {

    public static void main(String[] args) {
        firstException f = new firstException();
        secondException s = new secondException();
        first();
        second();


    }
    }

[내가 놓쳤던 점]

1. 예외전파에 대한 개념을 완전히 놓치고 있었던 것 같다. 해당 예외에 대한 '메소드'호출을 통해 예외를 전파시키는 것인데 나는 예외 클래스를 만들고 있었다.
2. SecondException은 왜 나오지도 않나 했는데 FirstException에서 main 시작과 끝을 다 해버렸다. 그래서 SecondException은 예외발생~처리 기회를 갖지 못한다.
3. 결국 실행 결과는 main 시작 FirstException 예외 발생 전 FirstException 예외 처리 main 끝

수정 후 코드

package p1;
class FirstException extends Exception { } 
class SecondException extends Exception { } 



public class p1 {

    static void first() throws FirstException { 
        System.out.println("FirstException 예외 발생 전");
        throw new FirstException();
    }
    static void second() throws SecondException { 
        System.out.println("SecondException 예외 발생 전");
        throw new SecondException();
    }

    public static void main(String[] args) {
        System.out.println("main 시작");
        try { 
            first();
            second();
        }
        catch(FirstException f) {
            System.out.println("FirstException 예외 처리");
        } catch (SecondException s) {
            System.out.println("SecondException 예외 처리");
        } 
        System.out.println("main 끝");

    }
    }

수정 전 코드

package p1;

class MinusException extends Exception {} 
class EmptyData extends Exception {} 

public class p1 {

    public static void main(String[] args) {

        int num=Integer.parseInt(args[0]); //args[0]번을 정수값으로 변환한다
        try { 
                if(num<0) {
                    throw new MinusException();
                }
                else if(num==0) {
                    throw new EmptyData();
                }

                System.out.println("읽어들인 숫자는:"+num);
            } 


        catch(MinusException m) {
                System.out.println("양수를 입력하시오!");
            } catch(EmptyData e) {
                System.out.println("데이터가 입력되지 않았어요!");
            } catch(NumberFormatException n) {
                System.out.println("숫자를 입력하세요");
            }
    }
}

수정 전 놓쳤던 점

1. 먼저 num을 선언해놓았었다. 근데 num값에 데이터가 없는 경우는 어떻게 처리해야 하는거지?하고 고민

수정한 코드

package p1;

class MinusException extends Exception {} 
class EmptyData extends Exception {} 

public class p1 {

    public static void main(String[] args) {

        try {
            int num;

            if(args.length==0) 

                throw new EmptyData();

        num = Integer.parseInt(args[0]);
        if(num<0) throw new MinusException();

        System.out.println("읽어들인 숫자는"+num);

        } catch(EmptyData e) {
            System.out.println("데이터를 입력하시오 !");
        } catch(MinusException m) {
            System.out.println("양수를 입력하시오!");
        } catch(NumberFormatException n) {
            System.out.println("숫자를 입력하시오");
        }
    }
    }

일단 예외처리는 프로그램 컴파일 중이 아닌** 실행중에 발생하는 오류**이다. 예외가 발생하면 그 실행이 정상적으로 이루어지지 않기 때문에 예외처리에서는 예기치 못한 사건들을 다루고, 만약 예외가 발생했을 경우 '~한 방법으로 처리해'라고 프로그래머가 직접 정의하거나 System에서 정의하는 처리 방법이 있다.

그렇다면 예외처리는 왜 사용하는걸까? 프로그래머가 만든 프로그램을 다른 사용자가 사용할 때 비정상적인 상황(예외)를 만나더라도 내 프로그램이 비정상적으로 종료되는 것이 아니라 다음 번 사용시에도 정상적으로 실행되고 프로그램이 종료될 수 있도록 하기 위해서이다.

예외클래스 종류

예외처리는 Object 클래스로부터 상속받는 Throwable 클래스로부터 Error클래스와 Exception 클래스로 나뉜다. 즉 Java의 모든 예외는 Throwable 클래스로부터 상속받는 것이다.

그중에서도 Error 클래스는 시스템에 변화를 주어야 하기 때문에 프로그래머가 직접 해결하기가 어렵다. Error 클래스를 상속받는 예외들은 H/W 관련 문제이거나 디스크 포맷이 망가지거나 StackOverFlow와 같은 문제이다.

반면에 Exception 클래스는 RuntimeException(ex.ArithmeticException,NullPointerException...)과 Instantiation Exception으로 나뉜다.

예외 클래스

위에서 Exception은 상속 받고, 또 상속을 받아 사용한다고 했다. 상속의 개념은 Class에 있는 개념이므로 클래스가 있다면 객체도 있어야 한다. 자바는 예외 하나하나를 '객체'로 취급하며 예외가 객체로 취급되기 위해서는 클래스가 있어야 하는 것이다.

자바의 모든 패키지 중에 기본 패키지가 되는 것은 java.lang이다.

내 전체 코드

import java.lang.*; 

class Student extends Thread { // 쓰레드 학생 클래스 
    String name; // 학생 이름 
    int hakbun; // 학생 학번 
    int time=System.currentTimeMillis(); //시험 시간 

    Student(String n,int h,int t){ 
        super(name);
        super(hakbun); 
        super(time);
    } 
    public void run() { 
        Test.test(int h,String n);
        Test.goBackHome(int h,String n);
        Test.checkProfessor(int h,String n);
        Test.checkTestTime(int h,String n,int h); 
    } 
} 

class Test { // 공유자원 클래스 

void test(int h,String n){ 
    System.out.println(hakbun+"번"+name+"가 JAVA 시험을 보고있다"); 
} 
void goBackHome(int h,String n){ 
    System.out.println(hakbun+"번"+name+"가 집으로 돌아간다"); 
} 
synchronized void checkProfessor(int h,String n) { 
    System.out.println("안유정교수가"+hakbun+"번"+name+"의 시험지를 확인하고 접수했다"); 
    }
void checkTestTime(int h,String n,int h){ 
    if(time>700){
        time.sleep(1.0);
    }
    else { System.out.println(hakbun+"번"+name+"가 시험본 시간은"+time.random()); } 
}

class TestJavaSync { // main 클래스 
    public static void main(String[] args){ 
        Student s1 = new Student("김별이",2020081001,time);
        Student s2 = new Student("유준서",2018081100,time);
        Student s3 = new Student("이지은",2019081077,time);

        s1.start();
        s2.start();
        s3.start();
    } 
} 

수정 코드

class Professor { // 공유자원 교수 클래스 
    String name; 
    Professor(String n) { name = n; } 

    synchronized void check_testpaper(Student s) { 
        s.end = System.currentTimeMillis();
        System.out.println(s.number+"번"+s.name+"가 시험본 시간은"+(s.end-s.begin)+"ms");
        if((s.end-s.begin)<=700)
            System.out.println(name+"교수가"+s.number+"번"+s.name+"의 시험지를 확인하고 접수했다");
        else 
            System.out.println(s.number+"번"+s.name+"의 시험지는 time over"); 
    }
} 

class Student extends Thread { 
    Professor prof;
    String name;
    int number; 
    long begin,end; 

     Student(Professor p,String n,int no){ 
        prof = p;
        name = n; 
        number = no; 
    } 
    public void run() { 
        begin = System.currentTimeMillis(); // end가 없는 이유는 교수님이 시간 check 
        testJava(name,number); // n,no라고 매개변수 값을 주면 어떻게 되지? 
        prof.check_testpaper(this); // 교수 객체가 시험지를 check하는 것이니 prof.check~ 
        goHome(name,number);
    } 

    void testJava(String n,int no){ 
        System.out.println(no+"번"+n+"가 JAVA 시험을 보고있다"); 
        try {                         
            Thread.sleep((int)(Math.random()*1000)); } 
        catch(InterruptedException e) { } 
    } 
    void goHome(String n,int no){ 
        System.out.println(no+"번"+n+"가 집으로 돌아간다");
}
} 

public class TestJavaSync2 { 
    public static void main(String[] args){ 
        Professor p = new Professor("방탄소년단");
        Student s1 = new Student(p,"김별이",2020081001); 
        Student s2 = new Student(p,"이지은",2019081077);
        Student s3 = new Student(p,"유준서",2018081100);
        s1.start();
        s2.start();
        s3.start();
    } 
}

코드 비교 main 클래스 (나)

class TestJavaSync { // main 클래스 
    public static void main(String[] args){ 
        Student s1 = new Student("김별이",2020081001,time);
        Student s2 = new Student("유준서",2018081100,time);
        Student s3 = new Student("이지은",2019081077,time);

        s1.start();
        s2.start();
        s3.start();
    } 
} 

main 클래스 (수정)

public class TestJavaSync2 { 
    public static void main(String[] args){ 
        Professor p = new Professor("방탄소년단");
        Student s1 = new Student(p,"김별이",2020081001); 
        Student s2 = new Student(p,"이지은",2019081077);
        Student s3 = new Student(p,"유준서",2018081100);
        s1.start();
        s2.start();
        s3.start();
    } 
}

1. 공유자원인 교수 객체 선언,생성을 하지 않았다.
2. time(시간)을 공유하는 것이 아닌 학생들이 교수 객체를 공유하는 것이므로, 교수 객체를 공유하도록 해야 한다 (같은 메모리 상에 있어 공유 가능)

Student 쓰레드 클래스 (나)

import java.lang.*; 

class Student extends Thread { // 쓰레드 학생 클래스 
    String name; // 학생 이름 
    int hakbun; // 학생 학번 
    int time=System.currentTimeMillis(); //시험 시간 

    Student(String n,int h,int t){ 
        super(name);
        super(hakbun); 
        super(time);
    } 
    public void run() { 
        Test.test(int h,String n);
        Test.goBackHome(int h,String n);
        Test.checkProfessor(int h,String n);
        Test.checkTestTime(int h,String n,int h); 
    } 
} 

Student 쓰레드 클래스 (수정)

class Student extends Thread { 
    Professor prof;
    String name;
    int number; 
    long begin,end; 

     Student(Professor p,String n,int no){ 
        prof = p;
        name = n; 
        number = no; 
    } 
    public void run() { 
        begin = System.currentTimeMillis(); // end가 없는 이유는 교수님이 시간 check 
        testJava(name,number); // n,no라고 매개변수 값을 주면 어떻게 되지? 
        prof.check_testpaper(this); // 교수 객체가 시험지를 check하는 것이니 prof.check~ 
        goHome(name,number);
    } 

    void testJava(String n,int no){ 
        System.out.println(no+"번"+n+"가 JAVA 시험을 보고있다"); 
        try {                         
            Thread.sleep((int)(Math.random()*1000)); } 
        catch(InterruptedException e) { } 
    } 
    void goHome(String n,int no){ 
        System.out.println(no+"번"+n+"가 집으로 돌아간다");
}
} 

1. 시험 시간 currentTimeMillis()는 int형 변수가 아닌 long형 변수에 따로 begin,end를 정의해주어야 한다.
2. Professor 클래스의 교수 객체를 따로 선언해주어야 한다. 애는 자료형 클래스가 아니라 내가 따로 만든 Professor 클래스의 교수 변수인 것이다.
3. main 클래스에서 객체 생성 시에 정의되었던 교수 객체 공유, 이름, 학번을 생성자에서 받아와야 한다. 생성자는 생성자가 진행될때만 그 값이 살아있으므로 따로 멤버변수를 지정하여 그 값을 넣어주어야 한다.
4. 쓰레드가 일을 하는 run() 클래스 안에는 쓰레드가 작업할 내용을 넣어준다. begin 변수 안에다가는 System으로부터 시험 시간을 받아와야 하므로 System 클래스 내의 time~ 메소드를 이용하여 학생이 시험 시작한 시간을 받아와야 한다. 나는 int형 변수에다가 그냥 time~ 메소드 값을 넣는 식으로 진행했는데 그러면 안된다.
5. run() 메소드 안에다가는 쓰레드가 해야 할 작업들을 모두 명시해 주었지만, void testJava나 void goHome 메소드의 경우는 동기화 메소드가 아닌 학생 쓰레드 클래스 안에서도 충분히 작업할 수 있는 내용이므로 공유자원 클래스가 아닌 쓰레드 클래스에서 선언해주었다 > 만약에 이 내용을 공유자원 클래스에 선언하면?
6. testJava 메소드 내에서 Math.random에서는 난수를 발생시키지만 0.0~1.0 내의 소수값을 반환한다. 그래서 1000을 곱하여 정수값으로 캐스트 형변환 해준다.
7. testJava 내에서 sleep을 사용하였기 때문에, sleep() 상태에서 깨어나지 않을 수 있기 때문에 trycatch문으로 예외처리를 꼭 해주어야 한다. 나는 sleep을 여기서 사용할 줄 생각도 못했고 sleep()이 나오면 반드시 trycatch 예외처리를 해주어야 한다는 것도 간과하였다.

Professor 공유자원 클래스 (나)

class Test { // 공유자원 클래스 

void test(int h,String n){ 
    System.out.println(hakbun+"번"+name+"가 JAVA 시험을 보고있다"); 
} 
void goBackHome(int h,String n){ 
    System.out.println(hakbun+"번"+name+"가 집으로 돌아간다"); 
} 
synchronized void checkProfessor(int h,String n) { 
    System.out.println("안유정교수가"+hakbun+"번"+name+"의 시험지를 확인하고 접수했다"); 
    }
void checkTestTime(int h,String n,int h){ 
    if(time>700){
        time.sleep(1.0);
    }
    else { System.out.println(hakbun+"번"+name+"가 시험본 시간은"+time.random()); } 
}

Professor 공유자원 클래스 (수정)

class Professor { // 공유자원 교수 클래스 
    String name; 
    Professor(String n) { name = n; } 

    synchronized void check_testpaper(Student s) { 
        s.end = System.currentTimeMillis();
        System.out.println(s.number+"번"+s.name+"가 시험본 시간은"+(s.end-s.begin)+"ms");
        if((s.end-s.begin)<=700)
            System.out.println(name+"교수가"+s.number+"번"+s.name+"의 시험지를 확인하고 접수했다");
        else 
            System.out.println(s.number+"번"+s.name+"의 시험지는 time over"); 
    }
} 

1.나는 왜 공유자원 클래스를 Professor가 아닌 시험으로 생각을 했었을까? 지금 생각해보면 시험은 학생들이 동시에 보고 시험이 끝나는 순서대로 나가는 것인데, 왜 처음에 '시험'을 공유자원으로 생각했는지 의문이다. 교수는 한 사람인데 시험지 체크는 한 학생밖에 하지 못하므로 교수를 공유자원으로 설정해야 한다. (학생들에 대한 공유자원) 2. 공유자원 Professor 클래스 안에서 교수 객체가 해야 할 동기화 메소드만 따로 정의하였다. 나는 모든 메소드를 다 집어넣었다. (syn~ 키워드를 통해 동기화 메소드를 구분하긴 했다) 3. 시험시간이 700ms를 오버하면 교수 객체가 time over라고 출력을 해주므로 여기서 end 시간을 만들어주고, 시간이 700ms 판단하여야 한다. s.name은 매개변수로 Student 클래스로부터 s로 해서 매개변수로 받아온다. 그래서 Student 클래스 내에 있는 (학생의) name인 것이다. 이런 식으로 접근을 해야 한다. 4. 시험지 제출을 하거나 time over이 되어 시험지 제출을 못하는 것은 교수 객체의 판단이다. 그래서 Student 객체의 s.end-s.begin 으로 해서 시험 시간을 판단한 뒤, if~else문을 활용하여 시간에 따른 시험지 제출 여부를 공유자원인 교수 클래스에서 설정해야 한다.

내가 작성한 코드

class Customer extends Thread { //쓰레드 고객 클래스 String name; int amount; int balance;

Customer(String n, int a, int b) { 
    name = n; 
    amount = a; 
    balance = b; 
} 

public void run() { BankBook.addMoney(String n,int a,int b); BankBook.subMoney(String n,int a,int b);

} }

class BankBook { //공유자원 통장 클래스

String name; 

synchronized void addMoney(String n,int a,int b){ 
    b=balance+amout; 
    System.out.println(name+"이"+a+"입금하여"+"잔액은"+b+"원");

}
synchronized void subMoney(String n,int a,int b){ 
    b=balance-amount; 
    System.out.println(name+"이"+a+"출금하여"+"잔액은"+b+"원");

}

class BankAccount { pubic static void main(String[] args){

Customer p1 = new Customer("첫번째 사람");
Customer p2 = new Customer("두번째 사람");
Customer p3 = new Cumstomer("세번째 사람");
p1.start();
p2.start();
p3.start(); 
}

답 코드

class Account { private int total_money=0; // private가 아니라 클래스형 변수로 정의한다면? synchronized void deposit(String name,int money) { // 입금하다 total_money+=money; System.out.println(name+"이"+money+"입금하여 잔액은"+total_money+"원"); } synchronized void withdrawal(String name,int money) { // 출금하다 total_money-=money; System.out.println(name+"이"+money+"출금하여 잔액은"+total_money+"원"); } }

class Man extends Thread { Account account; Man(Account act,String name){ super(name); account=act;
} public void run() { for(int i=0;i<5;i++){ account.deposit(getName(),1000); account.withdrawal(getName(),w100); } } }

public class BankAccount2 { public static void main(String[] args) { Account tongjang = new Account(); Man m1 = new Man(tongjang,"첫번째 사람"); Man m2 = new Man(tongjang,"두번째 사람"); Man m3 = new Man(tongjang,"세번째 사람"); m1.start(); m2.start(); m3.start(); } }

main 클래스부터 차근차근 보도록 하자.

(나)

class BankAccount {

_pubic _static void main(String[] args){

Customer p1 = new Customer(tongjang,"첫번째 사람");

Customer p2 = new Customer(tongjang,"두번째 사람");

Customer p3 = new Cumstomer(tongjang,"세번째 사람");

p1.start();

p2.start();

p3.start();

}

}

(수정)

public class BankAccount2 { public static void main(String[] args) { Account tongjang = new Account(); Man m1 = new Man(tongjang,"첫번째 사람"); Man m2 = new Man(tongjang,"두번째 사람"); Man m3 = new Man(tongjang,"세번째 사람"); m1.start(); m2.start(); m3.start(); } }

1. 지금 보니 내 코드에서 사람 객체 생성 시 cumstomer 라고 오답도 났다.

2. 각 쓰레드 객체가 공유하는 공유자원인 tongjang에 대해서 매개변수 값으로 넣어주지도 않았다.

3. public을 pubic 이라고 썼다.

4. 공유자원인 tongjang 객체 선언 생성도 해주지 않았다.

쓰레드 클래스 (나)

class Customer extends Thread { //쓰레드 고객 클래스 
    String name; 
    int amount;
    int balance; 

    Customer(String n, int a, int b) { 
        name = n; 
        amount = a; 
        balance = b; 
    } 
public void run() { 
    BankBook.addMoney(String n,int a,int b);
    BankBook.subMoney(String n,int a,int b);


} 
}

쓰레드 클래스(답)

class Man extends Thread { 
    Account account; 
    Man(Account act,String name){ 
        super(name);
        account=act;         
    } 
    public void run() { 
        for(int i=0;i<5;i++){ 
            _account.deposit(getName(),1000); _
        _    account.withdrawal(getName(),100); _
    }
} 
}

1. main 클래스에서 객체 생성시에 넘어오는 tongjang 객체와 name을 받아올 변수만 따로 생성자에 정의를 해주면 되는데 여기서 이름,잔액,입출금액 변수를 따로 정의하였다.
2. 쓰레드 run() 메소드 안에서는 각 쓰레드가 작업할 내용을 적어주면 되는데 쓰레드가 동작하는 deposit,withdrawal 메소드가 5번씩 일하면 되므로 for문이 들어갔어야 한다. (메소드 정의가 아니라)
3. 쓰레드가 일을 하면서 getName()을 통해 객체 생성 시에 넘겨온 이름을 저장한다. 1000원(입금), 100원(출금) 입금액과 출금액이 정해져 있으므로 매개변수로 넘겨준다.

공유자원 클래스 (나)

class BankBook { //공유자원 통장 클래스 

    String name; 

        synchronized void addMoney(String n,int a,int b){ 
        b=balance+_amout_; 
        System.out.println(name+"이"+a+"입금하여"+"잔액은"+b+"원");

    }
    synchronized void subMoney(String n,int a,int b){ 
        b=balance-amount; 
        System.out.println(name+"이"+a+"출금하여"+"잔액은"+b+"원");


}

공유자원 클래스 (답) 

class Account { private int total_money=0; // private가 아니라 클래스형 변수로 정의한다면? synchronized void deposit(String name,int money) { // 입금하다 total_money+=money; System.out.println(name+"이"+money+"입금하여 잔액은"+total_money+"원"); } synchronized void withdrawal(String name,int money) { // 출금하다 total_money-=money; System.out.println(name+"이"+money+"출금하여 잔액은"+total_money+"원"); } }

1. 괄호 닫아주는 것도 마지막에 } 를 해주지 않았다. 
2. 잔액을 정의하는 변수는 공유자원 클래스에서 따로 정의를 해줬어야 한다. 그래야 잔액에서 입금,출금 메소드를 이용하여 잔액에서 돈을 더해나가거나 빼나가야 한다. 
3. amount도 amout 라고 변수 오타가 났다.