해리코딩

https://denim-era-2c8.notion.site/JAVA-9f5f41fd7f424a35a4bb039b6c49d77d?pvs=4

OCP(Open-Close Principle) 원칙

→ Open for extenstion : 새로운 기능의 추가, 변경 사항이 생겼을 때, 기존 코드는 확장 할 수 있어야 함

→ Closed for modification : 기존의 코드는 수정되지 않아야 함

=> 기존 코드 수정 없이 새로운 기능을 추가할 수 있다

전략 패턴(Strategy Pattern)
실행(런타임)중에 알고리즘 전략을 선택하여 객체 동작을 실시간으로 바뀌도록 할 수 있게하는 행위 디자인 패턴
전략 = 일종의 알고리즘이 될 수 도 있고, 기능이나 동작이 될 수도 있는 특정한 목표를 수행하기 위한 행동 계획
알고리즘 변형이 빈번하게 필요한 경우에 쓰는 패턴

즉, 알고리즘을 클라이언트 코드의 변경 없이 쉽게 교체 가능.

예시) 다중 메세지 보내기

package poly.ex.sender;

public interface Sender {
    void sendMessage(String message);
}

package poly.ex.sender;

public class SmsSender implements Sender {
    @Override
    public void sendMessage(String message) {
        System.out.println("문자를 발송합니다 "+message);
    }
}

package poly.ex.sender;

public class EmailSneder implements Sender {
    @Override
    public void sendMessage(String message) {
        System.out.println("메일을 발송합니다." + message);
    }
}

package poly.ex.sender;

public class MetaSender implements Sender {
    @Override
    public void sendMessage(String message) {
        System.out.println("페메를 발송합니다."+message);
    }
}

package poly.ex.sender;

public class SendMain {
    public static void main(String[] args) {
        Sender[] senders = {new EmailSneder(), new SmsSender(), new MetaSender()};
        for (Sender sender : senders) {
            sender.sendMessage("환영합니다!");

        }
    }
}
--------------------------------------------------------

메일을 발송합니다.환영합니다!
문자를 발송합니다 환영합니다!
페메를 발송합니다.환영합니다!

예시2) 결제 시스템 개발 

- PayMain0을 수정하지 않고, 그대로 유지

- 실행결과는 동일

문제)

package poly.ex.pay0;

public class KakaoPay {
    public boolean pay(int amount) {
        System.out.println("카카오페이 시스템과 연결합니다.");
        System.out.println(amount + "원 결제를 시도합니다.");
        return true;
    }
}

package poly.ex.pay0;

public class NaverPay {
    public boolean pay(int amount) {
        System.out.println("네이버페이 시스템과 연결합니다.");
        System.out.println(amount + "원 결제를 시도합니다.");
        return true;
    }
}

package poly.ex.pay0;

public class PayService {
    public void processPay(String option, int amount) {

        boolean result;
        System.out.println("결제를 시작합니다: option=" + option + ", amount=" +
                amount);

        if (option.equals("kakao")) {
            KakaoPay kakaoPay = new KakaoPay();
            result = kakaoPay.pay(amount);
        } else if (option.equals("naver")) {
            NaverPay naverPay = new NaverPay();
            result = naverPay.pay(amount);
        } else {
            System.out.println("결제 수단이 없습니다.");
            result = false;
        }
        if (result) {
            System.out.println("결제가 성공했습니다.");
        } else {
            System.out.println("결제가 실패했습니다.");
        }
    }
}

package poly.ex.pay0;

public class PayMain0 {
    public static void main(String[] args) {
        PayService payService = new PayService();
        //kakao 결제
        String payOption1 = "kakao";
        int amount1 = 5000;
        payService.processPay(payOption1, amount1);

        //naver 결제
        String payOption2 = "naver";
        int amount2 = 10000;
        payService.processPay(payOption2, amount2);

        //잘못된 결제 수단 선택
        String payOption3 = "bad";
        int amount3 = 15000;
        payService.processPay(payOption3, amount3);
    }
}

내가 푼 정답)

package poly.ex.pay0;

public class KakaoPay {
    public boolean pay(int amount) {
        System.out.println("카카오페이 시스템과 연결합니다.");
        System.out.println(amount + "원 결제를 시도합니다.");
        return true;
    }
}

package poly.ex.pay0;

public class NaverPay {
    public boolean pay(int amount) {
        System.out.println("네이버페이 시스템과 연결합니다.");
        System.out.println(amount + "원 결제를 시도합니다.");
        return true;
    }
}

package poly.ex.pay0;

public class TossPay {
    public boolean pay(int amount) {
        System.out.println("토스페이 시스템과 연결합니다.");
        System.out.println(amount + "원 결제를 시도합니다.");
        return true;
    }
}

package poly.ex.pay0;

public class PayService {
    public void processPay(String option, int amount) {

        boolean result;
        System.out.println("결제를 시작합니다: option=" + option + ", amount=" +
                amount);

        if (option.equals("kakao")) {
            KakaoPay kakaoPay = new KakaoPay();
            result = kakaoPay.pay(amount);
        } else if (option.equals("naver")) {
            NaverPay naverPay = new NaverPay();
            result = naverPay.pay(amount);
        } else if (option.equals("toss")) {
            TossPay tossPay = new TossPay();
            result = tossPay.pay(amount);
        } else {
            System.out.println("결제 수단이 없습니다.");
            result = false;
        }
        if (result) {
            System.out.println("결제가 성공했습니다.");
        } else {
            System.out.println("결제가 실패했습니다.");
        }
    }
}

package poly.ex.pay0;

public class PayMain0 {
    public static void main(String[] args) {
        PayService payService = new PayService();
        //kakao 결제
        String payOption1 = "kakao";
        int amount1 = 5000;
        payService.processPay(payOption1, amount1);

        //naver 결제
        String payOption2 = "naver";
        int amount2 = 10000;
        payService.processPay(payOption2, amount2);

        //toss 결제
        String payOption3 = "toss";
        int amount3 = 12000;
        payService.processPay(payOption3, amount3);

        //잘못된 결제 수단 선택
        String payOption4 = "bad";
        int amount4 = 15000;
        payService.processPay(payOption4, amount4);
    }
}

다른방법 - 최적화)

package poly.ex.pay0;
interface Pay {
    boolean pay(int amount);

    public class KakaoPay implements Pay {

        @Override
        public boolean pay(int amount) {
            System.out.println("카카오페이 시스템과 연결합니다.");
            System.out.println(amount + "원 결제를 시도합니다.");
            return true;
        }
    }


    public class NaverPay implements Pay {

        @Override
        public boolean pay(int amount) {
            System.out.println("네이버페이 시스템과 연결합니다.");
            System.out.println(amount + "원 결제를 시도합니다.");
            return true;
        }
    }


    public class TossPay implements Pay {

        @Override
        public boolean pay(int amount) {
            System.out.println("토스페이 시스템과 연결합니다.");
            System.out.println(amount + "원 결제를 시도합니다.");
            return true;
        }
    }


    public class DefaultPay implements Pay {
        @Override
        public boolean pay(int amount) {
            System.out.println("결제 수단이 없습니다.");
            return false;
        }
    }
    
    
    public abstract class PayStore {

        public static Pay findPay(String option) {

            if (option.equals("kakao")) {
                return new KakaoPay();
            } else if (option.equals("naver")) {
                return new NaverPay();
            } else if (option.equals("toss")) {
                return new TossPay();
            } else {
                return new DefaultPay();
            }
        }
    }



    public class PayService {
        public void processPay(String option, int amount) {

            System.out.println("결제를 시작합니다: option=" + option + ", amount=" +
                    amount);


            Pay pay = PayStore.findPay(option);
            boolean result = pay.pay(amount);


            if (result) {
                System.out.println("결제가 성공했습니다.");
            } else {
                System.out.println("결제가 실패했습니다.");
            }
        }
    }
    

    public class PayMain0 {
        public static void main(String[] args) {
            PayService payService = new PayService();
            //kakao 결제
            String payOption1 = "kakao";
            int amount1 = 5000;
            payService.processPay(payOption1, amount1);

            //naver 결제
            String payOption2 = "naver";
            int amount2 = 10000;
            payService.processPay(payOption2, amount2);

            //toss 결제
            String payOption3 = "toss";
            int amount3 = 12000;
            payService.processPay(payOption3, amount3);

            //잘못된 결제 수단 선택
            String payOption4 = "bad";
            int amount4 = 15000;
            payService.processPay(payOption4, amount4);
        }
    }
}

예시2 + 사용자 입력받기

package poly.ex.pay0;

import java.util.Scanner;

public class PayMain2 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        PayService payService = new PayService();

        while(true){
            System.out.println("결제 수단을 입력하세요:");
            String payOption = scanner.nextLine();

            if(payOption.equals("exit")){
                System.out.println("프로그램종료");
                return;
            }
            System.out.println("결제 금액을 입력하세요:");
            int amount = scanner.nextInt();
            scanner.nextLine();

            payService.processPay(payOption, amount);

        }

    }
}

Scanner (편리함!)

• 다양한 입력 소스 지원
  (System.in), 파일이나 문자열 등 다른 소스에서도 데이터를 읽을 수 있음
• 다양한 데이터 유형 처리
  정수, 실수 ,문자열 등 여러 유형의 데이터를 쉽게 읽을 수 있고 각 유형에 맞게 메소드를 사욯애서 데이터 처리할 수 있다
• 유효한 데이터 추출
  유효한 형식인지 확인하여 유효하지 않은 데이터를 입력했을 때, 에외를 발생시킨다
• 간편한 사용
• 메모리 누수방지
  s.close()를 사용하여 누수를 방지할 수 있다

BufferedReader (성능!)

• 버퍼링
  버퍼를 이용하여 데이터를 읽어옴, 데이터를 한 번에 읽어와서 버퍼에 저장한 후, 필요할 때마다 버퍼에서 데이터를 읽어온다
• 한 줄씩 읽기
  readLine()메소드를 통해 데이터를 한 줄씩 읽어올 수 있다
  텍스트 파일이나 네트워크 연결에서 한 줄씩 데이터를 읽을 때 특히 유용하다
  readLine()은 읽은 데이터를 String 형태로 반환하고, 데이터의 끝에 도달하면 null을 반환한다
• 문자 인코딩
  생성자를 통해 InputStreamReader를 함께 사용하여 데이터의 인코딩을 지정할 수 있다.
• 입출력 예외 처리
  예외 처리 기능을 제공하여 발생하는 오류를 적절하게 처리가 가능하다
• 자동 리소스 관리
  try-with-resources 문을 활용하여 자동 리소스 관리를 할 수 있다

Scanner는 띄어쓰기와 개행문자를 기준으로 입력 값을 인식하기 때문에 따로 가공할 필요가 없지만,

BufferedReader 는 개행문자(엔터)만 경계로 인식하고 입력된 데이터의 형식이 String으로 고정되기 때문에 데이터를 따로 가공해주어야 한다

BufferedReader와 StringTokenizer를 사용하기 위해 import를 해준다

BufferedReader를 사용하기 위해선 예외처리가 필수적이기 때문에 try, catch문을 이용 or 메인문 중괄호 시작 전 throws IOException으로 처리해야만 한다

입력을 받기 위해선 readLine() 메소드를 사용하고, 데이터가 문자 값으로 들어오기 때문에 숫자 값을 받아올 땐 꼭 형변환이 필요하다

단일 입력을 받을 때는 상관없지만 다량의 데이터를 입력받을 때는 split 아니면 StringTokenizer를 사용해준다

split은 입력받는 동시에 별다른 처리 없이 배열로 데이터를 받아올 수 있다, StringTokenizer의 경우 토큰화 된 문자열을 다시 처리해주어야 한다.

StringTokenizer의 생성자에서 추가적인 구분자를 명시하지 않을 경우 default 값은 띄어쓰기로 데이터가 구분되기 때문에 필요시 다른 구분자를 사용할 경우 StringTokenizer st = new StringTokenizer(문자열, 구분자); 를 이용한다.

배열을 생성하며 크기를 정해줄 땐 countTokens() 메소드를 이용해 총 토큰의 수를 리턴 받는다.

그다음 hasMoreTokens() 메소드가 토큰이 더 이상 없을 때 false를 리턴한다는 것을 이용해 while문을 돌리며 데이터를 저장한다.

성능면에선 split은 정규식을 기반으로 문자열을 자르는 로직으로 동작하기 때문에 단순히 공백 자리를 당겨서 채우는 StringTokenizer가 더 빠르다.

import java.io.*; //BufferedReader 사용
import java.util.*; //StringTokenizer 사용

public class BufferEx {
	public static void main(String[] args) throws IOException { // 예외처리 필수
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 선언
		
		String s = br.readLine(); 
		System.out.println("String : " + s);
		
		int i = Integer.parseInt(br.readLine()); // readLine()으로 받은 String 값을 int로 형변환
		System.out.println("Int : " + i);
		
       	 	//여러 개의 데이터 입력받기
        	String s2[] = br.readLine().split(" "); //split을 이용해 다량의 데이터 입력 받기
        
		StringTokenizer st = new StringTokenizer(br.readLine());
		int arr[] = new int[st.countTokens()];
		int count=0;
		while(st.hasMoreTokens()) {
			arr[count] = Integer.parseInt(st.nextToken());
			System.out.println(arr[count++]);
       		//countTokens() : 총 토큰의 개수를 리턴
		//hasMoreTokens() : 토큰이 남아있다면 true, 없으면 false 리턴
		}
	}
}

출처: https://lasbe.tistory.com/48 [LasBe's Upgrade:티스토리]

예시)

성능향상스트림

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class test1 {
    public static void main(String[] args) throws IOException {
        
        FileWriter fw=new FileWriter("b.txt"); //b.txt파일이 생성됌
        BufferedWriter out=new BufferedWriter(fw);

        out.write("Halo");
        out.newLine(); // = \\n
        out.write("today is Friday");
        out.newLine();
        out.write("so exciting");
        out.close();

    }
}

문자입력 스트림 BuffredReader, Writer

import java.io.*;

public class test1 {
    public static void main(String[] args) {

        //FileReader f=new FileReader("b.txt");
        //BufferedReader in=new BufferedReader(f);
        try {
            BufferedReader in = new BufferedReader(new FileReader("b.txt"));
            String str;
            while (true) {
                try {
                    str = in.readLine();
                    if (str == null) {
                        break;
                    }
                    System.out.println(str);
                } catch (Exception e) {}
                }
                try {
                    in.close();
                } catch (IOException e) {
                }
            } catch(FileNotFoundException e){
            }
        }
    }

       /*
        FileWriter fw=new FileWriter("b.txt"); //b.txt파일이 생성됌
        BufferedWriter out=new BufferedWriter(fw);

        out.write("Halo");
        out.newLine(); // = \\n
        out.write("today is Friday");
        out.newLine();
        out.write("so exciting");
        out.close();
    */

예시)

Sample.txt파일에 “저는 자바를 좋아합니다”를 저장하고 파일을 읽어 화면에 출력해라 (String [] 배열로 초기화해서 for문으로 읽기)

import java.io.*;

public class test1 {
    public static void main(String[] args) throws IOException {

        // 파일 "Sample.txt"를 읽어오기 위해 BufferedReader를 생성합니다.
        BufferedReader br=new BufferedReader(new FileReader("Sample.txt"));
        // 3. 파일을 읽어옴

        // 무한 루프를 통해 파일의 각 라인을 읽어옵니다.
        for(;;){
            // 한 줄씩 읽어옵니다.
            String str=br.readLine();
            // 만약 읽어온 라인이 null이라면 파일의 끝에 도달했으므로 반복문을 종료합니다.
            if(str==null){
                break;
            }
            
            System.out.println(str); //4. 출력
        }

        /*
        파일에 문자열을 쓰는 코드입니다.
        String str[] = {"저는 자바를 좋아합니다."};

        // 파일 "Sample.txt"를 생성하기 위해 FileWriter를 생성합니다.
        FileWriter fw = new FileWriter("Sample.txt"); //1. 파일생성
        // BufferedWriter를 생성하여 문자열을 파일에 쓰기 위해 사용합니다.
        BufferedWriter bw = new BufferedWriter(fw);

        // 문자열 배열에 있는 각 문자열을 파일에 씁니다.
        for (int i = 0; i < str.length; i++) {
            bw.write(str[i]);
        }
       
        bw.close(); // 2.문자열 파일에 저장
        */
    }
}

예시)

1. FileOutputStream을 이용하여 byte [] 배열 속에 들어있는 바이너리 값을 fi.txt파일에 저장해라. (byte b []={1,2,3,4,5}; 로초기화)
2. 저장한 후 값을 읽어와서 출력해라.

💡 readAllBytes를 사용하면 따로 byte로 변환 안 시켜줘도 된다!

import java.io.*;

public class test1 {
    public static void main(String[] args) throws IOException {

        // 파일 "fi.txt"를 읽기 위해 FileInputStream을 생성합니다.
        FileInputStream fi = new FileInputStream("fi.txt"); //3.파일 읽기

        // 파일의 모든 바이트를 읽어와서 byte 배열에 저장합니다.
        byte c[] = fi.readAllBytes();

        // 읽어온 바이트 배열을 반복문을 통해 출력합니다.
        for (byte b : c) { //4.출력
            System.out.println(b);
        }

        /*
        // 파일에 바이트 배열을 쓰는 코드입니다.
        FileOutputStream fw = new FileOutputStream("fi.txt"); //1.파일생성
        byte b[]={1,2,3,4,5};

        // 파일에 바이트 배열을 씁니다.
        fw.write(b);
        // 파일 출력 스트림을 닫습니다.
        fw.close(); //2.문자열 파일에 저장
        */
    }
}

예시) BufferedReader, StringTokenizer 활용한 알람시계 맞추기

         - 일어나야 하는 시간 보다 45분 일찍 맞추기

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int H = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        if(M<45){
                H = (H == 0)? 23:H-1;
                M = 60 - (45 - M);
            } else {
                M = M -45;
            }
        System.out.println(H+" "+M);

    }
}

BufferedReader에서 입력종료시키기

IntelliJ에서는 eclipse와 같은 프롬프트나 터미널 환경에서 입력을 종료시키는 Ctrl + Z 를 사용 할 수 없으므로 특정 조건을 줘서 입력을 종료받아야함

예시1) end를 입력하여 종료시키기

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int sum = 0;
        int count = 0;

        System.out.println("정수를 입력하고 엔터를 누르세요. 입력을 종료하려면 'end'를 입력하세요.");

        while (true) {
            try {
                String input = br.readLine();      // compareTo를 사용하여도 가능
                if ("end".equals(input)) { // == if (input.compareTo("end")==0) {
                    break; // 
                }
                int number = Integer.parseInt(input); //
                sum += number; // 
                count++; //
           }catch (Exception e){}
        }

        double avg = (double)sum/count;
        System.out.println(avg);

        }
    }

예시2) 0을 입력하여 종료시키기

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));

        int sum = 0;
        int count = 0;

        System.out.println("정수를 입력하세요, 0을 입력하면 종료");

        while(true){
            try{
                int num = Integer.parseInt(br.readLine());

                if(num==0) {
                    break;
                }
                    sum +=num;
                    count++;
            }catch (Exception e){}
        }

        double avg = (double)sum/count;
        System.out.println(avg);

        }
    }

Split()

Split 메소드는 구분자를 "문자"로 받는 게 아니라 "정규식"으로 받는다

구분자로 문자열 분리

예시)

  String str="오늘은 금요일, 공부하고 운동가자!!";
	
	String ary[]=str.split(",");   // 쉼표를 기준으로 문자열을 나눈다 전[0] 후[1]
			System.out.println(a[0]);
			System.out.println(a[1]);
			
			for(String str:ary) {  //for(변수:배열명)
				System.out.println(str);
			}

-------------------------------

오늘은 금요일
 공부하고 운동가자!!
오늘은 금요일
 공부하고 은동가자!!

여러개 구분자로 문자열 분리하기

정규식 or를 의미하는 대괄호로 감싸서 구분자로 사용할 특수문자를 적어주면 된다.

예시)

import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {

        String str = "hello-world%inpa@tistory#com";
        String[] splitter = str.split("[%-@#]");

        for (int i = 0; i < splitter.length; i++) {
            System.out.printf("%d위치 : %s\n", i, splitter[i]);
        }
    }
}
---------------------
0위치 : hello
1위치 : world
2위치 : inpa
3위치 : tistory
4위치 : com

StringTokenizer 

문자열을 구분자를 이용하여 분리할 때 사용이 가능한 클래스

BufferedReader 클래스의 메소드로 입력을 읽어드린다면 라인 단위로 읽어 들일 수밖에 없는데,

꼭 BufferedReader 클래스만이 아니더라도,   스페이스를 기준으로  "," , "   "을 기준으로 문자열을 분리하거나 특정 문자에 따라 문자열을 나누고 싶을 때 사용됨

토큰을 꺼내와서 StringTokenizer에서 지원하는 메소드로 원하는 방식으로 문자열을 가공해야 하는 방식인 Split과는 사용방법이 차이가 있다.

1. StringTokenizer st = new StringTokenizer(str)
= 공백문자를 기준으로 문자열을 분리

예시)

import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {

        String str = "Manner make a man";
        StringTokenizer st = new StringTokenizer(str);

        System.out.println("str의 토큰 개수: "+st.countTokens());
        while(st.hasMoreTokens()){
            System.out.println(st.nextToken());
        }
    }
}

Qurious)
while(st.hasMoreTokens())는 문자열을 토큰으로 분리할 때, 아직 처리되지 않은 토큰이 남아 있는지 확인하기 위해 사용된다.
이 부분이 없으면 모든 토큰을 읽고 출력할 수 없어서 꼭 필요함
만약 이 부분을 제거하면 모든 토큰을 출력하는 대신 첫 번째 토큰만 출력됨

2. StringTokenizer st = new StringTokenizer(str. 구분자);
// 토큰을 기준으로 문자열을 분리
// 이때, 구분자는 토큰으로 간주되지 않음.

예시)

import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {

        String str = "Manner@make@a@man";
        StringTokenizer st = new StringTokenizer(str, "@");

        System.out.println("str의 토큰 개수: "+st.countTokens());
        while(st.hasMoreTokens()){
            System.out.println(st.nextToken());
        }
    }
}

3.StringTokenizer st = new StringTokenizer(str. 구분자, boolean);
= 구분자를 기준으로 문자열을 분리할 때 구분자도 토큰으로 포함(true)  /  미포함(false)

예시)

import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {

        String str = "Manner@make@a@man";
        StringTokenizer st = new StringTokenizer(str, "@",true);

        System.out.println("str의 토큰 개수: "+st.countTokens());
        while(st.hasMoreTokens()){
            System.out.println(st.nextToken());
        }
    }
}
-----------------------------------------------------------
str의 토큰 개수: 7
Manner
@
make
@
a
@
man

참조 및 인용

출처: https://inpa.tistory.com/entry/JAVA-☕-Split-StringTokenizer-문자열-자르기-비교하기 [Inpa Dev 👨‍💻:티스토리]

import java.util.Scanner;
class PhoneNumbers{
	String name;
	String phone;
	
	PhoneNumbers(String n, String p){
		name=n;
		phone=p;
	}
	void show() {
		System.out.println("이름 : "+name);
		System.out.println("번호 : "+phone);
	}
}

class SchoolMate extends PhoneNumbers{
	String major;
	
	SchoolMate(String n, String p, String major){
		super(n, p);
		this.major=major;
		
	}
	@Override
	void show() {
		super.show(); // 부모클래스 show 호출하기
		System.out.println("전공 : "+major);
	}
}

class Co_workers extends PhoneNumbers{
	String grade;
	
	Co_workers(String n, String p, String g){
		super(n,p);
		grade=g;
	}
	@Override
	void show() {
		super.show();
		System.out.println("직급 : "+grade);
	}
}

class Arr{
	
	PhoneNumbers [] ary; // 객체배열
	int n;
	
	Arr(int n){ // 생성자 역할 : 초기화 작업
		ary=new PhoneNumbers[n]; // PhoneNumbers [] ary = new PhoneNumbers[5];
		n=0;		
	}
	void add(PhoneNumbers p) {
		ary[n++]=p; //친구추가
	}
	void friend(char ch) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("이름: ");
		String name=scanner.nextLine();
		System.out.println("번호: ");
		String num=scanner.nextLine();
		
		switch(ch) {
		case'A': // 학교친구 입력
			System.out.println("전공: ");
			String major=scanner.nextLine();
			add(new SchoolMate(name, num, major));
			//PhoneNumber p = new School(name, num, major);
			break;
		case'B': // 회사동료 입력
			System.out.println("직급: ");
			String grade=scanner.nextLine();
			add(new Co_workers(name, num, grade));
			//PhoneNumber p = new School(name, num, grade);
			break;
			
		}
	}
		void all() {
			for(int i=0;i<n;i++) {
				ary[i].show();
			}
		}
	}
	

public class mmdd0229 {
	public static void main(String[] args) {

		Arr ar = new Arr(5);
		//객체 배열 5개
		
		while(true) {
			System.out.println("A. 학교친구");
			System.out.println("B. 직장동료");
			System.out.println("C. 종   료");
			System.out.println("D. 출   력");
			System.out.println("문자입력: ");
			
			Scanner scanner=new Scanner(System.in);
			char c=scanner.next().charAt(0); // A~D중 하나 입력
			
			switch(c) {
			case 'A': 
				ar.friend(c); 
				break;
			case 'B': 
				ar.friend(c); 
				break;
			case 'C': 
				System.out.println("종료"); // 
				return; 
				// continue를 적으면 아예 종료가 되기 때문에, return으로 가야 다시 위에서부터 반복될듯..?
				//return 문은 현재 메소드를 종료하고 호출자에게 반환하며, 만약 이 메소드가 main 메소드라면 프로그램 전체가 종료됩니다.
				//continue 문은 현재 반복의 나머지 부분을 건너뛰고 다음 반복으로 넘어가는 데 사용됩니다. 
				//하지만 여기서는 반복문이 아니라 switch 문 안에서 사용되고 있기 때문에 continue를 사용할 수 없습니다.
				
				
			case 'D': 
				ar.all(); 
				break;
			}
		}
	}
}

객체 배열

객체를 저장하는 배열로 배열의 자료형을 클래스명(사용자 정의 자료)으로 지정하여 활용

객체 배열의 선언과 동시에 값 입력

cf)

Circle [] ary = new Circle[4];

예시1)

import java.util.Scanner;

class Circle{
	int r;
	Circle(int r){
		this.r=r;
	}
	double area() {
		return r*r*3.14;
	}
}

public class mmdd0229 {
	public static void main(String[] args) {

		//객체 배열 : 객체를 저장할 수 있는 공간(타입: 클래스)
		Circle [] ary = new Circle[4]; // == int [] ary = new int [4]
		// 객체 배열 생성 = 객체 배열 선언
		
		//Circle c=new Circle();
	
		for(int i=0;i<ary.length;i++) {
			ary[i]=new Circle(i);	//객체를 4개 생성해서 배열위치에 저장
			System.out.println(ary[i].area());
		}
		
		
	}
}

예시2)

import java.util.Scanner;

class Song{
	String singer,song;
	
	Song(String singer, String song){
		this.singer=singer;
		this.song=song;
	}
}

public class mmdd0229 {
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		
		Song so[]=new Song[2];//객체배열 생성
		
		for(int i=0;i<2;i++) {
			System.out.println("가수");
			String singer=scanner.next(); //BTS IU
			System.out.println("제목");
			String title=scanner.next(); //Butter  Goodday
			
			so[i]=new Song(singer, title);
		}
		for(int i=0;i<2;i++) {
			System.out.println(so[i].singer+" "+so[i].song);
		}
		
	}
}

객체배열 및 추상 클래스 활용

예시1)

import java.util.Scanner;

abstract class Circle{
	protected double r; 
	
	Circle(double r){
		this.r=r;
	}
	abstract double get();
}

class Cir extends Circle{
	Cir(double r){
		super(r);
			
	}
	@Override
	double get() {
		return r;
	}
}

public class mmdd0229 {
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		
		Circle c[]=new Circle[5];
		
		for(int i=0;i<c.length;i++) {
			double r=scanner.nextDouble();
			c[i]=new Cir(r); //객체 생성
			//Circle c[]=new Cir(r); -> Upcasting
			System.out.println(c[i].get());
		}
		
	}
}

객체배열 (for-each)

import java.util.Scanner;

class Num{

int n;
Num(int n){
	this.n=n;	
}
int get() {
	return n;
	
}
}

public class mmdd0229 {
	public static void main(String[] args) {

	Num[] ary=new Num[] {new Num(1), // 객체 생성드(값 초기화)
						new Num(2),
						new Num(3)};
		
	//int [] arr= {1,2,3};
	for(Num n:ary) {
	System.out.println(n.get()); // 1,2,3 출력
	}
}
}