Study Web Development

11월 11일

이전으로

자바

11. 예외 처리

11-4 throw 예외의 인위적인 발생

• 의도적으로 예외를 만들어 try~catch문을 if~else문처럼 사용하는 기법
  • 웹사이트 로그인 처리시 ID와 비밀번호가 불일치하는 경우를 catch 블럭으로 보낼 수 있음

1. 새 클래스 ExceptionMain06 생성

package kr.s01.exception;

public class ExceptionMain06 {
	// throw를 이용한 인위적 예외 발생
	public void methodA(String[] n) throws Exception {
		if(n.length>0) { // 입력한 값이 있는 경우
			for(String s : n) {
				System.out.println(s);
			}
		}
		else { // 입력한 값이 없는 경우
			throw new Exception("입력한 데이터가 없습니다."); // 예외 객체를 생성하여 던짐(=조건을 만족하지 않는 경우에 catch 블럭으로 이동시킴); throw를 명시하지 않으면 생성된 예외 객체가 메서드와 관련 없는(=예외 발생이 아닌) 것으로 인식됨
		}
	}
	
	public static void main(String[] args) {
		ExceptionMain06 ex = new ExceptionMain06();
		try {
			ex.methodA(args);
		}
		catch(Exception e) {
			System.out.println(e.getMessage()); // 예외 객체에 명시한 메시지를 출력
		}
	}
}

11-6 사용자 정의 예외

• 프로그래머의 필요에 따라 예외 클래스(=Exception을 상속받은 클래스)를 만들어 사용하는 것
  • 자바에서 음수는 정상적인 데이터 입력이지만, 프로그램의 종류에 따라 음수를 입력하면 안 되는 경우가 있을 수 있음
• 예외 클래스의 이름(=자료형)이 예외의 종류를 의미하며, 기능은 상속한 Exception 클래스에서 제공하므로 추가적인 메서드를 정의할 필요는 없음
  • 예외 문구를 출력하고 싶은 경우, 인자가 있는 생성자를 정의하여 Exception의 생성자에 인자를 전달

1. ExceptionMain07 생성

package kr.s01.exception;

import java.util.Scanner;

class NegativeNumberUseException extends Exception { //사용자 정의 예외 클래스
	public NegativeNumberUseException(String str) { // 예외 문구를 지정할 수 있도록 인자를 명시
		super(str); // 인자를 Exception에 전달
	}
}

public class ExceptionMain07 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("0 이상의 수를 입력 > ");
		try {
			int a = input.nextInt();
			if(a >= 0) {
				System.out.println("입력한 수 : " + a);
			}
			else { // 사용자가 정의한 예외를 인위적으로 발생
				throw new NegativeNumberUseException("음수를 사용할 수 없습니다.");
			}
		}
		catch(NegativeNumberUseException e) { // 사용자가 정의한 예외가 발생한 경우
			System.out.println(e.getMessage());
		}
		catch(Exception e) { // 그 외의 예외가 발생한 경우
			System.out.println("예외가 발생했습니다.");
		}
		finally {
			if(input!=null) input.close(); // 예외 발생 여부와 관계없이 자원 정리; input이 null인 경우 close할 수 없으므로 조건문 처리
		}
	}
}

10. 자바 기본 클래스의 이해

10-8 Wrapper 클래스

• 기본 자료형을 감싸는 클래스로, java.lang 패키지에 포함된 기본 클래스
• int를 감싸는 Integer와 char를 감싸는 Character를 제외한 나머지의 클래스명은 기본 자료형과 동일(단, 클래스이므로 대문자로 시작)
• 명시적 객체 생성
  • new 연산자와 기본 자료형을 인자로 받는 생성자를 이용하여 객체를 생성하며, deprecated됨
• 암시적 객체 생성
  • 대입 연산자를 이용하여 객체를 생성
• 자동 Boxing
  • Wrapper 객체를 써야 할 자리에 기본 자료형 값을 쓰면 일어나는 자동 변환
• 자동 Unboxing
  • 기본 자료형 값을 써야 할 자리에 Wrapper 객체를 쓰면 일어나는 자동 변환

1. ch07-langnUtil 프로젝트에 새 패키지 kr.s05.wrapper 생성 후 새 클래스 WrapperMain01 생성

package kr.s05.wrapper;

public class WrapperMain01 {
	public static void main(String[] args) {
		boolean b = true; // 기본 자료형 데이터
		Boolean wrap_b = new Boolean(b); // 명시적 객체 생성; deprecated됨
		Boolean wrap_b2 = b; // 암시적 객체 생성
		System.out.println(wrap_b2); // 참조 자료형 데이터
		
		Integer wrap_i = new Integer(200);
		Integer wrap_i2 = 200;
		System.out.println(wrap_i2);
	}
}

2. 새 클래스 WrapperMain02 생성

package kr.s05.wrapper;

public class WrapperMain02 {
	public static void main(String[] args) {
		// 명시적으로 객체 생성
		Integer obj1 = new Integer(12);
		Integer obj2 = new Integer(7);
		
		// 연산
		int result = obj1.intValue() + obj2.intValue(); // intVaule() 메서드를 이용해 객체의 데이터를 int로 반환
		System.out.println("result = " + result);
		
		// 암시적으로 객체 생성
		Integer obj3 = 10;
		Integer obj4 = 20;
		int result2 = obj3 + obj4; // 자동 Boxing, Unboxing이 일어나므로 별도의 메서드 필요 없이 Integer 객체끼리 바로 연산하고 그 결과를 int 변수에 저장 가능
		System.out.println("result2 = " + result2);
	}
}

12. Collection

• java.util 패키지에 포함되어 있는 인터페이스로, List와 Set에 상속됨
• 데이터를 여러 개 저장할 수 있으며 크기를 변경할 수 있는 자료구조
• 데이터를 추가, 삭제, 검색할 수 있는 메서드를 제공
• 기본 자료형이 아닌 참조 자료형을 저장
  • 제네릭 표현으로 자료형을 지정하지 않을 경우, 주어진 객체를 Object로 업캐스팅하여 저장
• add()
  • 인자로 전달된 요소를 Collection에 추가하는 메서드
• remove()
  • 인자로 전달된 요소를 Collection에서 1개 삭제하는 메서드
• size()
  • Collection의 크기(요소의 수)를 반환하는 메서드
• contains()
  • 인자로 전달된 요소가 Collection에 포함되어 있으면 true, 그렇지 않으면 false를 반환하는 메서드
• isEmpty()
  • Collection이 비어 있으면 true, 그렇지 않으면 false를 반환하는 메서드

12-1 List

• java.util 패키지에 포함되어 있는 인터페이스로, Collection을 상속받음
• 순서가 있고 중복값을 허용하는 자료구조
• get()
  • 인덱스를 인자로 받아 해당하는 위치의 요소를 반환하는 메서드
• set()
  • 지정한 인덱스를 지정한 요소로 교체하는 메서드
• indexOf()
  • 요소를 인자로 받아 요소가 처음으로 등장하는 위치(=인덱스)를 반환하는 메서드
• lastIndexOf()
  • 요소를 인자로 받아 해당 요소가 마지막으로 등장하는 위치를 반환하는 메서드

ArrayList

• java.util 패키지에 포함되어 있는 클래스로, List 인터페이스를 구현
• 정렬 메서드가 없어서 요소를 정렬할 때 java.util 패키지의 Collections 클래스를 이용
  • sort()
    • 인자로 전달된 List의 요소를 사전순으로 정렬하는 메서드
  • reverse()
    • 인자로 전달된 List의 요소를 사전순의 역순으로 정렬하는 메서드

1. 새 자바 프로젝트 ch09-collections 생성하고 새 패키지 kr.s01.list 생성 후 새 클래스 ArrayListMain01 생성

package kr.s01.list;

import java.util.ArrayList;

class A {
	// Object의 toString() 메서드를 재정의
	@Override public String toString() {
		return "클래스 A";
	}
}

class B {
	
}

public class ArrayListMain01 {
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		// 데이터 저장; 서로 다른 클래스 자료형의 객체들을 보관할 경우, 다시 데이터 읽어올 때 다운캐스팅이 번거로우므로 실제로는 같은 클래스의 객체들만 보관
		al.add(new A()); // A 객체의 주소를 Object로 업캐스팅하여 전달
		al.add(new B()); // B 객체의 주소를 Object로 업캐스팅하여 전달
		al.add(10); // 10을 감싼 Integer 객체의 주소를 Object로 업캐스팅하여 전달(자동 Boxing)
		al.add("하늘"); // 문자열 객체의 주소를 Object로 업캐스팅하여 전달
		System.out.println(al); // toString() 메서드가 리스트에 저장된 데이터(=객체 주소)의 목록으로 재정의되어 있음
	}
}

2. 새 클래스 ArrayListMain02 생성

package kr.s01.list;

import java.util.ArrayList;

public class ArrayListMain02 {
	public static void main(String[] args) {
		// 리스트는 저장되는 순서를 유지하며, 중복 저장을 허용
		ArrayList al = new ArrayList();
		al.add("가나다"); // 인덱스 0번, String이 Object로 업캐스팅
		al.add("라마바");
		al.add("사아자");
		al.add("차카파");
		
		// 반복문을 이용한 ArrayList의 요소 출력
		for(int i=0;i<al.size();i++) { // 리스트의 길이는 size() 메서드를 이용
			String name = (String)al.get(i); // ArrayList에 저장된 요소는 get() 메서드를 통해 반환할 수 있으며, Object로 반환되므로 다운캐스팅해야 함
			System.out.println(name);
		}
	}
}

3. 새 클래스 ArrayListMain03 생성

package kr.s01.list;

import java.util.ArrayList;

public class ArrayListMain03 {
	public static void main(String[] args) {
		// 제네릭 표현: 객체를 생성할 때 객체에 저장할 수 있는 요소의 자료형을 클래스명과 생성자명 다음에 <>로 지정; 제네릭 표현을 사용하지 않으면 데이터 읽어올 때 ClassCastException 등 예외가 발생할 수 있으므로, 사용이 권장됨
		ArrayList<String> al = new ArrayList<String>();
		al.add("서울"); // 제네릭 표현을 쓰면 Object로 업캐스팅되지 않고 String으로 저장됨
		al.add("부산");
		// al.add(1000); // 제네릭 표현을 써서 ArrayList 객체를 생성할 때 저장되는 객체의 자료형을 String으로 지정했으므로 Integer 객체를 저장할 수 없음(=컴파일시 오류 발생)
		al.add("인천");
		
		// 반복문을 이용한 ArrayList의 요소 출력
		for(int i=0;i<al.size();i++) {
			String city = al.get(i); // 제네릭 표현을 쓰면 Object가 아니라 String으로 반환
			System.out.println(city);
		}
		
		// 확장 for문을 이용한 ArrayList의 요소 출력
		for(String city : al) {
			System.out.println(city);
		}
	}
}

4. 새 클래스 ArrayListMain04 생성

package kr.s01.list;

import java.util.ArrayList;

public class ArrayListMain04 {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("사과");
		al.add("망고");
		al.add("바나나");
		al.add("오렌지");
		al.add("사과");

		System.out.println("삭제 전");
		for(int i=0;i<al.size();i++) {
			System.out.println(i + " : " + al.get(i));
		}

		// al.remove(2); // remove() 메서드에 인덱스 값을 입력하여 지정한 요소 삭제; 인덱스 변동 발생
		al.remove("사과"); // remove() 메서드에 저장된 요소를 입력시, 일치하는 (첫 번째) 요소 삭제; 인덱스 변동 발생

		System.out.println("삭제 후");
		for(int i=0;i<al.size();i++) {
			System.out.println(i + " : " + al.get(i));
		}
		
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		al2.add(10);
		al2.add(5);
		al2.add(3);
		al2.add(20);
		
		System.out.println("삭제 전");
		for(int i=0;i<al2.size();i++) {
			System.out.println(i + " : " + al2.get(i));
		}
		
		// al2.remove(2); // 인덱스를 지정해 요소 삭제
		// Integer n = 10;
		// al2.remove(n); // 10과 일치하는 요소 삭제
		al2.remove((Integer)10); // 그냥 10을 입력하면 int라 인덱스로 인식하여 예외 발생하므로 Integer임을 명시해야 함
		
		System.out.println("삭제 후");
		for(int i=0;i<al2.size();i++) {
			System.out.println(i + " : " + al2.get(i));
		}
		
		al2.set(1, 30); // set() 메서드에 인덱스를 지정하고 변경할 데이터를 입력하여 지정한 요소의 데이터를 변경
		System.out.println("변경 후");
		for(int i=0;i<al2.size();i++) {
			System.out.println(i + " : " + al2.get(i));
		}
	}
}

5. 새 클래스 ArrayListMain05 생성

package kr.s01.list;

import java.util.ArrayList;

public class ArrayListMain05 {
	public static void main(String[] args) {
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(10);
		al.add(20);
		al.add(15);
		al.add(16);
		
		System.out.println(al);
		for(int i=0;i<al.size();i++) { // 요소의 값을 조건부로 삭제하는 경우, 인덱스를 0부터 검사하게 되면 요소가 삭제될 때 인덱스 변동이 일어나 놓치는 요소가 발생; 인덱스를 마지막부터 검사하면 요소를 삭제해도 인덱스 변동이 일어나지 않으므로 문제가 발생하지 않음
			if(al.get(i)%2==0) { //요소의 값이 짝수인 경우
				al.remove(i); // 해당 요소를 삭제
			}
		}
		System.out.println("인덱스 0부터 반복문 시작 : " + al);
		
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		al2.add(10);
		al2.add(20);
		al2.add(15);
		al2.add(16);
		
		System.out.println(al2);
		for(int i=al2.size();i>0;i--) {
			if(al2.get(i-1)%2==0) {
				al2.remove(i-1);
			}
		}
		System.out.println("마지막 인덱스부터 반복문 시작 : " + al2);
	}
}

6. 새 클래스 ArrayListMain06 생성

package kr.s01.list;

import java.util.ArrayList;
import java.util.Collections; // ArrayList에는 정렬 메서드가 없음

public class ArrayListMain06 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("머루");
		list.add("사과");
		list.add("앵두");
		list.add("자두");
		list.add("사과");
		list.add("사과");
		
		// 인덱스 탐색
		int index1 = list.indexOf("사과"); // 앞에서부터 "사과"를 탐색
		System.out.println("첫 번째 사과 : " + index1);
		int index2 = list.lastIndexOf("사과"); // 끝에서부터 "사과"를 탐색
		System.out.println("마지막 사과 : " + index2);
		int index3 = list.indexOf("망고"); // 없는 요소의 인덱스를 탐색하면 -1로 반환
		System.out.println("망고 : " + index3);
		
		// 정렬
		Collections.sort(list); // 사전순으로 요소를 정렬(=인덱스 재배치)
		System.out.println(list);
		Collections.reverse(list); // 사전순의 역순으로 요소를 정렬
		System.out.println(list);
	}
}

7. 새 클래스 ArrayListMain07 생성

package kr.s01.list;

import java.util.ArrayList;

class CartItem { // 문자열과 int를 묶어 관리하기 위해 클래스 생성
	private String name; // 상품명
	private int num; // 수량
	private int price; // 가격
	
	public CartItem() {} // 기본 생성자
	public CartItem(String name, int num, int price) { // 인자가 있는 생성자
		this.name = name;
		this.num = num;
		this.price = price;
	}
	
	// Getters and Setters
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
}

public class ArrayListMain07 {
	public static void main(String[] args) {
		ArrayList<CartItem> list = new ArrayList<CartItem>();
		list.add(new CartItem("라면", 10, 10000));
		list.add(new CartItem("김치", 5, 20000));
		list.add(new CartItem("만두", 20, 30000));
		
		// 반복문을 이용한 요소 출력; ArrayList가 2차원 배열을 대체할 수 있고, 데이터 추가, 변경, 삭제가 가능하므로 더 편리
		for(int i=0;i<list.size();i++) {
			CartItem c = list.get(i);
			System.out.println(c.getName() + ", " + c.getNum() + ", " + c.getPrice());
		}
		System.out.println();
		for(CartItem item : list) {
			System.out.println(item.getName() + ", " + item.getNum() + ", " + item.getPrice());
		}
	}
}

8. 새 클래스 ArrayListMain08 생성

package kr.s01.list;

import java.util.Random;
import java.util.ArrayList;

public class ArrayListMain08 {
	public static void main(String[] args) {
		/*
		 * [실습] 로또 프로그램
		 * 1부터 45까지의 범위에서 겹치지 않는 6개 수를 구하면서 ArrayList에 저장하고 출력하시오.
		 */
		ArrayList<Integer> lottery = new ArrayList<Integer>();
		Random lt = new Random();
		while(lottery.size()<6) { // lottery의 길이가 6이 되면 루프 중단
			int num=lt.nextInt(45)+1; // 0부터 44까지의 범위에서 정수형 난수를 발생하여 1을 더한 값을 num에 저장
			if(!lottery.contains(num)) { // lottery에 num이 없는 경우
				lottery.add(num); // lottery에 num을 저장
			}
		}
		System.out.println(lottery);
	}
}

Vector

• java.util 패키지에 포함되어 있는 클래스로, List 인터페이스를 구현
• ArrayList와 거의 비슷한 구조 및 메서드를 갖지만, ArrayList와 달리 스레드 동기화 체크를 하기 때문에 동작 속도가 더 느림

1. 새 클래스 VectorMain01 생성

package kr.s01.list;

import java.util.Vector;

public class VectorMain01 {
	public static void main(String[] args) {
		Vector<Double> v = new Vector<Double>();
		// 객체
		v.add(100.3);
		v.add(3.14);
		v.add(1000.); // 1000.0에서 0 생략 가능
		
		// 확장 for문
		for(Double n : v) {
			System.out.println(n); // Vector에 저장된 요소 출력
		}
		
		// 자원 검색
		double search = 1000.0; // 검색할 요소
		int index = v.indexOf(search);
		if(index!=-1) { // 검색할 요소가 v에 있는 경우
			System.out.println("검색 요소 " + search + "의 위치 : " + index);
		}
		else { // 검색할 요소가 v에 없는 경우
			System.out.println("검색 요소 " + search + "이/가 v에 없습니다.");
		}
		
		// 자원 삭제
		double del = 3.14; // 삭제할 요소
		if(v.contains(del)) { // 삭제할 요소가 v에 있는 경우
			v.remove(del);
			System.out.println(del + "의 삭제를 완료하였습니다 : " + v);
		}
		else { // 삭제할 요소가 v에 없는 경우
			System.out.println(del + "이/가 v에 없습니다 : " + v);
		}
	}
}

12-2 Stack

• java.util 패키지에 포함되어 있는 클래스로, Vector를 상속받음
• 가장 마지막에 넣은 데이터부터 순서대로 꺼낼 수 있는(=LIFO=후입선출) 자료구조
• push()
  • Stack에 인자로 전달된 요소를 추가하는 메서드
• pop()
  • Stack의 마지막 요소를 반환하고 제거하는 메서드
  • Stack이 비어 있는 경우 예외를 발생시킴
• peek()
  • Stack의 마지막 요소를 반환하는 메서드
  • Stack이 비어 있는 경우 예외를 발생시킴

1. 새 패키지 kr.s02.stack 생성하고 새 클래스 StackMain 생성

package kr.s02.stack;

import java.util.Stack;

public class StackMain {
	public static void main(String[] args) {
		String[] array = {"진달래", "백합", "개나리", "벚꽃", "장미"};
		Stack<String> stk = new Stack<String>();
		
		// stk에 push() 메서드로 데이터를 저장
		for(int i=0;i<array.length;i++) {
			stk.push(array[i]);
		}
		System.out.println(stk);
		
		// stk에서 pop() 메서드로 데이터를 꺼냄(=stk 안의 데이터는 지워짐)
		while(!stk.isEmpty()) { // stk이 비어 있지 않은 동안 루프
			System.out.print(stk.pop() + "\t");
		}
		System.out.println("\n"+stk);
	}
}

과제

package kr.s02.mathtest;

import java.util.Scanner;

public class RandomMain02 {
	public static void main(String[] args) {
		/*
		 * [실습] 가위바위보 게임
		 * 컴퓨터가 난수를 발생시켜 0=가위, 1=바위, 2=보를 낸다.
		 * 메뉴 > 1. 게임하기, 2. 종료
		 * [출력 예시]
		 * 가위바위보 입력 > 0. 가위, 1. 바위, 2. 보
		 * 경우 1) 무승부! (컴퓨터 : 가위, 당신 : 가위)
		 * 경우 2) 컴퓨터 승리! (컴퓨터 : 가위, 당신 : 보)
		 * 경우 3) 당신 승리! (컴퓨터 : 가위, 당신 : 바위)
		 */
		String[] item = {"가위", "바위", "보"};

		Scanner input = new Scanner(System.in);
		while(true) {
			System.out.println("========");
			System.out.println("1. 게임하기, 2. 종료하기");
			System.out.println("========");
			System.out.print("메뉴 > ");
			int num = input.nextInt();
			if(num == 1) {
				System.out.print("가위바위보 입력(0. 가위, 1. 바위, 2. 보) > ");
				int user = input.nextInt();
				// 배열의 인덱스로 사용할 것이므로 범위에 맞는지 검사
				if(user <0 || user > 2) {
					System.out.println("잘못 입력했습니다.");
					continue;
				}
				// 난수 생성하고 결과 판정
				int computer = (int)(Math.random()*3);
				/*
				 * 컴퓨터 - 사용자 = 결과 판정
				 * 0 - 0 = 0 무승부
				 * 0 - 1 = -1 사용자 승리
				 * 0 - 2 = -2 컴퓨터 승리
				 * 1 - 0 = 1 컴퓨터 승리
				 * 1 - 1 = 0 무승부
				 * 1 - 2 = -1 사용자 승리
				 * 2 - 0 = 2 사용자 승리
				 * 2 - 1 = 1 컴퓨터 승리
				 * 2 - 2 = 0 무승부
				 */
				int result = computer - user;
				if(result == 0) {
					System.out.println("무승부! 컴퓨터 : " + item[computer] + ", 사람 : " + item[user]);
				} else if(result == -1 || result == 2) {
					System.out.println("사람 승리! 컴퓨터 : " + item[computer] + ", 사람 : " + item[user]);
				} else { // result == -2 || result == 1
					System.out.println("컴퓨터 승리! 컴퓨터 : " + item[computer] + ", 사람 : " + item[user]);
				}
			}
			else if(num == 2) {
				System.out.println("프로그램 종료");
				break;
			}
			else {
				System.out.println("잘못 입력하셨습니다.");
			}
		}

		input.close();
	}
}

다음으로