[Day19] Java 19 - 인터페이스, 디폴트 메서드, 예외 처리

[Day19] Java 19 [9/2]

 

1. 인터페이스

1) 자바 자료형

  a) 기본형 - 8가지

  b) 참조형 - 배열, 클래스, [인터페이스]

 

2) 참조타입  

3) 일종의 추상클래스이다. 

- 추상클래스 ? 추상메서드 1개, [객체 생성 X 클래스]

 

4) 인터페이스 선언 형식

[접근지정자]  interface 인터페이스이름{   // 대문자로 시작         I인터페이스명

(public static 생략)

 

5) 멤버 선언

  a) 필드 X, 일반 인스턴스 메서드 X

  b) final 상수 O ,  추상메서드 O    JDK1.8 (  static 메서드 , default 메서드 )

       public static final   생략되어져 있다. 

       }           

 

6) 인터페이스의 상속  extends  키워드 사용

interface Fightable extends Movable, Attackable{

      

7) 클래스 implements 인터페이스,,,,,,,{

class Marine implements  Fightable {

}

 

8) 인터페이스는 다중 상속 가능

interface IA{
	void test();
}

interface IB extends IA{
	// void test();
	void testb();
}

// 인터페이스 끼리 상속 가능
interface IC   extends   IA{
	// void test();
	void testc();
}

// 인터페이스를 구현할 때는  implements 키워드 사용한다.  
//class A implements IA, IB{  // 인터페이스 다중 상속 가능
class A implements IC , IB{  // 인터페이스 다중 상속 가능
	
	@Override
	public void test() {
		System.out.println("오버라이딩~ ");
	}

	@Override
	public void testc() { 
		
	}

	@Override
	public void testb() {
		// TODO Auto-generated method stub
		
	}
}

 

예시)

public class Ex03 {

	public static void main(String[] args) {
		String fileName = "document.xml";  //    "document"  "html"
		
		//String fileName = "document.xml";
		//ParserManager클래스로부터 XML 문서 파싱하는 객체를 얻어와서 파싱 처리
		//ParserManager클래스로부터 HTML 문서 파싱하는 객체를 얻어와서 파싱 처리
		
		// 클래스 메서드  
		// String [] xx =  fileName.split(".");
		//  fileName.split(String regex)
		// regex 정규표현식   . any char~
		//                            \. == '.'
		
		String type =   fileName.split("\\.")[1].toUpperCase(); //  "HTML"
		// XMLParser/HTMLParser   parser = ParserManager.getParser( type );
		// *** 인터페이스 다형성 개념.  ****
		Parseable   parser = ParserManager.getParser( type );
		// 실제 객체의 오버라이딩 된 parse();
		parser.parse(fileName);

	} // main

} // class

// 인터페이스 선언
interface Parseable{
     // 구문 분석 작업  == 파싱
	 void parse(String fileName);
}

// XML 문서를 구분 분석하는 클래스
class XMLParser implements Parseable{ 
	@Override
	public void parse(String fileName) { 
		System.out.printf("%s -  XML 파싱 완료처리 구현.\n", fileName);
	} 
}

//HTML 문서를 구분 분석하는 클래스
class HTMLParser implements Parseable{ 
	@Override
	public void parse(String fileName) { 
		System.out.printf("%s -  HTML 파싱 완료처리 구현.\n", fileName);
	} 
}

class ParserManager{
	//                   리턴자료형 == 인터페이스
	// This method must return a result of type Parseable
	public static Parseable  getParser(String type) {
		if( type.equals("XML") ) {
			return  new XMLParser();
		}else if( type.equals("HTML")) {
			return  new HTMLParser();
		} 
		// xml, html 타입이 아닌 경우에는 처리할 객체 없다의미로   return null;
		return null;
	}
}

 

2. 인터페이스의 다형성

- 업캐스팅

예시1) List

List   alist =  new ArrayList();

 

예시2) Car - [S,K,H] Engine

/*
new K_Engine()
new S_Engine()
new H_Engine()
new S_Engine()
*/

// 인터페이스 다형성
IEngine engine = new H_Engine();

// S, K, H 회사 엔진 공급
Car c1 = new Car("K9", "수동", engine);  //외부 조립라인 자동카 + [S],K,H엔진

c1.speedUp(10);
c1.speedDown(10);

예시3) 매개변수 다형성(IEngine engine)

public Car(String name, String gearType, IEngine engine) {
		this(name, gearType);		
		this.engine = engine;
	}

3. 디폴트 메서드

조상 클래스에 새로운 메서드를 추가하는 것은 별일이 아니지만, 인터페이스의 경우에는 보통 큰 일이 아니다. 

 

- 인터페이스에 새로운 추상메서드 만들면 하위 메서드도 다 업데이트 시켜야하는 불편함

-> 디퐅트 메서드

-> default void newMethod() { 구현 하든 안하든 상관 없음 }

-> 문제가 없어짐

 

* static 메서드 : 클래스명.static메서드()로만 호출 가능

 

* 개방폐쇄의 원칙 위반한 케이스

* 아래 링크 추가 설명

https://velog.io/@heoseungyeon/%EB%94%94%ED%8F%B4%ED%8A%B8-%EB%A9%94%EC%84%9C%EB%93%9CDefault-Method

---

4. 인터페이스 장점

1) 개발시간 단축 

- 인터페이스만 작성되면 구현클래스가 안만들어져있더라도 해당 구현클래스를 인터페이스 다형성을 사용해서 Car 클래스를 동시에 개발할 수 있다.

- Engine 인터페이스만 작성되어도 Car 클래스 개발 가능하다는 얘기

public interface IEngine {
	// "상수, 추상메서드,        JDK1.8 새로 추가 - default메서드, static 메서드" 만 선언 가능
	int MAX_SPEED = 400;

	public abstract void moreFuel( int fuel ) ;
	void lessFuel( int fuel ) ;
	void stop() ;
	
	// 새로운 추상메서드     [  jdk 1.8 새로  멤버] 
	// default 메서드
	default void newMethod() {
		// 구현 X, O
	}
	
	// statc  메서드 
	static void staticMethod() {
		// 
	}

}

- Car 클래스의 getter, setter가 Engine 클래스가 아니라 IE 인터페이스 기준으로 만들어져야함

// 자동차 클래스 선언부
public class Car {
	// 필드
	String name;
	String gearType;
	int door;
	//           클래스   객체;
	// S,K,H 엔진 생산 + 납부
	// 인터페이스 다형성
	private  IEngine engine ; 
	
	// getter, setter
	public IEngine getEngine() {
		return engine;
	}

	public void setEngine(IEngine engine) {
		this.engine = engine;
	}

	// 생성자
	Car(){ 
	}
	
	public Car(String name, String gearType) {
	 
		this();
		this.name = name;
		this.gearType = gearType;
	}
                                                                       //  매개변수  다형성
	public Car(String name, String gearType, IEngine engine) {
		this(name, gearType);		
		this.engine = engine;
	}

	// 메서드
	void speedUp(int fuel) { 
		this.engine.moreFuel(fuel);  
	}
    void speedDown(int fuel) {
		this.engine.lessFuel(fuel);
	}
    void stop() {
    	this.engine.stop();
    }
} // class

 

2) 표준화 가능

- 기본 틀이되는 엔진 인터페이스 작성하면 S,K,H 클래스로 엔진 생산할 것이기 때문에 IE 안에 기능들이 반드시 일반되고 정형화된 프로그래밍 개발이 가능, 즉 표준화가 가능!

 

*주의 : 인터페이스에 구현된 메서드의 접근지정자가 public 일 때 해당 인터페이스를 상속받은 클래스들에서 메서드 구현할때 오버라이딩 조건을 지켜 (여기에선 public 붙여야함) 구현해야함.

 

3) 서로 관계없는 클래스들 간 관계 맺어줌 (서로 상속관계가 아니더라도)

- S,K,H 모두 IE라는 인터페이스를 구현한 클래스

/*
new K_Engine()
new S_Engine()
new H_Engine()
new S_Engine()
*/

// 인터페이스 다형성
IEngine engine = new H_Engine();

// S, K, H 회사 엔진 공급
Car c1 = new Car("K9", "수동", engine);  //외부 조립라인 자동카 + [S],K,H엔진

c1.speedUp(10);
c1.speedDown(10);

 

4) 독립적인 프로그래밍 가능

- 인터페이스를 이용하면 S,H,K 클래스 선언하는 곳과 실제 IE 인터페이스 사용하는 곳을 분리해서 독립적인 프로그래밍 가능

---

5. days19 Ex06

public class Ex06 {
	public static void main(String[] args) {
		/*
		List  list = new ArrayList();
		test(list);
		*/
		
		Tank tank= new Tank();		
		SCV scv = new SCV();
		
		// 
		scv.repair(tank);
		
		Marine m = new Marine();
		//   Repariable p = Marine m X  (마린은 Repairable인터페이스 없기때문!)
		//   업캐스팅 X
		//   scv.repair(m);
	} // main
	static void test( List list) {	
	}
} // class

// 인터페이스
// ( 멤버 하나도 없다. )
interface Repairable{}

class Unit{        // 구성단위
   int hitPoint;
   final int MAX_HP;
   Unit(int hp){
	   MAX_HP = hp;
   }
   // 멤버 구성
}

class GroundUnit extends Unit{ 
	GroundUnit(int hp) {
	    super(hp);	
	}
	// 멤버 구성
}

class AirUnit extends Unit { 
	AirUnit(int hp) {
	    super(hp);	
	}
}

// 수리가 가능한 객체
class Tank extends GroundUnit implements Repairable{

	Tank() {
		super(150); 
		this.hitPoint = MAX_HP;
	}
	
	public String toString() {
		return "Tank";
	}
}

class Marine extends GroundUnit{
	Marine(){
		super(40);
		this.hitPoint = MAX_HP;
	}
}

//수리가 가능한 객체
class SCV extends GroundUnit implements Repairable{
	SCV() {
		super(60); 
		this.hitPoint = MAX_HP;
	}
	
	// 수리 메서드 
	//                인터페이스 다형성
	// 인터페이스로 매개변수 받았지만 p로 할수있는건 없음, 그래서 Unit의 인스턴스인지 확인하고 다운캐스팅 하는 
	void repair( Repairable p) {
		
		 if(  p instanceof Unit ) {
			 Unit u  = (Unit)p;  // 다운캐스팅 
			 while( u.hitPoint != u.MAX_HP ) {
				 u.hitPoint++;
			 }
		 }
	}
}

implements serializable (직렬화 interface)

---

6. 내부 클래스

1) 내부 클래스 - 클래스 내에 선언 (사용 빈도 X)

2) 내부 클래스 장점

- 내부 클래스에서 외부 클래스의 멤버들을 쉽게 접근할 수 있다.

- 코드의 복잡성을 줄일 수 있다 ( 캡슐화 )

( 불필요한 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다 )

      

3) 내부 클래스의 4가지 종류

ㄱ. 인스턴스 클래스  X

ㄴ. 스태틱 클래스    X

ㄷ. 지역 클래스       X

ㄹ. 익명(무명) 클래스       O

  ㄴ Anoymous Class

  ㄴ 클래스 선언과 객체 생성을 동시에 하는 이름 없는 클래스( 일회성 )

  ㄴ 주로 GUI어플리케이션( AWT, Swing )의 이벤트 처리 사용.

 

4) 익명 클래스 선언 형식

new 조상클래스이름(){
// 멤버 선언          
}

또는 

new 구현인터페이스이름(){
// 추상메서드   오버라이딩.
}

new IEngine(){
// moreFuel()
// lessFuel()
// stop()
}

선언과 동시에 생성

this.addWindowListener ( new WindowAdapter() {
public void windowCllosing(Windw e ) {
////코딩
}
}

-> 다른 데서 쓸 필요가 없기 때문에 익명클래스로 선언과 동시에 실행하는 이벤트 처리로 선언하는 경우

-> 버튼, 이벤트 리스너에 사용

---

7. 에러

1. 에러(오류) - 프로그램 실행 중에 오작동, 비정상적으로 종료되는 원인

2. 에러 발생시점

      (빌드오류 = 컴오류 + 실오류)

      1) 컴파일 오류 - 컴파일 시에 발생하는 오류

              Test.java -> javac.exe -> Test.class

              소스파일                              Class파일

      2) 런타임(실행) 오류 - 실행 시 발생하는 오류 

                 java.exe Test 실행

            자바에서 런타임(실행) 오류를 2가지 구분

            ㄱ. 에러(error) - 메모리 부족, 스택오버플로워, 복구할 수 없는 심각한 오류

                                  Error 클래스 

            ㄴ. 예외(exception)      - 수습될 수 있는 비교적 덜 심각한 실행 오류

                                  Exception 클래스

                 예외 처리~

                 

      3) 논리적 오류  - 실행은 되지만 의도와 다르게 동작하는 것

                         ( 에러 잡기 가장 어렵다. )

           int i = 100 + Integer.MAX_VALUE;

           System.out.println( i );  // -2147483549

             

      3. 예외 클래스 상속 계층 구조 

                                Object

                                    ↑

                             Throwable

                                    ↑

          Exception                                         Error     

            ↑

                    ㄴ IOException    

                    ㄴ ClassNotFoundException

                    ㄴ RuntimeException

                                  ㄴ ArithmeticException

                                  ㄴ ClassCastException

                                  ㄴ NullPointException

                                  :

                                  ㄴIndexOutOfBoundsException

                                  ㄷ등등

             

      4.     예외 처리( exception handling )

              정의 : 프로그램 실행 시 발생할 수 있는 예외에 대비한 코드를 작성하는 것.

              목적 : 프로그램 비정상적으로 종료되는 것 막고, 정상적인 실행 상태를 유지하는 것.

               

      5.  발생한 예외를 개발자가 대비해서 예외처리를 하지 않으면 프로그램은 종료되고 처리되지 못한 예외는  JVM의 예외처리기(UncaughtExceptionHandler)가 받아서 예외의 원인을 화면에 출력한다.    

             

Exception in thread "main" java.lang.ArithmeticException: / by zero

at days19.Ex10.main(Ex10.java:36)

 

        6. 예외 처리하는 방법 2가지

              1) try~ catch 문

              2) throws 문

---

7. 예외 처리

1) try catch문

public class Ex11_02 {
	public static void main(String[] args) {
		// 
		int a, b;
		 
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("> a, b 정수 입력 ? ");
		a = scanner.nextInt();
		b = scanner.nextInt();
		 
		try {
        // 예외 발생 코딩
		double c =   a / b;
		System.out.printf("%d / %d = %.2f \n", a, b, c);
			    
		int [] m  = new int[3]; // 0, 1, 2
			    
			try {
        		m[3] = 100; 
				System.out.println( m[3] );
			} catch (ArrayIndexOutOfBoundsException e) {
				System.out.println("4");
			} // 
			   
			     
		}catch(IllegalFormatConversionException | ArithmeticException e) {  
			try {	
			} catch (Exception e2) {
				// TODO: handle exception
			}
			// jdk 1.7 제공                              멀티 catch 블럭
			// 예외처리 
			// System.out.println("1");
			// System.out.println(  e.getMessage() ); //  예외 저장된 메시지                / by zero
			// e.printStackTrace();
			// System.out.println(  e.toString() );  // java.lang.ArithmeticException: / by zero
		} catch ( Exception e ) {  // 다형성
        	// 예외처리 
			System.out.println("3");
		} 
		// 다중 catch문을 사용할 때는 순서(주의할 점)   instanceof 연산자

		System.out.println("> 프로그램 정상적으로 진행~~");
		// Exception in thread "main" java.lang.ArithmeticException: / by zero
		// at days19.Ex11.main(Ex11.java:47)
		//  java.util.IllegalFormatConversionException	
	} // main
} // class

예외처리 순서 (finally)

// 예외 처리 순서.
System.out.println(" 코딩 1 ");
	try {
		// 파일,  DB Open
        // 파일쓰기, 읽기
		// DB  CRUD 작업
		System.out.println(" 코딩 2 ");
		int i = 10/0;
		System.out.println(" 코딩 3 ");
	} catch (ArrayIndexOutOfBoundsException e) {
		System.out.println(" 코딩 4 ");
	} catch (Exception e) {
		System.out.println(" 코딩 5 ");
	} finally {
		// try {} 에서 예외 발생 유무에  상관없이 처리는 블럭
		System.out.println(" 코딩 6 ");
		// 파일 Close
		// DB   Close
	}
System.out.println(" 코딩 7 ");

2) try catch문

public class Ex13 {

	public static void main(String[] args) {
		int kor ;		
		Scanner scanner = new Scanner(System.in);
		
		try {
			System.out.print("> 국어 점수 입력 ? ");		
			kor =  scanner.nextInt();		
			//if( !( 0>=kor && kor<=100 ) )
			if(  0 > kor || kor > 100 ) {
				//  강제 예외 발생시키자.
				throw new ArithmeticException();  // 산술적 예외    10/0
			}
			System.out.printf("> 국어 점수 : %d 점\n", kor);
            
		} catch (ArithmeticException e) {
			 System.out.println("국어 점수 범위 벗어남!!");
		}catch (Exception e) {
			 e.printStackTrace();
		}
		System.out.println("end");	
	} // main
} // class

public class Ex14 {
	public static void main(String[] args)   {
		// br.readLine();
		// p 426   컴파일러 : unchecked예외, checked 예외
		/*
	    try {
			int one = System.in.read();
		} catch (IOException e) {
			e.printStackTrace();
		}
		*/
		
		int kor;
		try {
			kor = getScore();
			System.out.println( kor );
			
		} catch (InputMismatchException | IOException e) {
		 
			e.printStackTrace();
		} catch( Exception e) {
			e.printStackTrace();
		}
		
		System.out.println("end");
		
	} // main

	// 입력값이 0~100점 반환
	// 그밖      강제 예외 발생  throw
	private static int getScore() throws InputMismatchException, IOException{
		Scanner scanner = new Scanner(System.in);
		int score;
		
		System.out.print("> 점수 입력 ? ");
		String data = scanner.next();
		if( data.matches("100|[1-9]?\\d") ) {  // 0~100
			score = Integer.parseInt(data);
			return score;
		}else {
			//  입력 불일치 예외 클래스
			throw new InputMismatchException("점수 범위(0~100) 벗어났다.");
		}		
	} // getScore
}

*

Scanner 는 파일이든 뭐든 생성자든 에서부터 읽어들이는 역할

system.in = 생성자에 들어간 값

new Scanner( 여기 들어간 값 ) 필드 초기화됨