[JAVA] Day-16 _ 인터페이스 (interface)

day-16

인터페이스 (interface)

---

인터페이스 (interface) 란 ? 

• field 는 final 변수로만, 메소드는 추상 메소드(미완성 메소드)로만 이루어진 것을 말한다.
• 추상 메소드와 field의 접근 제한자는 public 으로만 되어진다.
• 추상 메소드 생성 시에 public abstract 가 생략 되어져 있다.
• field 생성 시에 public final 이 생략 되어져 있다.

 

예시 코드를 통해 확인해보자.

interface Figure

package my.day16.e.Interface;

public interface Figure {

	// field ==> public final 이 생략되어져 있다.
	double PI = 3.141592;
	// 즉, public final double PI = 3,141592; 이다.
	 
	
	// method
	double area(double x, double y);
	// public abstract 이 생략되어져 있다.
	// 즉, public abstract double area(double x, double y); 이 원래 형태이다.
	
	double area(double r); // method의 오버로딩은 파라미터 값이 다르면 메소드의 이름이 같아도 중복으로 보지 않는다.
	
	
}

 

Circle

package my.day16.e.Interface;

public class Circle implements Figure {

	
	
	@Override
	public double area(double r) {
		
		return PI*r*r;
	}

	@Override
	public double area(double x, double y) {
		return 0;
	}

}

 

Rectangle

package my.day16.e.Interface;

public class Rectangle implements Figure {

	// Rectangle 이라는 클래스는 Figure 라는 인터페이스를 implements(구현)한다는 말이다.
	
	@Override
	public double area(double x, double y) {

		return x*y;
	}

	@Override
	public double area(double r) {
		return 0;
	}

}

 

Triangle

package my.day16.e.Interface;

public class Triangle implements Figure {

	// Triangle 이라는 클래스는 Figure 라는 인터페이스를 implements(구현)한다는 말이다.
	
	@Override
	public double area(double x, double y) {

		return x*y*0.5;
	}

	@Override
	public double area(double r) {
		return 0;
	}

}

 

Main Interface

package my.day16.e.Interface;

public class MainInterface {

	public static void main(String[] args) {

		Rectangle rt = new Rectangle();
		Triangle tri = new Triangle();
		Circle cir = new Circle();
		
		System.out.println("가로 4, 세로 5 인 사각형의 넓이 => " + rt.area(4,5));
		System.out.println("밑변 4, 높이 5 인 삼각형의 넓이 => " + tri.area(4,5));
		System.out.println("반지름이 4인 원의 넓이 => " + cir.area(4));
		
		System.out.println("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
		
		// == 다형성(Polymorphism) == //
		// ==> 자식클래스로 생성된어진 객체를 부모클래스의 타입으로 받을 수가 있다.
		// ==> 특정한 인터페이스로 구현된 클래스의 객체는 특정한 인터페이스의 타입으로 받을 수가 있다. !!!
		
		Figure fg1 = new Rectangle();
		Figure fg2 = new Triangle();
		Figure fg3 = new Circle();
		
		System.out.println("가로 4, 세로 5 인 사각형의 넓이 => " + fg1.area(4,5));
		System.out.println("밑변 4, 높이 5 인 삼각형의 넓이 => " + fg2.area(4,5));
		System.out.println("반지름이 4인 원의 넓이 => " + fg3.area(4));
		
		System.out.println("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

		Figure[] fg_arr = new Figure[3];
		fg_arr[0] = new Rectangle();
		fg_arr[1] = new Triangle();
		fg_arr[2] = new Circle();
		
		for(Figure fg : fg_arr) {
			if( fg instanceof Circle)
				System.out.println(fg.area(4));
			else 
				System.out.println(fg.area(4,5));
		}// end of for()----------------------------
		
		
		
	}// end of public static void main(String[] args)-------------------------

}

 

 

코드를 보면 Figure 만 인터페이스로 만들어졌고, 추상 메소드와 final 변수로만 이루어져 있다.

이후 다른 클래스들에서 해당 인터페이스의 메소드를 오버라이딩 하여 사용하고 있음을 확인할 수 있다.

이처럼 인터페이스는 추상클래스와 비슷한 점을 많이 갖고 있다.

 

그렇다면 왜 굳이 인터페이스를 사용하는 것일까?

나는 수업시간에 의문이 생겼다. 굳이 인터페이스를 사용할 일이 있을까? 

추상 클래스와 크게 다를 점이 없어보이는데 말이다.

 

하지만 인터페이스를 쓰는 가장 큰 이유는 다중 상속이 가능하다는 점이라고 할 수 있다.

코드로 확인해보자.

 

InterFather

package my.day16.e.multiInterface;

public interface InterFather {

	void work();
	// public abstract void work(); 와 같다.
	
}

 

InterMother

package my.day16.e.multiInterface;

public interface InterMother {

	
	void cook();
	// public abstract void cook(); 와 같다.
}

 

InterChild

package my.day16.e.multiInterface;

public interface InterChild extends InterFather, InterMother {
	// 자바는 인터페이스에서 여러개의 인터페이스를 상속받는 다중상속이 가능하다.
	
	void play();
	// public abstract void play(); 와 같다.
	
}

interchild 에서 확인 가능한 것 처럼, 인터페이스는 다중 상속이 가능하다.

 

Child

package my.day16.e.multiInterface;

public class Child implements InterChild {

	@Override
	public void work() {
		System.out.println("보람차게 알헙나다.");
	}

	@Override
	public void cook() {
		System.out.println("맛있는 요리를 합니다.");
		
	}

	@Override
	public void play() {
		System.out.println("재미있게 놉니다.");
	}

}

 

MainChild

package my.day16.e.multiInterface;

public class MainChild {

	public static void main(String[] args) {

		Child cd = new Child();
		cd.work();
		cd.cook();
		cd.play();
		
		System.out.println("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
		
		InterFather infather = new Child();
		infather.work();
		
		InterMother inmother = new Child();
		inmother.cook();
		
		System.out.println("\n===================================\n");

		InterChild inchild = new Child();
		inchild.cook();
		inchild.work();
		inchild.play();
		
		
		
	}
}

 

현재 블로그에서 소개하는 인터페이스의 코드는 정말 기초 중의 기초다.

프로그래밍이 좀 더 복잡해지면 인터페이스도 헷갈리는 순간이 올 것이다.

중요한 것은 왜 인터페이스를 사용했는지,  만들고자 하는 프로그램에서 어떤 역할을 해주는지

그 의도를 파악하고 코드를 읽는 연습이 필요할 것이다.

 

수업을 들으며 "별 거 아니네" 라고 헸지만, 구인구직 프로그램 만들었던 코드를 인터페이스로 바꾸면서

머리가 지끈거리는 것을 경험할 수 있었다.

 

기본개념을 확실하게 익히고 코드의 흐름을 읽는 연습도 정말 중요한 거 같다.