추상 클래스 / 인터페이스

package ex0726;

public class Ex01_abstract {
	public static void main(String[] args) {
		// SortInt si = new SortInt(); // 컴파일 에러. 추상 클래스는 객체 생성 불가
		// 추상 클래스는 반드시 하위 클래스가 존재하고 하위 클래스를 통해서만 객체를 생성 할 수 있다.
		
		int [] data = new int[] {40, 50, 30, 35, 25};
		SortInt si = new BubbleSort(); // 업 캐스팅
		// SortInt si = new SelectionSort();
		
		print("source data : ", data);
		
		si.sort(data);
		
		print("sort data : ", data);
	}
	
	public static void print(String title, int[] value) {
		System.out.print(title);
		for(int n : value) {
			System.out.print(n+" ");
		}
		System.out.println();
	}
}

/*
  // 추상 클래스(abstract class)
    - 선언만 있고 정의가 없는 하나 이상의 추상 메소드를 갖는 클래스
      추상 메소드가 하나 이상 존재하는 경우 반드시 추상 클래스로 선언 해야 한다.
    - 하위 클래스에서 overriding 할 것으로 예상되는 메소드를
      메모리 낭비 없이 미리 호출 계획을 세워 두기 위해 작성
    - 추상 클래스는 객체를 생성할 수 없다.
    - 추상 클래스를 상속 받은 하위 클래스는
       추상 클래스가 아닌 경우 상위 클래스의 추상 메소드를 재정의 해야 한다.
    - 추상 메소드가 없어도 추상 클래스로 작성 할 수 없다. 
 */
abstract class SortInt {
	private int[] value;
	
	// 추상 메소드
	protected abstract void sorting(); // 메소드 만들어야지 딱 거기 까지 설계 까지만 한거 말 그대로 추상
	//이걸 하나 이상 가지고 있다는건 클래스를 만들다 만것임 (미완성)
	//그걸 나타내는게 abstract임 객체 생성 불가
	//자식에서 재정의
	
	public void sort(int[] value) {
		this.value = value;
		sorting();
	}
	
	// 배열의 길이
	protected int length() {
		int n = -1;
		if(value != null) {
			n = value.length;
		}
		return n;
	}
	
	// 두 정수 비교. final 메소드 - 하위 클래스에서 재정의 불가
	protected final int compare(int i, int j) {
		return value[i] - value[j];
	}
	
	// 배열의 두 요소 값을 서로 바꾸기
	protected final void swap(int i, int j) {
		int t = value[i];
		value[i] = value[j];
		value[j] = t;
	}
}

class SelectionSort extends SortInt {
	@Override
	protected void sorting() {
		for(int i = 0; i < length() - 1 ; i++) {
			for(int j = i+1; j < length(); j++) {
				if(compare(i, j) > 0) {
					swap(i, j);
				}
			}
		}
	}
}

class BubbleSort extends SortInt {
	@Override
	protected void sorting() {
		boolean flag = true;
		
		for(int i = 1; flag; i++) {
			flag = false;
			for(int j = 0; j < length() - i; j++) {
				if(compare(j, j + 1) > 0) {
					swap(j, j + 1);
					flag = true;
				}
			}
		}
		
	}
}

추상 클래스 = 미완성 클래스, 어떻게 어떻게 해야지 생각만한것, 메소드를 선언 

 

package ex0726;

public class Ex02_interface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Demo2 dm = new Demo2(); // 컴파일 오류 - 인터페이스는 추상 클래스의 일종으로 객체 생성 불가능
		
		//인터페이스는 구현 클래스의 상위 클래스와 유사하다.
		Demo2 dm = new DemoImp12(); //업 캐스팅
		dm.print();
		dm.disp();
		
		//dm.sub(); // 컴파일 오류 - 구현 클래스에는 정의 되어 있지만 인터페이스에는 존재하지 않으므로
		((DemoImp12)dm).sub(); // 다운 캐스팅
		
		System.out.println(Demo2.A);
		
		//Demo2.B = 50; // 컴파일 오류 - 인터페이스에 정의된 필드는 final이라서
	}

}

// interface : 선언만 있고 정의가 없는 abstract 클래스의 일종
// 인터페이스 작성
interface Demo2 {
	public static final int A = 10;
	public int B = 20; // static final을 붙이지 않아도 자동으로 public static final 붙여줌
	
	public void print(); //메소드는 선언만 가능 abstract 메소드
	public abstract void disp(); // abstract는 생략 가능
	
	/*
	public void sub() {
		
	}
	*/ //메소드를 정의하면 컴파일 오류 발생함
}

//인터페이스 구현
//인터페이스를 구현한 클래스가 추상 클래스가 아닌 경우 인터페이스의 모든 메소드를 재정의 해야 함.
class DemoImp12 implements Demo2 { //DemoImp12가 추상클래스면 상관없는데 아니면 Demo2의 모든 클래스를 재정의 해야함

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("print - 인터페이스 메소드 재정의");
		
	}

	@Override
	public void disp() {
		// TODO Auto-generated method stub
		System.out.println("disp - 인터페이스 메소드 재정의");
	}
	
	public void sub() {
		System.out.println("클래스에 정의된 메소드");
	}
	
}

인터페이스를 구현한 클래스가 추상 클래스가 아니면 인터페이스의 모든 메소드를 재정의 해야한다.

 

package ex0726;

public class Ex03_interface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DemoImp13 di1 = new DemoImp13();
		
		di1.print();
		di1.disp();
		di1.sub();
		
		Ademo3 di2 = new DemoImp13(); // 업 캐스팅
		Bdemo3 di3 = new DemoImp13(); // 업 캐스팅
		
		//di2.print(); // 컴파일 오류 Ademo2 인터페이스에는 print() 메소드가 선언 되어 있지 않음
		((Bdemo3)di2).print();
			// 클래스에 Ademo3과 Bdemo3 인터페이스가 구현되어 있으므로 가능
			// 만약 Bdemo3 인터페이스가 구현되어 있지 않으면 런 타임 오류 발생
		
		((DemoImp13)di3).sub(); // 다운 캐스팅

	}

}

interface Ademo3 {
	public void disp();

}

interface Bdemo3 {
	public void print();
}

// 클래스는 2개 이상의 인터페이스를 구현할 수 있다.(다중 상속이 되지 않는 부분을 보충)
class DemoImp13 implements Ademo3, Bdemo3 {

	@Override
	public void print() {
		System.out.println("Bdemo3 인터페이스 메소드");
		
	}

	@Override
	public void disp() {
		System.out.println("Ademo3 인터페이스 메소드");
		
	}
	
	public void sub() {
		System.out.println("클래스에 정의된 메소드");
	}
	
}

 

package ex0726;

public class Ex04_interface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo4 ob = new Test4(); // 업 캐스팅
		ob.print();
		ob.disp();

	}

}

interface Demo4 {
	public void print();
	public void disp();
	
}

//추상 클래스는 인터페이스의 모든 메소드를 구현하지 않아도 된다.
abstract class DemoImpl4 implements Demo4 {
	@Override
	public void disp() {
		// TODO Auto-generated method stub
		System.out.println("disp 메소드");
	}
}

class Test4 extends DemoImpl4 {

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("print 메소드");
		
	}
	
}

 

package ex0726;

public class Ex05_interface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DemoImpl5 di = new DemoImpl5();
		di.print();

	}

}

interface Ademo5 {
	public void print();
}

interface Bdemo5 {
	public void disp();
}

// 인터페이스는 다른 인터페이스를 상속 받을 수 있다.
// 인터페이스는 클래스와 다르게 2개 이상의 인터페이스를 상속 받을 수 있다.
interface Cdemo5 extends Ademo5, Bdemo5 {
	public void sub();
}

class DemoImpl5 implements Cdemo5 {

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("print");
		
	}

	@Override
	public void disp() {
		// TODO Auto-generated method stub
		System.out.println("disp");
		
	}

	@Override
	public void sub() {
		// TODO Auto-generated method stub
		System.out.println("sub");
		
	}
	
}

package ex0726;

public class Ex06_interface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Store st = new Store();
		
		Orange ob = new Orange();
		
		
		st.sell(ob);
		st.sell(new Apple());

	}

}

interface Fruit {
	public int getPrice(); //이걸 누르면 가격을 볼수 있음 인터페이스 개념임
	public String getName();
	
}

class Apple implements Fruit {

	@Override
	public int getPrice() {
		// TODO Auto-generated method stub
		return 1000;
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "사과";
	}
	
}

class Orange implements Fruit {

	@Override
	public int getPrice() {
		// TODO Auto-generated method stub
		return 800;
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "오렌지";
	}
	
}

class Store {
	public void sell(Fruit ft) {
		System.out.println(ft.getName() + "->" + ft.getPrice());
	}
}

 

인터페이스에서 메소드 생성

package ex0726;

public class Ex07_interface {

	public static void main(String[] args) {
		// 인터페이스에서 메소드 생성
		
		int s = Demo7.sum(10);
		System.out.println(s);
		
		Demo7 dm = new DemoImpl7();
		int x = dm.max(5, 10);
		dm.write(x);
		

	}

}

interface Demo7 {
	public void write(int n);
	
	// JDK 8 부터 가능. 인터페이스를 이용하여 바로 접근 가능
	public static int sum(int n) {
		int s = 0;
		for(int i=1; i<=n; i++) {
			s+=i;
		}
		return s;
	}
	
	// JDK 8 부터 가능. 
	// default 키워드를 이용하여 메소드 구현 가능
	// 구현 클래스에서 재정의 가능
	public default int max(int m, int n) {
		return m > n ? m : n;
	}
}

class DemoImpl7 implements Demo7 {

	@Override
	public void write(int n) {
		System.out.println("결과 : "+n);
		
	}
	
}

 

인터페이스의 익명 구현

package ex0726;

public class Ex08_interface {

	public static void main(String[] args) {
		// 인터페이스의 익명 구현
		// 이름없는 클래스
		
		Demo8 ob = new Demo8() {
			
			@Override
			public void disp() { 
				// TODO Auto-generated method stub
				System.out.println("disp");
				
			}
		};
		
		ob.disp();
	
	}

}

interface Demo8 {
	public void disp();
}