JAVA study 15

1. exception 예외처리

1) try_catch

자바에서 프로그램이 실행되는 도중 예외(오류, 에러, 버그)가 발생하면, 그 시점에서 강제적으로 종료된다.

이것은 올바른 판단이지만, 때로는 예상 할 수 있는 예외에 대해 프로그램을 종료하지 않고 이후의 작업을 이어 나가야할 때가 있다. 이때 예외 처리를 통해 프로그램의 비정상적인 종료를 줄일 수 있다.

package ex1_exception;

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

		// try-catch(예외처리)
		// 자바에서 프로그램이 실행되는 도중 예외(오류, 에러, 버그...)가 발생하면
		// 그 시점에서 강제적으로 종료된다. 이것은 올바른 판단이지만, 때로는 예상할 수 있는
		// 예외에 대해 프로그램을 종료하지 않고 이후의 작업을 이어 나가야 할때가 있다.
		// 예외 처리를 통해 프로그램의 비정상적인 종료를 줄일 수 있다.

		int result = 0;
		int[] arr = new int[2];

		// try는 하나밖에 만들지 못함
		// try 영역 밖에서 오류가 나면 코드 자체가 실행이 안됨
		try { 
			int n = 2; // try 영역에서 만든 변수는 지역 변수로서 catch에서도 사용 불가

			result = 10 / n; // try에서 오류가 나면 오류가 난 시점에서 아래 내용을 실행하지 않고 바로 catch로 빠져 나간다

			arr[1] = 100; // try영역에서는 최초 오류만 확인 가능하고 그 다음 생긴 오류에 대해서는 위 오류를 수정할때까지 확인 할 수 없다.
			System.out.println("안녕");

			// catch를 여러개 만들어 각 오류에 대해 대응할 수 있다.
			// 이때는 Exception의 명칭을 정확히 해주는 것이 좋다
		} catch (ArithmeticException e) { // try에서 오류가 나면 실행 되는 영역으로 오류가 없을 경우 실행된지 않는다
			// n = 10;
			System.out.println("0으로 나눌 수 없어요");
			// e.printStackTrace(); //오류의 문제 파악 (개발자 측면)

		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("존재하지 않는 index로 접근함");

		} finally {
			//예외 발생 여부와 관계 없이 반드시 실행되는 영역
			System.out.println("finally");
		}

		System.out.println(result);

	}// main
}

 

2) throws

package ex2_exception;

public class Exception1 {

	public void div1(int n) throws ArithmeticException {

		//throws를 통해 현재 메서드에서 발생한 오류를
		//다른 클래스에서 잡아 줄 수 있도록 넘길 수 있다.
		int num = 10 / n;
		System.out.println(num);
		
	}
}

package ex2_exception;

public class Exception2 {

	public void div2(int n) throws ArithmeticException {

		int num = 10 / n;
		System.out.println(num);

	}
}

--

package ex2_exception;

public class ExceptionMain {
	public static void main(String[] args) {
		
		Exception1 e1 = new Exception1();
		Exception2 e2 = new Exception2();
		
		try {
		e1.div1(0);
		e2.div2(0);
		}catch (Exception e) {
			System.out.println("0으로 나눌 수 없어요");
		}
		
		System.out.println("프로그램 종료");
		
	}//main
}

 

예제1)

package ex3_exception;

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

public class Ex1_exception {

	public static void main(String[] args) {
		
		//Scanner를 통해 키보드에서 정수를 입력받도록한다
		//정수를 받았을때는 그 값을 그대로 출력하되
		//정수가 아닐경우 '정수만 입력하세요'를 출력
		//-------------
		//정수 : 10
		//입력받은 수 :10 
		
		//정수 : a
		//정수만 입력하세요
		
		Scanner sc = new Scanner(System.in);
		System.out.println("입력 : ");
	
		try { 
			int num = sc.nextInt();
			System.out.println("입력받은 수 : " + num);
			
		}catch (Exception e) {
			System.out.println("정수만 입력하세요");
			
		}
		
	}//main
}

 

예제2)

package ex3_exception;

import java.util.Scanner;

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

		// 정수 : 100
		// 결과 : 100

		// 정수 : abc
		// abc는 정수가 아님

		Scanner sc = new Scanner(System.in);
		System.out.print("입력 : ");
		String number = sc.next();

		try {

			int n = Integer.parseInt(number);
			System.out.println("결과 : " + n);

		} catch (Exception e) {
			System.out.println(number + "는 정수가 아님");
		}

	}// main
}

 

2. thread

메인 스레드 이외 추가로 스레드가 하나 더 있으면 Single thread, 2개 이상이면 Multi thread

package ex4_thread;

public class ThreadTest extends Thread {
//스레드는 독립적인 실행 단위
// 한번에 두가지 이상의 프로세스를 실행 가능하게 해 준다

//Thread를 사용하려면 Thread를 부모 클라스에서 상속받은 후 run 메소드를 반드시 오버라이딩해서 스레드 사용
//run 밖에서는 순차적으로 실행되고 독립적으로는 실행되지 않는다	

	@Override
	public void run() {
		// 프로세스의 독립적인 수행을 위한 영역

		for (int i = 0; i < 10; i++) {
			System.out.println("스레드 실행중");

			try {
				Thread.sleep(1000); // try-catch에 반드시 씌워야함
			} catch (InterruptedException e) {

				e.printStackTrace();
			}

		} // for

	}

}

--

package ex4_thread;

public class ThreadMain {

	public static void main(String[] args) {

		ThreadTest tt = new ThreadTest();
		// start라는 메소드로 run()내부의 코드를 독립적으로 실행
		tt.start();

		System.out.println("메인스레드 종료");

	}// main
}

 

thread 특징

package ex5_thread;

public class T1 extends Thread {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("1");
		}
	}
}

package ex5_thread;

public class T2 extends Thread {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("2");
		}
	}
}

--

package ex5_thread;

public class TMain {

	public static void main(String[] args) {

		T1 t1 = new T1();
		T2 t2 = new T2();

		// 인접한 위치에서 호출된 스레드들은 누가먼저 실행될지 절대로 예측할 수 없다
		t1.start();

		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		t2.start();

	}

}

 

runnable

어떤 클래스가 이미 extends(상속) 되어있을때, runnable을 이용하여(implements) 스레드 사용 가능

package ex6_runnable;

public class RunnableTest implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		} // for
	}

}

--

package ex6_runnable;

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

		RunnableTest rt = new RunnableTest();
		Thread t1 = new Thread(rt); //어떤 클래스가 이미 상속(extends) 되어 있을때 runnable을 이용하여(implements) 스레드 사용 가능. 어떤것을 run 시킬지 rt자리에 씀
		t1.start();
		
		System.out.println("메인종료");

	}// main
}

 

예제)

package ex7_thread;

public class TCount extends Thread {

	private int num = 0;

	public void setNum(int num) {
		this.num = num;
	}

	@Override
	public void run() {

		for (int i = num; i >= 0; i--) {
			System.out.println(i);

			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}

	}

}

--

package ex7_thread;

import java.util.Scanner;

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

		// 스캐너를 통해 키보드에서 정수를 입력받는다
		// 입력받은 숫자가 1초에 1씩 감소되면서 출력되다가 0이 되었을때
		// 프로그램(스레드)을 종료하시오
		// ---------

		Scanner sc = new Scanner(System.in);
		System.out.println("입력 : ");
		int n = sc.nextInt();

		TCount t1 = new TCount();
		t1.setNum(n);
		t1.start();

	}// main

}

 

throws를 이용하여 강제로 try-catch를 만들어야하는 구문을 한곳으로 던져서 그곳에서 한번에 처리 가능

package ex8_throws;

public class T1 {

	public void showNum1() throws InterruptedException {

		for (int i = 0; i < 10; i++) {

			System.out.println("num1");
			Thread.sleep(1000);

		} // for
	}
}

package ex8_throws;

public class T2 {

	public void showNum2() throws InterruptedException {

		for (int i = 0; i < 10; i++) {

			System.out.println("num2");
			Thread.sleep(1000);

		} // for
	}
}

--

package ex8_throws;

public class TMain {

	public static void main(String[] args) {

		T1 t1 = new T1();
		T2 t2 = new T2();

		// throws로 넘겨받은 오류에 대해서
		// 한번에 처리하기 위해 main 메서드가 try-catch구문을 생성
		try {
			t1.showNum1();
			t2.showNum2();
		} catch (Exception e) {

		}

	}// main

}

 

daemon thread

package ex9_daemon;

public class Work extends Thread {

	@Override
	public void run() {

		while (true) {

			try {
				Thread.sleep(3000);
				System.out.println("자동저장 완료");

			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		} // while
	}

}

--

package ex9_daemon;

public class DaemonMain {

	public static void main(String[] args) throws InterruptedException {

		// 데몬스레드
		// 다른 스레드의 작업을 돕는 보조적인 역할을 수행
		// 데몬스레드를 호툴한 클래스가 종료되면 함께 종료된다

		Work dm = new Work();

		// Work 클래스를 데몬스레드로 지정. main에서 지정한 Daemon class에서 종료하면 다른 곳에서 while문으로 무한 반복하던
		// 영역도 종료
		dm.setDaemon(true);
		dm.start();

		for (int i = 1; i <= 15; i++) {
			Thread.sleep(1000);

			System.out.println(i);
		}

		System.out.println("게임종료");

	}// main
}

 

synchonized

package ex10_synchronized;

public class SyncEx implements Runnable {
//여러개 자원을 하나의 메소드에서 구현하려면 러너블이 구현되야함

	private int money = 10000;

	// 스레드 동기화
	// 특정 (여러개의) 스레드들이 하나의 자원을 공유하고 있을 때, 현재 자원을 사용중이지 않은 다른 스레드가
	// 작업을 멈추고 대기상태가 되도록 처리하는 것

	@Override
	public void run() {

		//synchronized 영역을 만들면 해당 영역에서 사용되는 코드를
		//먼저 접근한 스레드가 작업을 마무리 할때까지, 다른 스레드에서 접근할 수 없다.
		synchronized (SyncEx.class) {

			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(500);

					String tname = Thread.currentThread().getName();

					if (money > 0) {
						money -= 1000;
						System.out.println(tname + "- 잔액 : " + money);
					} else {
						System.out.println(tname + "- 잔액부족");
					}

				} catch (Exception e) {

				}
			} // for

		} // synchronized

	}

}

--

package ex10_synchronized;

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

		SyncEx atm = new SyncEx();
		Thread mom = new Thread(atm, "엄마");
		Thread son = new Thread(atm, "아들");

		mom.start();
		son.start();

	}// main
}

 

과제 1) 문제 정답까지 시간 측정

package ex11_work;

import java.util.Random;
import java.util.Scanner;

public class Quiz extends Thread {

	private int su1, su2;
	private int timer = 0;
	private int playCount = 0;
	private boolean isCheck = true; // 두개의 스레드를 한번에 멈추기 위해서 (하단 isCheck 쓴거 확인)
	private final int FINISH = 5; // 상수값 관리, 몇문제 맞출지, 맞췄는지 위에서 관리 가능
	private Random rnd = new Random(); // 랜던음 계속 활용하니 변수로 선언
	private Scanner sc = new Scanner(System.in); // 이것도

	public void startGame() {

		while (isCheck) { // isCheck == true / !isCheck == false

			su1 = rnd.nextInt(100) + 1;
			su2 = rnd.nextInt(100) + 1;
			System.out.printf("%d + %d = ", su1, su2);
			int result = sc.nextInt();

			if (result == su1 + su2) {
				System.out.println("정답");
				playCount++;
			} else {
				System.out.println("오답");
			}

			// 정답처리
			if (playCount == FINISH) {
				System.out.printf("결과 : %d초\n", timer);
				isCheck = false; // while문 종료 -> while문 나감
			}
		} // while

	}// startGame

	@Override
	public void run() {
		// 1초에 1씩 timer를 증가시키는 영역
		while (isCheck) {

			try {
				Thread.sleep(1000);
				timer++; // 1초 뒤에 타이머 카운터 하나 증가

			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		} // while

	}

}

--

package ex11_work;

public class QuizMain {

	public static void main(String[] args) {

		Quiz q = new Quiz();
		q.start(); // 게임보다 시간 스타트를 먼저하는 것이 좋음
		q.startGame();

	}// main
}

 

과제2) Runners

package ex12_work;

import java.util.Random;

public class Runners {

	public static void main(String[] args) throws InterruptedException {

		int[] playerRandom = new int[2]; // 달리기 인원
		String[] playerJump = new String[playerRandom.length]; // 달리는 사람 공간 배열
		for (int i = 0; i < playerJump.length; i++) {
			playerJump[i] = "";

		}

		boolean finish = false;
		int winnerPlayer = 0;

		Random rnd = new Random();

		while (true) {

			for (int i = 0; i < playerRandom.length; i++) {
				playerRandom[i] = rnd.nextInt(2);
			}
			// 0.1초 간격으로 휴식
			Thread.sleep(100);

			// 각 선수에게 달릴 거리를 적용
			for (int i = 0; i < playerJump.length; i++) {
				switch (playerRandom[i]) {
				case 0:
					playerJump[i] += "";
					break;

				case 1:
					playerJump[i] += " ";
					break;
				}// switch

			} // for

			// 달리기
			System.out.println("============================================================");
			for (int i = 0; i < playerJump.length; i++) {
				System.out.print(playerJump[i]);
				System.out.println(i + 1 + "옷");

				if (playerJump[i].length() >= 50) { // 결승점(50)까지 먼저 도달한 선수
					winnerPlayer = i + 1;
					finish = true;
				}
			} // for
			System.out.println("============================================================");

			if (finish) { // finish == true
				System.out.println("win - " + winnerPlayer);
				break;
			}
		} // while

	}// main

}