TIL(Today I Learned)_230728

☝🏻오늘 배운 것

1. 추상

- 추상 클래스

: 몸체 없는 메소드(추상 메소드)를 포함한 클래스 (미완성 설계도)
: 추상 클래스일 경우 클래스 선언부에 abstract 키워드 사용

• [접근제한자] abstract class 클래스명 {}

- 추상 메소드

: 몸체 없는 메소드
: 추상 메소드의 선언부에 abstract 키워드 사용
: 상속 시 반드시 구현해야 하는, 📌오버라이딩이 강제화되는 메소드

• [접근제한자] abstract 반환형 메소드명(자료형 변수명);

- 추상 클래스의 특징

1. 특징
   : 미완성 클래스(abstract 키워드 사용)
   자체적으로 객체 생성(객체화) 불가 → 반드시 상속하여 객체 생성
   : abstract 메소드가 포함된 클래스는 반드시 abstract 클래스로 표기 / abstract 메소드가 없어도 abstract 클래스로 선언 가능
   : 클래스 내에 일반 변수, 메소드 포함 가능
   : 객체 생성은 안되지만 참조형 변수 타입으로는 사용 가능
2. 장점
   : 상속 받은 자식에게 공통된 멤버 제공.
   : 일부 기능(오버라이딩)의 구현을 강제화(공통적이거나 자식 클래스에 따라 재정의 되어야 하는 기능).

- 추상클래스 사용해보기

✅ Animal (부모클래스 / 추상 클래스)

package edu.kh.poly.ex2.model.vo;

public abstract class Animal {
	/* 추상 클래스(abstract class)
	 * 1. 미완성 메소드(추상 메소드)를 보유하고있는 클래스
	 * 2. 객체로 만들면 안되는 클래스 -> instance화 불가
	 * 		-> 여러타입들을 관리하기 위한 상위 타입의 목적이며,
	 * 			객체로 생성하여 사용하기 위한 목적이 아니다.
	 * 			-> 객체화 할 시 오류남(Cannot instantiate the type Animal)
	 * 
	 * 
	 */
	
	
	private String type; // 종, 과
	private String eatType; // 식성(초식, 육식, 잡식..)
	
	
	
	
	public Animal() {} // 기본생성자
	
	// 추상클래스는 new 연산자를 통해 직접적인 객체 생성은 불가능하지만
	// 상속받은 객체 생성 시 내부 부모부분이 생성될 때 사용된다.

	public Animal(String type, String eatType) { // 매개변수 생성자(오버로딩 적용)
		this.type = type;
		this.eatType = eatType;
	}
	
	


	public String getType() {
		return type;
	}


	public void setType(String type) {
		this.type = type;
	}


	public String getEatType() {
		return eatType;
	}


	public void setEatType(String eatType) {
		this.eatType = eatType;
	}

	
	// toString()오버라이딩
	@Override // 오버라이딩이 되었음을 컴파일러에게 알려주는 어노테이션
	public String toString() {
		return type + " / " + eatType;
	}
	
	
	// 동물의 공통 기능 추출(추상화)
	// -> 동물은 공통적으로 먹고, 숨쉬고, 움직이지만
	// 	  어떤 동물이냐에 따라 그 방법이 다름!
	// 		-> 해당 클래스에 메소드를 정의할 수 없다.
	// 		-> 미완성 상태로 두어 상속받은 자식클래스가 해당 메소드를 정의하도록 
	// 		-> 오버라이딩 강제화를 시켜야함 -> 추상메소드로 작성
	
	
	// 먹다
	public abstract void eat(); // - > 추상 메소드 -> 추상메소드만 작성하면 오류남
								// -> 해당 클래스도 추상클래스로 만들어줘야함
	
	// 숨쉬다
	public abstract void breath();
	
	// 움직이다
	public abstract void move();
	
}

✅ Fish (자식클래스)

package edu.kh.poly.ex2.model.vo;

public class Fish extends Animal{
	
	public Fish(){}
	
	public Fish(String type, String eatType) {
		super(type, eatType);
	}
	
	

	@Override
	public void eat() {
		System.out.println("입을 뻐끔뻐끔 거리면서 먹는다");
	}

	@Override
	public void breath() {
		System.out.println("아가미 호흡을 한다.");
	}

	@Override
	public void move() {
		System.out.println("꼬리로 헤엄치며 움직인다.");
	}
	
	
	@Override
	public String toString() {
		return "Fish : " + super.toString();
	}
	
}

✅ Person (자식클래스)

package edu.kh.poly.ex2.model.vo;

public class Person extends Animal {
	// Animal의 추상메서드를 오버라이딩 하지않으면 오류 발생
	
	private String name;
	
	
	
	public Person() {}
	 
	public Person(String type, String eatType, String name) {
		super(type, eatType);
		this.name = name;
	}
	
	

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
	
	

	@Override
	public void eat() {
		System.out.println("숟가락, 젓가락 등 도구를 이용해서 먹는다.");
	}

	@Override
	public void breath() {
		System.out.println("코와 입으로 숨쉰다.");
	}

	@Override
	public void move() {
		System.out.println("두발로 걷는다.");
	}
	
	@Override
	public String toString() {
		return "Person : " + super.toString() + " / " + name;
	}
}

✅ AbstractService (서비스 클래스)

package edu.kh.poly.ex2.model.service;

import edu.kh.poly.ex2.model.vo.Animal;
import edu.kh.poly.ex2.model.vo.Fish;
import edu.kh.poly.ex2.model.vo.Person;

public class AbstractService {
	
	public void ex1() {
		
//		Animal animal = new Animal();
		// 추상 클래스를 객체화 할 시 오류남(Cannot instantiate the type Animal)
		
		// 클래스 : 객체의 속성, 기능을 정의한 것 (일종의 설계도)
		// 추상클래스 : 미완성 메소드를 포함한 클래스 (미완성 설계도)
		// -> 미완성 설계도로는 객체를 만들 수 없다! -> 오류발생
		
		// 해결방법 : Animal을 상속받아 미완성 부분을 구현한
		// 클래스를 이용해 객체 생성
		
		
		// 추상클래스를 상속받은 자식클래스 객체 생성
		Person p1 = new Person();
		
		p1.setName("홍길동");
		// 상속받은 기능 호출
		p1.setType("척추동물");
		p1.setEatType("잡식");
		
		// 오버라이딩한 메서드 호출
		p1.eat();
		p1.breath();
		p1.move();
		
		p1.toString();
		
		
		Fish f1 = new Fish();
		
		f1.eat();
		f1.breath();
		f1.move();
		
		f1.toString();
		
	}
	
	public void ex2() {
		// * 추상클래스와 다형성 + 바인딩
		
		// - 추상클래스는 객체로 만들 수 없다!
		// 하지만, "참조변수"로는 사용할 수 있다.
		
		// Animal a1 = new Animal(); -> X
		
		// 사람 -> 동물 / 물고기 -> 동물
		//Animal a1 = new Person(); -> O
		//Animal a2 = new Fish(); -> O
		
		// Animal 참조변수 배열선언 및 할당
		Animal[] arr = new Animal[2];
		
		arr[0] = new Person("사람", "잡식", "김사람");
		// Animal 부모 = Person 자식(다형성 중 업캐스팅)
		
		arr[1] = new Fish("물고기", "잡식");
		
		// 바인딩 확인
		for(int i = 0; i < arr.length; i++) {
			// arr[i] == Annimal 참조변수
			arr[i].eat();
			arr[i].breath();
			System.out.println(arr[i].toString());
			// edu.kh.poly.ex2.model.vo.Animal.toString() - 정적바인딩
			System.out.println("=============");
			
			// 프로그램 실행 시 
			// 참조하고 있는 자식 객체의 오버라이딩된 eat() 메소드 실행
			// - 동적 바인딩
			// -> 부모타입 참조변수로 메소드를 호출했지만
			// 자식타입의 오버라이딩된 메소드가 수행된다.
		}
	}
}

2. 인터페이스

- 인터페이스란?

: 뜻 - 클래스간의 접점
: 클래스가 공통적으로 가져야하는 필드, 메소드를 모아두고 상속하는 것
: 추상클래스는 추상메소드 외에 멤버변수 일반메소드들의 사용이 가능하지만, 인터페이스는 추상메소드 외에 사용이 불가하다.

- 인터페이스 사용해 계산기 만들기

✅ Calculator (인터페이스)

package edu.kh.poly.ex2.model.service;

// 계산기 인터페이스
// -> 모든 계산기에 대한 공통 필드, 기능명을 제공하는 접점의 용도
public interface Calculator {
	
	// 인터페이스 : 추상클래스의 변형체(추상클래스보다 추상도가 높음)
	// - 추상클래스 : 일부만 추상메서드(0개 이상)
	// - 인터페이스 : 모두 추상 메서드
	
	// 필드(묵시적으로 public static final 상태로 선언 ==> 상수)
	public static final double PI = 3.14;
	static final int MAX_NUM = 100000;
	public int MIN_NUM = -100000;
	int ZERO = 0;
	
	// 메서드(묵시적으로 public abstract 상태로 선언)
	public abstract int plus(int num1, int num2);
	
	public abstract int minus(int num1, int num2);

	public abstract int multiple(int num1, int num2);
	
	public abstract int divide(int num1, int num2);
	

}

✅ CJECalculator 클래스 (나의 계산기)

package edu.kh.poly.ex2.model.service;

	// extends : 확장하다, implements : 구현하다
	// (부)클래스 - (자)클래스 : extends 사용(추상클래스 포함)
	// (부)인터페이스 - (자)클래스 : implements 사용
public class CJECalculator /*extends Animal*/ implements Calculator{
	// 인터페이스는 클래스, 인터페이스 동시 상속 가능 -> 다중 상속 가능
	
	@Override
	public int plus(int num1, int num2) {
		return num1 + num2;
	}

	@Override
	public int minus(int num1, int num2) {
		return num1 - num2;
	}

	@Override
	public int multiple(int num1, int num2) {
		return num1 * num2;
	}

	@Override
	public int divide(int num1, int num2) {
		return num1 / num2;
	}
	
}

✅ AbstractRun (Run 클래스)

package edu.kh.poly.ex2.run;

import edu.kh.poly.ex2.model.service.CJECalculator;

public class AbstractRun {
	
	public static void main(String[] args) {
		
		CJECalculator cal = new CJECalculator();

		System.out.println("합 : " + cal.divide(20, 15));
		System.out.println("차 : " + cal.divide(20, 15));
		System.out.println("곱 : " + cal.divide(20, 15));
		System.out.println("몫 : " + cal.divide(20, 15));
		
		// 인터페이스 == 미완성 설계도 == 객체 생성 불가능
		// 추상클래스처럼 참조 변수로는 사용 가능하다
		
		// 코드의 큰 수정없이
		// 객체 생성 코드만 바꾸면 새로운 클래스 코드를 수행할 수 있다.
		
		// 인터페이스 특징
		// 1) 인터페이스를 부모 참조변수로 사용하면 다형성 중 
		//	업캐스팅이 적용돼서 상속받은 모든 클래스를 자식 객체로 참조할 수 있다.
		
		// -> 이를 이용하여 중요한 메인코드의 수정을 최소화할 수 있다.
		// ex) Run에 작성된 합, 차, 곱, 몫을 출력하는 코드의 수정없이
		// 		객체생성코드 한 줄만 수정하여 다르게 작성된 기능을 수행할 수 있다.
		
		// 2) 자식 클래스에 공통된 메서드 구현을 강제하기 때문에
		// 		모든 자식 클래스가 동일한 형태를 띄게 된다.
		//		-> 이를 활용하여 공동작업(팀프로젝트)에 필요한 개발환경을 조성할 수 있다.
		
	}

}

- 추상클래스와 인터페이스 비교

3. 예외 처리(Exception Handling)

- 프로그램 오류

: 프로그램 수행 시 치명적 상황이 발생하여 비정상 종료 상황이 발생한 것, 프로그램 에러라고도 함

- 오류의 종류

1. 컴파일 에러 : 프로그램의 실행을 막는 소스 코드상의 문법 에러(개발자가 코드를 잘못쓴 경우)
   -> 소스 코드 수정으로 해결
   **예 int a = 99.9;)
2. 런타임 에러 : 프로그램 실행 중 발생하는 에러 -> 주로 if문 사용으로 에러 처리
   (ex. 배열의 인덱스 범위를 벗어났거나, 계산식의 오류)
3. 📌시스템 에러 : 컴퓨터 오작동으로 인한 에러(버그), 외부적인 요인으로 개발자가 해결하지못하는 경우
   -> 소스 코드 수정으로 해결 불가

- 오류의 종류 알아보기

package edu.kh.exception.test;

import java.util.Scanner;

public class ExceptionTest {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		while(true) {
			System.out.print("정수 입력(0입력 시 종료) :");
			int input = sc.nextInt();
			
			// 컴파일 에러 -> 개발자가 코드 잘못쓴것
			// 자료형이 맞지않아 연산을 못해서 "컴파일 에러"가 발생. 코드틀림
//			int a = 00.9;
			int a = (int)00.9; // 코드로 수정 가능
			
			if(input == 0) {
				break;
			}
			
		}
		
		
		// 런타임에러 예제
		// 런타임 에러 : 프로그램 수행 중 발생하는 에러
		// 				주로 if문으로 처리가 가능하다.
		
		int[] arr = new int[3]; 
		
		arr[0] = 10;
		arr[1] = 20;
		arr[2] = 30;
		//arr[3] = 40;
		// java.lang.ArrayIndexOutOfBoundsException : 배열 범위 초과 예외
		
		if(3 >= arr.length) {// 배열 인댁스 범위 초과 시
			System.out.println("배열 범위를 초과했습니다");
		}else {
			arr[3] = 40;
		}
	}
}

- 오류해결 방법

소스 코드 수정으로 해결 가능한 에러를 예외(Exception)라고 함.
이러한 예외 상황(예측 가능한 에러) 구문을 처리 하는 방법인 예외 처리를 통해 해결할 수 있음.

- 예외 클래스 계층 구조

: Exception과 Error 클래스 모두 Object 클래스의 자손이며 모든 예외의 최고 조상은 Exception 클래스

- 예외 처리 방법 1 (try ~ catch)

try : Excption 발생할 가능성이 있는 코드를 try안에 작성
catch : try 구문에서 Exception 발생 시 처리할 코드 작성
finally : Exception 발생 여부와 관계없이 꼭 처리해야하는 코드 작성

try{
예외(에러)가 발생할것같은 코드
}catch(에러잡는 부분...?){
처리할 내용의 코드
}finally{
에러가 나든 안나든 무조건 수행하는 코드
}

- Exception 처리를 호출한 메소드에게 위임

- Exception 실습

package edu.kh.exception.model.service;

import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class ExceptionService {
	
	// 예외(Exception) : 소스코드의 수정으로 해결가능한 오류
	
	// 예외는 두 종류로 구분됨
	// 1) Unchecked Exception : 선택적으로 예외처리해야하는 Exception
	// 2) Checked Exception : 필수로 예외처리해야하는 Exception
	
	private Scanner sc = new Scanner(System.in);
	
	public void ex1() {

		
		System.out.println("두 정수를 입력받아 나누한 몫을 출력");
		
		System.out.print("정수 1 입력 : ");
		int input1 = sc.nextInt();
		
		System.out.print("정수 2 입력 : ");
		int input2 = sc.nextInt();
				
		try{
			System.out.println("결과 : " + input1 / input2);
			// input1 == 5 input2 == 0으로 입력할 경우
			// java.lang.ArithmeticException: / by zero -> 산술적예외
			// 산술적 예외로 0으로 나눌 수 없다.
			
		} catch(ArithmeticException e) {
			// try에서 던져진 예외를 catch문 매개변수 e로 잡음
			
			System.out.println("infinity"); // 처리할 코드
		}
			
		
		if(input2 != 0) {
			System.out.println("결과 : " + input1 / input2);
		}else {
			System.out.println("infinity"); // 처리할 코드
		}
		// 발생하는 예외 중 일부 예외는 try-catch 구문 사용하지않아도
		// 예외상황을 방지할 수 있다.
		// 일부예외 == Unchecked Exception
		
	}
	
	public void ex2() {

		// 여러가지 예외에 대한 처리 방법
		
		
		try {
			
			System.out.print("입력1 : ");
			int num1 = sc.nextInt(); // java.util.InputMismatchException
			
			System.out.print("입력2 : ");
			int num2 = sc.nextInt(); // java.util.InputMismatchException
			
			System.out.println("결과 : " + num1 / num2); // ArithmeticException
			
			String str = null;
			System.out.println(str.charAt(0));
			// java.lang.NullPointerException: Cannot invoke "String.charAt(int)" because "str" is null
			// 참조하지 않는 참조변수를 이용해서 코드 수행 시 발생
			
		}catch(InputMismatchException e) {
			
			System.out.println("타입에 맞는 값만 넣어주세요.");
		}catch(ArithmeticException e) {
			
			System.out.println("0으로 나눌 수 없습니다.");
		}catch(Exception e) {
			System.out.println("뭔지 모르겠으나 예외가 발생해서 처리함.");
			
		}
		
		// 예외처리 + 다형성 
		
		// Exception 클래스 : 모든 예외의 최상위 부모
		// 다형성 - 업캐스팅 : 부모타입 참조변수로 자식객체를 참조.
		
		// ** 상위 타입의 예외클래스를 catch문에 작성하면
		//		다형성 업캐스팅에 의해 모두 잡아서 처리 가능 **
		
	}

	public void ex3() {

		// 1) try - catch - finally
		// finally : try구문에서 예외가 발생하든말든 무조건 마지막에 수행하는 코드를 작성
		
		try{
			System.out.println(4/0);
			
		}catch(ArithmeticException e) {
			System.out.println("예외처리됨");
			
			// 2) catch문 매개변수 활용
			// 매개변수 e : 예외 관련된 정보 + 기능이 들어있음
			System.out.println(e.getClass()); // 어떤 예외클래스인지 알려줌
			// class java.lang.ArithmeticException
			
			System.out.println(e.getMessage()); // 예외 발생 시 출력된 내용
			// / by zero
			
			System.out.println(e); // e.toString();
			// java.lang.ArithmeticException: / by zero
			
			e.printStackTrace();
			
		}finally {
			System.out.println("무조건 수행 됨");
			
		}
		
	}

	public void ex4() {// 예외 던지기
		//throws : 호출한 메서드에 예외를 던질때 쓰는 키워드
					// -> 호출한 메서드에게 예외를 처리하라고 위임하는 행위
		// throw : 예외 강제 발생 구문
		
		
		try {
			methodA();
		} catch (Exception e) {
			// Exception : 모든 예외의 최상위 부모
			// Exception이 catch 매개변수로 작성되었다
			// == 예외종류 상관없이 모두 처리하겠다라는 내용
			
			e.printStackTrace();
			// 발생한 예외가 메서드와 위치에 대한 모든 내용을 출력
			// 예외 발생 지점 추적
			
		}
	}
	
	public void methodA() throws IOException {
		methodB();
	}
	
	public void methodB() throws IOException {
		
		methodC();
	}
	
	public void methodC() throws IOException {
		
		// 예외 강제 발생 구문
		throw new IOException();
		
	}

}