DAY 11 - interface / iterator (2024.07.17)

 

 

interface

- is~a 관계

- 틀

 

1. 표준명세서의 역할

 

2. 상수와 추상메소드만 존재 public static final는 생략가능 abstract는 생략가능

 

3. interface를 implements 한 클래스는 반드시 추상메소드를 Override(재구현)해주어야 한다.

 

4. Override(재구현) 할때 반드시 public를 붙여야 한다.

 

5. 다중상속이 가능

 

6. 상속과 같이 쓰일 때는 extends, implements 순서로 쓴다.

---

[형식]

interface 인터페이스명 {

.....

}

 

class 클래스명 implements 인터페이스명{

...

}

---

클래스 extends 클래스

인터페이스 extends 인터페이스

같은애들끼리만 상속가능

---

*interface

1. implements 쓰면 됨.

=> 모든 추상메소드를 Override 해줘야함.

public class CollectionMain implements Collection

-> 이렇게 하면 15개 다 오버라이드 해야됨.

인터페이스의 추상메소드가 너무 많으면 오버라이딩 해줄 수 없음.

 

2. 대신 Override 해주는 클래스 찾으면 됨.(Sub class(자식 클래스)) - Override 함.

 

3. 메소드 제공해줌. (인터페이스 생성시켜주는 메소드)

 

4. 익명 inner class

---

InterMain.java

package interface_;

//인터페이스는 여러개 받아도 됨. -> 반드시 오버라이드해줘야함.
//public class InterMain implements InterA, InterB { 
//오버라이드 하기 싫으면 추상클래스로 바꾸면 해결은 되지만 
// new안되고, 자식이 오버라이드 해야함.

//IneteC의 부모가 InterA, InterB이므로 이렇게 해도 됨.
public class InterMain implements InterC { 
	public void aa() {}
	public void bb() {}
	
	public void cc() {}
	public void dd() {}
	
	public static void main(String[] args) {

	}
}

 

 

InterA.java

package interface_;

public interface InterA {
	public static final String NAME = "홍길동"; //상수
	int age =25; //public static final 생략가능

	public abstract void aa(); //추상메소드
	public void bb(); //abstract는 생략가능 - 구현x
}

 

 

InterB.java

package interface_;

public interface InterB {
	public void cc();
	public void dd(); //추상
}

 

 

InterC.java

package interface_;

//추상메소드 4개 다 갖고있음.
public interface InterC extends InterA, InterB{ //다중상속 가능

}

 

---

ComputeMain.java

package compute;

public class ComputeMain {

	public static void main(String[] args) {
		ComputeService computeService = new ComputeService();	
		computeService.menu();
		System.out.println("프로그램을 종료합니다.");
	}
}

 

computeService.menu(); → 이 코드통해서 밑에가 실행됨.

 

 

ComputeService.java

package compute;

import java.util.Scanner;

public class ComputeService {
	
	public void menu() {
		Scanner scan = new Scanner(System.in);
		int num = 0;
		Compute com = null; //부모는 new할 필요x 리모콘 역할만 하면됨.
		
		while(true) {
			System.out.println();
			System.out.println("****************");
			System.out.println("      1. 합");
			System.out.println("      2. 차");
			System.out.println("      3. 곱");
			System.out.println("      4. 몫");
			System.out.println("      5. 끝내기");
			System.out.println("****************");
			System.out.print("    번호 : ");
			num = scan.nextInt();
			
			if(num == 5)
				break;
			if(num == 1) 
				com = new Sum(); //생성 / 클래스-대문자 / 객체명-소문자			
			else if(num == 2) 
				com = new Sub();				
			else if(num == 3) 
				com = new Mul();				
			else if(num == 4) 
				com = new Div();				
			
			com.execute(); //if문안에 들어갈 필요x
		}		
	}//menu()
}

 

 

Compute.java → interface

package compute;

public interface Compute {
	public void execute(); //추상걸어줌. -> 자식들 가져야함
}

 

 

Sum.java

package compute;

import java.util.Scanner;

public class Sum implements Compute {
	private int x, y;
	
	public Sum() {
		Scanner scan = new Scanner(System.in);
		
		System.out.print("x의 값 입력 : ");
		x = scan.nextInt();
		System.out.print("y의 값 입력 : ");
		y = scan.nextInt();
	}
	public void execute() {
		System.out.println(x + " + " + y + " = " + (x+y));
	}
}

 

 

Sub.java

package compute;

import java.util.Scanner;

public class Sub implements Compute {
	private int x, y;
	
	public Sub() {
		Scanner scan = new Scanner(System.in);
		
		System.out.print("x의 값 입력 : ");
		x = scan.nextInt();
		System.out.print("y의 값 입력 : ");
		y = scan.nextInt();
	}
	public void execute() {
		System.out.println(x + " - " + y + " = " + (x-y));
	}
}

 

 

Mul.java

package compute;

import java.util.Scanner;

public class Mul implements Compute {
	private int x, y;
	
	public Mul() {
		Scanner scan = new Scanner(System.in);
		
		System.out.print("x의 값 입력 : ");
		x = scan.nextInt();
		System.out.print("y의 값 입력 : ");
		y = scan.nextInt();
	}
	public void execute() {
		System.out.println(x + " * " + y + " = " + (x*y));
	}
}

 

 

Div.java

package compute;

import java.util.Scanner;

public class Div implements Compute {
	private int x, y;
	
	public Div() {
		Scanner scan = new Scanner(System.in);
		
		System.out.print("x의 값 입력 : ");
		x = scan.nextInt();
		System.out.print("y의 값 입력 : ");
		y = scan.nextInt();
	}
	public void execute() {
		System.out.println(x + " / " + y + " = " + (double)x/y);
	}
}

 

 

[결과]

****************
      1. 합
      2. 차
      3. 곱
      4. 몫
      5. 끝내기
****************
    번호 : 1
x의 값 입력 : 2
y의 값 입력 : 3
2 + 3 = 5

****************
      1. 합
      2. 차
      3. 곱
      4. 몫
      5. 끝내기
****************
    번호 : 2
x의 값 입력 : 4
y의 값 입력 : 5
4 - 5 = -1

****************
      1. 합
      2. 차
      3. 곱
      4. 몫
      5. 끝내기
****************
    번호 : 3
x의 값 입력 : 5
y의 값 입력 : 6
5 * 6 = 30

****************
      1. 합
      2. 차
      3. 곱
      4. 몫
      5. 끝내기
****************
    번호 : 4
x의 값 입력 : 8
y의 값 입력 : 9
8 / 9 = 0.8888888888888888

****************
      1. 합
      2. 차
      3. 곱
      4. 몫
      5. 끝내기
****************
    번호 : 5
프로그램을 종료합니다.

 

---

it.hasNext() - 현재 위치에 항목이 있으면 true

없으면 false

 

it.next() - 현재 위치의 항목을 꺼내서 버퍼(임시 기억장소)에 기억을 시킨다음,

다음 항목으로 이동한다.

 

package collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionMain{

	@SuppressWarnings("all") //윽박지르는거 = 억제
	public static void main(String[] args) {
		//인터페이스 new 안됨.
		//배열처럼 들어감.
		Collection coll = new ArrayList(); //대신해주는 클래스 사용해주면 됨.
		coll.add("호랑이");
		coll.add("사자");
		coll.add("호랑이"); //중복허용
		coll.add(25);
		coll.add(43.8);
		coll.add("기린");
		coll.add("코끼리");
		
		Iterator it = coll.iterator(); //메소드 이용해서 인터페이스 생성가능
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

 

호랑이
사자
호랑이
25
43.8
기린
코끼리

 

위 코드랑 차이점 확인 !!

package collection;

import java.util.ArrayList;

public class CollectionMain2 {
//둘의 차이점 확인
	public static void main(String[] args) {
		//안에 뭐가 들었는지 알려주는거 <String>
		ArrayList<String> list = new ArrayList<String>(); 
		list.add("호랑이");
		list.add("사자");
		list.add("호랑이"); //중복허용
		//list.add(25);
		//list.add(43.8);
		list.add("기린");
		list.add("코끼리");
		
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("------------");
		
		for(String data : list) {
			System.out.println(data);
		}
	}
}

 

호랑이
사자
호랑이
기린
코끼리
------------
호랑이
사자
호랑이
기린
코끼리

 

---

PersonDTO.java

package collection;

//implements 걸었으니 오버라이딩해야함.// extends Object 생략 (
public class PersonDTO extends Object implements Comparable<PersonDTO>{
	private String name;
	private int age;

	public PersonDTO() {			
	}

	public PersonDTO(String name, int age) {
		//super();//Object 호출
		this.name = name;
		this.age = age;
	}

	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;
	}


	@Override 
	public String toString() {			
		return "이름 = " + name + "\t 나이 = " + age;
	}

	@Override
	public int compareTo(PersonDTO p) {
		//나이로 오름차순
		/*
		if(this.age < p.age) 
			return -1;
		else if(this.age > p.age) 
			return 1;
		else
			return 0;
		 */

		//나이로 내림차순
		/*
		if(this.age < p.age) 
			return 1;
		else if(this.age > p.age) 
			return -1;
		else
			return 0;
		*/
		
		//이름으로 오름차순 //문자열에는 비교해주는 compareTo()가 있음.
		//return this.name.compareTo(p.name);
		
		//이름으로 내림차순
		return this.name.compareTo(p.name) * -1;
	}
}

 

 

 

PersonMain.java

package collection;

import java.util.ArrayList;

public class PersonMain {
	public ArrayList<PersonDTO> init(){ //return 타입 -> ArrayList<PersonDTO>
		PersonDTO aa = new PersonDTO("홍길동", 25);
		PersonDTO bb = new PersonDTO("프로도", 40);
		PersonDTO cc = new PersonDTO("라이언", 30);
		
		//ArrayList<PersonDTO> list = new ArrayList<>();
		ArrayList<PersonDTO> list = new ArrayList<PersonDTO>();
		list.add(aa); //주소값 추가
		list.add(bb);
		list.add(cc);
		
		return list; //주소주는 것
	}//init()가 끝나면 안에 있는거 다 소멸
	//------------------
	public static void main(String[] args) {
		/*
		PersonDTO personDTO = new PersonDTO(); 
		System.out.println("객체 personDTO = " + personDTO);//personDTO-주소갖고있음
		
		//위에서는 toString() 생략하고있음. /toString() -> Object에 있는 메소드	                                                             
		System.out.println("객체 personDTO = " + personDTO.toString()); 
		personDTO.setName("홍길동");
		personDTO.setAge(25);
		System.out.println("이름 = " + personDTO.getName() + "\t 나이 = " + personDTO.getAge());
		System.out.println(personDTO); //자식클래스에서 오버라이딩했으므로
		*/
		
		PersonMain main = new PersonMain();
		ArrayList<PersonDTO> list = main.init(); //주소값 list에 보관하는 것 
										// 이 때 자료형 - ArrayList<PersonDTO>
		System.out.println(list); //aa, bb, cc 주소담은거
		
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i).getName() + "\t" + list.get(i).getAge());
		}
		System.out.println();
		
		for(PersonDTO personDTO : list) {
			System.out.println(personDTO.getName() + "\t" + personDTO.getAge());
		}
		System.out.println();
		
		for(PersonDTO personDTO : list) {
			System.out.println(personDTO);
		}
		
		//System.out.println(list.get(0).getName() + "\t" + list.get(0).getAge());
		//System.out.println(list.get(1).getName() + "\t" + list.get(2).getAge());
		//System.out.println(list.get(3).getName() + "\t" + list.get(3).getAge());

	}
}

 

System.out.println(personDTO);

System.out.println(personDTO.toString());

.toString()을 생략해도 같은 결과가 나온다.

[이름 = 홍길동	 나이 = 25, 이름 = 프로도	 나이 = 40, 이름 = 라이언	 나이 = 30]
홍길동	25
프로도	40
라이언	30

홍길동	25
프로도	40
라이언	30

이름 = 홍길동	 나이 = 25
이름 = 프로도	 나이 = 40
이름 = 라이언	 나이 = 30

 

 

PersonSort.java

package collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class PersonSort {

	public static void main(String[] args) {
		String[] ar = {"orange", "apple", "banana", "pear", " peach", "applemango"};
		
		System.out.print("정렬 전 = ");
		for(String data : ar) {
			System.out.print(data+"  ");
		}
		System.out.println();
		
		Arrays.sort(ar);
		
		System.out.print("정렬 후 = ");
		for(String data : ar) {
			System.out.print(data+"  ");
		}
		System.out.println();
		

 

//객체 비교
		PersonDTO aa = new PersonDTO("홍길동", 25);
		PersonDTO bb = new PersonDTO("프로도", 40);
		PersonDTO cc = new PersonDTO("라이언", 30);
		
		ArrayList<PersonDTO> list = new ArrayList<PersonDTO>();
		list.add(aa); 
		list.add(bb);
		list.add(cc);
		System.out.println();
		
		System.out.println("[정렬 전]");
		for(PersonDTO personDTO : list) {
			System.out.println(personDTO);
		}
		System.out.println();
		
		Collections.sort(list); // 인터페이스 구현해줘야 사용가능
		
		System.out.println("[정렬 후]");
		for(PersonDTO personDTO : list) {
			System.out.println(personDTO);
		}
		System.out.println();
	}
}

 

정렬 전 = orange  apple  banana  pear   peach  applemango  
정렬 후 =  peach  apple  applemango  banana  orange  pear  

[정렬 전]
이름 = 홍길동	 나이 = 25
이름 = 프로도	 나이 = 40
이름 = 라이언	 나이 = 30

[정렬 후]
이름 = 홍길동	 나이 = 25
이름 = 프로도	 나이 = 40
이름 = 라이언	 나이 = 30