하위^^

1.Generic 메소드

메소드 안에서 객체화

package chap08.exam08.gmethod;

public class Gmethod {
	
	// 매개변수에 T 사용
	// 인자값의 타입에 따라 제너릭에 영향을 준다.
	// 들어오는 타입에 따라 대응이 된다.
	public <T> void method1(T t) {
		System.out.println("입력 값 : " + t);
	}
	
	// 받은 값을 그대로 반환
	public<T> T method2(T a) {
		return a;
	}
	
	// 매개변수를 이용한 반환타입 설정
	public <T> Box<T> method3(T t){ // 1. 100이 들어온다.
													// 2. T의 타입이 Integer가 된다.
		Box<T> box = new Box<T>();   // Integer 형태로 객체화
													// 객체에 100이 들어간다.
		box.setValue(t);
		return box;								// 이 객체를 반환 한다.
	}
}

package chap08.exam08.gmethod;

public class Box<T> {
	// 아직 뭔지는 모르나 어떤 타입이 설정 될 예정
	// 타입이 설정되면 클래스 모든 타입이 통일 된다.
	// 클래스 선언/객체화 될 때 타입을 설정함.
	// T 자리에는 쓰고싶은거 써도 됨
	private T value;

	public T getValue() {
		return value;
	}

	public void setValue(T value) {
		this.value = value;
	}
}

package chap08.exam08.gmethod;

public class Main {

	public static void main(String[] args) {
		Gmethod test = new Gmethod();
		
		test.method1("ㅎㅇ");
		
		String str = test.method2("고길동 재산 : ");
		int money = test.method2(Integer.MAX_VALUE);
		System.out.println(str + money);
		
		Box<Integer> box1 = test.method3(100);
		System.out.println(box1.getValue());
		Box<String> box2 = test.method3("hong");
		System.out.println(box2.getValue());
		
		// Method의 return type과 Reference type이
		// 상황에 따라 유연하게 변경가능
	}

}

2.Generic 상속

Generic 역시 상속이 가능하다.

package chap08.exam09.inheritance;

public class BasicInfo <N, A> {
	private N name;
	private A age;
	public N getName() {
		return name;
	}
	public void setName(N name) {
		this.name = name;
	}
	public A getAge() {
		return age;
	}
	public void setAge(A age) {
		this.age = age;
	}
}

package chap08.exam09.inheritance;

public class DetailInfo<N, A, H> extends BasicInfo<N, A> {
	private H hobby;

	public H getHobby() {
		return hobby;
	}

	public void setHobby(H hobby) {
		this.hobby = hobby;
	}
	
}

package chap08.exam09.inheritance;

public class Main {

	public static void main(String[] args) {
		//
		DetailInfo<String, Integer, String> info = new DetailInfo<String, Integer, String>();
		
		info.setName("둘리");
		info.setAge(56);
		info.setHobby("호잇");
		
		System.out.println(info.getName() + ", 나이는 " + info.getAge() + "\n" + "취미는 " + info.getHobby());
	}

}

1.Generic

Generic은 클래스의 인자를 유동적으로 사용하기 위해 만들어진 개념이다.

클래스 생성자나 메소드 그리고 변수의 자료형은 상황에 따라서 유동적일 필요가 있기 때문이다.

사용법은 [접근제한자] class [이름] [<A, B, C, .....>] 와 같이 사용할 자료형 갯수만큼 <> 안에 넣어두면 된다.

기본적인 예제

package chap08.exam04.generic;

public class Box<T> {
	// 아직 뭔지는 모르나 어떤 타입이 설정 될 예정
	// 타입이 설정되면 클래스 모든 타입이 통일 된다.
	// 클래스 선언/객체화 될 때 타입을 설정함.
	// T 자리에는 쓰고싶은거 써도 됨
	private T value;

	public T getValue() {
		return value;
	}

	public void setValue(T value) {
		this.value = value;
	}
}

package chap08.exam04.generic;

public class Main {

	public static void main(String[] args) {
		// 객체화 할 때 타입을 지정
		Box<Integer> box = new Box<Integer>(); // 뒤에 인티져는  생략 가능
		box.setValue(1234);
		int val = box.getValue();
		System.out.println(val);
	}

}

제네릭 선언시에는 다음과 같이 인자를 무한히 사용 할 수 있다.

하지만 getter와 setter 설정과 선언, 객체화 시 번거로움이 생긴다.

package chap08.exam05.multi;
// 복수의 파라미터는 , 로 구분
public class MultiBox<K, V> {
	
	private K key;
	private V value;
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
}

package chap08.exam05.multi;

public class Main {

	public static void main(String[] args) {
		MultiBox<String, Integer> box = new MultiBox<String, Integer>();
		
		// 추천 메소드 항목에서도 반환타입이 바뀐걸 확인 할 수 있다.
		// 데이터 넣기
		box.setKey("홍길동");
		box.setValue(90);
		
		// 데이터 빼기
		String name = box.getKey();
		int score = box.getValue();
		System.out.println(name + " : " + score);
	}

}

제네릭 응용

제네릭의 요소가 너무 많을경우 코드 길이가 길어지고 작성하는데도 오래 걸리지만 다음과 같이 사용하면 된다.

package chap08.exam07.classtype;

public class Employee <T> {
	
	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
}

package chap08.exam07.classtype;

public class Info {
	
	private int emp_no;
	private String name;
	private int age;
	private long salary;
	private long asset;
	private float commision;
	private boolean married;
	private String hobby;
	public int getEmp_no() {
		return emp_no;
	}
	public void setEmp_no(int emp_no) {
		this.emp_no = emp_no;
	}
	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 long getSalary() {
		return salary;
	}
	public void setSalary(long salary) {
		this.salary = salary;
	}
	public long getAsset() {
		return asset;
	}
	public void setAsset(long asset) {
		this.asset = asset;
	}
	public float getCommision() {
		return commision;
	}
	public void setCommision(float commision) {
		this.commision = commision;
	}
	public boolean isMarried() {
		return married;
	}
	public void setMarried(boolean married) {
		this.married = married;
	}
	public String getHobby() {
		return hobby;
	}
	public void setHobby(String hobby) {
		this.hobby = hobby;
	}
}

package chap08.exam07.classtype;

public class Main {

	public static void main(String[] args) {
		Employee<Info> emp = new Employee<Info>();
		// 넣는 과정 info에다가 값 넣음 -> Employee에 저장
		Info info = new Info();
		
		info.setEmp_no(123);
		info.setName("Kim");
		info.setSalary(1000000);
		info.setHobby("movie");
		emp.setT(info);
		// emp에서 info를 빼옴 -> info에서 개별값을 꺼내옴
		info = emp.getT();
		System.out.println(info.getEmp_no());
		System.out.println(info.getName());
		System.out.println(info.getSalary());
		System.out.println(info.getAge());
	}

}

1.Object 형

Object형은 모든 자료형의 상위, 부모에 위치한 자료형이다.

모든 자료형을 받을 수 있다.

안에 무엇이 들어갈지 모를때 Object로 선언하여 먼저 값을 받고 instance of로 값을 확인하여 사용한다.

package chap08.exam03.obj;

public class Box {
	private Object value; // 이 안에 뭐가 들어갈지 모르기 때문에 object 선언

	public Object getValue() { // 겟터 셋터 설정
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}
}

package chap08.exam03.obj;

public class Main {

	public static void main(String[] args) {
		// 송장 없는 택배박스
		Box box = new Box();
		box.setValue(1234);
		//캐스팅을 할 때는 instanceof를 활용해야 안전하다.
		int val = (int) box.getValue();
		System.out.println(val);
	}

}

1.String

String은 하나의 자료형이라기 보다는 클래스라고 이해하는편이 쉽다.

문자형을 배열처럼 나열하여 문자열을 만든게 String이다.

String은 만들때 다양한 메소드들, 생성자들이 구현되어 있다.

- 다양한 초기화 방법

package chap08.exam01.string;

public class StringMehod {

	public static void main(String[] args) {
		// 문자열 만드는 방법
		String str1 = "abcd";
		
		String str2 = new String("abcde");
		
		char[] alphabet = {'a','b','c','d','e','f'};
		String str3 = new String(alphabet);
		
		System.out.println(str1);
		System.out.println(str2);
		System.out.println(str3);
	}

}

- 문자열 길이 (length())

- 특정 인덱스 가져오기 (charAt(n))

- 특정 부분부터 원하는 부분까지 잘라내기 (substring(n1, n2) , 자주 쓰이므로 꼭 알아두자

- 문자 배열을 문자열으로 / 문자열을 문자 배열로 넣기

- 특정 구분자를 기준으로 나누기 (split(""))

- 특정 문자열 찾기 (indexOf("")), (lastIndexOf(""))

package chap08.exam01.string;

public class CharArr {

	public static void main(String[] args) {
		
		// 문자열이 배열을 기반으로 해서 가능한 기능
		String str = "asdfghj";
		String strResult;
		int intResult;
		char charResult;
		
		// 문자열의 길이
		System.out.println(str.length());
		
		// 특정 인덱스 가져오기
		System.out.println(str.charAt(3));
		
		// 잘라내기 (자주 씀)
		strResult = str.substring(1, 5); // asdfghj
		// 1번 부터 보여주고 5번부터 잘라내라
		System.out.println(strResult); // sdfg
		
		// 문자열 -> 배열
		char[] chararr = str.toCharArray();
		System.out.println(chararr);
		
		// 배열 -> 문자열
		strResult = new String(chararr);
		System.out.println(strResult);
		
		// 특정 구분자를 기준으로 나누기
		str = "a|b|c|d|e|f|g";
		// 역슬래쉬나 버티컬바와 같은 특수 문자는 문자로 인식이 안됨
		String[] strArr = str.split("\\|"); // 이스케이프 문자인 역슬래쉬를 사용
		for(String s : strArr) {
			System.out.println(s);
		}
		
		// 특정 문자열 찾기
		str = "asfgdhgvabfkjaffasjkfn"; // 0, 8, 13, 16
		int idx = str.indexOf("a");
		// 무조건 첫번째 문자만 반환 한다.
		System.out.println(idx);
		idx = str.lastIndexOf("a");
		// 무조건 뒤에서 부터 첫번째 문자의 인덱스를 반환 한다.
		System.out.println(str.length() + "중 " + idx + "번째");
		// 3개의 a를 모두 찾을 수 있는 방법
		// indexOf("찾을 문자", 시작할 인덱스)
		int a = 0;
		while(true) {
			System.out.println(str.indexOf("a", a));
			a = str.indexOf("a", a) + 1;
			if(str.lastIndexOf("a") < a) {
				break;
			}
		}
	}

}

- 같은지 다른지 비교 (equals(""))

- 공백 제거, Excel 자료 불러올 때 쓰임 (trim())

- 특정 문자 포함 여부 (contains(""))

- 특정 문자열로 시작 or 끝나는가?, 파일 형식 알아낼 때 자주 쓰임 (startsWith(""), endWith(""))

- 문자열 교체 (replace(""))

package chap08.exam01.string;

public class StringUtil {

	public static void main(String[] args) {
		String str = "asdfg";
		
		String strResult;
		int intResult;
		boolean boolResult;
		
		// 문자열 비교
		boolResult = str.equals("abc"); // true | false
		System.out.println("두 문자가 같습니까? " + boolResult);
		
		intResult = str.compareTo("asd"); // 일치하지 않는 갯수
		System.out.println("두 문자가 같습니까? " + intResult);
		
		// 앞 뒤 공백제거 (excel 자료 불러올 때 종종 쓰임)
		str = " 가나다라마바사 ";
		strResult = str.trim();
		System.out.println(str);
		System.out.println(strResult);
		
		// 특정 문자 포함 여부 확인(잘 안씀)
		boolResult = str.contains("다");
		System.out.println("'다'를 포함하고 있는가? " + boolResult);
		
		// 특정 문자열로 시작 | 끝나는가?
		str = "[img]uploadFile.png";
		boolResult = str.startsWith("[img]");
		System.out.println("[img]로 시작되나? " + boolResult);
		boolResult = str.endsWith("png");
		System.out.println("png로 끝나는가? " + boolResult);
		
		// 문자열 교체
		strResult = str.replace("img", "이미지");
		System.out.println("str : " + strResult);
	}

}

- 더해서 넣기

- String Builder

- String Buffer

package chap08.exam02.compare;

public class Compare {

	public static void main(String[] args) {
		String str = "문자열을 "; // 객체 1개
		str += "추가 할 때 마다 "; // 객체 1개
		str += "객체가 추가 된다."; // 객체 1개
		System.out.println("String : " + str);
		
		// Builder나 Buffer는 하나의 객체를 확장하며 사용
		StringBuilder builder = new StringBuilder("문자열을 ");
		builder.append("추가 할 때 마다 ");
		builder.append("객체의 크기가 늘어 난다.");
		System.out.println("builder : " + builder);
		
		// StringBuffer는 동시 접속을 허용하지 않는다
		StringBuffer buffer = new StringBuffer("문자열을 ");
		buffer.append("추가 할 때 마다 ");
		buffer.append("객체의 크기가 늘어 난다.");
		System.out.println("buffer : " + buffer);
	}

}

1.Throw

Throw 예외처리는 예외가 예상되는 클래스와 메소드 이름 옆에 명시해줘야 하며 

오류가 발생한다면 throw에 적어놓은 클래스가 작동한다.

다르게 말하면 책임을 다른 클래스에 전가한다고 할 수도 있으며

따로 만들어 예외상황을 대처할 수 있다.

Java에서 미리 만들어둔 다양한 Exception도 역시 사용 가능하다.

package chap07.exam07.turn;

public class Sub {
	public void method1() throws NumberFormatException {
		// 2. method2()에게 일을 시킨다.
		method2();
		// 5. main에 책임 전가
	}
	public void method2() throws NumberFormatException {
		Integer.parseInt("asdfg"); // 3. 문제발생
		// 4. method1에 책임 전가
	}
}

package chap07.exam07.turn;

public class Main { // 비유로 폭탄돌리기

	public static void main(String[] args) throws Exception {
		// 1.main에서 Sub.method1()에게 일을 시킨다.
		Sub sub = new Sub();
		sub.method1();
		// 6. 결국 JVM에 책임을 전가 - 예외 메세지만 뿌려준다.
	}

}

2.커스텀 예외처리

Throw에 직접 작성한 클래스 파일을 지정하는 것이다. 예제를 확인해보자

package chap07.exam08.custom;

// 처음에 exception을 상속하는데 일반 예외라서 컴파일러에 오류가 걸리므로
// runtime exception으로 변경
public class ReservedException extends RuntimeException {

	public ReservedException(String msg) {
		super(msg);
	}
	
}

package chap07.exam08.custom;

public class JoinMember {
	
	String[] reserved = {"admin", "tester", "member"};
	
	public void regId(String userId) {
		// userId가 reserved에 있는 값과 일치 하면 안됨
		for(String name : reserved) {
			if(name.equals(userId)) {
//				System.out.println("예약어 입니다.");
				// 예외 발생이 목적이므로 변경
				// throw new XXXException("msg");
				// throw new RuntimeException("실행 예외");
//				throw new Exception("일반 예외"); // java에서 잡아주는 예외이므로 빨간줄
				throw new ReservedException(userId + "는 예약어 입니다.");
			}
		}
	}
}

package chap07.exam08.custom;

public class Main { // 임의의 예외처리 만들기

	public static void main(String[] args) {
		JoinMember join = new JoinMember();
		join.regId("admin");
	}

}

1.예외처리, instance of

예외처리는 자바 작성 하고 실행 할 때에 발생하는 오류를 말한다.

예외는 수없이 많지만 대표적인것 3가지만 설명하자면

- NullPointerException

String data = null;

// ex 돈 안주고 심부름 시킬 경우

data.toString(); // null인 값에 무언가 하려고 할 경우

위와 같이 null값을 넣거나 초기화 하지 않아 null값이 들어가 있는데 참조 또는 호출을 할 경우 발생하는 오류이다.

가장 많이 발생하며 코딩의 논리적 순서나 어딘가에서 실수를 하였을 경우 자주 등장한다.

- ArrayIndexOutOfBoundsException

String[] var = new String[2];

var[0] = "data1";

var[1] = "data2";

// 예외 발생 지점

var[2] = "data3";

배열의 방의 크기는 2인데 3으로 가정 하고 작성하였을 경우 발생하는 오류이다.

- NumberFormatException

String data;

int val;

// "1234" -> 1234

data = "1234";

val = Integer.parseInt(data);

// "1q2w3e" -> 1q2w3e (예외 발생)

data = "1q2w3e";

val = Integer.parseInt(data);

System.out.println(data);

자료형을 잘못 지정하여 발생하는 오류이다.

값을 입력받을때 어떤 형식이 들어올지 예측할 수 없다면 instance of 라는 기능을 사용하여 조건문에 사용하면

구분 할 수 있다. 다음의 예제를 통해 쓰임을 살펴보자

package chap07.exam04.exception;

public class ClassCastingEx {

	public static void main(String[] args) {
		Object value = 1234;
		int intVal = (int)value;
		// 원래 숫자기 때문에 문자열 변환이 안된다.
//		String stringVal = (String)value;
		// 이것을 방지하기 위한 방법
		String strVal;
		
		if(value instanceof String) {
			strVal = (String)value;
		}else {
			strVal = "" + value;
			System.out.println(strVal + "숫자형을 문자로 변환이 불가능 합니다.");
		}
	}

}

2.try catch문

try catch문은 특정 코드 부분에서 예상된 오류가 발생했을 경우 처리할 구문을 작성 할 때에 쓴다.

try{ 진행할 코드 } catch ( 예상되는 오류 코드 ) { 오류 발생 시 작동 할 코드 } 

위와 같이 작성하며 오류코드는 너무 많기 때문에 보통 Exception e와 같이 작성하여 모든 예외를 받는다.

package chap07.exam05.tryCatch;

public class Main {

	public static void main(String[] args) {
		String data1 = "12345";
		String data2 = "asd";
		String data3 = "56789";
		
		try { // 문제가 날 것 같은 예상 지점
			
			int value1 = Integer.parseInt(data1);
			int value2 = Integer.parseInt(data2);
			
		} catch (NumberFormatException e) { // 예외 발생 시
			
			System.out.println("입력된 문자가 숫자로만 구성되었나?");
			System.out.println(e.toString());
			
		} finally { // 예외이던 아니던 무조건 실행
			
			System.out.println("data1 : " + data1);
			System.out.println("data2 : " + data2);
			
		}
	}

}

1.중첩 클래스

중첩 클래스란 클래스 안의 클래스라고 보면 된다.

중첩 클래스는 바깥의 클래스에 접근하기 용이하고 다른 사람이 읽기에도 좀 더 편리하며

유지 보수에도 효율적이다.

인스턴스, 정적, 로컬 멤버가 있으며 다음 예제를 통해 확인해보자.

package chap07.exam01.overClass;

public class Exclass {
	public Exclass() {
		System.out.println("외부 클래스 생성");
	}
	
	// 1. 인스턴스 멤버 - 객체화 해야 사용 할 수 있는 클래스 (클래스 영역에 생성)
	
	public class InsClass {
		public InsClass() {
			System.out.println("인스턴스 멤버 생성");
		}
		int field = 0;
		void method() {
			System.out.println(field + "을 출력하는 메서드");
		}
	}
	
	// 2. 정적 멤버 - 객체화를 하면 사용 할 수 없는 클래스

	public static class StaticClass{
		public StaticClass() {
			System.out.println("인스턴스 멤버 생성");
		}
		int field = 0;
		void method() {
			System.out.println(field + "을 출력하는 메서드");
		}
		
		static int sfield = 0;
		static void smethod() {
			System.out.println(sfield + "을 출력하는 메서드");
		}
	}
	
	// 3. 로컬멤버 - 메서드가 실행되어야 사용할 수 있는 클래스
	
	void localMethod() {
		// 메서드 안에서만 사용 할 수 있는 클래스
		// 메서드 안에서 선언 생성 전부 해야한다.
		class Local{
			Local(){
			System.out.println("Local 객체 생성");
			}
			int field = 0;
			void method() {
				System.out.println(field + "을 출력하는 메서드 실행");
			}
		}
		Local lo = new Local();
		lo.field = 10;
		lo.method();
	}
}

package chap07.exam01.overClass;

import chap07.exam01.overClass.Exclass.InsClass;

public class Main {

	public static void main(String[] args) {
		// Exclass에 있는 InsClass 사용 하기
		Exclass ex = new Exclass();
		Exclass.InsClass ins = ex.new InsClass();
		// Exclass를 import를 통해서 명시 하여도 됨
		InsClass ins2 = ex.new InsClass();
		ins.field = 3;
		ins2.field = 4;
		ins.method();
		ins2.method();
		
		System.out.println();
		
		
		
		// Static 멤버 가져오기, static 멤버의 static도 객체화 하지 않아야 접근 가능
		Exclass.StaticClass.sfield = 40;
		Exclass.StaticClass.smethod();
		// field와 method 호출 해 보기
		Exclass.StaticClass sta = new Exclass.StaticClass();
		sta.field = 99;
		sta.method();
		
		System.out.println();
		
		// Local member 호출
		ex.localMethod();
	}

}

2.중첩 인터페이스

인터페이스는 중첩 클래스의 인터페이스 버전으로 생각하면 된다.

중첩 클래스와 같이 직관적으로 보이고 특징들은 비슷하다.

예제를 통해 이해해보자.

package chap07.exam02.overInter;

public class Element {
	
	EventListener listener;
	
	void regist(EventListener listener) { // 특정 감시자를 등록
		this.listener = listener;
	}
	
	void trigger() {
		listener.call();
	}

	// Element와 EventListener의 관계가 직관적으로 보인다.
	interface EventListener{
		void call(); // 이벤트 발생 시 호출 할 메소드 구현
	}
	
}

package chap07.exam02.overInter;

public class Main { // 중첩인터페이스

	public static void main(String[] args) {
		// Element에 Listener 등록
		// 이벤트 발생 시 어떻게 되나?
		Element ele = new Element();
		ele.regist(new OnClickListener());
		
		ele.trigger();
		

		Element ele2 = new Element();
		ele2.regist(new OnKeyListener());
		
		ele2.trigger(); // 이벤트 발생 시 호출 할 메소드 구현
	}

}