Contents Creator

[day18]

1. Network

1) 네트워크  :  데이터를 전송할 수 있는 통신망, 전자장비들의 집합, 장비와 장비를 연결한 것.

노드 Node : 네트워크에 연결된 모든 장치들

호스트 Host : 노드에게 하나 이상의 서비스를 제공해주는 노드

-> 데이터 주고 받기 위해 존재 (통신)

-> 통신을 하려면 약속이 필요함 : protocol : 데이터 전송 규약

유형 : 네트워크 크기와 용도에 따라 LAN, WAN으로 구성

LAN Local Area Network : 지역망 ( 작은 망)

통신 주체인 자신과 “동일한” 네트워크간의 통신을 의미하며

작은 범위로 구성된다 -> 스위치

통신장비 : NIC(랜카드), T/P cable, Switch 

통신 프로토콜 : Ethernet < FastEthernet < GigabitEthernet

통신주소 : Mac-address : 물리주소 

WAN Wide Area Network : 큰망

내부 -> 외부로 통신할때 

일반적으로. ISP(kt, sk…..)로 부터 임대회선을 사용하기 때문에 구축비용은 감소하지만 통신 및 유지/보수 비용이 증가

자신이 포함되지 않은 “외부” 네트워크 구간을 의미하며, 비교적 큰 범위로 구성된다.

대표장비 : Router 라우터

통신프로토콜 : IPv4 (Internet Protocol version4)

통신주소 : IP address : 논리주소

2) IP address : Internet Protocol Address

: 통신을 하는 모든 기계는 네트워크상에서 유일하게 자신을 식별 할 수 있는

“고유주소”를 가지고 있다.

IP 주소는 32비트의 이진수로 구성, 보통 8비트 씩 4부분으로 나누어 십진수로 표현

ex)192.168.100.74

숫자로 된 주소는 기억하기 어려우므로 www.naver.com 과 같은 문자열로 구성된

도메인 이름으로 바꿔서 사용한다.

사용자가 도메인 이름으로 페이지를 요청하면,

DNS(Domain Name System) 서버에 의해 숫자로 구성된 IP 주소로 자동 변환.

IPv4 : 4개의 숫자로 구성된 32비트의 IP 주소

IPv6 : 128비트로 구성 

IP조수 확인 : Cmd - > ipconfig (요약)

ipconfig -all (자세히)

3) Port : 데이터를 주고받는 통로, 여러개의 서비스를 해줄 때

서로 충돌이 나지 않도록 포트를 구분해서 만들어 놓음.

포트번호는 개발자가 임의로 선택해 사용할 수 있으나,

기존 응용 프로그램에서 사용하는 번호나 시스템 포트 번호는 피하는 것이 좋다.

잘 알려진 포트번호 : HTTP = 80, FTP = 21, Telnet = 23

기존 잘 알려진 포트는 0 ~ 1023 사이번호를 가지며,

사용자 지정하는 번호는 이 범위를 피해서 선택하도록

윈도우 cmd > netstat -a

    맥.  sudo lsof -PiTCP -sTCP:LISTEN. https://velog.io/@taelee/%ED%98%84%EC%9E%AC-%EC%97%B4%EB%A0%A4%EC%9E%88%EB%8A%94-%ED%8F%AC%ED%8A%B8-%ED%99%95%EC%9D%B8mac)

4) Protocol : 통신 규약

컴퓨터간에 정보를 주고받을 때의 통신 방법에 대한 규칙과 약속

대표적인 표준 프로토콜의 예는 인터넷에서 사용하는 TCP/IP가 이에 해당한다.

5) 데이터 전송 방식

: IP 프로토콜 위에서 동작 

# 1.  TCP Transmission Control Protocol

연결형 서비스를 제공함. 신뢰성 높음.

ex) download

데이터 전송시 세그먼트 블록단위로 분할해 전송하고,

하나 전송하고 받는쪽에서 잘 받았다는 ACK 신호를 보내면

다음 블록을 전송.

# 2. UDP User Datagram Protocol

비연결형 서비스를 제공. 빠른 전송. 신뢰성 떨어짐

ex) streaming service

전송한 데이터가 목적지 까지 제대로 도착했는지 확인하지 않는다.

6) OSI 7 계층 : 모든 네트워크 통신에서 생기는 여러가지 충돌 문제를 완화하기 위하여

국제 표준기구(IOS)에서 표준화된 네트워크 구조를 제시한 기본 모델

https://shlee0882.tistory.com/110

2. Java.net (더 좋은게 있어서 잘 안쓴다)

InetAddress 클래스

: 자바에서 IP다루기 위한 클래스

URL 클래스

: 자바에서 URL을 다루기 위한 클래스

프로토콜 :  //호스트명:포트번호/경로명/파일명?쿼리스트링# 참조  

https://isplus.joins.com/2022/05/27/enter/entertainment/20220527085428908.html : URL

포롴토콜 : HTTPS, HTTP     https=443. http =80

ip(호스트명) : 도메인 주소 

포트번호 : 443 생략

경로명 : 접근하려는 자원이 저장된 서바상의 위치 : contect path, 루트 컨텍스트

파일명 : 접근하려는 페이지 이름

쿼리스트링 : ? 뒷부분 ( 데이터 문자형태로 전송 파라미터명 =값&파라미터명 = 값..)

URL !=URI

3.소켓 프로그래밍

: 소켓을 이용한 통신 프로그래밍

소켓 = 통신하는 두 응용 프로그램간의 통신 링크 각 끝단 (endpoint)

TCP/IP 프로토콜을 따르며, TCP/UDP 방식이 있다. 

1) TCP 소켓 : 클라이언트( 사용자, 요청자)와 서버(서비스 제공자, 호스트) 간의 1 : 1 통신

통신은 서버가 먼저 클라이언트의 접속을 기다리고, 클라이언트가 서버에 접속을 하면,

그때부터 서로 데이터를 주고 받을 수 있다.

(1) 서버 프로그램에서 포트와 연결된 서버소켓을 사용하여 클라이언트 연결 요청을 처리할 준비함.

(2) 클라이언트 프로그램은 접속할 서버의 IP주소와 포트번호를 가지고 서버소켓을 생성해서 서버에 연결 요청

서버 소켓은 클라이언트 연결을 요청받아, 서버에 새로운 소켓을 만들어 클라이언트 소켓과 연결되도록 한다.

(3) 클라이언트 끼리 서버를 통해 데이터를 주고 받는다.

(4) 연결해제

[day17]

1. 입출력 : java.io 패키지

IO = I/O = input/output 

1. File 클래스 : java.io.File

  : 크기, 생성, 삭제, 변경 등등 내용 관리 가능

입출력 X 

1) 생성자

File(String pathname) :  파일확장자명을 포함한 전체 경로를 문자열로 주며 생성

File(File parent, String child) : parent(부모) 디렉토리안에 child 이름의 서브디렉토리나 파일을 나타내는 객체생성

File(String parent, String child) : parent(부모) 디렉토리안에 child 이름의 서브디렉토리나 파일을 나타내는 객체생성

File(URI uri) : file:URI를 추상경로명으로 변환하여 객체생성 

2) 객체 생성

File 참조 변수명 = new File(“전체 경로”);

c: [temp]-test.txt

File(String pathname) -> File f = new File(“c:\\temp\\test.txt);

File(String parent, String child) -> File f = new File(“c:\\temp”, “test.txt”);

* 파일은 확장자명까지 표기

3) 주요 메서드++

boolean mkdir() :  새로운 디렉토리(폴더) 생성

boolean createNewFile() : 빈 파일 생성. 생성하려는 파일이 이미 존재하면 생성X

String[] list() : 디레고리내의 파일과 서브 디렉토리 목록을 문자열 배열로 리턴

File[] listFiles() : 디레고리내의 파일과 서브 디렉토리 목록을 File 객체로 리턴

boolean delete() : 파일 또는 디렉토리 삭제

boolean renameTo(File dest) : dest 경로명으로 파일 이름(경로) 변경

long length() : 파일 크기 리턴

String getPath() : 경로 문자열로 리턴

String getAbsolutePath() : 절대경로를 문자열로 리턴

String getParent() : 파일이나 디렉토리의 부모디렉토리 이름 리턴

String getName() : 파일이나 디렉토리의 이름 문자열 리턴

boolean isFile() : 파일이면 true 

boolean isDirectory() : 디렉토리면 true 

long lastModified() : 마지막 변경시간 리턴

boolean exists() : 파일 또는 디렉토리가 존재하면 true

1. Stream 스트림 ( 와이파이라 생각하면 쉬움)

: 데이터가 돌아다니는 통로 (선) -> 데이터를 목적지로 I/o 하기 위한 방법.

- 스트림은 다른 목적지로 데이터를 보낼때 가장 중요한 역학을 한다. 

- 스트림은 단 방향 : input 따로 output 따로

- 자바 응용 프로그램은요 입력 스트림과 출력스트림과만 연결을하고, 

입출력장치 제어하고 실질적인 입출력처리는 스트림이 진행한다.

입력장치 or 파일 ——> 입력 스트림 ——-> 자바 응용 프로그램

출력장치 or 파일 <——출력스트림 ——— 자바 응용프로그램

- 스트림을 통해 흘러가는 기본 단위는 바이트나 문자이다.

자바 스트림 객체는 바이트 단위로 입출력하는 바이트 스트림과

문자 단위로 입출력하는 문자 스트림으로 나뉜다.  

바이트 스트림을 다루는 클래스는 공통적으로 뒤에 Stream 붙고

문자 스트림을 다루는 클래스는 공통적으로 뒤에 Reader/Writer가 붙어 구분 가능.(문자하나 2바이트 취급)

- close() : 스트림을 열었으면 사용 후 반드시 닫아줘야 메모리 누수가 안된다, 

1. 바이트 스트림

- 바이트 단위로 데이터 전송 (바이너리 데이터가 흐르는 스트림)

- 다양한 클래스 제공으로 용도에 맞게 골라 사용

- 이미지, 동영상 등 전송 가능

***1) InputSteam, OutputSream ***

: 추상 클래스. 바이트 단위 입출력 처리를 위한 공통기능을 가진 수퍼 클래스

2) FileOutputStream

: 파일에 출력을 하기 위한 클래스

파일에 바이너리 데이터를 저장할 수 있다.

바이너리 파일은 사람이 읽고 해석하는것이 거의 불가능. 

#1. 생성자

FileOutputStream(File file) : file이 지정하는 파일에 출력 스트림 생성

FileOutputStream(String name) : name이 지정하는 파일에 출력 스트림 생성

FileOutputStream(File file, boolean append) : append가 true면 파일 마지막부터 데이터 저장

FileOutputStream(String name, boolean append) : append가 true면 파일 마지막부터 데이터 

#2. 주요 메서드

void write(int b) : int 형으로 넘겨진 바이트 한개 출력

void write(byte[] b) : 배열 b의 바이트를 모두 출력

void write(byte[] b, int offset, int Len) : Len 크기만큼 offset 부터 배열 b를 출력

void flush() : 출력스트림에 남아있는 바이너리 데이터 모두 내보내기

void close() : 출력스트림 닫고, 관련된 시스템 자원 해제

3) FileInputStream

: 바이트 스트림으로 파일 읽는 스트림 클래스

#1. 생성자 

FileInputStream(File file) : file이 지정하는 파일로부터 읽어오는 스트림 생성

FileInputStream(String name) : name 지정하는 파일로부터 읽어오는 스트림 생성

#2. 주요 메서드

int read() :입력 스트림에서 한 바이트 읽어 int형으로 리턴

int read(byte[] b) : 최대 배열 b의 크기 만큼 바이트를 읽음

int availble() : 현재 읽을 수 있는 바이트 수 리턴

void close() : 스트림 닫고 관련 시스템 자원 해제

#EOF : End of File 파일의 끝

read()할때 EOF를 만나면 -1을 리턴

* read()의 리턴이 int 형인 이유

byte 0xFF(-1)

byte값 -1 int 로 리턴 : 0x000000FF 리턴

EOF -1 리턴 : 0xFFFFFFFF리턴 (32비트)

4) DataInput/OutputStream

: boolean, char, byte 등 기본타입의 값을 바이너리 형태로 출력.

바이너리 형태를 기본값으로 읽어옴

각 자료형에 맞는 값들을 입력/ 출력할 수 있는 메서드들이 존재

5) ObjectInputStream / ObjectOutputStream.  (잘 안쓴다 )

: 객체를 스트림에 입/출력하는데 사용하는 클래스

보조 스트림으로 사용

1. 문자 스트림

- 자바형에서는 char형이 2바이트이기 때문에, 한글과 같은 2바이트 문자는 바이트 스트림으로 전송시 깨지는 경우가 있다.

이러한 점을 보완하기 위해 문자 스트림 제공

- 문자화되지 않는 바이너리 값은 처리불가 -> 이미지 같은것 처리불가

- 클래스들의 이름이 Reader/Writer로 끝남

- 메서드 리턴타입을 잘 보면 byte[]가 아닌 char[]을 사용하는것을 볼 수 있다.

1) Reader / Writer

:문자 스트림 클래스들의 부모. 추상클래스

2) OutputStreamWriter

: 파일에 텍스트데이터를 저장할 때 생성자 인코딩 지정하여 처리가능

인코딩을 지정하지 않으면 OS에서 디폴트로 사용하는 인코딩으로 데이터 저장.

#1 생성자 ( api 문서 참고)

charset = encoding : 문자셋

#2 주요 메서드 (바이트 스트림참고)

String getEncoding() : 인코딩값 리턴

void flush() : 스트림 비우기 ( 닫기전에 호출하기)

3) InputStreamReader

: 바이트 스트림을 문자 스트림으로 연결시켜주는 역할을 하는 보조 스트림

바이트 스트림의 데이터를 지정된 인코딩의 문자 데이터로 변환하는 작업 수행

#1 생성자 (api 문서 참고)

#2 주요메서드 (바이트 스트림 참고)

String getEncoding() : 인코딩값 리턴

  # 윈도우에서 사용하는 인코딩

MS949 :  마이크로소프트사에서 한글 국가 표준 코드를 확장해서

MS949라고 불리는 코드 체계를 만들고

윈도우 기본 문자 체계로 사용함.

4) BufferedReader

: 버퍼를 이용해서 입력의 효율을 높일 수 있도록 해주는 역할

readLine() 을 사용해서 데이터를 라인단위로 읽어 올 수 있다.

BufferedReader + InputStreamReader -> Scanner

6. OS

: 하나의 소프트웨어로, 소프트웨어들을 관리하는 소프트웨어(App)

windows, linux, iOS,  android, unix, MacOS

자바 -> JVM : 자바 App을 관리하는 소프트웨어

7. Thread 스레드

1) 프로세스 process

현재 실행중인 프로그램이다.

프로그램이 실행하면 OS로 부터 실행에 필요한 자원(메모리) 를 할당받아 프로세스가 된다.

프로세스 = 프로그램을 수행하는데 필요한 메모리 같은 자원 + 스레드

자원을 이용하여 “실제로 작업을 수행하는것이 스레드” 이다.

싱글 프로세스 = 하나의 프로그램을 돌리기위해 1개의 프로세스가 실행되는것.

멀티 프로세스 = 하나의 프로그램을 돌리귀해 여러 프로세스가 실행되는것.

2) 멀티태스킹 multitasking : multi + tasking

태스크 task = 프로세스가 하는 일

태스킹 = 포로세스가 일을 하는것

멀티태스킹 = 하나의 프로세스가 여러일을 하는것

3) 스레드 thread

하나의 태스크를 수행하는 일꾼

프로세스 = 공장(자원 + 일꾼), 스레드 = 일꾼 

싱글스레드 = 자원 + 일꾼

멀티 스레드 = 자원 + 일꾼 + 일꾼 ….

둘 이상의 스레드를 가지고 있는것을 멀티스레드 프로세스라고 부른다

(multi-thread process)라 부른다.

하나의 프로세스가 가질 수 있는 스레드의 개수는 제한되어있지는 않으나

스레드가 작업을 수행하는데 개별적인 메모리 공간을 필요로 하므로

프로세스의 메모리 한계에 따라 생성될 수 있는 스레드의 수가 결정된다,

4) 멀티태스킹과 멀티스레딩

멀티태스킹을 실현하기 위한 2가지 방법

- 멀티 프로세싱  : 하나의 프로그램을 여러개의 프로세스로 구성 

-> 각 프로세스가 하나의 작업을 처리하도록

-> 단점 : 프로세스간 변수 공유 X -> 통신으로 공유해야함

통신이 어렵고, 문맥교환에 따른 과도한 작업량 소요될수도..

- 멀티 스레딩 : 하나의 프로그램을 동시 처리 가능하게 작업을 분할하고 

작업의 개수만큼 스레드를 생성, 스레드 하나당 하나의 작업처리하게함

자원과 메모리 공유, 문맥교환 빠름

활용분야

- 웹서버 시스템

- 워드, 한컴

5) 자바의 멀티스레딩 

JVM이 알아서 한다.

8. 스레드 만들기

# 개발자가 할일 

1) 스레드 할일 코드로 작성

2) JVM에게 스레드 생성하고 코드 실행하도록 요청

# 구현방법

1) Thread 클래스 상속받아 스레드 만들기

java.lang.Thread

# 1. 생성자 (문서참고)

# 2.  주요 메서드

void run() : JVM에 의해 호출 (핵심 메서드)

스레드가 해야할 작업을 구현해놀는 메서드 

개발자는 반드시 이 메서드 오버라이딩하여 스레드가 할일을 코드로 작성햐야함

이 메서드가 종료하면 스레드도 종료.

void start() : JVM에게 스레드 실행하도록 요청하는 메서드

void interrupt() : 스레드 강제 종료

static void yield() : 다른 스레드에게 실행을 양보

void join() : 스레드 종료할때까지 기다린다.

long getId() : 스레드 id값 리턴

String getName() : 스레드 이름 리턴

int getPriority : 스레드의 우선순위값 리턴 1~10사이 값

void setPriority(int n) : 스레드의 우선순위 n으로 변경

Thread.State getState() : 스레드의 상태값 리턴

static void sleep(long mills) : mills 밀리초동안 스레드 잠재우기

static Thread currentThread() : 현재 실행중인 스레드 객체의 레퍼런스 리턴

# 1. 스레드 클래스 상속 받은 클래스 작성

# 2. run() 메서드 오버라이딩 : 스레드가 할일 작성

# 3. 스레드 객체 생성

# 4. 스레드 시작 : start() 호출

2) Runnable 인터페이스 구현 

java.lang.Runnable

# 1. Runnable 인터페이스 구현하는 클래스 선언

# 2. run() 오버라이딩 : 스레드가 할일 작성

# 3. 객체 생성

Thread th = new Thread(new 우리가 만든 클래스명());

# 4. 스레드 시작 : start()

9. 스레드 생명 주기

1) 스레드 상태

Thread Life Cycle : 스레드 생명 주기 갖고 있고, 상태 6가지로 표현

NEW : 스레드 탄생. new Thread()

RUNNABLE : 스레드가 현재 실행되고 있거나, 실행 준비되어 스케줄링 기다리는 상태

WIMED_WAITING : 스레드가 sleep(n)을 호출하여 n 밀리초 동안 기다리면서 멈춘 상태.

BLOCK : 스레드가 I/O 작업을 실행하여 I/O 완료기다리면서 멈춘 상태

WAITING : 스레드가 어떤 객체에 대해 wait() 호출하여; 다른 누가 notify()로 깨워줄때 까지 무한정 기다리는 상태

TERMINATED :  스레드 종료한 상태

package day16;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

//HashMap을 이용하여 학생 이름과 자바 점수를 기록하는 
// 관리 프로그램을 작성하세요. 
// 아래 프로그램 메뉴에서 각 번호로 서비스 선택하고, 
// 6번을 입력받으면 프로그램 종료. 
/*
 	** 자바 성적 관리 프로그램 **
	1. 전체 조회 
	2. 등록
	3. 수정
	4. 삭제
	5. 전체 평균
	6. 프로그램 종료
*/
public class Test04Ex {
	HashMap<String, Integer> data = new HashMap<String, Integer>(); 
	Scanner sc = new Scanner(System.in);
	
	private void printAll() {
		Set<String> keys = data.keySet(); 
		Iterator<String> it = keys.iterator(); 
		while(it.hasNext()) {
			String name = it.next(); 
			int score = data.get(name); 
			System.out.println(name + " : " + score);
		}
		System.out.println("=====================================");
	}
	private void addData() {
		System.out.print("이름>> ");
		String name = sc.nextLine(); 
		System.out.print("점수>> ");
		// String name = sc.nextLine();
		// int score = Integer.parseInt(name);
		int score = Integer.parseInt(sc.nextLine()); 
		// map안에 key값으로 이미 저장된 이름이 있는지 확인 
		Set<String> keys = data.keySet(); 
		if(keys.contains(name)) { // key들중에 입력받은 name과 동일한 값이 있냐? 
			System.out.println("이미 존재하는 학생입니다. 이름을 다시 입력해주세요.");
			//addData(); 
		}else {
			data.put(name, score); // map에 저장 			
			System.out.println("저장 완료");
		}
		System.out.println("=====================================");
	}
	private void modifyData() {
		System.out.print("수정할 학생 이름>> ");
		String name = sc.nextLine(); 
		Set<String> keys = data.keySet(); 
		if(keys.contains(name)) {
			// 점수 입력받아 수정 
			System.out.print("점수 >> ");
			//String name = sc.nextLine();
			//int score = integer.parseInt(name);
			int score = Integer.parseInt(sc.nextLine());
			
			data.put(name, score); // 수정 put(같은키값, 다른벨류값);
			System.out.println("수정완료!");
		}else {
			System.out.println("존재하지 않는 학생입니다..");
		}
		System.out.println("=====================================");
	}
	private void deleteData() {
		System.out.print("삭제할 학생 이름>> ");
		String name = sc.nextLine(); 
		Set<String> keys = data.keySet(); 
		if(keys.contains(name)) {
			data.remove(name);  // 삭제 
			System.out.println("삭제완료!");
		}else {
			System.out.println("존재하지 않는 학생입니다..");
		}
		System.out.println("=====================================");
	}
	private void printAvg() {
		Collection<Integer> col = data.values(); // map에서 값들만 뽑아
		Iterator<Integer> it = col.iterator(); 
		int sum = 0; 
		while(it.hasNext()) {
			sum += it.next(); // 값하나씩 꺼내서 sum에 누적해 더하기 
		}
		double avg = (double)sum / data.size(); 
		System.out.println("평균 점수 : " + avg);
		System.out.println("=====================================");
	}
	public void run() {
		while(true) {
			System.out.println("** 자바 성적 관리 프로그램 **\n"
					+ "1. 전체 조회 \n"
					+ "2. 등록\n"
					+ "3. 수정\n"
					+ "4. 삭제\n"
					+ "5. 전체 평균\n"
					+ "6. 프로그램 종료");
			System.out.print("원하는 서비스 번호를 입력해주세요 >> ");
			int sel = Integer.parseInt(sc.nextLine());
			System.out.println("=====================================");
			if(sel == 1) printAll(); 
			else if(sel == 2) addData(); 
			else if(sel == 3) modifyData(); 
			else if(sel == 4) deleteData(); 
			else if(sel == 5) printAvg(); 
			else if(sel == 6) {
				sc.close();
				System.out.println("프로그램 종료!");
				break;
			}else {
				System.out.println("잘못된 메뉴번호... 다시 입력해주세요.");
			}
		}
	}
	public static void main(String[] args) {
		
		Test04Ex prg = new Test04Ex();
		prg.run();
	}
}​

package day16;

import java.util.Scanner;
import java.util.Vector;

/*
	Scanner 클래스로 -1이 입력될때까지 양의 정수를 입력받아 벡터에 저장하고,
	벡터를 검색하여 가장 큰 수를 출력하는 프로그램을 작성하세요. 
	실행예시:
		정수>> 10 6 22 6 88 77 -1
		가장 큰 수는 88
*/
public class Test01Ex {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		Vector<Integer> v = new Vector<Integer>(); 
		
		System.out.print("정수 >> ");
		while(true) {
			int n = sc.nextInt(); 
			if(n == -1) { // -1인지 먼저 검사 
				break;
			}
			v.add(n); // 벡터에 추가 
		}
		
		// 저장된것이 하나도 없을 경우 예외 처리 
		if(v.size() == 0) {
			System.out.println("저장된 수가 하나도 없습니다.");
			sc.close();
			return;  // main 메서드 강제 종료 
		}
		
		// 가장 큰 수 찾아서 출력 (메서드로 작성해보자)
		printBiggerNum(v); // v를 인자로 던져서 가장큰수 찾아 출력하라고 명령! 
		
	}
	
	
		int max = vector.get(0);
		for(int i = 0; i < vector.size(); i++) {
			if(max < vector.get(i)) {
				max = vector.get(i);
			}
		}
		System.out.println("가장 큰 수는 : " + max);
	
}

package day16;

import java.util.ArrayList;
import java.util.Scanner;

/*
	Scanner 클래스를 사용하여 6개 학점('A', 'B', 'C', 'D', 'F')을 문자로 입력받아
	ArrayList에 저장하고, ArrayList를 검색하여 학점을 점수(A=4.0, B=3.0, C=2.0, D=1.0, F=0)로 변환하여
	평균을 출력하는 프로그램을 작성하세요.
	실행예시:
		6개의 학점을 빈 칸으로 분리 입력(A/B/C/D/F)>>	 A C A B F D
		2.3333333333333335
*/
public class Test02Ex {
	
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
	 	Scanner sc = new Scanner(System.in);
	 	
	 	
	 		System.out.println("학점을 입력하세요 >> ");
			/*
			 * 		System.out.println("6개의 학점을 빈 칸으로 분리 입력(A/B/C/D/F)>>");
		for (int i = 0; i < 6; i++) {
			Character grade = sc.next().charAt(0);    //입력값 중 첫번째 문자 입력받기 
			list.add(grade);		//어레이에 등급 추가 
		}
		
		double sum = 0;
		for (int i = 0; i < 6; i++) {
			if(list.get(i).equals('A')) {sum += 4.0;}
			else if(list.get(i).equals('B')) {sum += 3.0;}
			else if(list.get(i).equals('C')) {sum += 2.0;}
			else if(list.get(i).equals('D')) {sum += 1.0;}
			else if(list.get(i).equals('F')) {sum += 0;}
			
		}
		System.out.println(sum/list.size());
		sc.close();
			 */
	 	String grade = sc.nextLine();
	 	String[] split = grade.split(" ");
	 		for(String s: split){
	 		list.add(s);
	 		}
		
	 	System.out.println(list);
	 	
	 	System.out.println("학점을 입력하세요 >>");
	 		double sum = 0;
	 		for (int i = 0; i < list.size(); i++) {
	 			
				if(list.get(i).equals("a")) {sum += 4.0;}
				if(list.get(i).equals("b")) {sum += 3.0;}
				if(list.get(i).equals("c")) {sum += 2.0;}
				if(list.get(i).equals("d")) {sum += 1.0;}
				if(list.get(i).equals("f")) {sum += 0.0;}
			}
		System.out.println(" 평균 " +  sum/list.size());
	}
}

package day16;

import java.util.HashMap;
import java.util.Scanner;

public class Test03Ex {
	public static void main(String[] args) {
		// 영한 사전 만들기 
		// : HashMap을 이용하여 10개의 단어를 영어,한글의 쌍으로 저장하고 
		// 영어로 한글을 검색하는 프로그램을 만들어보세요.
		// 단, exit가 입력되면 프로그램 종료!
		
		HashMap<String, String> dict = new HashMap<String, String>();
		
		dict.put("apple", "사과");
		dict.put("paper", "종이");
		dict.put("book", "책");
		dict.put("car", "자동차");
		dict.put("pants", "바지");
		dict.put("bottle", "병");
		dict.put("chair", "의자");
		dict.put("extend", "확장하다");
		dict.put("implement", "실행하다");
		dict.put("banana", "바나나");
		
		Scanner sc = new Scanner(System.in); 
		while(true) {
			System.out.print("찾고싶은 단어 >> ");
			 
			if(eng.equals("exit")) {
				System.out.println("프로그램 종료!");
				break;
			}
			String kor = dict.get(eng);
			if(kor == null) {
				System.out.println(eng + "는 사전에 없는 단어입니다.");
			}else {
				System.out.println(kor);
			}
		}
	
		sc.close();
	}
}

package day16;

import java.lang.ProcessHandle.Info;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

/*
	id와 tel(전화번호)로 구성되는 Student클래스를 만들고, 이름을 key로 하고 Student객체를 값으로 하는 해쉬맵을 작성해보세요.
	이름을 검색하면 id와 전화번호 출력되고, exit 입력하면 프로그램 종료. 
*/
class Student{
	private int id;
	private String tel;
	public Student(int id, String tel) {
		this.id = id; this.tel =tel;
	}
		public int getId(){return id;}
		public String getTel() {return tel;}
		
		public static void run() {
			
			
			HashMap<String, Student> map = new HashMap<String, Student>();
			map.put("피카츄", new Student(1, "010-1111-2222"));
			map.put("라이츄", new Student(2, "010-1234-5678"));
			map.put("파이리", new Student(3, "010-9999-9999"));
			
			
			Scanner sc = new Scanner(System.in);
			
			
			
			while(true) {
				System.out.println("이름을 입력하세요 ");
				String name = sc.nextLine();
				
				if(name.equals("exit")) {break;}
				
				
				Student info = map.get(name);
				if(info==null) { System.out.println("없는사람입니다 .");}
				
				else {
					System.out.println(name+  ":" + "  id  :  " + info.getId() + "  Tel  :"+info.getTel() );
				
				}
			}	System.out.println("프로그램 종료...");
			sc.close();
		}
		
}

public class Test05Ex {
	public static void main(String[] args) {
	
		Student.run();
	
	}
}

package day16;

import java.util.HashMap;
import java.util.Scanner;

/*
	"그만"이 입력될 때까지 나라이름과 인구를 입력받아 저장하고, 
	다시 나라이름을 입력받아 인구를 출력하는 프로그램을 작성하세요. 
	아래 해쉬맵을 이용하세요.
	HashMap<String, Integer> nations = new HashMap<String, Integer>();
	실행예시 :
		나라 이름과 인구를 입력하세요.(예: Korea 5000)
		나라 이름, 인구 >>  Korea 5000
		나라 이름, 인구 >>  USA 1000000
		나라 이름, 인구 >>  Swiss 2000
		나라 이름, 인구 >>  France 3000
		나라 이름, 인구 >>  그만
		
		인구 검색 >> France
		France의 인구는 3000
		인구 검색 >> 스위스
		스위스 나라는 없습니다.
		인구 검색 >> 그만
		프로그램 종료!
*/
public class Test06Ex {
	public static void main(String[] args) {
		
		HashMap<String, Integer> nations = new HashMap<String, Integer>();
		Scanner sc = new Scanner(System.in);
		
		System.out.println("나라 이름과 인구를 입력하세요.(예: Korea 5000)");
		
		// 나리이름, 인구 입력받아 저장 (그만이 break 포인트) 
		while(true) {
			System.out.print("나라 이름, 인구 >> ");
			String txt = sc.nextLine();
			if(txt.equals("그만")) {
				break; 
			}
			String[] txtSplit = txt.split(" ");
			nations.put(txtSplit[0], Integer.parseInt(txtSplit[1]));
		}
		
		// 나라이름 입력받아 인구 출력 
		while(true) {
			System.out.print("인구 검색 >> ");
			String n = sc.nextLine(); 
			if(n.equals("그만")) {
				break;
			}
			// map의 get(key값) 은 해당 키벨류가 없으면 null 리턴 
			Integer popul = nations.get(n); // 저장하는 변수를 Integer로 받은 이유 : null 체크하려고 
			if(popul == null) {
				System.out.println(n + " 나라는 없습니다.");
			}else {
				System.out.println(n + "의 인구는 " + popul);
			}
		}
		
		System.out.println("프로그램 종료! ");
		sc.close();

	}
}

package day16;

import java.util.Scanner;
import java.util.Vector;

/*
	Vector 컬렉션을 이용하여 강수량의 평균을 유지 관리하는 프로그램을 작성하세요.
	강수량을 입력하면 벡터에 추가하고 현재 입력된 모든 강수량과 평균을 출력한다.
	실행 예시 :
		강수량 입력 (0 입력시 종료)>>	5
		5
		현재 평균 5
		
		강수량 입력 (0 입력시 종료)>>	80
		5 80
		현재 평균 42
		
		강수량 입력 (0 입력시 종료)>>	53
		5 80 53
		현재 평균 46
		
		강수량 입력 (0 입력시 종료)>>	22
		5 80 53 22
		현재 평균 40
		
		강수량 입력 (0 입력시 종료)>>	0
		프로그램 종료!
*/
public class Test07Ex {
	
	public static void main(String[] args) {
	
		Vector<Integer> data = new Vector<Integer>(); 
		Scanner sc = new Scanner(System.in);
		
		while(true) {
			System.out.print("강수량 입력 (0 입력시 종료)>> ");
			int amount = Integer.parseInt(sc.nextLine().trim());
			if(amount == 0) {
				break;
			}
			data.add(amount); 	// 강수량 저장 
			printVector(data);  // 벡터에 저장된 모든 강수량 출력 메서드 호출~ 
			printAvg(data);		// 벡터에 저장된 강수량 평균 출력 메서드 호출~ 
			System.out.println();
		}//while
		
		System.out.println("프로그램 종료!");
		sc.close();
	}//main
	
	public static void printVector(Vector<Integer> vector) {
		for(int i = 0; i < vector.size(); i++) {
			System.out.print(vector.get(i) + " ");
		}
		System.out.println();
	}
	public static void printAvg(Vector<Integer> data) {
		int sum = 0; 
		for(int i = 0; i < data.size(); i++) {
			sum += data.get(i);
		}
		int avg = sum / data.size(); 
		System.out.println("현재 평균 : " + avg);
	}
}

package day16;

import java.util.ArrayList;
import java.util.Scanner;

/*
	하나의 학생 정보를 나타내는 StudentClass에는 
	이름, 학과, 학번, 학점 평균을 저장하는 필드가 있다. 
	학생마다 StudentClass 객체를 생성하고 4명의 학생정보를 
	ArrayList<StudentClass> 컬렉션에 저장한 후에,
	ArrayList<StudentClass>의 모든 학생(4명) 정보를 출력하고 
	학생 이름을 입력받아 해당 학생의 학점 평균을 출력하는 프로그램을 작성하세요.
	실행예시:
		학생이름, 학과, 학번, 학점평균 입력하세요.
		>> 호크아이,모바일,1,4.1
		>> 데드풀,안드로이드,2,3.9
		>> 헐크,웹개발,3,3.5
		>> 아이언맨,빅데이터,4,4.25
		---------------------------
		이름:호크아이
		학과:모바일
		학번:1
		학점평균:4.1
		---------------------------
		이름:데드풀
		학과:안드로이드
		학번:2
		학점평균:3.9
		---------------------------
		이름:헐크
		학과:웹개발
		학번:3
		학점평균:3.5
		---------------------------
		이름:아이언맨
		학과:빅데이터
		학번:4
		학점평균:4.25
		---------------------------
		학생 이름 >> 아이언맨 
		아이언맨, 빅데이터, 4, 4.25
		학생 이름 >> 데드풀
		데드풀, 안드로이드, 2, 3.9
		학생 이름 >> 그만 
		프로그램 종료!
*/
class StudentClass {
	private String name; // 이름
	private String dept; // 학과 
	private String id;   // 학번
	private double grade; // 학점평균 
	StudentClass(String name, String dept, String id, double grade){
		this.name = name; this.dept = dept; this.id = id; this.grade = grade;
	}
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
	public String getDept() { return dept; }
	public void setDept(String dept) { this.dept = dept; }
	public String getId() { return id; }
	public void setId(String id) { this.id = id; }
	public double getGrade() { return grade; }
	public void setGrade(double grade) { this.grade = grade; }
}

public class Test08Ex {
	// 학생 정보 저장할 ArrayList 인스턴스로 만들어 모든 메서드에서 접근할 수 있게..
	ArrayList<StudentClass> list = new ArrayList<StudentClass>(); 
	Scanner sc = new Scanner(System.in);
	
	// 학생정보 저장 
	void setList() {
		System.out.println("학생이름, 학과, 학번, 학점평균 입력하세요.");
		for(int i = 0; i < 4; i++) {
			System.out.print(">> ");
			String data = sc.nextLine(); // 호크아이,모바일,1,4.1
			String[] splited = data.split(","); // 쉼표를 구분자로 분할하여 문자열배열로받기 
			String name = splited[0]; 
			String dept = splited[1]; 
			String id = splited[2]; 
			double grade = Double.parseDouble(splited[3]); // 꺼내서 형변환 
			list.add(new StudentClass(name, dept, id, grade)); 
		}
		System.out.println("---------------------------");
	}
	// 학생정보 출력 
	void printAll() {
		for(int i = 0; i < list.size(); i++) {
			StudentClass stu = list.get(i); 
			System.out.println("이름:" + stu.getName());
			System.out.println("학과:" + stu.getDept());
			System.out.println("학번:" + stu.getId());
			System.out.println("학점평균:" + stu.getGrade());
			System.out.println("---------------------------");
		}
	}
	// 학생 검색 
	void search() {
		while(true) {
			System.out.print("학생 이름 >> ");
			String input = sc.nextLine(); 
			if(input.equals("그만")) {
				break; 
			}
			// list에 저장된 정보에 모두 접근 
			for(int i = 0; i < list.size(); i++) {
				StudentClass stu = list.get(i);
				if(stu.getName().equals(input)) {
					System.out.print(stu.getName() + ", " + stu.getDept() + ", ");
					System.out.println(stu.getId() + ", " + stu.getGrade());
					break; // 먼저 찾으면 for문 끝까지 돌릴필요없이 for문 종료
				}
			}
		}
	}
	
	public void run() {
		setList(); 	// 학생정보 입력받아 저장해라~
		printAll(); // 전체 학생정보 출력해라~ 
		search();	// 학생 검색 하는 기능 실행해라~ 
	}
	
	public static void main(String[] args) {
		Test08Ex ex = new Test08Ex();
		ex.run();
		System.out.println("프로그램 종료!");
	}
}

package day16;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

/*
	Test08Ex문제를 ArrayList<StudentClass>대신 
	HashMap<String, StudentClass> 을 이용하여 다시 작성해보세요. 
	해쉬맵에서 키는 학생 이름으로 한다.
*/
public class Test09Ex {
	// ArrayList<StudentClass> 컬렉션에 저장
	// 학생 정보 저장할 HashMap 인스턴스로 만들어 모든 메서드에서 접근할 수 있게..
	HashMap<String, StudentClass> map = new HashMap<String, StudentClass>(); 
	Scanner sc = new Scanner(System.in);
	
	// 학생정보 저장 
	void setList() {
		System.out.println("학생이름, 학과, 학번, 학점평균 입력하세요.");
		for(int i = 0; i < 4; i++) {
			System.out.print(">> ");
			String data = sc.nextLine(); // 호크아이,모바일,1,4.1
			String[] splited = data.split(","); // 쉼표를 구분자로 분할하여 문자열배열로받기 
			String name = splited[0]; 
			String dept = splited[1]; 
			String id = splited[2]; 
			double grade = Double.parseDouble(splited[3]); // 꺼내서 형변환 
			//list.add(new StudentClass(name, dept, id, grade)); 
			map.put(name, new StudentClass(name, dept, id, grade));
		}
		System.out.println("---------------------------");
	}
	// 학생정보 출력 
	void printAll() {
		
		//Set<String> keys = map.keySet(); 
		//Iterator<String> it = keys.iterator(); // 키들만 뽑음 (이름들) 
		Iterator<String> it = map.keySet().iterator(); 
		while(it.hasNext()) {
			String key = it.next(); // 키값(학생이름) 하나 뽑고 
			StudentClass stu = map.get(key); // 키값주고 벨류값 뽑음 
			System.out.println("이름:" + stu.getName());
			System.out.println("학과:" + stu.getDept());
			System.out.println("학번:" + stu.getId());
			System.out.println("학점평균:" + stu.getGrade());
			System.out.println("---------------------------");
		}
	}
	// 학생 검색 
	void search() {
		while(true) {
			System.out.print("학생 이름 >> ");
			String input = sc.nextLine(); 
			if(input.equals("그만")) {
				break; 
			}
			StudentClass stu = map.get(input);
			if(stu == null) {
				System.out.println(input + " 학생은 없습니다.");
			}else {
				System.out.print(stu.getName() + ", ");
				System.out.print(stu.getDept() + ", ");
				System.out.print(stu.getId() + ", ");
				System.out.println(stu.getGrade());
			}
		}//while
	}// search()
	public void run() {
		setList(); 	// 학생정보 입력받아 저장해라~
		printAll(); // 전체 학생정보 출력해라~ 
		search();	// 학생 검색 하는 기능 실행해라~ 
	}
	public static void main(String[] args) {
		Test09Ex ex = new Test09Ex();
		ex.run();
	}
}

package day16;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;

/*
	이름과 학점(4.5만점)을 5개 입력받아 해쉬맵에 저장하고, 
	장학생 선발 기준을 입력받아 장학생 명단을 출력하세요.
	실해예시:
		자바장학금관리시스템입니다.
		이름과 학점 >> 호크아이 3.1
		이름과 학점 >> 블랙위도우 3.6
		이름과 학점 >> 토르 2.9
		이름과 학점 >> 데드풀 3.7
		이름과 학점 >> 아이언맨 4.3
		장학생 선발 학점 기준 입력 >> 3.2
		장학생 명단 : 블랙위도우 데드풀 아이언맨
*/
class Scholarship {
	private String title; 
	private HashMap<String, Double> map = new HashMap<String, Double>(); 
	private Scanner sc = new Scanner(System.in);
	
	Scholarship(String title) {
		this.title = title;
	}
	void insert() {
		System.out.println(title + "관리시스템입니다.");
		for(int i = 0; i < 5; i++) {
			System.out.print("이름과 학점 >> ");
			String[] txt = sc.nextLine().split(" "); 
			map.put(txt[0], Double.parseDouble(txt[1]));
		}
	}
	void select() {
		System.out.print("장학생 선발 학점 기준 입력 >> ");
		double cutline = Double.parseDouble(sc.nextLine());
		
		System.out.print("장학생 명단 : ");
		Iterator<String> it = map.keySet().iterator(); // 키들만 뽑아서 반복자 얻어오기(키들 일렬로 나열)
		while(it.hasNext()) {
			String name = it.next(); // 키하나 나옴
			double score = map.get(name); 
			if(score >= cutline) {
				System.out.print(name + " ");
			}
		}
		System.out.println();
	}
}

public class Test10Ex {
	public static void main(String[] args) {
		Scholarship sship = new Scholarship("자바장학금");
		sship.insert();
		sship.select();
	}
}

package day16;

import java.util.ArrayList;
import java.util.Scanner;

/*
	나라와 수도 맞추기 게임을 만들어 보세요. 
	1) 나라이름(country)과 수도(capital)로 구성된 Nation클래스를 작성하고,
		ArrayList<Nation> 컬렉션을 이용하여 
		아래 실행 예시와 같이 작동되도록 프로그램을 작성하세요.
		
	실행예시:
		** 수도 맞추기 게임을 시작합니다 **
		입력:1, 퀴즈:2, 종료:3 >> 1 (사용자가 입력)
		
		현재 8개의 나라와 수도가 입력되어 있습니다. (input())
		나라와 수도 입력9>> 한국 서울
		나라와 수도 입력10>> 그리스 아테네
		그리스는 이미 있습니다!!
		나라와 수도 입력10>> 호주 시드니
		나라와 수도 입력11>> 이탈리아 로마
		나라와 수도 입력12>> 그만
		
		입력:1, 퀴즈:2, 종료:3 >> 2
		
		호수의 수도는? 시드니 (quiz())
		정답!!
		독일의 수도는? 하얼빈
		아닙니다!!
		멕시코의 수도는? 하얼빈
		아닙니다!!
		이탈리아의 수도는? 로마
		정답!!
		한국의 수도는? 서울
		정답!!
		영국의 수도는? 그만
		
		입력:1, 퀴즈:2, 종료:3 >> 3
		게임을 종료합니다.
*/
class Nation {
	private String country;
	private String capital;
	Nation(String country, String capital){
		this.country = country; this.capital = capital;
	}
	public String getCountry() {
		return country;
	}
	public String getCapital() {
		return capital;
	}
}
class CapitalGame {
	Scanner sc; 			//       0						1 .....
	ArrayList<Nation> list; // [N(멕시코, 멕시코시티), N(스페인, 마드리드)...]
	
	CapitalGame() {
		sc = new Scanner(System.in);
		list = new ArrayList<Nation>();
		// 나라 정보 초기값으로 미리 추가 
		list.add(new Nation("멕시코", "멕시코시티"));
		list.add(new Nation("스페인", "마드리드"));
		list.add(new Nation("프랑스", "파리"));
		list.add(new Nation("영국", "런던"));
		list.add(new Nation("이탈리아", "로마"));
		list.add(new Nation("그리스", "아테네"));
		list.add(new Nation("중국", "베이징"));
		list.add(new Nation("우크라이나", "키이우"));
	}// 생성자
	
	void input() {
		int n = list.size(); // 8
		System.out.println("현재 "+ n +"개의 나라와 수도가 입력되어 있습니다.");

		while(true) {
			n++; 
			System.out.print("나라와 수도 입력" + n + ">> ");
			String txt = sc.nextLine(); 
			if(txt.equals("그만")) {
				break; // while true 종료 
			}
			String[] split = txt.split(" ");
			String country = split[0]; // 나라이름 
			String capital = split[1]; // 수도 
			// 나라가 존재하는지 체크 -> 메서드 
			if(isExists(country)) { // true 리턴받았을 경우 
				// 있으면 예외 메세지 
				System.out.println(country + "는 이미 있습니다!");
				n--; 
			}else { // false 리턴받았을 경우 
				// 없으면 list에 Nation으로 객체 만들어 추가 
				list.add(new Nation(country, capital));
			}
		}// while
	}// input()
	private boolean isExists(String country) {
		boolean result = false; // 마지막에 리턴해줄 결과 변수 미리 선언 
		
		// 리스트 저장된 개수만큼 전체 돌면서 나라이름 같은지 결과 리턴  
		for(int i = 0; i < list.size(); i++) {
			Nation nation = list.get(i);
			String ctr = nation.getCountry(); // 이미 저장된 나라이름 하나 꺼냄 
			if(ctr.equals(country)) {
				result = true; 
				break; // 한번 걸리면 나머지는 안돌아도 ok 
			}
		}
		return result; // 최종 boolean변수에 남은 결과 리턴 
	}
	void quiz() {
		// 반복해서 문제내고 (그만을 입력할때까지) 
		while(true) {
			//	 문제는 랜덤으로 뽑아서 내보자 (중복 문제는 무시) 
			// 	 문제를 내려면 list에서 나라하나 뽑아야되고 -> list.get(인덱스);
			//		=> 인덱스 번호를 랜덤으로 하나 받아서 
			//			범위 : 0 ~ 마지막 방번호 (list.size()-1)
			int index = (int)(Math.random() * list.size()); // 0 ~ 9 = 10 0 ~ 5 = 6 
			Nation nation = list.get(index); // country=나라이름, capital=수도
			//	  ->나라 뽑은거에서 나라이름 검색해서 문제로 내고 
			String question = nation.getCountry(); 
			String answer = nation.getCapital(); 
			System.out.print(question + "의 수도는?"); // 문제 지문
			String capAsw = sc.nextLine(); // 정답받기 
			// 그만을 입력했는지 먼저 체크
			if(capAsw.equals("그만")) {
				break; // while문 종료! 
			}
			//	  ->나라 뽑은거와 수도이름이 같은지 체크 
			if(capAsw.equals(answer)) {
				// 맞으면 정답!! 
				System.out.println("정답!!");
			}else {
				// 틀리면 틀렸다고 출력 
				System.out.println("아닙니다!!!!!");
			}
		}
	}// quiz() 
	
	// main 대신 전체 프로그램을 돌려주는 메서드 
	void run() {
		System.out.println("** 수도 맞추기 게임을 시작합니다 **");
		while(true) {
			System.out.print("입력:1, 퀴즈:2, 종료:3 >> ");
			int menu = Integer.parseInt(sc.nextLine());
			if(menu == 1) { // 입력
				input(); 
			}else if(menu == 2) { // 퀴즈 
				quiz(); 
			}else if(menu == 3) {
				System.out.println("게임을 종료합니다.");
				sc.close();
				break;
			}else {
				System.out.println("메뉴 번호 오류... 다시 입력해보세요.");
			}			
		}//while
	}//run()
}

public class Test11Ex {
	public static void main(String[] args) {
		
		CapitalGame game = new CapitalGame();
		game.run();
		
	}
}

package day16;
/*
	나라와 수도 맞추기 게임을 만들어 보세요. 
	* Test11Ex문제를 HashMap<String, String>을 이용하여 작성하세요. 
	Key는 나라이름이고, Value는 수도입니다.
*/
public class Test12Ex {
	public static void main(String[] args) {
		/*
		CapitalGame game = new CapitalGame();
		game.run();
		*/
		int a = 10;
		boolean b = false;
		if ((b == false) || (++a == 10)) {
			System.out.println("Equal " + a);
		} else {
			System.out.println("Not equal! " + a);
		}
		

	}
}

#2. Calendar의 get(), set() 메서드에 사용되는 상수
YEAR : 년도
DAY_OF_MONTH : 한달의 날짜
MONTH : 달(0~11)  0-> 1월
DAY_OF_WEEK : 한주의 요일
HOUR : 시간 (0~11) 0-> 1시
AM_PM : 오전/오후
HOUR_OF_DAY : 24시간 기준으로 한 시간
MINUTE : 분
SECOND : 초
MILLISECEND : 밀리초 (1초 =1000밀리초)

#3.Gragorian Calendar 클래스
1970.1.1.0.0.0을 기준으로 365.25일 (4년에 1번씩 윤달)


2) Date 클래스 (비추천, 하지만 아직까지많이 쓴다)
: 단일 클래스로 날짜/시간 관련 클래스
1900.1.1.0.0.0을 기준,
1970.1.1.0.0.0을 기준

package day15;

import java.util.Calendar;
public class ClassEx47 {

		static String toCalString(Calendar date) {
			return date.get(Calendar.YEAR) + "년" +
		(date.get(Calendar.MONTH)+1) + "월"+ (date.get(Calendar.DATE))
 +"일";	 	}
	
	public static void main(String[] args) {
		
			Calendar now = Calendar.getInstance();
			System.out.println(now);
		
		//년도와 월 알아내기
		int year = now.get(Calendar.YEAR);	
		int month = now.get(Calendar.MONTH)	+1 ; //0~11월 : 0 -> 1월
		System.out.println("year : " +year );
		System.out.println("month : " +month );
		System.out.println();
		
		// 일 = 1, 월 =2 
		final String[] DAY_OF_WEEK = {"","일","월","화","수","목","금","토","일"};		
		System.out.println(toCalString(now));
		System.out.println(DAY_OF_WEEK[now.get(Calendar.DAY_OF_WEEK)]+"요일");
		
		Calendar date1 = Calendar.getInstance();
		date1.set(2022,12,25);  //올해 크리스마스로 세팅
		System.out.println(toCalString(date1)+""+ DAY_OF_WEEK[date1.get(Calendar.DAY_OF_WEEK)]);

	}

}

package day15;
import java.util.Calendar;
public class ClassEx48 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Calendar time1 = Calendar.getInstance();
		Calendar time2 = Calendar.getInstance();
		
		
		
		// time1 : 10시 20 분 30초
		time1.set(Calendar.HOUR_OF_DAY, 10);
		time1.set(Calendar.MINUTE, 20);
		time1.set(Calendar.SECOND, 30);
		
		//time2  :  20시 30분 10초
		time1.set(Calendar.HOUR_OF_DAY, 20);
		time1.set(Calendar.MINUTE, 30);
		time1.set(Calendar.SECOND, 10);
		
		
		System.out.println(time1.getTimeInMillis());
		System.out.println(time2.getTimeInMillis());
		long differ = Math.abs(time1.getTimeInMillis() - time2.getTimeInMillis()/1000);	
		System.out.println(differ);
		
		final int [] TIME_UNIT= {3600,60,1};
		final String[] TIME_UNIT_NAME = {"시간","분","초"};
		System.out.print("tim1 1 과 2 차이는 ");
		String tmp = "";
		for(int i=0;i<TIME_UNIT.length; i++) {
			tmp += differ/TIME_UNIT[i] + TIME_UNIT_NAME[i];
		}
		System.out.println(tmp + "입니다");
			
	}
}

package day15;

import java.util.Calendar;

public class ClassEx49 {
	static String toCalString(Calendar date) {
		return date.get(Calendar.YEAR) + "년" +
	(date.get(Calendar.MONTH)+1) + "월"+ (date.get(Calendar.DATE))
+"일";	 	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		Calendar date = Calendar.getInstance();
		date.set(2022, 7,31);  //2022 8월 31
				System.out.println(toCalString(date));
				System.out.println("1일 후");
				date.add(Calendar.DATE, 1);
				System.out.println(toCalString(date));
				
				System.out.println("6달전");
				date.add(Calendar.MONTH,-6);
				System.out.println(toCalString(date));
				
				System.out.println(" 31 일 후 roll");
				date.roll(Calendar.DATE, 31);
				System.out.println(toCalString(date));
				date.add(Calendar.DATE,31);
				System.out.println(toCalString(date));
	}
}

package day15;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ClassEx50 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Date day = new Date();  // 오늘 현재 시각  값을 지정해서 객체 생성
		System.out.println(day);
		System.out.println(day.getMonth()+1);
		
		
		// 날짜 포맷(형태)를 원하는 형태로 변경해서 사용을 원할때
		SimpleDateFormat abc1 = new SimpleDateFormat("yyyy-MM-dd");
		SimpleDateFormat abc2 = new SimpleDateFormat("yy년-MM월-dd일");
		System.out.println(abc1.format(day));
		System.out.println(abc2.format(day));
		
	}
}

package day15;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class ClassEx51 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		
			// 날짜 입력받아 현재 시간과의 차이 출력
			String pattern = "yyyy/MM/dd";
			DateFormat ab= new SimpleDateFormat(pattern);
			
			Scanner sc = new Scanner(System.in);
			
			Date inputDate = null;
			System.out.println("날짜를 " + pattern + "의 형태로 입력하세요");
			// inputDate = ab.parse(sc.nextLine());
			while(sc.hasNextLine()) {
				try {
					inputDate = ab.parse(sc.nextLine());
					break;
				}catch(Exception e) {
					System.out.println("날짜를 " + pattern + "형태로 다시 입력");
				}
			}
			//System.out.println(inputDate);
			Calendar cal = Calendar.getInstance();
			cal.setTime(inputDate); // Date -> Calendar
			Calendar now = Calendar.getInstance(); // 현재시각
			
			long hours = Math.abs(cal.getTimeInMillis() - now.getTimeInMillis())/(1000*60*60);
			System.out.println(hours);
	}
}

[day16]

1. 컬렉션 Collection
JDK는 소위 자료구조 과목에서 배우는 많은 자료 구조들을 컬렉션으로 만들어 제공
제네릭이라는 기법으로 구현.

1)컬렉션을 위한 자바 인터페이스와 클래스 

[Collection]
- Vector, **ArrayList**  : 가변크기의 배열
- LinkedList : 노드들이 링크로 연결되는 리스트
- Stack : 스택
- HashSet: 집합

[Map]
- **HashMap** : 키와 값의 쌍으로 저장되는 컬렉션

2) 제네릭(generics) 기법
JDK1.5 부터 도입된 제네릭기법으로 컬렉션이 만들어짐
컬렉션들 이름에 <E><K><V>등이 포함 -> 타입매개변수(generic type)
ArrayList<Integer>  -> 정수만 저장하는 ArrayList
ArrayList<String>   -> 문자열만 저장가능하는 ArrayList

특정타입만 다루지 않고 여러종류의 타입으로 변신할 수 있도록 <E>을 사용
단, int, char, double등 기본타입으로는 제네릭 사용 불가!!
-> Integer, Character, Double 등 Wrapper 클래스로 지정해줘야함.
제네릭 객체형으로 기본형이랑은 안맞음
ArrayList<int>  (X)  -> ArrayList<Integer>

ex) 제네릭 타입을 가진 클래스
class Stack<E>{
.... void push(E element){.....}
E pop(){....}
}
E에 대한 구체적인 타입을 지정하면 지정된 타입만 다룰 수 있는 구체화된 스택이 된다.
-> 정수 스택 Stack<Integer>
void push(Integer element){...}
Integer pop(){...}

-> 문자열 스택 Stack<String>
void push(String elemet){...}
String pop(){...}
-> Tv 스택 Stack<Tv>
void push(Tv element){...}
Tv pop(){...}

E : element 요소
T : type
V : value
K : key

3) ArrayList<E> : java.util.ArrayList
: 가변 크기의 배열을 구현, vector와 거의 동일.
삽입되는 요소의 개수에 따라 자동 크기 조절.
요소 삽입/삭제에 따라 요소들의 자리 이동도 자동으로 처리.

# 주요 메서드
boolean  add(E elem) : 맨뒤에 elem 추가
void add(int idx, E elem) : idx위치에 elem 추가
boolean addAll(Collection c) : 컬렉션 c의 모든 요소를 뒤에 추가
void  clear() : 모든 요소 삭제
E remove (int idx) : idx 위치 요소 하나 삭제
boolean remove(Object o) : o와 같은 요소 삭제
E elemenAt(int idx) : idx 위치요소 리턴
E get(int idx) : idx 위치요소 리턴
E set(int idx, 값) : 수정전의 인덱스 값 리턴
boolean contains(Object o) : o를 포함하고 있으면 true
int  indexOf (Object o) : o와 같은 요소가 저장된 첫 인덱스 리턴, 없으면 -1 리턴
boolean isEmpty() : ArrayList가 비어있으면 true
int size() : 저장된 요소의 개수 리턴
Object[] toArray() : 저장된 요소를 배열로 리턴

package day16;

import java.util.ArrayList;

public class ClassEx52 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		// ArrayList 객체생성
		// 컬렉션명<제네릭 타입> 변수명 = new 컬렉션명<타입>();
		ArrayList<Integer> list = new ArrayList<Integer>(10);
		// ArrayList<int> list = new ArrayList<int>(10); 기본형으로 타입지정불가
		
		// #2. 요소삽입
		list.add(10);
		list.add(20);
		list.add(30);
		list.add(null); //null 삽입가능 주의
		list.add(3, 100); //원하는 인덱스 위치에 삽입가능
		
		System.out.println(list);
		
		//#3. 요소 꺼내기
		Integer i = list.get(0); // 리턴타입 그대로 받기
		int ii = list.get(1);    // 언박싱해서 기본형으로 받기
		System.out.println(i);
		System.out.println(ii);
		
		// #4. 요소의 개수
		int size = list.size();
		System.out.println(size);  //5개
		
		// #5. 요소의 삭제
		list.remove(2);
		System.out.println(list);
		//list.remove(10)        remove(Obeject o): 요소같은거 삭제 에러발생
		list.remove(new Integer (100));    //요소와 같은거 삭제시 객체로 전달해야함
		//기본형값 -> index, 객체값 -> 값으로 인식
		System.out.println(list);
		
		list.clear();
		System.out.println(list); // []
		System.out.println(list.isEmpty()); //true
		System.out.println(list.size());  // 0

	}
}

4) 제네릭 없이 사용
제네릭 없이 사용하면 다양한 타입의 요소를 같이 저장가능.
제네릭을 지정하지 않았기 때문에
모든 객체의 최상위 클래스인 Object형으로 처리된다.  // 대신 형변환 해서 꺼내써야한다. 


5) Vector<E> : java.util.Vector<E>
: 가변 배열 구조, ArrayList와 거의 동일
Vector는  스레드간 동기화 지원, ArrayList는 스레드간 동기화 지원 X



6) Iterator<E> : java.util.Iterator<E> 인터페이스 : 반복자
: Vector, ArrayList 등과 같이 컬렉션에 저장된 요소를 
순차적으로 검색할때 사용하면 편리함.

#주요 메서드
boolean  hasNext() : 다음 요소가 있으면 true
E next() : 다음요소를 가르키고 다음 요소를 리턴
void  remove() : 리턴된 요소 제거


7) **HashMap<K, V> : java.uti.HashMap ***
: 키(key)와 값(value)의 쌍으로 구성되는 요소들을 저장할 수 있는 자료구조.
K는 키로 사용할 데이터의 타입, V의 값으로 저장할 데이터의 타입을 제네릭으로 명시한다.

-> index가 없다. index 대신 key값으로 value를 꺼내옴
-> inderx를 사용자가 원하는 값으로 지정하는 사용자 지정 index라고 할 수도 있다.
-> key값 중복 허용 안되고, 순서가 없다.

#장단점
- 삽입, 삭제 시간이 매우 빠르다. 
위치를 결정하는 해쉬함수가 간단한 코드로 구성되어있고,
vector나 ArrayList 처럼 삽입, 삭제시 요초 위치 이동이 필요없기 때문
- 검색은 더욱 빠름
해쉬함수가 key 저장 위치를 바로 찾기 때문에
vector나 ArrayList처럼 모든 요소를 하나씩 비교하는 시간 낭비가 없다.

#주요 메서드
V  put(K key, V value) : key와 value 쌍으로 데이터 저장
V get(Obeject key) : 키에 해당하는 value 값 리턴, 없으면 null리턴
V remove(Object key) : 키를 찾아 키+밸류 삭제 
void clear() : 모든 요소 삭제
int size() : 요소의 개수 리턴
boolean isEmpty() : 요소가 하나도 없으면 true
      **Set<K>** keySet() : 모든 키들만 담아서 Set<K> 타입으로 리턴
boolean containKey(Object key) : key를 포함하고 있으면 true
boolean containValue(Object key): value에 일치하는 값이 있으면 true


8) LinkedList<E> 
: 요소들을 양방향으로 연결하여 관리한다는 점을 제외하고는
Vector, ArrayList와 거의 같다.
맨앞과 맨 뒤를 가르키는 haed, tail 레퍼런스 가지고있다.

9) Stack<E>
: Vector의 자식 클래스.
제한적으로 접근할 수 있는 나열식 구조로, 접근 방법은 마지막에서만 접근가능
LIFO (Last In First Out)


Queue<E> : FIFO(First In First Out)

10) Set<E> 인터페이스 -> HashSet<E> 구현 클래스
: 순서가 없고, 중복 데이터가 없는 컬렉션.
-> 동일한 값을 저장할 수 없다.

11) Properties 클래스
: HashMap의 구버전인 HashTable을 상속받아 구현한 클래스
K, V 형태로 데이터를 저장 (K = String, V = String)
주로 어플리케이션의 환경 설정과 관련된 속성을 저장하는데 사용한다. (컴파일안해도됨)

.properties 확장자를 가진 파일의 내용을 읽어들일때 유용한 클래스.

#주요 메서드
String  getProperty(String key) :키주고 값 꺼내기
Object setProperty(String key, String value)  : 키, 밸류 세트로 데이터추가
void load(InputStream inStream) : 외부파일을 스트림으로 읽은것 k,v 형태로 로딩함)



C Create : 생성 add()
R read   : 읽기 get()
U Update : 수정
D Delete : 삭제 remove() / clear()

[day15]

1. 패키지 package
: 폴더 디렉토리 : 서로관련있는 클래스나 컴파일된 클래스 파일들을 한 곳에 묶어 놓은 것.
JDK는 개발자에게 많은 클래스 파일들을 패키지 형태로 제공 .jar 압축파일로 제공됨

1) 클래스 명
클래스를 지칭할때는 패키지명을 포함하는 경로명을 사용한다.
패키지와 클래스 사이는 점(.) 연산자로 표현

java.lang.Object

2) 패키지 필요성
소스파일을 목적에 맞게 구조적으로 관리하여
유지보수를 편하게 한다.

3) 패키지 사용
기본적으로 클래스 사용시, 패키지 명을 포함한 전체 경로명을 기술해야한다.
ex) Scanner 
java.util.Scanner sc = new java.util.Scanner(System.in);

4) import 문
import 패키지. 클래스명; 
한 패키지에 있는 여러 클래스들을 import 하고자 하는 경우,
import 패키지명.*;
위와같이 클래스명대신 *을 사용하여 선언가능
* : 모든 ~~~

ex)
import java.util.Scanner;
Scanner sc = new Scanner(System.in);

5) package 만들기
package 패키지명; 

이 클래스는 저 패키지 안에 포함되어있다!

dafault package : package 선언하지 않은 경우 현재 디렉토리를 인지함

2. API Apllication Programming Interface
: 자바에서도 제공해주는 기본 패키지 : Java API
JDK 설치하면 개발자들이 사용할 수 있도록 오라클에서 미리 만들어 놓은 많은 클래스들을 패키지로
제공한다.

1) API문서
#Java SE(Standard Edition)
https://docs.oracle.com/en/java/javase/11/docs/api/

#Java EE(웹)
https://docs.oracle.com/javaee/7/api/toc.htm (Java EE7)
https://javaee.github.io/javaee-spec/javadocs/   (Java EE8)

2) API
java.awt : GUI 관련 클래스.
java.beans : == 컴포넌트 클래스
java.io : input/output (I/O) 데이터를 내보내고 들여보내는 것
**java.lang** : 기본패키지 * (자동적으로 import됨 자주쓰는애들)
java.math : 기본연산 이외에 더 큰 다양한 연산등이 필요할때
java.net  : 네트워크 관련
java.nio  : new I/O
java.security : 보안관련 
java.sql  : 데이터 베이스 관련
java.text : 글자 관련 
**java.util** : 배열을 대신하는 클래스 이 곳의 위치, 날짜, 벡터, 해시맵, 간단한 입출력등

javax.~~  : 서포트하는 클래스

그 외,
구글 API : https://console.cloud.google.com/apis/library?project=concise-reserve-268502
네이버 API : https://developers.naver.com/main/
카카오 API : https://developers.kakao.com/
공공데이터 포털 : https://www.data.go.kr/


3. java.lang
import 필요없음.
System 을 비롯하여 문자열, 수학함수, 입출력등 과 같이
자바 프로그래밍에 필요한 기본적인 클래스와 인터페이스 제공한다.

1) Object 클래스 : 최상위 클래스
모든 클래스의 조상, 모든 클래스에 강제로 상속되는 부모.

  clone  : 복사
equals(object 던져주는애): 어떤 객체가 같은 파일인지(주소)
finalize:  비추
hashcode  해쉬코드를 주는 애
toString 해쉬코드 문자열로 주는애 (주로 오버라이딩해서 씀)
wait 쓰레드를 잠재워줌

#주요 메서드
String toString()
boolean equals(Object obj)


2) String 클래스
문자열 클래스
스트링 리터럴은 자바 컴파일러에 의해 모두 String 객체로 처리

#1. 생성자
String() : 기본 생성자, 빈 스트링객체 생성
String(String org): String 타입의 문자열 저장하면서 객체 생성
String(char[] value) : char 배열의 문자들을 스트링 객체로 생성
String(StringBuffer buffer) : 스트링버퍼 문자열을 스트링 객체 생성

3) 스트링 리터널과 new String()
스트링리터널과 new String() 으로 생성된 객체는 서로 다르게 관리된다.
스트링리터널 String str = "hello";
-> 자바 배누에서 리터럴 테이블로 특별 관리하여 동일한 리터럴 공유함.

new String() String Str = new String("hello");
-> new로 생성된 스트링은 다른 객체와 동일하게 heap 메모리에 생성

4) 스트링 객체 수정 불가능
리터럴이던, new String() 이던 수정 불가
수정 => 스트링 객체 만들어 덮어쓰기


5) 주요메서드
 리턴타입  메서드명 설명
char charAt(int idx) : index에 있는 문자 값 char 로 리턴
boolean         equals(String str) : 문자열 비교
int  compaerTo(String other) : 두 문자열을 사전순으로 비교,
같으면 0, 현자문자열이 먼저나오면 음수, 아니면 양수리턴
String concat(String str) : 현재문자열뒤에 str 매개변수 문자열 이어준 
새로운 문자열 리턴
boolean  contains(CharSequence s) : S에 지정된 문자를 포함하면 true, 포함안하면 false 리턴
int  length() : 문자열 길이 리턴
String  replace(CharSequence target, CharSequence replacement)
 : target을 replacemetn로 변경한 문자열 리턴

String[]  split(String regex) :regex 정규식에 일치하는 부분을 구분자로 
문자열을 분할하여 배열로 리턴
*자주씀* String subString(int beginIdx) : beginIdx 인덱스번호부터 끝까지 문자열을 잘라서 리턴
String toLowerCase() : 전체 소문자로 변경해 리턴
String toUppercase() : 전체 대문자로 변경해 리턴
String trim() : 문자열 앞뒤 공백 제거하고 문자열 리턴(중간은 x)

6) StringBuffer 클래스  (우리 수업에는 잘안씀)
문자열 다루는 클래스
String과 다르게 StringBuffer객체는 문자열을 저장하는 가변 버퍼를 가지고 있다.
문자열 수정가능.

7) Wrapper 클래스
: Wrapper 라는 이름의 클래스는 존재하지 않는다
int, char, double 등 의 8개의 기본형을 객체로 다루기위해
JDK에 만들어진 8새의 클래스를 통칭해서 Wrapper 클래스라 함.


기본타입 : byte short int       long char       float double boolean
Wrapper  : Byte Short Integer   Long Character  Float Double Boolean

#1. 객체 생성
클래스명 참조변수명 = new 클래스명(값);

#2. 주요메서드
static int     parseInt(String s) : 문자열을 10진수로 변경
static int     parseInt(String s , int radix) : s를 radix 진법 정수로 변경한 값 리턴
static String toBinaryString(int i) :이진수로 변환한 문자열 리턴
static String  toHexString(int i) :16진수로 변환한 문자열 리턴
static String  toOctalString(int i) :8진수
static String  toString(int i ) :문자열로 리턴

float   floatValue()  : float으로 리턴
int  intValue() : int로 리턴
long longValue() : long으로
shor  shortValue()    : short으로 

#3. 박싱 / 언박싱

<박싱> 10이라는 숫자를 ten이라는 객체에 넣기
Integer ten =  new Integer(10);
int ----------> Integer 객체
10 10


<언박싱>
int n = ten.intValue();

8) Math 클래스
: 수학 관련 클래스
모든 메서드가 static 타입으로 객체생성없이 바로 사용가능
Math.메서드명();


4. java.util
1) Calendar 클래스
: 추상클래스 (객체생성 불가능)
년, 월, 일 요일, 시간, 분, 초, 밀리초 등을 get(),set 메서드를 이용해서 저장하거나
알아낼 수 있는 클래스
1970.1.1.0.0.0 을 기준으로

#1. 객체생성 X
getInstance() 메서드를 통해 Calendar 얻어와서 사용

#2. Calendar의 get(), set() 메서드에 사용되는 상수
YEAR : 년도
DAY_OF_MONTH : 한달의 날짜
MONTH : 달(0~11)  0-> 1월
DAY_OF_WEEK : 한주의 요일
HOUR : 시간 (0~11) 0-> 1시
AM_PM : 오전/오후
HOUR_OF_DAY : 24시간 기준으로 한 시간
MINUTE : 분
SECOND : 초
MILLISECEND : 밀리초 (1초 =1000밀리초)

#3.Gragorian Calendar 클래스
1970.1.1.0.0.0을 기준으로 365.25일 (4년에 1번씩 윤달)


2) Date 클래스 (비추천, 하지만 아직까지많이 쓴다)
: 단일 클래스로 날짜/시간 관련 클래스
1900.1.1.0.0.0을 기준,
1970.1.1.0.0.0을 기준

package day15;

class AClass{}
public class ClassEx41 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Object obj = new Object();
		
		AClass a = new AClass();
		
		System.out.println(a.getClass());
		System.out.println(a.hashCode());
		System.out.println(a.toString());
		System.out.println(a.getClass().getName()+"@"+Integer.toHexString(a.hashCode()));

	}
}

package day15;

class Point{
	int x, y;
	Point(int x , int y){
		this.x = x; this.y =y;
	}
	@Override
	public String toString() {
		return "(" + x + ","+ y + ") ";
		
	@Override
	public boolean equals(Object obj) { //obj가 들고있는 실제 객체가  Point 객체라면
		boolean result = false;     // 형변환해서 담고
		if(obj instanceof Point) {
			Point p = (Point)obj;
			
		}
	
		if(x == obj.x && y == obj.y) { // 형변환 한 p와 현제매서드를 부른 객체와 비교
			result = true;
			
		}
		return result;
	
	}
}
public class ClassEx42 {
	
	
	
	public static void main(String[] args) {
		Point p1 = new Point(1,3);
		Point p2 = new Point(1,3);
		System.out.println(p1.equals(p2)); //주소비교 false
		Point p3 = p1;
		System.out.println(p1.equals(p3)); //주소비교 true
		
		
	}
		static void print(Object obj) {
			System.out.println(obj.getClass().getName());
			System.out.println(obj.hashCode());
			System.out.println(obj.toString());
			System.out.println(obj);
		
		Point p = new Point(2, 5);
		// TODO Auto-generated method stub
		print(p);
		
		Object obj = new Object();
		print(obj);
	}
}

package day15;

public class ClassEx43 {

	public static void main(String[] args) {
		
		// 리터럴 방식
		String a = "hello" ;
		String b = "hello" ;
		if(a==b) { // 리터럴 방식은 주소가 같아서 ==으로 비교해도 같다고 나옴
				System.out.println("a==b");
				}
		
		if(a.equals(b)) {//문자열 값비교
			System.out.println("a equals b");
		}
		System.out.println();
		//System.out.println(System.identityHashCode(a)); 주소같음
		//System.out.println(System.identityHashCode(b));
		
		// 객체생성
		String c = new String("hello");
		String d = new String("hello");
		if(c==d) {
			System.out.println("c==d");
		}
		
		if(a.equals(b)) {//문자열 값비교
			System.out.println("c equals d");
		}
		//System.out.println(System.identityHashCode(c)); 주소다름
		//System.out.println(System.identityHashCode(d));
		System.out.println();
	
		
		// 문자열을 비교하고 싶다면 == 쓰지말고 equals 써야한다 !!!
		//		==는 주소비교
 	}
}

package day15;

public class ClassEx44 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			String str = "hello";
			char ch	=	str.charAt(2);
			System.out.println(ch);
			
			// 문자열 연결 : concat()
			String str2 = str.concat("java");
			System.out.println(str2);
			
			// 문자열 연결 : + 연산자
			String str3 = str + "java";
			System.out.println(str3);
			
			// 문자열 사전순으로 비교
			String java = "Java";
			String cpp = "C++";
			int res = java.compareTo(cpp);
			System.out.println(res);
			
			// 문자열 앞뒤 공백 제거 : trim()
			String a = "                abcd  efg ";
			String b = " bb            sdfef  d\t";
			System.out.println(a);
			System.out.println(b);
			// 앞뒤 공백제거 
			String c = a.trim();
			String d = b.trim();
			System.out.println(c);
			System.out.println(d);
					
			// 문자열의 길이
			String str4 = "hello";
				System.out.println(str4.length());
			// 문자열 바꾸기
			String str5 = "Apple Tree";
			String str6 = str5.replace("Apple", "Lemon");
				System.out.println(str6);
				
			System.out.println(str6.toLowerCase());
			System.out.println(str6.toUpperCase());
			
			// subString()
			String str7=str6.substring(4); // 시작번호는 포함
			System.out.println(str7);
			String str8 = str6.substring(4, 7);  // 끝번호 포함x(끝번호 전까지 잘라줌)
			System.out.println(str8);
			
			String [] words = {new String("hello"), new String("java"), new String("spring")};
			
			// 정수 -> 문자열
			int value = 100;
			String strValue = String.valueOf(value);
			
			// 정수 -> 문자열
			String strVal = value +"";
			
			// substring() : 파일명 나누기   (확장자 나눌때 자주쓰임)
			String fullName = "Hello.java";
			int index = fullName.lastIndexOf(".");   // 점의 위치를 찾음
			String name = fullName.substring(0,index);
			String ext = fullName.substring(index);
			System.out.println("파일명 : " + name);
			System.out.println("확장자명 : " + ext);
			System.out.println(index);
	}		
}

package day15;

public class ClassEx45 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Integer i = new Integer(10);   // 밑줄은 곧 사라질 기능이다라는거  46class 참고
		// Interger -> int
		int ii = i.intValue();
		System.out.println(ii);
		
		//문자열 -> 기본형
		int num = Integer.parseInt("132");
		boolean bool = Boolean.parseBoolean("true");
		
		//기본형 -> 문자열
		Character c = new Character('c');
		Double d = new Double(3.14);
		d.doubleValue();
		
		
		Boolean b= new Boolean(true);
		
		
		Character cc = new Character('c');
		Double dd = new Double(3.14);
	
		Boolean bb= new Boolean(true);
		
	}
}

package day15;

public class ClassEx46 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n = 10;
		Integer ten = n;		//박싱   객체 <= 기본형
		System.out.println(ten);
		
		
		int num = ten+10;			//언박싱 기본형 <= 객체대입 
		System.out.println(num);
		
		Integer i =10; // new integer(10)   // 굳이 객체생성할 필요가없음
		Double d = 3.14;
		Boolean b = true;
		
		// 기본형 사용하듯 사용하면된다. (점 찍으면 api 기능도 있음)
		
	}
}

[day14]

1. 싱글턴 Singleton (싱글인스턴스)  모두에게 도서관이 필요하다해서 여러개 지을 필요는 없다!
여기서 도서관은 인스턴스! (객체 =인스턴스(물품) + 클래스(설계도))

1) 싱글턴의 구성 요소 
1 - 자기 클래스 타입의 private static 변수 (객체 생성해 초기화) 
private static 클래스명 instance = new 클래스명(); 

외부에서 객체생성 못하니 내 안에 미리 만들고, 
자기 자신 타입으로 객체생성하므로 무한로딩에 빠지지 않게
한번만 로딩되라고 static붙혀 클래스 변수로 만든다.
함부로 외부에서 변수값 수정 못하게 private 해놓기 

2 - private 생성자 
private 클래스명() {...}

외부에서 이 클래스 객체 생성 못하게 
생성자에 private 붙히기 

3 - instance의 get 메서드 생성해서 공개
public static 클래스명 getInstance() {  
return instance; 
}

외부에서 객체 생성못하니,
메서드도 static 붙혀 클래스명.메서드명()으로 
사용가능하게, 그리고 어디서든 필요하면 사용가능하게
public으로 완전 공개

2. 내부 클래스 inner class , nested class (*이런게 있구나 정도만 알면됨)
클래스 내부에 또 다른 클래스를 정의하는 것. 
이유 : 은닉화를 위해 사용 

1) 구조
class 외부클래스 {
외부 변수; 
외부 메서드;

class 내부클래스 {
내부 변수;
내부 메서드;
}
}

2) 종류 : 클래스 정의 위치에 따라 구분 
1. 멤버 클래스 
1 - 인스턴스 멤버 클래스 
: A클래스 객체를 생성해야만 사용할 수 있는 B 내부 클래스 

class A {
class B {
B() {}
int x;
void method(){}
//static int y; 
//static void method2() {}
}
}

# 객체 생성 & 사용 
A a = new A(); 
A.B b = a.new B(); 
b.x = 10; 
b.method();

2 - static 멤버 클래스 
: A클래스를 통해 바로 접근 가능한 B 내부 클래스 

class A {
static class B {
B() {}
int x;
void method(){}
static int y; 
static void method2() {}
}
}

# 객체 생성 & 사용 
A.B b = new A.B(); 
b.x = 10; 
b.method(); 
A.B.y = 20; 
A.B.method2(); 

# 멤버 클래스도 하나의 클래스이므로 
컴파일하면 바이트코드파일(.class) 별도로 생성 
A$B.class 

2. 로컬(지역) 클래스 
: method() 가 실행될때만 사용할 수 있는 B 내부 클래스 

class A {
void method() {
class B {
B() {}
int x;
void method(){}
//static int y; 
//static void method2() {}
}
# 객체 생성 & 사용
B b = new B(); 
b.x = 10; 
b.method(); 
}
}

A$1 B.class

3. 익명 클래스 anonymous class 
: 이름이 없는 클래스 
클래스를 정의하고 동시에 객체 생성해서 사용. 

변수의 초기값, 지역변수의 초기값, 매개변수의 매개값으로 주로 대입됨.
이벤트처리할때나 스레드 객체를 간편하게 생성할 목적으로 많이 활용됨.
단독으로 생성 불가, 클래스를 상속하거나 인터페이스를 구현해야 생성가능.

1) 구조 
new 클래스명() {
// 클래스 정의 
}

new 인터페이스() {

}

package day14;
class SingleT{
	static int b = 1;
	int a = 100;
	//싱글턴
	private static SingleT instance = new SingleT();
	private SingleT() {}
	public static SingleT getInstance() {
		return instance;
	}
	
	void func() {
		System.out.println("~~~");
	}
}


public class ClassEx31 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//SingleT sing = new SingT();
		SingleT sing = SingleT.getInstance();
		SingleT sing2 = SingleT.getInstance();
		
		sing.func();
		
		System.out.println(sing.a);
		sing.a= 123;
		System.out.println(sing.a);
				
	}
}

package day14;

public class ClassEx32 {

	
	interface MyInter{
		void func();

		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			
			//	MyInter a = new MyInter();
			//	a.func();
		//-> 계속생성가능
			//MyInter 인터페이스 규겍에 맞는 
			// 구현 익명 클래스 만들어서 객체 생성하고, 메서드 호출!
			new MyInter() {
				@Override
				public void func() {
					System.out.println("MyInter의 func 구현부 ~~");
				}
			}.func();
		// 1회성 코드
	}
}

package day14;
class Person{
	void wake() {
		System.out.println("7시에 기상");
	}
	
}

class Anony{
	Person p2 = new Person();
	// 변수의 초기값 대입
	Person p = new Person() {
		void walk() {
			System.out.println("출근~~~");
		}
		@Override
		void wake() {
			System.out.println("6시에 기상!");
			
		}
	};
	
	void func() {
		//지역 변수의 초기값으로 대입
		Person localP = new Person() {
			@Override
			void wake() {
				System.out.println("8에 일어나서....");
				
				
			}
		};
		localP.wake();
	}
	void func2(Person person) {
		person.wake();
		
	}
}
public class ClassEx33 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Anony anony = new Anony();
		//anony.p.wake();
		//anony.p2.wake();
		
		anony.func2(new Person(){
			//void study() };
	}		
}

package day13;
// 상속문제
/*
 	#1. 
	아래 main()메소드 #1번과 아래 실행결과를 참고하여 TVClass를 상속받은 ColorTV클래스를 작성하세요. 
	실행결과 : 32인치 1024컬러
	
	#2. 위 1번 문제를 푼후, main()메소드 #2번과 아래 실행결과를 참고하여 ColorTV를 상속받는  IPTV클래스를 작성하세요.
	실행결과 : 나의 IPTV는 192.1.1.2 주소의 32인치 2048컬러
*/
class TVClass {
	private int size=0;
	public TVClass(int size) { this.size = size; }
	protected int getSize() { return size; }
	
}

class ColorTV extends TVClass{
	int color;
	ColorTV(int size, int color){
		super(size);     //부모한테 보
		this.color = color;
	  }
	
	public void printProperty() {
		System.out.println(getSize()+"사이즈"+color+"컬러");
	}
}

class IPTV extends ColorTV{
	String ip;
	IPTV(String ip, int size, int color){
	super(size, color);   //부모한테 보냄
	this.ip = ip;
	}
	
	public void printProperty() {
		System.out.print(ip+"주소의 "); super.printProperty();
	}
	

}

public class ClassEx20 {
	public static void main(String[] args) {
		//#1. 
		ColorTV myTV = new ColorTV(32, 1024);
		myTV.printProperty();
		
		//#2. 
		IPTV iptv = new IPTV("192.1.1.2 ", 32, 2048);
		iptv.printProperty();
	
	}
}

package day13;
import java.util.Scanner;

// 추상클래스

/*
	#1. Converter클래스를 상속받아 원화를 달러로 변환하는 Won2Dollar 클래스를 작성하세요. 
		main()메소드의 #1번 코드와 아래 콘솔 출력예를 참고하세요. 
		콘솔출력예)
			원을 달라로 바꿉니다.
			원을 입력하세요>>  24000 (<-사용자가 값 입력)
			변환결과: 20.0달러 입니다
			
	#2. Converter 클래스를 상속받아 Km를 Mile(마일)로 변환하는 Km2Mile 클래스를 작성하세요. 
		main()메소드 #2번 코드와 아래 콘솔 출력예를 참고하세요.
		콘솔출력예)
			Km을 mile로 바꿉니다.
			Km을 입력하세요>>  30(<-사용자가 깂 입력)
			변환결과: 18.75mile입니다
*/

abstract class Converter {
	abstract protected double convert(double src);	// 추상메소드
	abstract protected String getSrcString();			// 추상메소드
	abstract protected String getDestString();			// 추상메소드
	protected double ratio;							// 비율
	
	public void run(Scanner scanner) {
		System.out.println(getSrcString() + "을 "+getDestString()+ "로 바꿉니다.");
		System.out.print(getSrcString() + "을 입력하세요>> ");
		double val = scanner.nextDouble();
		double res = convert(val);
		System.out.println("변환결과: "+res+getDestString()+"입니다");
	}
}

class Won2Dollar extends Converter{ // ratio, run
	public Won2Dollar(double ratio) {this.ratio = ratio; }
	protected String getSrcString() { return "원"; }
	protected String getDestString() { return "달러"; }
      protected double convert(double src) { return src/ratio; }
 }

	
class Km2Mile extends Converter{
	public Km2Mile(double ratio) {this.ratio = ratio; }
	protected String getSrcString() { return "km"; }
	protected String getDestString() { return "mile"; }
      protected double convert(double src) { return src/ratio; }
 
}


public class ClassEx21 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		//#1.
		Won2Dollar toDollar = new Won2Dollar(1200);		// 1달러는 1200원
		toDollar.run(sc);
		
		//#2. 
		Km2Mile toMile = new Km2Mile(1.6);			// 1마일은 1.6km
		toMile.run(sc);
		
		sc.close();
	}
}

package day13;


// 상속, 생성자
/*
 	Point를 상속받아 색을 가진 점을 나타내는 ColorPoint 클래스를 작성하세요. 
 	main()메소드 적힌 코드들을 포함하고 아래와 같은 실행결과 출력되게 만드세요. 
 	실행결과:
 		RED색의 (10,20)의 점입니다.
*/
class Point {
	private int x, y;
	public Point(int x, int y) { this.x = x; this.y = y; }
	public int getX() { return x; }
	public int getY() { return y; }
	protected void move(int x, int y) { this.x = x; this.y = y; }
}

class ColorPoint extends Point{
	String color;
	
	public ColorPoint(int x, int y, String color) {
		 super(x,y);
		this.color = color;
				
	}

		
	 public void setXY(int x, int y) {
		 move(x, y);

			
	}
	public void setColor(String color) {
		this.color = color;
		
	}
	@Override
	public String toString() {
		return   color+ "색의"+ getX()+","+getY()+"의 점";
		
	}
	
}
 
public class ClassEx22 {
	public static void main(String[] args) {

		ColorPoint cp = new ColorPoint(5, 5, "Yellow");
		cp.setXY(10,20);
		cp.setColor("RED");
		String str = cp.toString();
		System.out.println(str+"입니다.");
	}
}

package day13;
// 상속, 생성자
/*
 	Point1를 상속받아 색을 가진 점을 나타내는 ColorPoint1 클래스를 작성하세요. 
 	main()메소드 적힌 코드들을 포함하고 아래와 같은 실행결과 출력되게 만드세요. 
 	실행결과:
 		BLACK색의 (0,0)의 점입니다. 
 		RED색의 (5,5)의 점입니다.
*/
class Point1 {
	public int x;
	protected int y;
	public Point1(int x, int y) { this.x = x; this.y = y; }
	public int getX() { return x; }
	public int getY() { return y; }
	protected void move(int x, int y) { this.x = x; this.y = y; }
}

	


class ColorPoint1 extends Point1{//x,y  getx() gety() move()
	String color;
public ColorPoint1(){
		super(0,0);
		color="BLACK";
		
	}
	
	ColorPoint1(int x, int y){
		super(x,y);
	}
		
	

	public void setXY(int x, int y) {
		move(x,y);
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return  color+ "색의"+ getX()+","+getY()+"의 점";
	}
}
	


public class ClassEx23 {
	public static void main(String[] args) {
		
		//ColorPoint1 zeroPoint = new ColorPoint1();	// (0,0) 위치의 BLACK 색 점
		//System.out.println(zeroPoint.toString() + "입니다.");
		
		ColorPoint1 cp = new ColorPoint1(10,10);	// (10,10) 위치의 BLACK 색 점
		cp.setXY(5,5);
		cp.setColor("RED");
		System.out.println(cp.toString() + "입니다.");
		
	}
}

package day13;
// 상속, 생성자
/*
 	Point2를 상속받아 3차원의 점을  나타내는 Point3D 클래스를 작성하세요. 
 	main()메소드 적힌 코드들을 포함하고 아래와 같은 실행결과 출력되게 만드세요. 
 	실행결과:
		(1,2,3)의 점입니다.
		(1,2,4)의 점입니다. 
		(10,10,3)의 점입니다.
		(100,200,300)의 점입니다.
*/
class Point2 {
	private int x, y;
	public Point2(int x, int y) { this.x = x; this.y = y; }
	public int getX() { return x; }
	public int getY() { return y; }
	protected void move(int x, int y) { this.x = x; this.y = y; }
}

class Point3D extends Point2{
	int z;
	
	Point3D(int x, int y, int z){
	super(x,y);
	this.z=z;
	}
	
	@Override
	public String toString() {
		return  "("+getX()+","+getY()+","+z+")의 점";
	}
	
	void moveUp() {
		z++;
	}
	
	void moveDown() {
		z--;
	}
	void move() {
		move(10,10);
	}
	void move(int x, int y , int z) {
		move(x,y); 
		this.z = z;
	}
}
public class ClassEx24 {
	public static void main(String[] args) {
		
		Point3D p = new Point3D(1,2,3);		// 1,2,3은 각각 x,y,z축의 값.
		System.out.println(p.toString() + "입니다.");
		
		p.moveUp();		// z 축으로 위쪽 이동
		System.out.println(p.toString() + "입니다.");
		
		p.moveDown();	// z 축으로 아래쪽 이동
		p.move(10, 10);	// x,y 축으로 이동
		System.out.println(p.toString() + "입니다.");
		
		p.move(100,200,300);	// x, y, z 축으로 이동
		System.out.println(p.toString() + "입니다.");
		
	}
}

package day13;
// 상속, 생성자
/*
 	Point3를 상속받아 양수의 공간에서만 점을 나타내는 PositivePoint 클래스를 작성하세요. 
 	main()메소드 적힌 코드들을 포함하고 아래와 같은 실행결과 출력되게 만드세요. 
 	실행결과:
		(10,10)의 점입니다.
		(10,10)의 점입니다.
		(0,0)의 점입니다.
*/
class Point3 {
	private int x, y;
	public Point3(int x, int y) { this.x = x; this.y = y; }
	public int getX() { return x; }
	public int getY() { return y; }
	protected void move(int x, int y) { this.x = x; this.y = y; }
}
class PositivePoint extends Point3{
	
	PositivePoint(){
		super(0,0);
	}
	public void move(int x, int y) {
			move(x,y);
	}
	@Override
	public String toString() {
		return "("+getX()+","+getY()+")의 점입니다.";
	}
	PositivePoint(int x ,int y){
		super(x,y);
		if(x<0 || y<0) {
			super.move(0, 0);
		}
	}
	
}

public class ClassEx25 {
	public static void main(String[] args) {
		
		PositivePoint p = new PositivePoint();
		p.move(10, 10);
		System.out.println(p.toString() + "입니다.");
		
		//p.move(-5, 5);		// 객체 p는 음수 공간으로 이동되지 않음
		//System.out.println(p.toString() + "입니다.");
		
		//PositivePoint p2 = new PositivePoint(-10, -10);
		//System.out.println(p2.toString() + "입니다.");
		
	}
}

package day13;

// 인터페이스
/*
	Stack 인터페이스를 상속받아 문자열을 저장하는 StringStack 클래스를 구현하세요. 
	아래와 같은 실행결과가 나오도록 main()을 참고하여 작성하세요. 
	실행결과:
		총 스택 저장 공간의 크기 입력 >>  3 (사용자가 입력)
		문자열 입력 >> hello
		문자열 입력 >> sunny
		문자열 입력 >> smile
		문자열 입력 >> happy
		스택이 꽉 차서 푸시 불가!
		문자열 입력 >> 그만
		스택에 저장된 모든 문자열 팝 : smile sunny hello
*/
interface Stack {
	int length();					// 현재 스택에 저장된 개수 리턴
	int capacity();					// 스택의 전체 저장 가능한 개수 리턴
	String pop();					// 스택의 톱(top)에 저장된 문자열 리턴하고 저장소에서 문자열 삭제
	boolean push(String val);		// 스택의 톱(top)에 저장소에 문자열 넣고 실행 결과 boolean 타입으로 리턴
}


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

		//StringStack s = new StringStack();
		//s.run();	// 프로그램 구동 시작

	}
}

package day13;

// 추상 클래스 
/*
	아래와 같이 4개의 멤버(변수와 메소드)를 가진, 4개의 클래스 Add,Sub,Mul,Div 를 작성하세요. 
	- int타입의 a, b 변수 : 2개의 피연산자 저장할 변수
	- void setValue(int a, int b) : 피연산자 값을 객체 내에 저장
	- int calculate() : 클래스의 목적에 맞는 연산을 실행하고 결과를 리턴한다.

	그런데, 각각의 클래스마다 공통된 필드와 메소드가 존재하는 구조이므로, 
	Calc라는 이름의 추상클래스를 작성하여 Calc를 상속받아 각 4개의 클래스를 작성해보세요.
	그리고, main()메소드에서 실행예시와 같이 2개의 정수와 연산자를 입력받은 후,
	4개의 클래스중 적합한 연산을 처리할 수 있는 객체를 생성하고 메서드 호출하여 그 결과 값을 화면에 출력하게 작성 해보세요. 
	실행 예시 :
		두 정수와 연산자를 입력하세요 >> 5 7 +
		12
		힌트 : 문자열 자르기 String의 기능중 split() 메서드 사용 
	      String str = "5,7,+"; 
	      String[] arr = str.split(","); 
	      for(String s : arr) {
	         System.out.println(s);
*/

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

package day13;

// 추상클래스
/*
	텍스트로 입출력하는 간단한 그래픽 편집기 만들기. 
	아래 추상클래스 ShapeAbst를 상속받은 Line, Rect, Circle 클래스를 만들고, 
	실행 예시처럼 "삽입", "삭제", "모두보기", "종료"의 4가지 그래픽 편집 기능을 가진 
	클래스 GraphicEditor를 작성하세요.
	실행예시 : 
		그래픽 에디터를 실행합니다. 원하는 기능의 번호를 눌러주세요.
		1.삽입  2.삭제  3.모두보기  4.종료 >>  1 (사용자 입력)
		1.Line  2.Rect  3.Circle >>  2
		1.삽입  2.삭제  3.모두보기  4.종료 >>  1
		1.Line  2.Rect  3.Circle >>  3
		1.삽입  2.삭제  3.모두보기  4.종료 >>  3
		Rect
		Circle
		1.삽입  2.삭제  3.모두보기  4.종료 >>  2
		삭제할 도형의 위치 >> 3
		삭제할 수 없습니다.
		1.삽입  2.삭제  3.모두보기  4.종료 >>  4
		에디터를 종료합니다.
*/
abstract class ShapeAbst {
	private ShapeAbst next;
	public ShapeAbst() { next = null; }
	public void setNext(ShapeAbst obj) { next = obj; }	// 링크 연결
	public ShapeAbst getNext() { return next; }
	abstract public void draw();						// 추상메서드 : 도형이름 출력하는 기능을 갖고 있다.
}


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

[day12]

1. 상속과 생성자
1) 서브와 수퍼클래스의 생성자 호출 및 실행
서브클래스가 생성될때, 서브클래의 생성자와 수퍼클래스 생성자 둘다 생성
-> 생성자의 목적은 객체의 초기화, 완성된 객체를 만들기 위해서 둘다 필요.
생성자 실행 순서 : 수퍼 -> 서브 

2) 서브클래스에서 수퍼 클래스 생성자 선택
부모 클래스의 생성자가 여러개 있는 경우,
개발자가 부모생성자를 명시적으로 지정하지 않는 경우
컴파일러가 부모의 기본 생성자를 호출하도록 실행시킴.

#1. 부모클래스의 기본생성자가 자동으로 선택되는 경우
자식 클래스에서 부모 생성자를 명시적으로 부르지 않은 경우
이때, 부모에 기본 생성자가 없고, 매개변수있는 생성자만 명시되어있는 경우
에러발생
#2. 부모 생성자를 명시적으로 부르는 방법
super()를 이용하여 부모의 생성자를 명시적으로 선택해야함.
자식 생성자 안에서 super() 명령이 첫번째 명령이 되어야함
소괄호 안에 매게변수 넣어서 부모 생성자 선택가능


2. **오버라이드** override (**중요함 **)
1) 상속관계에서 성립
2) 재작성, 덮어씌우기, 재정의 한다~~
: 부모로부터 물려받은 메서드의 기능이 마음에 안들어
내용물만 변경해서 사용하는 것.
3) 메서드 선언부는 똑같이, 중괄호 영역 안의 내용물만 바꾸는 것.
void int ~~~~(){
4) 오버로딩과는 완전히 다름
오버로딩 : 같은 이름의 여러개의 메서드를 만드는 것.
오버라이딩: 안에 내용물만 수정 (재정의)
(Object 클래스로부터 물려받은 equals(), toString() 같은 메서드는 실제로
오버라이딩해서 주로 사용함)

5) 동적바인딩 : 자식 클래스에 오버라딩된 메서드가 있으면,
부모가 만든 형태는 무시하고, 자식이 오버라이딩한 메서드가 무조건 실행된다.

6) @Override : 어노테이션(annotation)이라 부르며,
메서드 바로 위에 붙혀서 컴파일러에게
오버라이딩이 정확한지 확인하도록 지시하는 것.
가독성 Up/ 개발자가 실수로 잘못작성하거나 오타를 방지할 수 있다.

7) 부모메서드의 접근 지정자보다 접근의 범위를 좁혀서 오버라이딩 불가
public > protected > default > private

부모 protected -> 자식 오버라이딩 protected / public
부모 public -> 자식 오버라이딩 public

8) super : = 부모클래스. 부모 클래스의 레퍼런스를 가르킴.
자식클래스에서 메서드 오버라이딩시,
동적바인딩으로 오버라이딩된 메서드가 무조건 실행되는데,
부모의 맴버를 호출하고자 할때 사용하는 키워드

#this. super. this(). super()
this : 현재 객체 (내가 가진~)
super : 부모 객체
this() : 보무 생성자에서 내 클래스의 다른 생성자 호출
super() : 자식 생성자에서 부모 생성자 호출


3. **** 다형성 **** polymorphism  [****자바의 화룡점정****]
여러가지 형태를 가질 수 있는 능력
상속관계에서 성립가능.
참조형의 형변환 


4. instanceof 연산자
참조하는 변수가 다르키는 실제 객체의 타입을 체크하는데 사용

참조변수 instanceof 클래스명 ---> true/ false 로 결과 돌려줌


5. 추상클래스
1) 설계와 구현을 분리한다면, 설계부분에 해당
2) 키워드 : abstract
3) 추상메서드 : abstract 키워드를 붙혀 메서드의 선언분(원형)만 있고
구현은 되어있지 않은 형태 (중괄호 부분 없음) 
  public String getNAme(){} 이지만 
->로 표현 public abstract String getName();


4) 추상클래스 : 일반 맴버 (변수, 메서드)들과 함께 추상 메서드를 포함하는 클래스
추상 메서드가 하나라도 있으면 무조건 추상 클래스
추상 클래스가에는  abstract 키워드를 붙혀야 한다.

abstract class Sharpe{ // 추상클래스
int a ;
abstract void draw(); //추상 메서드
}

5) 추상 클래스로는 객체 생성 불가!! 불완전한 / 미완성인 클래스이므로 메모리에 올릴 수 없다
Shape s = new Shape ();   -----> (X)
Shape s;  ----> (O) 변수 선언만은 괜찮다.

6) 상속에서 수퍼클래스로 사용된다. 부모 클래스 될 수 있음. extends 키워드로 상속시킬수 있다.

7) 추상클래스를 물려받은 자식클래스를 완성시키려면 추상메서드를 오버라이딩(내용물 구현)해야한다.
추상클래스를 단순히 상속만 받은 자식클래스는 그 또한 추상클래스가 된다.

# 추상 클래스 단순 상속  : 상속받은 추상 메서드 구현 안하면,
abstract class Rect extends Shape {
int width
}

# 추상 클래스를 상속 + 구현 
class Rect extends Shape {
int width;
@override
void draw(){....
}
}

8) 추상클래스를 상속받은 자식클래스는 개발자들이 추상메서드를 모두 구현해야함.
-> 추상 클래스를 가이드라인,
자식 클래스는 가이드를 따른 구현된 사용가능한 실제 클래스

6. 인터페이스 interface : 규격   / 골격제작
1) 키워드 : interface  //클래스 대신 사용
키워드 사용해서 클래스를 선언하듯이 인터페이스를 선언
2) 인터페이스 멤버는 추상메서드와 상수만으로 구성된다.

interface Phone {
public static final 타입 변수명;      //상수
public abstract 리턴타입 메서드명();  //추상 메서드

}

interface Phone {
public static final int BUTTONS = 20;   int BUTTONS = 20;
public abstract void sendCall(); void senCall();
public abstrcat void receiveCall(); receiveCall();
}

* 인터페이스 멤버는 어디서라도 접근 가능하게 모두 public으로 만듬

3) 모든 메서드는 public abstract 이며 생략 가능하다. 

4) 상수는 public static final 타입이며 생략 가능하다.

5) 인터페이스는 객체 생성 불가!
메서드는 모두 구현안된 추상메서드이므로 미완성/불완전해 객체 생성 불가능

Phone p = new Phone(); ----> X

6) 인터페이스 타입의 변수 선안만은 가능 

Phone p; ---> O

7) 인터페이스 상속
인터페이스는 다른 인터페이스를 상속 받을 수 있다.
인터페이스는 규격과 같은 것으로, 상속을 통해
기존 인터페이스에 새로운 규격을 추가한 새로운 인터페이스를 만들 수 있다.
extends 키워드 사용

interface Mobile extends Phone {
void sendSMS();    // 상수, 추상메서드
void receiveSMS();     규격추가 
}

### 인터페이스는 다중 상속 허용 ###  (구현이 안되니 충돌날일이 없으니깐)
interface DualcameraPhone extends Mobile, Camera {
void makeVideo();
}

8) 인터페이스 구현
인터페이스의 추상 메서드를 모두 구현한 클래스를 작성하는 것
키워드 : implements

class Iphone Implementes Mobile{
// 추상메서드 모두 구현
public void senCall(){.....}
public void receiveCall(){.....}
public void sendSMS(){...}
public voiud receiveSMS(){...}
//추가적으로 일반 메서드 , 변수선언
public int doubleFingerTouch(){...}

} 

* 추상메서드중 하나라도 구현안하면 에러!!
  키워드 implements는 객체생성가능
                   Mobile m = new Iphone();

9) 인터페이스의 목적
10) 인터페이스의 다중 구현
클래스는 하나 이상의 인터페이스 구현 가능.,
class Iphone Implementes Mobile, Camera,

package day12;

class Car{
	public void drive() {
		
	}
}

class Supercar extends Car{
	public void burst() {
		System.out.println("뿌아앙");
	}
}

public class Class2222222 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	Supercar s = new Supercar();
	s.burst();
	}
}

package day12;

class A{
	A(){
		System.out.println("생성자 A");
	}
	
}

class B extends A{
	B(){
		System.out.println("생성자 B");
	}
}
class C extends B {
	C(){
		System.out.println("생성자 C");
	}
}

public class ClassEx04 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		C c = new C();

		
	}
}

package day12;

class Person{
	private int weight;
	public void setWeight(int weight) {this.weight=weight;}
	public int getWeight() {return weight;}
	int age;
	protected int height;
	public String name;
}

class Student extends Person{
	void set() {
		age = 30;
		name= "홍길동";
		height = 170;
		//weight = 50; // private 부모 클래스안에서만 사용가능
		setWeight(100); // 물려받았기 때문에 바로 사용가능
				System.out.println(getWeight());
	}
	
}
public class ClassEx05 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	 Student s = new Student();
	 s.set();
	}
}

package day12;
class A1{
	 A1(){
		System.out.println("생성자 A");}
	
	A1(int x){
	System.out.println("생성자 A-param :" + x);	
	}
}

class B1 extends A1{
	 B1(){
		 super(100);
		System.out.println("생성자 B");
	}
	 B1(int x){
		 super(x); // 첫번째 자리에있어야함
		 			// 부모의 매개변수있는 생성자 호출
		System.out.println("생성자 B-param :"+ x);
	}
}

public class ClassEx06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
B1 b = new B1();

	}
}

package day12;

class Super {
	void add() {
		System.out.println("Super");
	}
}

class Sub extends Super{ //add()
	// 오버라이딩!!
	@Override
	void add() {
		System.out.println("Sub");
		System.out.println("Sub");
		System.out.println("Sub");
		super.add(); // 부모가 가진 add 기능을 호출해서 사용가능
		add();   // 내가 오버라이딩한거
	}
}

public class ClassEx07 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//부모객체
		Super sup = new Super();
		sup.add();
		//자식객체
		Sub s = new Sub();
			s.add();
	}
}

package day12;
class AClass{
	int x;
}

class BClass extends AClass{ //x, y
	int y;
}

public class ClassEx08 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

			// 기존 객체 생성하던 방식
		//	AClass a = new AClass();
		//	BClass b = new BClass();
			
			// 다형성 : 조상의 참조변수로 자식의 실 객체를 담아주는것.
			AClass a = new BClass();
		  //부모 변수  자식 객체
			//BClass b = new AClass //(X) 부모객체가 자식변수에 들어갈 수는 없다.
			System.out.println(a.x);
		 // System.out.println(a.y)

			BClass bbbb= (BClass)a;
			System.out.println(bbbb.x);
			System.out.println(bbbb.y);
			
	/*	
		int a = 10;     //정수 10
		double d = 3.14;// 정수 10 + 실수부 0.14
		a = (int)d
*/
	}
}

package day12;
class AClass2{
	int x;
	void add() {
		System.out.println("AAA");
	}
}
class BClass2 extends AClass2{ // x, @add() , y , func()
	int y;
	void add() { //override
		System.out.println("BBB");
	}
	
	void func() {
		System.out.println("subsub");
	}
}


public class ClassEx09 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	//		AClass2 a = new AClass2(); //기본적으로 만들던 객체생성
	//		AClass2 a2 = new BClass2(); //다형성으로 객체생성
	/*		
			a.add();
			System.out.println("ㅡㅡㅡㅡㅡ");
			a2.add();
			//a  [x,  add("AAA")
			//a2 [x,y,@add("BBB"), func()]
			//    A  B   A@B        B
			
	 */
			
			AClass2 a = null;
			BClass2 b = new BClass2();
			a = (AClass2)b;   // AClass2 a = new BClass2();
			a.add();
			//a.func();  b에 있는 기능이라 a에서는 사용 불가
			
		/*	
			AClass2 a = new AClass2();
			BClass2 b = null
					b = (BClass2)a ; // 컴파일은 되지만 실행할때 런타임 에러
				BClass2 b = new AClass2(); // 부모객체는 자식변수가 담을 수 없다.
		 */	
	
					AClass2 x = null;
					BClass2 y = new BClass2();
					BClass2 y2 = null;
			x= (AClass2)y;   // 다향성 upcasting : 형변환 생략가능
			y2= (BClass2)x;  //다향성 downcasting : 형변환 필수
	
			if(x instanceof BClass2) {
			System.out.println("형변환");
			y2=(BClass2)x;
			}	
	}
}

package day12;
class Product{
	int price; // 제품가격
	int bonusPoint; // 제품 구매시 제공하는 보너스 포인트
	Product(int price){
		this.price = price;
		bonusPoint = (int)(price / 10.0);
	}

	
}

class Tv extends Product{
	Tv(){
		super(100);// 생성자로 들어감
	}
	@Override
	public String toString() {
		
		return "Tv";
	}
}

class Computer extends Product{
	Computer(){
		super(200);
	}
	@Override
	public String toString() {
		
		return "Computer";
	}
}

class Buyer { // 고객님 
	int money = 1000;//지갑
	int bonusPoint = 0; //고객 소유의 보너스 포인트

	void buy(Product p) {// 제품 산다. 매개변수의 다형성
		money -= p.price;
		bonusPoint += p.bonusPoint;
		System.out.println(p + "를 구매하셨습니다.");
	}
}
public class ClassEx11 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Buyer b = new Buyer();
		Tv tv = new Tv();
		Computer com = new Computer();
		// System.out.println(tv);
		// 참조변수 출력하면 참조변수의 toString() 메서드가 호출되어
		// 메서드가 돌려주는 값을 출력하게 된다.
		// 출력하는 형태가 마음에 안들면 Object로 부터 물려받은
		// toString()메서드를 오버라이딩해서 원하는 문자열을 리던하주게 변경하면 된다
		// 나 또는 부모가 오버라이딩을 안했으면 Object 클래스가 만들어 놓은 형태로 사용
		// Object가 만들어 놓은 형태는 "패키지명.클래스명@레퍼런스16진수"이와 같다
		// System.out.println(tv.toString());
		
		b.buy(tv);
		System.out.println(" 현재 남은돈은 " + b.money+ "만원입니다");
		System.out.println(" 현재 포인트는 " + b.bonusPoint+ "점입니다");
		
		b.buy(com);
		System.out.println(" 현재 남은돈은 " + b.money+ "만원입니다");
		System.out.println(" 현재 포인트는 " + b.bonusPoint+ "점입니다");
	
	}
}

package day12;

class Shape{
	 void draw() {
		System.out.println("Shape");
	}
}

class Line extends Shape{
	@Override
	 void draw() {
		System.out.println("Line");
	}
}
class Rect extends Shape{
	@Override
	 void draw() {
		System.out.println("Rect");
	}
}
class Circle extends Shape{
	@Override
	 void draw() {
		System.out.println("Circle");
	}
}

public class ClassEx12 {
static void paint(Shape s) { // 매개변수의 다형성
	s.draw(); //오버라이딩 다형성
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Line line = new Line();
			paint(line);
			paint(new Shape());
			paint(new Line());
			paint(new Rect());
			paint(new Circle());
	}

}

package day12;

class ShapeClass{
	 void draw() {
		System.out.println("Shape");
	}
}

class LineClass extends ShapeClass{
	@Override
	 void draw() {
		System.out.println("Line");
	}
}
class Rect extends Shape{
	@Override
	 void draw() {
		System.out.println("Rect");
	}
}
class Circle extends Shape{
	@Override
	 void draw() {
		System.out.println("Circle");
	}
}

public class ClassEx122 {
static void paint(Shape s) { // 매개변수의 다형성
	s.draw(); //오버라이딩 다형성
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Line line = new Line();
			paint(line);
			paint(new Shape());
			paint(new Line());
			paint(new Rect());
			paint(new Circle());
	}
}

package day12;

// 추상 클래스
abstract class SuperClass{
   // 추상 메서드 : 구현부가 없는 메서드를 말함
   abstract void add();   // 선언부, 헤드
   
//   void add() {
//            구현부, 바디
//   }



// 일반 멤버들도 같이 포함 가능
   int a = 10;
   void aaa() {
      // ......
   }
   
}

class SubClass extends SuperClass{
   @Override
   void add() {
      
   }
}
public class ClassEx14 {
   public static void main(String[] args) {
      
//      SuperClass s = new SuperClass();   // 추상클래스는 객체생성 불가능
//      SuperClass s;						// 추상클래스는 선언은 가능
      
      SubClass sub = new SubClass();

   }
}

package day12;
// 아래 추상클래스 Calculator를 상속받아  MyCalc클래스를 구현하세요.
abstract class Calculator{
		public abstract int add(int a, int b);   //  두정수의 합을 리턴
		public abstract int substract(int a, int b); // 두 정수의 차를 리턴
		public abstract double average(int[] a);    // 배열에 저장된 정수의 평균값
	
}

 class MyCalc extends Calculator{
	
	@Override
public int add(int a, int b) {
		return a+b;
	}
	@Override
	public int substract(int a, int b) {
		return a-b;
	}
	@Override
	public double average(int[] a) {
		int sum = 0;
		 	for(int i=0; i<a.length;i++) {
				sum +=	 a[i] ;
							
					
				}
			return sum/(a.length);
}
}

public class ClassEx15 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		MyCalc my = new MyCalc();
		System.out.println(my.add(10,20));
		System.out.println(my.substract(10,20));
		System.out.println(my.average(new int[] {1,2,3,4,5}));
		
	}
}

package day12;
// 인터페이스!!!!
interface Test{
	public static final int NUM = 1;     // 상수
	public abstract void add();    		 // 추상메서드

	int x = 100; //interface에서는 상수가 됨 (public static final) 생략
	//void sub();  // 추상메서드(public abstract) 생략가능
}
interface Test2{
	void func();
}
class Hello{
	int xxx=10;
}

// 인터페이스를 구현한 클 ! 래 ! 스
class Inter extends Hello implements Test, Test2{

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

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

}
public class ClassEx16 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// 구현한 클래스로 객체 생성
		Inter i = new Inter();
		i.add();
		i.func();
		
		// 다형성 : 인터페이스가 부모 격
		Test t = new Inter();
		t.add();
		
		Test2 tt = new Inter();
		tt.func();
		Hello h = new Inter();
		h.xxx= 200;
	}
}

[day11]

1. 상속 inheritance
1) 클래스와 클래스 사이(1:1)의 부모자식 관계를 만듬.
2) 자바 다중상속 x
3) 상속은 부모의 변수, 메서드들을 물려받는것.
4) 상속시, 생성자와 초기화 블럭은 제외
5) 상속 키워드 : extends
6) 필요한 이유 : 코드 중복 제거 -> 클래스를 간격하게 구현,
 유지보수가 편함, SW생성산 향상.
부모클래스 = super = parent = base
자식클래스 = sub     child    derived

class Object{}  // 조상님 (자동으로 상속받는 *자바 기능들)
class Parent{} // 할아버지 할머니 : x
class Child extends Parent{}    //아빠 엄마        : x, y
class Child2 exnteds Parent{}    //삼촌?..남       : x, z
class GrandChild extends Child{} //아들 딸         : x,y ,a ,b

7) Object 클래스 : 모든클래스의 조상
자바에서는 모든 클래스가 자동으로 Object 클래스를 상속받는다.
모든 클래스는 object 클래스의 맴버를 모두 사용할 수 있다.
object 클래스는 11개의 메서드만 가지고 있다.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html

2. 상속과 접근자
1) 부모 클래스의 private 맴버
오직 부모안에서만 사용가능, 자식 클래스 포함해서 다른 모든 클래스에서 접근x

2) 부모 클래스의 default 맴버
같은 패키지라면 가능, 자식이라도 다른 패키지라면 접근 x

3) 부모 클래스의 public 멤버
모든 곳에서 접근 허용

4) 부모 클래스의 protected 멤버
같은 패키지의 속한 모든 클래스에서 접근 가능,
패키지 상관없이 자식이라면 어디서든 접근 가능


3. final
1) final 클래스 :
클래스 앞에 붙으면, 상속할 수 없다 (부모가 될 수 없다)
final class FinalClass{}
class A extends FinalClass{}  X

2) final 매서드
메서드 앞에 붙으면, 오버라이딩 할 수 없음 선언함.
class Super {
final void test(){AAA}

class Sub extends Sup[ // test 
@override
void test(){BBB---> x

3) final 변수 : 상수 
변수 앞에 붙으면, 상수가 된다.
상수는 한번 초기화(값대입) 되면 값을 변경할 수 없다.

final int ROW = 10;
ROW = 20; ---> X 수정안됨!!!

final 키워드를 public static과 함께 선언하면
프로그램 전체에서 사용할 수 있는 상수가 된다.
ex) public static final double PI = 3.14.....;

package day11;
//상속
class Super{
	static int a = 1000;
	int x = 10;
	
}

class Sub extends Super{// x, y
	int y = 20;
	
}
public class ClassEx01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sub s = new Sub();
		System.out.println(s.x);
		System.out.println(s);
		System.out.println(s.toString());  // object로 부터 물려받은 메서드
		System.out.println(Sub.a);
		
		System.out.println(Sub.a);
		System.out.println();
	}
}

package day11;
// 상속을 이용하여 아래 클래스들을 간결한 구조로 재 작성해보세요
class GetSetter{
	public void getset() {
		
	}
}


class pen{
	private int amount;
	public int getAmount(){return amount;}
	public void setAmount(int amount) {this.amount = amount;}
	
}

	
class SharpPencil extends pen{
	private int width;
}

class Ballpen extends pen{ //color, (amount), get/set amount
	private String color;
	public String getColor() {return color;}
	public void setColor(String color) {this.color = color;}
}

class Fount extends Ballpen{ 
		public void refill(int n) {setAmount(n);}
	
	
}
public class ClassEx02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}

package day11;
/*
final class SuperClass {
}
class Subclass exntends SuperClass{
	
}
class Test exntends Math{
} */

class SuperClass{
	final void add() {System.out.println("aaa");}
}

class SubClass extends SuperClass { //add()
		//void add() { System.out.println("bbb");
		//}
}
class Test{
	final static int x = 10;
	final int y = 20;

	//명시적으로 초기화 한 경우 생성자에서 값 대입 불가
	final int X;
	
	// 명시적 초기화를 하지 않고 생성자에서 값 대입하는것은 가능
	// 해당 객체 안에서는 객체 생성시 던져준 값을 X에 넣고 상수로 값 변경없이
	// 	고정값으로 사용하고싶은데  그 값이 객체마다 조금 달라져야 할 경우
	Test(int x){
		this.X=x;
	}
}
public class ClassEx03 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t = new Test(10);
		System.out.println(t.x);

		System.out.println(Test.x);
		//Test.x = 100;  x에 final이 붙어있어서 불가능 //20
		
		//Test t = new Test();
		System.out.println(t.y);
		/*	SubClass sub = new SubClass();
			sub.add();*/
		
	}

}

package day11;

public class Math {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	      
	      int[][]score = {
	            {100,70,50},
	            {70,50,30},
	            {50,80,70},
	            {55,85,77},
	            {100,80,75}
	         };
	      
	      int korTotal = 0;
	      int engTotal = 0;
	      int mathTotal = 0;
	      
	      int totalSum = 0;
	      int totalAvg = 0;
	      
	      System.out.println("번호\t국어\t영어\t수학\t총점\t평균\t");
	      System.out.println("===============================================");
	      
	      for(int i = 0; i < score.length; i++) {
	         int sum = 0;
	         double avg = 0.0;
	         
	         korTotal += score[i][0];
	         engTotal += score[i][1];
	         mathTotal += score[i][2];

	         System.out.print(i+1);
	         for(int j = 0; j < score[i].length; j++) {
	            sum += score[i][j];
	            System.out.print("\t" + score[i][j]);
	         }
	         totalSum += sum;
	         avg = sum / score[i].length;
	         totalAvg += avg;
	         System.out.print("\t" + sum + "\t" + avg);
	         System.out.println();
	      }

   
	}
}

[day10]
**중요**
1. this 레퍼런스
1) 객체 자기 자신을 가르키는 레퍼런스
-> 현재 실행되고 있는 메서드가 속한 실객체에 대한 레퍼런스다.

Class c{
	int a = 10;
	
    void X(){
    	int a = 20;
        System.out.println(a);   //20 이출력 (지역)
        System.out.println(this.a); // 10이 출력 (전역) 자기자신을 가리킴
    }
}

2) 인스턴스 매서드나 생성자에서 사용됨.
3)this의 필요성
1#. 지역변수나 매개변수와 인스턴스 변수의 이름이 같은경우
구별하려는 목적으로 사용

2#. 메서드가 객체 자기자신의 래퍼런스를 리턴해야하는 경우로 사용
**중요**
2. this()

1) 클래스안의 생성자가 다른 생성자를 호출 할 때 사용.
2) 생성자 안에서만 사용 가능
3) 생성자 안에서 다른 생성자의 기능이 필요할 때 사용
4) 생성자가 두개 이상일 경우 사용가능 (생성자 오버로딩)
5) 다른 생성자 호출 시, 반드시 생성자의 첫번째 문장이 되어야한다.
6) 코드 재사용성을 높이는 방법.

class Calculator{
	int a, b;
    
    public Calculator(int a, int b)
    	this.a = a;
        this.b = b;
        
       public void sum(){
       System.out.println(this.a+this.b);
	   }
       public void avg(){
       System.out.println((this.a+this.b)/2);
	   }
}

public class CalcuDemo1{
	// 생성자를 활용하여 식을 간단히
    public static void main(String[] args){
    Cacculator c1 = new Caculator(30,20);
    c1.sum(); = 50
	c1.avg(); = 25
    
    Cacculator c2 = new Caculator(10, 20);
     c1.sum(); = 30
	 c1.avg(); = 15
     }
}

package day10;

class Circle{
	int radius;
	
	Circle(int radius ){           // 라디어스값 변경 1 - 초기화 생성
		this.radius = radius;   //this.radius -> new로 만든 객체의 radius로 바뀜
	}
	void setRadius(int radius) {   // 라디어스값 변경 2 (두개 같이 써야하는 경우가 종종있음 - 2번은 메서드로 사용가능함
		this.radius = radius;
	}
	double getArea() {
	return radius * radius * 3.14;
	}
}


public class Test82 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Circle c = new Circle(5);
		System.out.println(c.getArea());
	}
}

package day10;

class Book{
	String title;
	String author;
	
	
	Book(){
		this("무제", "작자미상");
		System.out.println("생성자 1호출");
		title = "무제";
		author = "작자미상";
	}
	
	
	Book(String title){
		this(title, "작자미상"); // 생성자 안에서 첫번째 명령이 되어야한다. 다른 생성자를 부름
		System.out.println("생성자 2호출");
		//this.title=title;
		//this.author=author;
		//--->this(title, "작자미상");으로 바꿔줄수있음
	}
	
	Book(String title, String author){
		System.out.println("생성자 3호출");
		this.title=title;
		this.author=author;
	}
	void show() {
		System.out.println(title+ " "  +author);
	}
	
}

public class Test84 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Book book = new Book();
			Book.show();
	}
}

3. 객체배열
1) 배열은 기본타입뿐만 아니라, 객체를 요소로 갖는 객체 배열도 만들 수 있다.
2) 객체에 대한 레퍼런스(주소)들을 하나의 데이터로 저장하는 배열
3) 배열 선언 및 생성
# 선언
클래스명 [] 변수명;
int [] arr / / Tv [] arr 
#생성
변수명 = new 클래스명[방개수];
 
#줄여서
클래스명[]변수명 = new 클래스명[방개수];   // 빈 방이 만들어짐.

#저장
변수명[0] = new 클래스명();  //값을 넣음
4) 배열의 요소 객체에 접근
변수명[인덱스].맴버변수
변수명[인덱스].맴버메서드

package day10;
class Car {
	String color = "";
	Car(String color){
		this.color=color;
	}
	String drive() {
		return color + "색 차가 지나갑니다~~ ";
	}
	
}

public class Test85 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Car[] garage = new Car[5];  // 자동차 5개 저장가능한 주차장
		garage[0] = new Car("빨간");
		String [] colors = {"빨간","노란", "검정","흰색","초록"};
		
	//	garage[0].drive(); NullPointerException 발생!!!! -> 객체생성했는지
		
	for(int i = 0; i< garage.length; i++) {
			garage[i] = new Car(colors[i]);
		}
		for(int i = 0; i< garage.length; i++) {
	System.out.println(garage[i].drive());
		}
	}
}

package day10;

import java.util.Scanner;

//Book2 클래스를 활용하여 2개짜리 Book2 타입 객체 배열을 만들고,
// 사용자로부터 책의 제목과 저자를 입력받아 배열을 완성하고 출력하세요
// 출력 예 : 어린왕자, 생텍쥐베리
class Book2{
	String title;
	String author;
	Book2(String title, String author){
		this.title = title;
		this.author = author;

	}
	
}
public class Test86 {

		public static void main(String[] args) {
			// TODO Auto-generated method stub
			Book2[] books = new Book2[2];  //  배열 두칸만들기
			Scanner sc = new Scanner(System.in);
				
			
		for(int i = 0; i< books.length; i++) {  //배열 크기만큼 반복
				System.out.println("제목>>");
				String title = sc.nextLine();
				System.out.println("저자 >>");
				String author = sc.nextLine();
				books[i] = new Book2(title, author);
		}
		// 배열 크기만큼 반복
		for(int i = 0; i < books.length; i++) {
			System.out.println(books[i].title + " , "+ books[i].author);
		}
	}
}

4. 객체의 소멸
자바에서는 객체를 생성 (메모리를 점유)하는 new 연산자는 있지만, 
객체를 소멸(메모리 해제)하는 연산자는 없다.
대신 가비지 컬렉터가 적절한 시점에 자동으로 실행되어 메모리를 해제해준다. 

5. 가비지
더 이상 사용되지 않는 객체나 배열 메모리를 칭함.
참조하는 레퍼런스가 하나도 없는 객체나 배열을 가비지로 판단.

a= new Person("피카츄")  (a 피카츄를 가리키는중)
b= new Person("꼬부기")  (b 꼬부기를 가리키는중)

b= a; (b에게 a대입 = b 피카츄를 가리킴)  -> 꼬부기 사라짐 

6. 가비지 컬렉션 Gabage Collection
가비지를 자동적으로 처리함
인터넷 검색해봐야함 

7. 접근 지정자 modifier

1) 객체 지향 언어는 접근지정자를 두고있다.
객체를 캡슐화 하기 때문에, 객체에 다른 객체가 접근하는것을 
허용할지 말지를 지정할 필요가 있기 때문

2) 패키지 package
자바는 서로 관련있는 클래스 파일들을 패키지에 묶어서 저장하여 관리함.
패키지: 디렉토리 or 폴더 개념

3) 자바의 4가지 접근 지정자

# 클래스 접근 지정자 : 다른 클래스에서 이 클래스를 활용할 수 있는지 허용 여부 지정.
1. public 클래스
: 패키지에 상관없이 다른 어떤 클래스에서도 사용이 허용.
public class 클래스명 {....}

2. default 클래스
: 같은 패키지내의 클래스들에게만 사용이 허용됨
class 클래스명 {...}


# 맴버 접근 지정자 :  이 맴버를 활용 할 수 있는지 허용 여부 지정.

1. public 맴버
: 모든 클래스에서 접근 가능 

public 타입 변수명
public 리턴타입 메서드명(){...}
2. private 맴버 
: 비공개, 같은 클래스안의 맴버들에게만 접근 허용

private 타입 변수명
private 리턴타입 메서드명(){...}

3. protected 멤버
: 보호된 공개, 같은 패키지의 모든 클래스와 다른 패키지에 있어도
자식 클래스라면 접근 허용 -> 상속유도

protected 타입 변수명
protected 리턴타입 메서드명(){...}

4. default 멤버
: 같은 패키지의 클래스들에게 접근허용

타입 변수명
리턴 타입 매서드명(){...}

package day10;
//defualt 클래스 : 같은 패키지
class Sample {
   public int a ;   // 모두 허용
   private int b;   // 같은 클래스
   int c;           // 같은 패키지
   protected int d; // 같은패키지 + 자식 클래스

}
// public 클래스 : 전체공개
public class Test87 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Sample s = new Sample();
			s.a = 10;
			//s.b = 100; 접근 불가능
			s.c = 200;
			s.d = 300;
	}
}

4) 캡슐화 encaptulation : 자바가 지향하는 코드 스타일

변수 : private
메서드 : public

데이터를 보관하는 변수에 접근하기위해서는 
메서드를 통해 우회접근하도록하여,
데이터의 무분별한 공개를 막고, 적합한 가공과 검증을 통하여
데이터에 접근하도록 유도하는 방법.

getter / setter
(외부에서 보내주는거 / 외부에서 세팅)

get변수명 (){} : 데이터 꺼내기
set변수명 (){} : 데이터 대입
* 변수명 첫글자 대문자로 !!

private String name;
public String getName(){
return name;
}

public void setName(String name){
this.name = name;
}

package day10;
 // 캡슐화로 클래스 만들어보자
class Person{
	//String name = '';
	//int age = 0;
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		if(name == null) {
			System.out.println("null 은 저장할 수 없습니다");
		}else {
			
		
		 this.name = name;
		}
	}
	
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		// 검증처리, 유효성 검사
		if(age>0 && age<150) {
			
			this.age = age;   //대입
		}else {
			System.out.println("이상한 나이");
		}
	}
	
}
public class Test88 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p = new Person();
		//p.name = "피카츄"
		p.setAge(160);
		
		//System.out.println(p.name);
		System.out.println(p.getAge());
		
		p.setName("d");
		
		//System.out.println(p.name);
		System.out.println(p.getName());
		
	}
}

package day10;
// 같은 이름의 변수 우선순위 : 지역 > 인스턴스 > 클래스
public class Test83 {
	int x = 10;
		void add (int x) {
			// 인스턴스보다 지역변수가 우선순위가 높으므로, x는 모두 매게변수만 가르키게됨.
			//x = x;
			this.x = x;
		}
		
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			
	}
}

package day10;
class Car {
	String color = "";
	Car(String color){
		this.color=color;
	}
	String drive() {
		return color + "색 차가 지나갑니다~~ ";
	}
	
}

public class Test85 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Car[] garage = new Car[5];  // 자동차 5개 저장가능한 주차장
		garage[0] = new Car("빨간");
		String [] colors = {"빨간","노란", "검정","흰색","초록"};
		
	//	garage[0].drive(); NullPointerException 발생!!!! -> 객체생성했는지
		
	for(int i = 0; i< garage.length; i++) {
			garage[i] = new Car(colors[i]);
		}
		for(int i = 0; i< garage.length; i++) {
	System.out.println(garage[i].drive());
		}
	}
}

package day10;
/*
	main() 메서드를 실행하였을때 예시와 같이 출력되도록 Tv 클래스를 작성하세요. 
	콘솔 출력예 > LG에서 만든 2022년형 32인치 TV
*/
class Tv{
	   private String brand;
	   private int year;
	   private int inch;


Tv(String brand, int year, int inch){
		this.brand = brand;
		this.year = year;
		this.inch = inch;
	 }
public String getBrand() {
    return brand;
 }
 
 public void setBrand(String brand) {
    this.brand = brand;
 }
 public int getYear() {
    return year;
 }
 public void setYear(int year) {
    this.year = year;
 }
 public int getInch() {
    return inch;
 }
 public void setInch(int inch) {
    this.inch = inch;
 }
		
	
	 public void show(){
		System.out.println(this.brand + "에서 만든" + this.year + 
				"년형" + this.inch +"인치 Tv");
	 }
}

public class Test89 {
	public static void main(String[] args) {
		// main은 작성완료, 주석해제하고 실행하면 지문에 나온 콘솔출력예처럼 보이게 작업. 
		Tv myTv = new Tv("LG", 2022, 32); 
		myTv.show(); 
	}
}

package day10;

import java.util.Scanner;

/*
 	Grade 클래스를 완성하세요. 
 	3과목의 점수를 입력받아 Grade 객체를 생성하고 성적 평균을 출력하는 
 	main() 과 실행예씨는 아래와 같다. 
 	콘솔 출력예)
 		수학, 과학, 영어점수를 입력하세요. 
 		수학 >> 90
 		과학 >> 88
 		영어 >> 96
 		평균은 91
*/
class Grade {
	private int math;
	private int sci;
	private int eng;
	double avg;
	Grade(int math, int sci, int eng){
		this.math = math;
		this.sci = sci;
		this.eng = eng;
	}
	
	public int getMath() {return math;}
	public void setMath(int math) {this.math=math;}
	public int getsci() {return sci;}
	public void setSci(int sci) {this.sci=sci;}
	public int getEng() {return eng;}
	public void setEng(int eng) {this.eng=eng;}
	
	
	
	double getAvg() {
		return (math + sci + eng)/3;
	}
}

public class Test90 {
	public static void main(String[] args) {
		//main 완성 
		Scanner sc = new Scanner(System.in);
		System.out.println("수학, 과학, 영어점수를 입력하세요.");
		System.out.print("수학>>");
		int math = Integer.parseInt(sc.nextLine());
		System.out.print("과학>>");
		int sci = Integer.parseInt(sc.nextLine());
		System.out.print("영어>>");
		int eng = Integer.parseInt(sc.nextLine());
		
		Grade me = new Grade(math, sci, eng);
		System.out.println("평균은 " + me.getAvg());
		
		sc.close();
	}
}

package day10;

/*
	노래 한곡을 나타내는 Song 클래스를 작성하세요. Song은 아래와 같은 변수로 구성된다. 
		- 노래 제목을 나타내는 title 
		- 가수를 나타내는 artist
		- 노래가 발표된 연도를 나타내는 year
		- 국적을 나타내는 country 
	또한, Song클래스에 다음 생성자와 메서드를 작성하세요. 
		- 생성자 2개 : 기본생성자, 매개변수로 모든 변수를 초기화해주는 생성자 
		- 노래 정보를 출력하는  show() 메서드 
		- main() 메서드에서는 2017년, 한국국적의 Collective Arts가 부를 Alone이라는 
		 	Song 객체를 생성하고, show() 를 이용하여 노래의 
			정보를 이용하여 아래와 같이 출력되도록 하세요. 
	콘솔 출력예 >> 2017년 한국국적의 Collective Arts가 부른 Alone
*/
class Song {
	String title;
	String artist;
	int year;
	String country;
	
	Song(){} //기본 생성자
	Song(String title, String artist, int year, String country){  //매게변수로 모든변수 초기화
		this.title = title;
		this.artist = artist;
		this.year = year;
		this.country = country;
	
	 }
	
	void show(){
		System.out.println( year +"년 " +country +" 국적의 " + artist + "가 부른 " + title);
	}
}
public class Test91 {
	public static void main(String[] args) {

		Song s = new Song();
		Song album= new Song("제목","아티스트 ",2022,"한국");
		s.show();
		album.show();
	}
}

package day10;
/*
	직사각형을 표현하는 Rectangle 클래스를 작성하세요. 
	- int 타입의 x, y, width, height 변수 : 사각형을 구성하는 점과 크기 정보 
		x,y는 사각형 왼쪽 위 점의 좌표를 말함. 
		0,0은 왼쪽 위, x는 오른쪽으로 늘어나고 y는 밑으로 늘어난다. 
	- x, y, width, height 값을 매개변수로 받아 필드를 초기화 하는 생성자 
	- int squareArea()	: 사각형의 너비를 리턴 
	- void show()		: 사각형의 좌표와 가로세로 출력 
	- boolean contains(Rectangle r) : 매개변수로 받은 r이 현 사각형 안에 있으면 true리턴 
	- 콘솔 출력 결과 :
		(2,2)에서 크기가 8x7인 사각형 
		b의 면적은 36
		c는 a를 포함합니다. 
*/
class Rectangle{


	int x,y,width,height ;

	Rectangle(int x, int y, int width, int height){
	this.x=x;
	this.y=y;
	this.width=width;
	this.height=height;
	}


	int squareArea() {
	return (width)*(height);
}
	void show() {
		System.out.println("("+x+","+y+")+에서 크기가 " + width + "*"+height + "인 사각형");
	}

	boolean contains(Rectangle r) {
		if(x<r.x && y<r.y && (x+width)>(r.x+r.width)&& (y+height)>(r.y + r.height)) {
			return true;
		}
		return false;
	}
}
public class Test92 {
	public static void main(String[] args) {

		// main은 작성 완료. 주석해제해서 실행 
		
		
		Rectangle a = new Rectangle(2,2,8,7); // x. y. width. height
		Rectangle b = new Rectangle(5,5,6,6); 
		Rectangle c = new Rectangle(1,1,10,10); 
		
		a.show(); 
		System.out.println("b의 면적은 " + b.squareArea());
		if(c.contains(a)) { System.out.println("c는 a를 포함합니다."); }
		if(c.contains(b)) { System.out.println("c는 b를 포함합니다."); }

	}
}

package day10;

import java.util.Scanner;

/*
	n명이 참가하는 끝말잇기 게임을 만들어보자. 
	처음단어는 "자동차"이다. 
	몇명(n)이 참가하는지 입력받고, n명의 참가자들은 순서대로 자신의 단어를 입력하면된다. 
	끝말잇기에서 틀리면 게임오버 -> 진사람 이름 출력하고 프로그램 종료. 
	WordGameApp 클래스와 각 선수를 나타내는 Player 클래스로 구성하세요. 
	WordGameApp : 게임을 전체적으로 진행하는 run() 메서드, 
				run()에서 플레이어 수만큼 Player 객체 배열 생성 
	Player : 플레이어 이름 저장, 단어 입력받는 getWordFromUser()메서드, 
			끝말잇기 성공여부와 게임계속할지 판별하는 checkSuccess() 메서드 
	# 힌트 
		* 문자열 첫번째 문자 알아내는 방법 
			String word = "자동차"; 
			char ch = word.charAt(0); 
		* 문자열의 길이 알아내는 방법 
			word.length(); --> 3 
*/
class Player {
	// 캡슐화 
	private String name;	// 플레이어 이름 
	private String word;	// 이 플레이어가 입력한 단어 저장해놓을 변수 
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
	String getWordFromUser(Scanner sc) {
		System.out.print(name + " >> ");
		word = sc.nextLine(); 
		return word;
	}
	boolean checkSuccess(String lastWord) { // 맞았는지 체크 : 방금입력한단어, 이전단어 
		boolean check = false; 
		// lastWord 끝 글자 찾기 
		int lastIdx = lastWord.length() - 1;  // 마지막 글자의 인덱스번호 찾기
		char lastChar = lastWord.charAt(lastIdx); // 마지막글자 꺼내오기
		// 입력한 word의 첫글자 찾기 
		char firstChar = word.charAt(0);
		// 두개비교 
		if(lastChar == firstChar) { // 두개가 같으면 
			check = true; // 결과 true로 변경
		}
		return check; // 결과 담고있는 변수의 값 리턴 
	}
}
class WordGameApp {
	Player[] p = null; 	// 플레이어들을 객체로 생성해서 저장시켜놓을 배열변수
	Scanner sc; 
	
	WordGameApp() {
		sc = new Scanner(System.in);
	}
	
	// 참가인원 세팅 
	void setPlayers() {
		System.out.print("게임에 참가하는 인원 >> ");
		int num = Integer.parseInt(sc.nextLine()); 
		p = new Player[num];	// 참가인원수 만큼 방크기 만들기 (빈방)
		for(int i = 0; i < p.length; i++) { // 방크기 만큼 반복 
			// Player 객체생성해, 
			p[i] = new Player(); 
			// 참가자 이름 입력받아, 해당 배열안 객체에 바로 이름 저장
			System.out.print("이름 >> ");
			p[i].setName(sc.nextLine()); 
	         //p[i].setName(name);
			//String name = sc.nextLine(); 
		}
	}
	// 게임을 전체적으로 진행시킬 메서드 
	void run() {
		System.out.println("끝말잇기 게임시작!!!");
		setPlayers();
		// 게임 진행 
		String lastWord = "자동차";
		System.out.println("시작 단어는 " + lastWord + "입니다.");
		int idx = 0; // while 안에서 인덱스번호 처럼 사용할 변수 
		while(true) {
			// 단어 입력받고 
			String newWord = p[idx].getWordFromUser(sc);
			// 맞았는지 검사 -> 맞으면 계속 돌고, 틀리면 누가 졌는지 출력하고while 종료! 
			boolean result = p[idx].checkSuccess(lastWord);
			if(!result) {
				System.out.println("게임오버!!" + p[idx].getName() + "님이 졌습니다.");
				sc.close(); // 더이상 입력받을거 없을때 닫아주기 
				break;
			}
			idx++; 
			idx %= p.length; 
			// 다음 회차를 위해 lastWord를 방금 입력받은 단어로 변경
			lastWord = newWord; 
		}
	}
}
public class Test933 {
	public static void main(String[] args) {
		// main 작성 완료!! 
		WordGameApp game = new WordGameApp(); 
		game.run(); 
		
	}
}

package day10;

import java.util.Scanner;

/*
	하루 할일을 표현하는 클래스 Day는 다음과 같다. (그대로 사용하기) 
	한달의 할일을 표현하는 MonthSchedule 클래스를 작성하세요. 
	MonthSchedule 클래스에는 Day 객체 배열과 적절한 변수, 메서드를 작성하고
	실행 예시처럼 입력,보기,끝내기 등의 3개의 기능을 작성하세요. 
	콘솔 실행예시 : 
		이번달 스케쥴 관리 프로그램. 
		할일(입력:1, 보기:2, 끝내기:3) >>   1  (사용자 입력) 
		날짜(1 ~ 31)?   1 
		할일?   자바공부 
		
		할일(입력:1, 보기:2, 끝내기:3) >>   2 
		날짜(1 ~ 31)?   1 
		1일의 할 일은 자바공부입니다.
		
		할일(입력:1, 보기:2, 끝내기:3) >>   3 
		프로그램 종료 
*/
class Day {
	private String work; 
	public void setWork(String work) { this.work = work; }
	public String getWork() { return work; }
	public void show() {
		if(work == null) { System.out.println("없습니다."); }
		else {System.out.println(work + "입니다.");}
	}
}
class MonthSchedule {
	private Day [] days;
	private Scanner sc;
	private int dayNum; // 다른 메서드에서 필요하면 사용하기 위해 인스턴스로 만듬
	 MonthSchedule(int dayNum){
		 days = new Day[dayNum]; // 방크기만들기 (빈방)
		 for(int i=0; i<days.length; i++) {// 방마다 day 객체 생성해 채우기
			 days[i] = new Day();
		 }
		 sc = new Scanner(System.in);
	 } 
	 void intput() {// 입력
		 System.out.println("날짜(1~  "+ dayNum + ")?");
		 int day = Integer.parseInt(sc.nextLine());
		 day--; // 인덱스 번호로 변경
		 if(day<0 || day>dayNum) {
			 System.out.println("날짜를 잘못 입력하셨습니다");
			 //input();
			 return;
		 }
		 System.out.println(" 할일 ? ");
		 String work = sc.nextLine();
		 days[day].setWork(work); //달력해당 날짜에 할일 저장
	 }
	 void show() {// 할일보기
		 System.out.println("날짜(1~  "+ dayNum + ")?");
		 int day = Integer.parseInt(sc.nextLine());
		 day--; // 인덱스 번호로 변경
		 if(day<0 || day>dayNum) {
			 System.out.println("날짜를 잘못 입력하셨습니다");
			 //input();
			 return;
		 }
		 System.out.println(day +1 +"일의 할 일은 :");
		 days[day].show();
	 }
	 void finish() {// 끝내기
		 
	 }
	 // 달력 프로그램 전체 진행시키는 메서드
	 void run() {
		 System.out.println("이번달 스케쥴 관리 프로그램.");
		 
		 while (true) {
			 System.out.println("할일(입력:1, 보기:2, 끝내기:3) >> ");
			 int menu = Integer.parseInt(sc.nextLine());
			 switch(menu) {
			 case 1: intput(); break;
			 case 2: show(); break;
			 case 3: finish(); return; // run()메서드 종료 !!
			 default : System.out.println("잘못입력했습니다 다시하세요");
			 }
		 }
		 
	 }
}
public class Test94 {
	public static void main(String[] args) {

		// main은 작성 완료 
		//MonthSchedule may = new MonthSchedule(31); // 5월달 스케쥴 생성 
		//may.run();  0
		
	}
}

package day10;

import java.util.Scanner;

/*
	콘서트 예약 프로그램 
	- 공연은 하루만 예약 
	- 좌석은 S석, A석, B석으로 나뉘며, 각 10개의 좌석이 있다. 
	- 예약 시스템의 메뉴는 "예약", "조회", "취소", "끝내기" 가 있다. 
	- 예약은 한자리만 가능하고, 좌석타입, 예약자이름, 좌석번호를 입력받아 예약한다. 
	- 조회는 모든 좌석을 출력한다. 
	- 취소는 예약자의 이름을 입력받아 취소한다. 
	- 없는이름, 없는메뉴번호, 없는좌석번호 등 예외가 발생할것들을 미리 처리
		-> 오류 메세지 출력하고 사용자가 다시 시도하도록 한다. 
	실행 예시 : 
		자바콘서트홀 예약시스템입니다. 
		예약:1, 조회:2, 취소:3, 끝내기4 >>   1 
		좌석구분 S(1), A(2), B(3) >>  1 
		S >> ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
		이름 >>   피카츄 
		번호 >>   1 
		<<예약 완료>>
		
		예약:1, 조회:2, 취소:3, 끝내기4 >>   1 
		좌석구분 S(1), A(2), B(3) >>  2 
		A >> ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
		이름 >>   꼬북이 
		번호 >>   5 
		<<예약 완료>>
		
		예약:1, 조회:2, 취소:3, 끝내기4 >>   2 
		S >> 피카츄 ___ ___ ___ ___ ___ ___ ___ ___ ___
		A >> ___ ___ ___ ___ 꼬북이 ___ ___ ___ ___ ___
		B >> ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
		<<조회 완료>>
		
		예약:1, 조회:2, 취소:3, 끝내기4 >>   3 
		좌석구분 S(1), A(2), B(3) >>  2 
		A >> ___ ___ ___ ___ 꼬북이 ___ ___ ___ ___ ___
		이름 >>  꼬북이 
		<<취소 완료>>
		
		예약:1, 조회:2, 취소:3, 끝내기4 >>   2 
		S >> 피카츄 ___ ___ ___ ___ ___ ___ ___ ___ ___
		A >> ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
		B >> ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
		<<조회 완료>>
		
		예약:1, 조회:2, 취소:3, 끝내기4 >>   4
		<<프로그램 종료>>
*/
class Seat { // 좌석 한개 정보 담을 클래스 
	private String name = "___"; 
	public void setName(String name) { this.name = name; }
	public String getName() { return name; }
}

class Booking { // 예약 프로그램 
	private Scanner sc; 
	private Seat[] seatS = new Seat[10]; 
	private Seat[] seatA = new Seat[10];
	private Seat[] seatB = new Seat[10]; 
	
	Booking() {
		sc = new Scanner(System.in); // Scanner 객체생성해서 사용가능하게 준비 세팅
		for(int i = 0; i < seatS.length; i++) {
			seatS[i] = new Seat(); 
		}
		for(int i = 0; i < seatA.length; i++) {
			seatA[i] = new Seat(); 
		}
		for(int i = 0; i < seatB.length; i++) {
			seatB[i] = new Seat(); 
		}
	}
	
	void showSeats(int sel) {
		if(sel == 1) {
			System.out.print("S >> ");
			for(int i = 0; i < seatS.length; i++) { 
				System.out.print(seatS[i].getName() + "  ");
			}
			System.out.println();
		}else if(sel == 2) {
			System.out.print("A >> ");
			for(int i = 0; i < seatA.length; i++) { 
				System.out.print(seatA[i].getName() + "  ");
			}
			System.out.println();
		}else if(sel == 3) {
			System.out.print("B >> ");
			for(int i = 0; i < seatB.length; i++) { 
				System.out.print(seatB[i].getName() + "  ");
			}
			System.out.println();
		}
	}
	void book() {
		System.out.print("좌석구분 S(1), A(2), B(3) >> ");
		int sel = Integer.parseInt(sc.nextLine());
		showSeats(sel); // 해당 좌석 출력해라 
		System.out.print("이름 >> ");
		String name = sc.nextLine(); 
		System.out.print("번호 >> ");
		int seatNum = Integer.parseInt(sc.nextLine());
		// 좌석 구역 선택한것에 따라 맞는 배열에 저장 
		if(sel == 1) seatS[seatNum-1].setName(name);
		else if(sel == 2) seatA[seatNum-1].setName(name);
		else if(sel == 3) seatB[seatNum-1].setName(name);
		System.out.println("<<예약 완료>>");
	}
	void search() {
		showSeats(1);
		showSeats(2);
		showSeats(3);
		System.out.println("<<조회 완료>>");
	}
	/*
		좌석구분 S(1), A(2), B(3) >>  2 
		A >> ___ ___ ___ ___ 꼬북이 ___ ___ ___ ___ ___
		이름 >>  꼬북이 
		<<취소 완료>>
	 */
	void cancel() {
		System.out.print("좌석구분 S(1), A(2), B(3) >> ");
		int sel = Integer.parseInt(sc.nextLine());
		showSeats(sel); // 해당 좌석 출력해라 
		System.out.print("이름 >> ");
		String name = sc.nextLine(); 
		if(sel == 1) {
			for(int i = 0; i < seatS.length; i++) {
				if(seatS[i].getName().equals(name)) {
					seatS[i].setName("___");
				}
			}
		}else if(sel == 2) {
			for(int i = 0; i < seatA.length; i++) {
				if(seatA[i].getName().equals(name)) {
					seatA[i].setName("___");
				}
			}
		}else if(sel == 3) {
			for(int i = 0; i < seatB.length; i++) {
				if(seatB[i].getName().equals(name)) {
					seatB[i].setName("___");
				}
			}
		}
	}

	void run() {
		System.out.println("자바콘서트홀 예약시스템입니다.");
		while(true) {
			// 반복해서 메뉴 번호 입력받고,
			System.out.print("예약:1, 조회:2, 취소:3, 끝내기4 >> ");
			int menu = Integer.parseInt(sc.nextLine());
			if(menu == 1) { book(); }
			else if(menu == 2) { search(); }
			else if(menu == 3) { cancel(); }
			else if(menu == 4) {
				System.out.println("예약 프로그램 종료!!");
				sc.close();
				break;
			}
			else {
				System.out.println("메뉴 선택 오류!! 다시 입력하세요...");
			}
			// 번호에 해당하는 처리 메서드 호출 
		}// while
	}// run
}// Booking

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

		Booking book = new Booking(); 
		book.run();
		
	}
}

[day09]

1. 재귀호출 recursive call
메서드 안에서 자기자신을 호출하는 것을 말함.

2. 메서드 오버로딩 method overloading    **중요함**

1) 한 클래스 내에, 이름이 같지만 매개변수의 타입이나 개수가 서로 다른
여러개의 메서드를 중복 작성 가능.
자바 다형성의 한 경우

2) 조건 
1 - 메서드의 이름이 같아야한다.
2 - 매개변수의 개수 또는 데이터타입이 서로 달라야한다.

주의 - 매개변수의 이름이 다른것은 조건에 해당 안됨.
리턴타입도 오버로딩 조건에 해당 안됨.

3. 생성자 constructor
1) 객체가 생성될때, 객체의 초기화를 위해 사용되는 메서드.
모든 클래스에는 생성자가 있으며, 생성자가 기술이 안되어있으면
"기본 생성자"가 눈에는 안보이지만 자동으로 아무것도 없는 형태로 
만들어지고 호출된다.

2) 초기화 3가지 방식
#1. 생성자 : 인스턴스 변수를 초기화할때 많이 사용



#2. 초기화 블럭 : 클래스 블럭 / 인스턴스 블럭
(주로 안드로이드 할때)
초기화 블럭도 인스턴스 변수를 초기화할때 사용될 수 있는데
생성자와 블럭 둘다 있으면 순서가 블럭이 먼저다.
*구 조 *
#클래스 블럭
static {
// 초기화 코드 작성....
}

#인스턴스 블럭
{
// 초기화 코드 작성....
}


#3. 명시적 초기화
int a = 10; 

3) 생성자 선언 및 활용
- 객체가 생성되는 순간에 new를 통해 자동으로 단 한번만 호출된다.
(반면, 메서드는 필요할때마다 호출가능)


- 생성자의 이름은 반드시 클래스 이름과 동일
- 리턴타입 없다. (return; 키워드는 사용가능
- 매개변수 지정 가능.
- 생성자는 오버로딩 할 수 있다.
- 목적은 객체생성시, 필요한 초기 작업을 하기 위함이다.
변수 초기화, 필요한 메모리 확보, 파일 열기,
네크워크 연결 등 객체 활동전 필요한 초기 준비시 이용

4) 구조
클래스명(타입 파라미터,.....){
// 초기화 시키는 코드들...
}


4. 기본 생성자 dafault contstructor

1) 매게변수없는 생성자
클래스명(){}

2) 클래스 생성자가 하나 이상은 반드시 존재한다.
객체 생성시, 반드시 한번 실행.
클래스에 작성된 생성자가 하나도 없으면 
컴파일러가 자동으로 내용없는 기본 생성자를 추가하고 실행해서 객체 생성한다.
3) 기본생성자가 자동으로 생성되는 경우
4) 기본생성자가 자동으로 생성되지 않는 경우
매게변수 있는 생성자가 작성되어 있을 경우,
컴파일러는 기본 생성자를 만들어 주지 않는다.

package day09;


class Mycard{
	int num;
	boolean isBonus;
}
class Student{
	String name;
	int age;
}


class MobilePhone{
	double width;
	double height;
	double depth;
	String color;
	String brand;
}
	
class TheJoeunStudent{
		String name;
		String color;
}

public class Test700 {
		public static void main(String[] args) {
	/*1. 아래와 같은 멤버변수를 갖는 MyCard 클래스를 정의 하세요. 
	   (MyCard 클래스는 카드 한장 만들수 있는 클래스) 
	   - 1 ~ 10 사이 카드의 숫자(정수)를 저장할 num이라는 변수 
	   - 카드가 보너스 카드인지 판단할 isBonus 라는 이름의 변수 (보너스카드면 true, 아니면 false저장) 
	2. 1번에서 만들 MyCard 클래스를 이용하여 카드 한장을 만들고 
	   해당 카드가 몇번이며, 보너스인지 아닌지 지정하고 
	   출력해서 확인해보세요. */
			
			Mycard card = new Mycard();
			card.num= 10;
			card.isBonus = true;
			System.out.println(card.num);
			System.out.println(card.isBonus);
			
		
		Student stu = new Student();
		stu.name = "김범수";
		stu.age = 10;
			
			
		MobilePhone handy = new MobilePhone();
		//handy.width = 5.7;
		//handy.height = 5.7;
				
		TheJoeunStudent s1 = new TheJoeunStudent() ;	
	
		s1.name = "홍길동";
		s1.color = "블랙";
		
		TheJoeunStudent s2 = new TheJoeunStudent() ;	
		s2.name = "홍길동";
		s2.color = "블랙";
			
		}
}

package day09;

import java.util.Scanner;

// 재귀호출 : factorial : 1부터 입력받은 수 n 까지 곱한 결과를 돌려주는 메서드
public class Test7000 {
	
	static long factorial (int n) {
		if(n==1) {
			return 1;
		}else {
			return n * factorial(n-1);
		}
	}

	public static void main(String[] args) {
		
		
		Scanner sc = new Scanner (System.in);
		System.out.println("정수 입력>>");
		int n = Integer.parseInt(sc.nextLine());
		long result = factorial(n);
		System.out.println(result);
		
		factorial(n);
		sc.close();
		
	}
}

package day09;
/*
 * tv 기능 구현
 * 1. 채널 = 배열 10개방 만들어 랜덤값 10개 생성후 배열에 낮은값부터 대입
   2.  채널(up.down)
   3. 채널값 입력받아 저장(없는 채널 입력시 변경 안됨)
   4. 볼륨은 0~ 10 까지 증감
   5. 음소거 기능 
   6. TV 상태값 출력 하는 메서드 (전원 상태, 채널, 볼륨)
   7. 전원이 꺼져있는 경우 모든 기능 동작 안함.
 */

class Tv {
	
	int vol =0;  
	int []ch = new int [10];
	boolean power = false;
	void powerOnOff() {
		power = !power;
	}
	
	void chUp() {
	for(int i=0; i<=10;i++) {
		int ch[i]	
		}
	}
	
	void chDown() {
	//	ch--;
	}
	void volup() {
		
		
		vol++;
	}
	void volDown(){
		vol--;
	}
	void chChange(int num){
		
	//	ch = num; 
	}
}
public class Test71 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		int []ch1 = new int [10];
		int []ch = new int [10];
		// 채널 모두 0으로
			for(int i=0; i<ch1.length;i++ ) {
					ch1[i] = 0;
			}
			

	// 100개 랜덤 생성
			for(int i=0; i<ch1.length ;i++ ) {
	  	 
	  		  ch1[i] =((int)(Math.random()*100)+1);	
	    }
	    // 10개 랜덤을 보드에 넣기
	    for(int i = 0; i<ch1.length; i++) {
	    //보드의 임의의 위치
	  	  // 행 0~10
		
			int x =  (int)(Math.random()*10+1); //행 인덱스 랜덤
		
		
	    // 중복체크 : 같은 자리가 다시 뽑히면 안된다.
	    if(ch1[x]!=0) {
	  	  i--;
	  	  System.out.println("자리중복");
	 
	    		}else {
	  		 ch[x]=ch1[i];
	  	  }
		
	    }
	 }
}

package day09;
/*
 *  char[] 배열을 전달받아 출력하는 printCharArray() 메서드와
 *  배역속의 ' ' 공백문자를 ',' 쉼표로 대치하는 
 *  replaceSpace() 메서드를 작성해보저 
 */



public class Test72 {
	
	static	void printCharArray(char[] c) {
	//for(int i = 0; i< c.length; i++)
		 for (char a : c){
			 System.out.print(a);
		 }System.out.println();
	}
	
	static void replaceSpace(char[] c) {
		for(int i = 0; i < c.length; i++) {
			if(c[i] ==' '){
			c[i] = ',';
			
			}
		}
	
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char[] c = {'I',' ', 'a', 'm', ' ', 'a', ' ', 'b', 'o', 'y'}; 
	
	printCharArray(c); // i am a boy 출력
	replaceSpace(c);
	printCharArray(c); // i,am,a,boy 출력
	}

}

package day09;

// 메서드 오버로딩  같은 버튼에 다른 기능 추가
public class Test73 {
	
	
	// 개수차이
	int getSum(int a, int b) {
		return a + b ;
	}
	int getSum(int a, int b, int c) {
		return a + b + c ;
	}
	
	// 타입차이
	int getMul (int a, int d) {
		return a * (int)d;
	}
	int getMul (int a, double d) {
		return a * (int)d;
	}
	
	//순서 + 타입차이
	double Test (int a, double b) {
		return a * b;
	}
	double Test (double a, int b) {
		return a * b;
	}
	
	// 안되는 것들
/*	//-> 리턴타입은 오버로딩 조건에 포함 안됨
	int getSub(int a, int b) {
		return a- b;
	}
		
	double getSub(int a, int b) {
		return (double)a- b;
	}
	
	//-> 매개 변수 이름은 상관없다!! 타입이나 개수가 달라야함 !
	int getDiv(int a, int b){
	return a/ b;
	}
	
	int getDiv(int C, int d){
	return c/ d
	}
*
*
*/	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Test73 test = new Test73();
		System.out.println(test.getSum(0, 0));

	}
}

package day09;

public class Test74 {

	static void add() {}
	static void add(int x){System.out.println(x);}
	//static void add(int a) {System.out.println(a);}
	static void add(long x){System.out.println(x);}
	static void add(long a, int b){System.out.println(a+b);}
	static void add(int a, long b){System.out.println(a+b);}
	static void add(long a, long b){System.out.println(a+b);}
	static void add(int a, int b){System.out.println(a+b);}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

package day09;

class Ex01{
 		String str = "hello java";
 		int year = 2022;

 		void printstr () {
 			System.out.println(str);
 		}

 		void printyear () {
 			System.out.println(year);
 		}
}

class Ex02 {
    int a; 
    boolean isPlay; 
    double d; 
    void printint (int num) {
    	a = num;
    	}
    
    void printbool (boolean or) {
    	isPlay = or;
    }
    
    void printdouble (double numd) {
    	d = numd;
    }
 }


class MobPhone{
	int width ;
	int height;
	double weight;
	String brand;
	
	void Changwid (int num) {
		weight = num;
	}
	
	void call (int num) {
			System.out.println("연결중입니다");
	}
}
/*
1. 아래와 같은 클래스를 만들고, 
   class Ex01{
      String str = "hello java"; 
      int year = 2022; 
   }
   str 변수값을 출력하는 인스턴스 메서드 1개 
   year 변수값을 출력하는 인스턴스 메서드 1개
   총 두개의 메서드를 추가해보세요.
   
2. 1번에서 만든 Ex01 클래스로 객체 생성 2개하고 각각 메서드를 호출해보세요. 

3. 아래와 같은 클래스를 만들고, 
   class Ex02 {
      int a; 
      boolean isPlay; 
      double d; 
   }
   Ex02 클래스안에 변수에 해당하는 메서드를 총 3개 만든다. 
   각 메서드는 외부로부터 데이터를 전달받아, 변수에 대입하는 처리를 한다. 
4. 3번에서만든 Ex02 클래스로 객체생성 한개 하고 
   메서드들을 호출하여 변수에 값대입시키고, 출력해서 확인해보세요. 
   
5. 모바일 폰 클래스 만들기 
   MobPhone 클래스를 만들고, 
   브랜드 이름, 폰의 가로크기, 세로크기, 무게를 저장할 변수를 만드세요. 
   그리고, 전화걸기, 전화받기, 문자 보내기, 문자받기 메서드도 추가하세요. 
   (메서드 안에는 실행되었는지 확인하기 위해 단순히 출력문 하나만 작성) 
6. 5번에서 만든 MobPhone을 이용하여 폰을 하나 생성하고, 
   폰의 모든값을 출력하고, 값도 변경한후, 다시 출력해서 확인해보세요. 
7. 위 모바일 폰 클래스에 만들어둔 메서드중 전화걸기 메서드를 수정하세요. 
   전화걸기 메서드에 전화번호를 던져주면 (예: "010-1111-2222") 
   메서드에서는 해당 전화번호로 전화를 걸고 있다는 출력문 작성. 
   (출력예: 010-1111-2222로 전화를 걸고 있습니다.)
*/
public class Test75 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ex01 test = new Ex01();
		System.out.println(test.str);
		System.out.println(test.year);
		
			
		Ex02 test2 = new Ex02();	
		System.out.println(test2.d);
		test2.printbool(false);
		test2.printint(100);
		System.out.println(test2.printbool(false));
		
		MobPhone handy = new MobPhone();
		//handy.width = 5.7;
		//handy.height = 5.7;
		System.out.println(test2.a);
		System.out.println(test2.isPlay);
		System.out.println(test2.d);
	}	
}

package day09;

public class Test76 {
	
	// 클래스 변수
	static int x = 10;
	int y = 20;
	// 클래스 초기화 블럭 : 프로그램 시작하면 자동실행
	static {
		System.out.println("클래스 초기화 블럭");
		x = 200; 
		// y= 300; 객체생성이 안되서
	}
	
	
	// 인스턴스 초기화블럭 : 객체 생성하면 자동실행
	{
		System.out.println("인스턴스 초기화 블럭");
		y=400;
	}
	
	
	public static void main(String[] args) {
		
		Test76 test = new Test76();
		System.out.println(Test76.x);
		System.out.println(test.y);
		
	}
}

package day09;

public class Test77 {
	Test77(){
		System.out.println("생성자 실행");
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Test77 test = new Test77();
		Test77 test1 = new Test77();
		Test77 test2 = new Test77();
	}
}

package day09;

public class Test78 {

		// 인스턴스 변수
		double d;
		
		Test78(){
		d= Math.random();
	    }
		
		Test78(double a){
			System.out.println("매개변수 있는 생성자 호출");
			d = a;
		}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Test78 test = new Test78();
		System.out.println(test.d);
		
		Test78 test2 = new Test78(3.14);
				System.out.println(test2.d);
	}
}

package day09;

class Book {
	String title; 	//제목
	String author;	//작가
	
	Book(String t){
		title = t; 
		author = "작자미상"; 
	}
	Book(String t, String a){
		title = t; 
		author = a; 
	}
}

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

		Book book = new Book("콩쥐팥쥐");  // 책 생산 
		System.out.println(book.title + " " + book.author);
		Book little = new Book("어린왕자", "생텍쥐베리"); 
		System.out.println(little.title + " " + little.author);
	}
}

package day09;
// 기본생성자 자동으로 만들어지는 예시 
class Circle {
	int radius; 
	
	// Circle(){ }
	
	void set(int r) {
		radius = r; 
	}
	double getArea() {
		return radius * radius * 3.14; 
	}
}
public class Test80 {
	public static void main(String[] args) {

		Circle pizza = new Circle(); 
		//pizza.set(15);
		System.out.println(pizza.getArea());
		
	}
}

package day09;
// 기본생성자 자동으로 안만들어주는 예시
class Circle1 {
	int radius; 
	
	Circle1() { }
	// 매개변수 있는 생성자를 개발자가 작성하면, 
	// 기본생성자는 안만들어준다. 
	Circle1(int r) {
		radius = r; 
	}
	
	void set(int r) {
		radius = r; 
	}
	double getArea() {
		return radius * radius * 3.14; 
	}
}

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

		Circle1 c = new Circle1(10); 
		System.out.println(c.getArea());
		
		Circle1 c2 = new Circle1();
	}
}

[day08]

클래스 : 변수 + 메서드

1. 메서드 method

1) 메서드 : 함수

어떠한 작업을 수행하기 위한 명령문들의 집합. manin()도 메서드
메서드 -> 연산을 처리하는 곳
변수 -> 그 결과를 저장하는 곳
메서드는 어떤 값을 입력 받아 처리하고
그 결과(하나만)를 돌려준다. (입력값, 리턴값 유/무)

목적, 장점 : 재사용 : 반복적인 코드를 줄이고 코드 관리가 용이함.
System.out.println(); 출력해주는 메소드

2) 메서드의 정의와 사용

#1. 입력값 x , 리턴값 x
#정의
리턴타입 메서드명(){
실행할 코드들
}

#사용(호출)
메서드명();


#2. 입력값 o , 리턴값 o
#정의
리턴타입 메서드명(타입 파라미터명, 타입 파라미터명,....){
실행할 코드들...
return 값;
}
#사용
메서드명(인자, 인자,....); 
#3. 

3) 용어 정리
리턴타입 : 메서드의 작성된 코드를 실행하고 리턴해주는 결과의 타입.
모든 타입이 될 수 있고, 리턴해줄것이 없다면 void 라고 작성.

메서드명 : 변수명명규칙 참고 (소문자) , 무슨 작업을 하는지 유추 가능한 이름으로 만들기
파라미터 : 매개변수, arguments
메서드를 실행할때(부를떄) 외부에서 던져주는 데이터를 받아주는 변수
메서드에 입력받을 값을 담아주는 변수
외부에서 던져주는 값이 없다면 괄호안 비워두기

return   : 함수를 호출한 곳으로 값을 돌려주는 키워드
1) 메서드를 종료시킴
2) 뒤에 작성한 값을 호출한 곳으로 
리턴타입이 void가 이 아닌 이상 반드시 return 값이 있어야한다.
리턴타입과 return 뒤에 기입할 데이터의 타입이 동일해야함.
void 타입에서도 어떤 조건에 의해 메서드가 중간에 강제종료하고 싶을때는
return; 값없이 키워드만 사용가능
인자     : 매게변수, 인수, 인자값, 인수값, 파라니처, arguments
메서드 호출시, 메서드에게 던져줄 데이터를 말함.
인자 -> 파라미터

주의!! 인자와 파라미터의 개수/순서/데이터타입은 반드시 일치해야함.

4) 메서드의 종류
#1. 클래스 메서드   : static이 붙은 메서드
객체 생성안하고 바로 사용가능
#2. 인스턴스 메서드 : 일반메서드
객체 생성한 후 사용가능
(같은 클래스안에 있는 애들을 부를때는 객체생성 안해도 됨)
-> 메모리 생성 시기가 같아서 가능함.


5) main() 메서드
public static void main(String[] args){
}

2. 메서드 인자 전달 방식

자바의 인자 전달 방식은 "값의 의한 호출 : Call-by-value" 이다.
호출하는 곳에서의 인자값이 복사되어 파라미터에게 전달된다.

1) 기본형 값 전달 : read only : 값만 복사해줌. 원본 훼손 x
2) 참조형 값 전달 : read & write : 객체의 레퍼런스(주소값)이 전달된다.

3. JVM 메모리 구조

RAM OS가 관리
JVM이 OS로 부터 메모리 할당 받음 (Runtime Data Area)
5개 영역, Class Area (= Method Area), Call Stack, Heap, Native Method Stack Area, Pcredgister

1) Method Area : static 이 붙어있는 것들의 영역. 
2) Call Stack : 현재 실행중인 메서드들이 차지하는 메모리 영역.
3) Heap : new ~~~ 로 생성되는 모든것들
4) Native : c/c++과 연동하는 작업을 함.

package day08;
class Test{
	
	int a= 10 ; // 인스턴스 변수
	static String str; // 클래스 참조형 변수
	Test 63 te; //인스턴스 참조형 변수
	static Tv t; //클래스 참조형 변수
	Person p ; //인스턴스 참조형 변수
	
	int test() {
		int abc; //지역변수 (메서드 안)
		Test test; //지역변수 (메서드 안)
		Tv tvtv; //지역변수
	}
	Stringahahahahaha(String a)// 인스턴스{
		int b ; //지역변수
		static Tv t2; // 불가능함 
	}
	
	static int[][] bbb; // 클래스 변수
	
}

public class Test63 {
	boolean b; //인스턴스 
	in [] arr; // 인스턴스 
	static String[] //클래스
	Scanner sc; //인스턴스
	
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		test55 t; //지역변수	
	}
}

package day08;
/* 클래스 기본형 변수   : 클래스명.변수명 : static 키워드. 메서드 밖
 * 클래스 참조형 변수   : 
 * 
 * 인스턴스 기본형 변수 : new 객체생성 후 참조변수명.변수명. 메서드 밖
 * 인스턴스 참조형 변수
 * 
 * 지역 기본형 변수      : 변수명 : 메서드 안 : 메서드 끝나면 값 소멸
 * 지역 참조형 변수      :
 */
class TvTest {
	
	boolean power = false;
	int ch = 1, vol =4;
	
}

public class Test64 {
	static int a;      // 클래스 기본형 Test64.a   자동 초기화 0
	static String s;   // 클래스 참조형 Test64.s   자동 초기화 null
	static Test64 t;   // 클래스 참조형 Test64.t   자동 초기화 null
	static TvTest tv; // 클래스 참조형 Test64.tv   자동 초기화 null
	
	int x;				// 인스턴스 기본형      자동 초기화 0
	TvTest t1;			// 인스턴스 참조형		자동 초기화 null
	
	//Test64 test64 ;		// 인스턴스 참조형 		자동 초기화 null
	//내 클래스 안에 내 타입으로 인스턴스 객체 생성하여 선언하면 안된다 !! (무한반복)
	//Test64 test64 ;		선언까지는 괜찮은데
	// Test64 test64 = new Test64();		// 객체를 생성하면 안됨
		
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Test64.a);  // 값 없이 선언만해도 0으로 값 넣어줌 
		
		int b;
	//	System.out.println(b);  // 지역변수는 안됨 (클래스, 인스턴스는 선언하면 자동 초기값)
		
		//값넣기 
	/*	Test64.a = 100;
		System.out.println(Test64.s);
		
		Test64.s = "hello";  // new String("hello")
		System.out.println(Test64.t);
		
		Test64.tv = new TvTest(); // 기본형 아니라 객체 생성하고 넣어줌
		System.out.println(Test64.tv); //주소가 나옴
		System.out.println(Test64.tv.ch );
		System.out.println(Test64.tv.vol );
		
		Test64.t = new Test64();
		System.out.println(Test64.t);
		
		
		Test64 test = new Test64();
				System.out.println(test.x);
		Test64 test1 = new Test64();
				System.out.println(test2.t1);
		
	*/	

				

	//	Test64 test2 = new Test64();		
	//	System.out.println(test2.s);		
				
		Test64 test3 = new Test64();
		
		test3.t1 = new TvTest();
		
		
		System.out.println(test3.t1.vol);
		
	//	Test64 test4 = new Test64(); // test 64 값을 넣고 싶어서 객체생성
	//	test4.test64 = new Test64(); // test 64값 대입
	//	System.out.println(test4.test64);
		
	}
}

package day08;
/*
 *  리턴타입 메서드명(타입 파라미터,000){
 		실행할 코드들
 		return 값;
 *  }
 */


class Hello{
	// 입력 x, 리턴 x
	void printHello() {
		System.out.println("hello method");
		System.out.println("hello method");
	}
	
	
	// 입력 o, 리턴 x
	void helloName(String name) {
		System.out.println(name+"님 안녕하세요");
	}
	
	
	// 입력 x, 리턴 o
	int getTen() {
		return 10;
	}
	
	
	// 입력 o, 리턴 o
	int sum(int a, int b) {
		int c = a + b;
		return c;
	}
}


public class Test65 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Hello h = new Hello();
	//	h.printHello();
		
	//	h.helloName("피카츄");
		int result = h.getTen();
		System.out.println(h.getTen());
		System.out.println(result);
		int resultsum = h.sum(10, 10);
		System.out.println(h.sum(10, 10));
		System.out.println(resultsum);
	}
}

package day08;

class Calc{
	double mySum(double a, double b){
		double c = a + b;
		return c;
	}
	double mySub(double a, double b){
		double c = a - b;
		return c;
	}
	double myMul(double a,double b){
		double c = a * b;
		return c;
	}
	double myDiv(double a, double b){
		double c = a / b;
		return c;
	}
}	
	
public class Test66 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// Calc라는 클래스를 만들고,
		//덧셈 mySum, 뺄쎔 mySub, 곱셈 myMul, 나눗셈 myDiv 메서드 4개를 만들어보고
		//main에서 각각 호출
		
		Calc h = new Calc();
		double sum = h.mySum(10, 0);
		System.out.println(sum);
		
		double sub = h.mySub(0, 1);
		System.out.println(sub);
		
		double Mul = h.myMul(5, 4);
		System.out.println(Mul);
		
		double Div = h.myDiv(6, 3);
		System.out.println(Div);	
	}
}

package day08;



//Tv 클래스
//변수 : 채널, 볼륨, 전원,
//메서드 : 전원 on/off, 채널변경, 볼륨조정, 채널입력해서 변경
class Tv {
	int ch = 1, vol = 0;
	boolean power = false;
	
	void powerOnOff() {
		power = !power;
	}
	
	void chUp() {
		ch++;
	}
	
	
	void chDown() {
		ch--;
	}
	void volup() {
		vol++;
	}
	void volDown(){
		vol--;
	}
	void chChange(int num){
		
		ch = num; 
	}
}


public class Test67 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		Tv tv = new Tv();
		System.out.println(tv.power);
		tv.powerOnOff();
		System.out.println(tv.power);
		tv.volup();
		tv.volup();
		tv.volup();
		tv.volup();
		System.out.println(tv.vol);
		tv.chChange(4);
		System.out.println(tv.ch);
	}
}

package day08;
// 인자 전달 방식
class Circle{
	int radius = 30;
	int numm = 0;
	int num = 10;
	
}
public class Test68 {

	int tot = 0;
// 편의를 위해 static 붙힘 다른 의도 없음!!	
static void plus(int num) {
	num ++ ;
	}
	static void biggerPizza(Circle pizza) {
		pizza.radius++;
	}
	
	static void increase(int[]arr) {
		for(int i = 0; i <arr.length; i++) {
			arr[i]++;  // arr[i] = arr[i] + 1
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	
		// #1. 기본형
		int num = 10 ;
		Circle num2 = new Circle();
		System.out.println("222"+num);
		plus(num);
	
	
		System.out.println(num);
		
	//	Circle h = new Circle();
	//	h.plus(10);
	// .out.println(h.numm);
		
		// #2. 참조형 (객체)
		Circle pizza = new Circle();
		System.out.println("pizza: " +pizza.radius);
		biggerPizza(pizza);
		System.out.println("pizza: " +pizza.radius);
		
		// #3. 배열
		int [] arr = {1,2,3,4,5};
		increase(arr);
		for(int a :arr)System.out.println(a);
		
	}
}

package day08;
class MyCard{
int num = 0;
boolean isBonus ;
}


class Student{
	String name;
	int age;
	void name(String whois) {
		name = whois;
		System.out.println(name);
	}
	
	void age(int num){
	  age = num; 
	  System.out.println(age);
	}
}

class MobilePhone{
	double width;
	double height;
	double depth;
	String color;
	String brand;
	
	void width(double num) {
		width = num;
		System.out.println(width);
	}
	void height(double num) {
		height = num;
		System.out.println(height);
	}
	void depth(double num) {
		depth = num;
		System.out.println(depth);
	}
	void color(String blabla) {
		System.out.println("색상은" + blabla);
	}
	void brand (String blabla) {
		System.out.println("브랜드는" + blabla);
	}
	
}
class  TheJoeunStudent {
	
	public static String[] Members() {
		String[] members = {"홍길동","가나다","잘모르겠따"};
		return members;
	}
}

public class Test69 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	/*	[ 객체 생성 + 변수 문제 ] 
				1. 아래와 같은 멤버변수를 갖는 MyCard 클래스를 정의 하세요. 
				   (MyCard 클래스는 카드 한장 만들수 있는 클래스) 
				   - 1 ~ 10 사이 카드의 숫자(정수)를 저장할 num이라는 변수 
				   - 카드가 보너스 카드인지 판단할 isBonus 라는 이름의 변수 (보너스카드면 true, 아니면 false저장) 
				2. 1번에서 만들 MyCard 클래스를 이용하여 카드 한장을 만들고 
				   해당 카드가 몇번이며, 보너스인지 아닌지 지정하고 
				   출력해서 확인해보세요. 

				3. 학생의 이름과 나이를 저장할 Student 클래스를 만들어보세요. 

				4. 3번에서 만든 Student 클래스를 이용하여 학생 한명을 만들고,
				   이름과 나이를 저장한 후 출력해서 확인해 보세요. 
				 Student some =new Student();   
				   some.age(5);
				   some.name("name");
	
				
				  5. 아래와 같은 속성을 저장할 수 있는 멤버변수를 갖는 MobilePhone 클래스를 정의하세요. 
*/
		MobilePhone handy = new MobilePhone();
		handy.width(4);
		handy.height(7);
		handy.depth(9);
		handy.color("파란색");
		handy.brand("삼성");
		//handy.width = 5.7;
		//handy.height = 5.7;
		
		
/*
				   - 가로사이즈 (실수 ex: 7.5) 
				   - 세로사이즈 (실수)
				   - 두께    (실수) 
				   - 폰색상
				   - 폰 브랜드 이름
				
	
				6. 5번에서 만든 MobilePhone 클래스를 이용하여 폰을 하나만들고, 
				   모든 속성을 변경하고 출력해보세요. 

				7. 학생의 이름과 옷색상을 저장할 TheJoeunStudent 클래스를 정의하세요. 
				 
				8. 7번에서 만든 클래스를 이용하여, 우리반 같은 분단에 앉은 학생들을 모두 만들고,
				   각 학생에 맞는 이름과 옷색상을 저장하고, 출력해보세요. 
*/
		
	}
}

package day08;
class Test{
	
	static int x = y;   //y가 아직 만들어 지기전에 x를 만들고있다
	 int y = 0;
}


class Test1{
	// 순서는 중요하지 않다 static이 먼저 로딩된다
	int y = x;
	static int x =100;	 // 
}

public class Test70 {
	static int a = 100;
	int i = 20;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//x출력 -> x는 클래스변수
		System.out.println(Test.x);  //클래스명 .변수명
		
		//y출력 -> y는 인스턴스
		// 객체 생성해야함
		Test t = new Test();
		System.out.println(t.y);
		
		//a	출력 -> a는 test70의 클래스변수	
		System.out.println(Test70.a);
		
		//i 출력 -> 객체생성
		Test70 test = new Test70();
		System.out.println(test.i);  //참조변수.변수명
		
		
		// 1회용으로 변수 출력만 하고 말것이다~
		System.out.println(new Test().i);
		
	}
}

[day07]

변수
연산자 화폐매수 구하기

if 짝수 홀수
for 구구단 전체 ~별찍기 10번
배열 1차원 치대값, 최소값, 정렬, 2차원 아파트 6번



1. 객체 지향 
# 객체지향
# 특징
코드 재사용성이 높다 : API 사용
코드 관리가 쉽다 : 상속, 다향성, 추상화. 캡슐화
신뢰성이 높은 프로그램 개발 가능

# 캡슐화 (encapsulation) : 자바가 지향하는 코드 스타일
# 상속 (inheritance)
# 다형성 (polymorphism)
상속관계에서 성립
같은 이름의 기능이 클래스나 객체에 따라 
다르게 동작하도록 구현되는 것.

2. 클래스와 객체

1) 클래스 (설계도)
객체를 정의해 놓은 것
용도는 객체를 만들기 위한 것

2) 객체
실제로 존재하는 것
클래스 모양 (설계) 그대로 생성된 실체

3) 객체와 인스턴스 
객체 == 인스턴스 

4) 객체 : 속성 + 기능
속성과 기능을 통틀어 맴버라고 부른다.
속성 : 맴버변수, 필드
기능 : 매서드 

5) 객체를 생성과 사용

#1. 클래스 정의
* 클래스 구조 *
class 클래스명 {
변수
메서드
}

# 클래스명은 첫글자 대문자, 숫자로 시작 X, 띄어쓰기 X, 특수기호 _ $ 만 허용
   패키지내 클래스명은 한개만 존재해야함.


#2. 객체 생성
**선언**
클래명 참조변수명;        String str

**생성**
참조변수명 = new 클래스 명 ()

**선언 + 생성 **
클래스명 참조 변수명 = new 클래스명 ();
Scanner sc = new Scanner();

참조 변수 (레퍼런스 변수) : 객체를 가르키는, 객제츠이 주소 (레퍼런스)
new : 클래스 모양의 메모리를 점유하는 문법적으로 중요한 키워드


#3. 객체 사용

참조변수명.변수 = 값;
참조변수명.메서드();


 ---> 정리
클래스 == 사용자 정의 데이터 타입
기본형 : 메모리 양이 정해진것
클래스 : 개발자가 필요한 만큼 메모리 크기를 직접 지정해서 만든것.
클래스 : 유사한 특징을 지닌 객체들의 속성과 기능을 묶어 놓은 집함


3. 변수의 종류
: 선언 위치(어디서 변수가 만들어졌느냐)에 따라 변수의 종류와 성질이 달라짐.

1) 클래스 변수  (static 변수)
- 클래스 안에 생성 (메서드 밖)
- 이름앞에 static 키워드가 붙는다

- 종류 : 클래스 기본형 변수(int string) / 클래스 참조형 변수(tv.. /
- 특징 : 모든 객체들이 공유하는 변수
 프로그램시작하면 먼저 한번만 로딩하고,
 new로 객체생성하지 않아도 바로 사용가능.
- 접근방법 
클래스명.변수명
참조변수명.변수명

2) 인스턴스 변수 
- 클래스 안 생성 (메서드 밖)
- 종류 : 인스턴스 기본형 변수 / 인스턴스 참조형 변수 
- 특징 : 각 객체(인스턴스)의 개별적인 저장 공간 갖는다.
new~ 로 객체생성한 후 메모리가 점유되면 사용가능.
가르키는 참조변수가 없을 경우 가비지 컬렉터가 수거해감.
또는 프로그램 종료시 소멸됨.
- 접근 방법
참조변수명. 변수명

3) 지역 변수   
- 메서드 안 생성
- 종류 : 지역 기본형(int, char 소문자) 변수 / 지역 참조형(Scanner, String 대문자) 변수
- 특징 : 메서드 (,조건문 , 반목문) 내에서 선언된 변수를 가르키며,
메서드 종료시 소멸

# 메모리 로딩순서
클래스 영역-> static -> main 실행 -> (new~~) 인스턴스 생성 
:클래스 범위 만들고
| static 붙은 아이들 모두 로딩
|메인 있다면 실행
| new로 객체 생성된 아이들 실행

package day07;    //패키지명
// #1. 클래스 정의
class Person{
	// 속성 (변수)
	String name = "홍길동" ;
	int age = 10;
	
	// 기능 (메서드)
	void breathe() {
		System.out.println("숨쉬기");
	}
	
	void sleep() {
		System.out.println("잔다");
	}
	
}
public class Test60 { 

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// #2. 객체 생성
			Person p = new Person();
			p.name = "피카츄";
			p.age = 100;
			System.out.println(p);
			System.out.println(p.name);
			System.out.println(p.age);
			p.breathe(); //기능 실행해
			p.sleep(); 
			
			
			Person p2 = new Person();
			System.out.println(p2);
			System.out.println(p2.name);
			System.out.println(p2.age);
			p2.breathe();	
	}
}

package day07;

class Tv {
	boolean power = false;
	int vol = 0, ch =1;
	
	
}
public class Test61 {

	public static void main(String[] args) {
		
		
		Tv t1 = new Tv();
		Tv t2 = new Tv();
		t1.ch = 100;
		System.out.println(t1.ch);
		System.out.println(t2.ch);
		
		t1= t2;   //주소값이 같아져서 밑에 값 같아짐
		t1.ch= 500;
		t2.ch= 200;
		System.out.println(t1.ch);
		System.out.println(t2.ch);
		

/*		
		// TODO Auto-generated method stub
		// 변수    (속성)
		// 메서드  (기능)
		// 메인 메서드
		
		//Test61 test = new Test61();
		String s = new String();
		
		Tv t = new Tv();
		System.out.println(t.power);
		System.out.println(t.vol);
		System.out.println(t.ch);
		
		Tv t1 = new Tv ();		
		Tv t2 = new Tv ();		
		Tv t3 = new Tv ();		
		
		t1.ch = 10;
		t2.ch = 20;
		System.out.println(t1);
		System.out.println(t2.ch);
		System.out.println(t3.ch);
		
		
		
		// 같은 타입끼리 대입가능
		int a = 10;
		int b = 20;
		a = b; 
		b = a;
		
		t1 =t2;
		t1.ch = t1.vol;
		
		// 다른타입끼리는 불가능
		//t1 = t2.ch; 
	*/
	}
}

package day07;


class TvEx {
// 클래스 기본형 변수
	static boolean power = false;
// 인스턴스 기본형 변수
	int vol = 0, ch = 1;
}
public class Test62 {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 지역 기본형 변수 
		int a = 10;
		
		// 지역 참조형 변수 }중 괄화 안에서만 유효함
		String str = "hello";
		
		// 지역 기본형 변수 : for 문이 끝나면 사라짐
		for(int i= 0; i<5; i++) {
			System.out.println(i);
		}
		// 클래스 변수 출력 : 객체 생성없이 바로 사용가능
		System.out.println(TvEx.power);
		// 인스턴스 변수 출력 : 객체 생성해야 사용가능!!!!!!
		TvEx t1 = new TvEx();
		System.out.println(t1.vol);
		System.out.println(t1.ch);
		System.out.println("------------------");
		TvEx tv1 = new TvEx();
		TvEx tv2 = new TvEx();
		tv1.ch=200;
		System.out.println(tv1.power+"   " + tv1.ch);
		System.out.println(tv2.power+"   " + tv2.ch);
	}
}

[day 06]

1. 배열 array
행
1) 다차원 배열
: 정방배열

*선언*                   열열열
int [행][렬] arr;      행
int arr [][];        행
            






2) 가변 배열
: 비 정방배열, 길이가 다른 배열

package day06;

public class T123 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int [][] arr4 = new int [2][3];
		
		System.out.println(arr4.length);
	}
}

package day06;

public class Test50 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

/*
	//	System.out.println(args[1]);
		// 정방배열
		// 선언
		int [][] arr = new int[2][3];
		arr[0][0]=100;
		arr[0][1]=200;
		arr[0][2]=300;
		arr[1][0]=400;
		arr[1][1]=500;
		arr[1][2]=600;
		System.out.println(arr[1][2]);
		
	
			// 초기화
		int[][] arr2= {{10,20,30 },{40,50,60}};
		System.out.println(arr2);     //주소값 나옴
		System.out.println(arr2[0]);  // 주소값 나옴
		System.out.println(arr2.length);  //행의 길이
		System.out.println(arr2[0].length); // 정방에서 열의 길이
	
	*/
		
		// 가변배열 : 행크기 지정, 열은 추후에
		int [][]arr3 = new int[2][];
		arr3[0] = new int[2];    //0번행에 열 2개
		arr3[1] = new int[3];    //1번행에 열 3개
		arr3[0][0] = 1;
		arr3[0][1] = 2;
		arr3[1][0] = 3;
		arr3[1][1] = 4;
		arr3[1][2] = 5;
		
			//초기화
		int [][] arr2 = {{10,20},{30,40,50}};
		System.out.println("arr2.length :" + arr2.length);
		System.out.println(arr2[0].length);
		System.out.println(arr2[1].length);
		for(int i = 0; i < arr2.length; i++) {//행
			for(int j = 0; j< arr2[i].length;j++) {
				System.out.println(arr2[i][j]);
			}
		}
	}
}

package day06;

import java.util.Scanner;

public class Test51 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// * (비)정방배열 문제 *
	      // 문제1. 아래와 같은 형태의 정방배열을 만들어 값을 저장하고 출력해보세요. 
	      /*
	         10 20 30 
	         40 50 60
	         70 80 90
	      */
	      // 문제2. int 형 3행 2열의 정방배열을 만들고 
	      //         각 방에 정수를 입력받아 저장하고 출력하세요. 
	      
	      // 문제3. 아래와 같은 형태의 비정방배열을 만들어 
	      //      아래와 같이 값을 저장하고 출력하세요. 
	      /*
	         10 11 12
	         20 21
	         30 31 32
	         40 41 
	      */
	      
	      // 문제4. 한층에 5호씩있는 3층짜리 아파트가 있다. 
	      // 1) 배열로 만들어서 각각 호마다 관리비를 입력받고, 전체 출력해보세요. 
	      // 2) 층별 관리비 평균을 구해서 출력해보세요. 
	      // 3) 전체 관리비 평균을 구해서 출력해보세요. 
	      // 4) 103호와 203호의 관리비가 서로 바뀌었다합니다. 교환해주세요. 
	      // 5) 전체 관리비 평균보다 관리비가 적게 나오는 호수들을 출력하세요. 
	      // 6) 관리비 가장 적게 나온 호수와 가장 많이 나온 호수를 출력하세요. 
	      // 7) (심화) 관리비 적게 나온 순으로 정렬해보세요. 
	      
		
		//1번 문제
/*
		int [][] arr = {{10,20,30},{40,50,60},{70,80,90}};
		for(int i = 0; i < arr.length; i++) {//행
			for(int j = 0; j< arr[i].length;j++) {
				System.out.println(arr[i][j]);
			}
		}
*/		
	    // 문제2. int 형 3행 2열의 정방배열을 만들고 
	    //         각 방에 정수를 입력받아 저장하고 출력하세요. 
	/*	
		int [][]arr2 = new int[3][2];
		Scanner sc = new Scanner (System.in);
			System.out.println("[0][1] 입력>");
			int num1 = sc.nextInt();
			arr2[0][1] = num1 ;
			
			System.out.println("[0][1] 입력>");
			int num2 = sc.nextInt();
			arr2[0][2] = num2 ;
			
			System.out.println("[1][0] 입력>");
			int num3 = sc.nextInt();
			arr2[1][0] = num3 ;
		*/			
	/*	int [][]arr2 = new int[3][2];
		Scanner sc = new Scanner (System.in);
		for(int i=0 ; i<arr2.length; i++) {
			for(int j=0; j<arr2[i].length; j++) {
				System.out.println(i+"행" + j+"렬" + "를 입력하세요" );
				arr2[i][j] = sc.nextInt();
			}
		}
		sc.close();
		
		for(int i = 0; i < arr2.length; i++) {//행
			for(int j = 0; j< arr2[i].length;j++) {
				System.out.println(arr2[i][j]);
			}
		}
		
		 10 11 12
	     20 21 (22)
	     30 31 32
	     40 41 (42)
	*/	//3번문제
/*		int [][]arr3 = new int[4][3];
		int i, j;
		for(i=0 ; i<arr3.length; i++) {
			
			
			for(j=0; j<arr3[i].length; j++) {
				
				System.out.print((i+1)+""+ j+" " );
			}System.out.println(" ");
		}
*/		
/*
			if(2%(i+1)==0) {
				for(j=0; j<arr3[i].length; j++) {
					for(j=0; j<arr3[i].length; j++) {
					System.out.print((i+1)+""+ j );
					
					}System.out.println(" ");
				}
				
			}else {
				for(i=0 ; i<arr3.length; i++) {
				}
					for(j=0; j<3; j++) {
					
					System.out.print((i+1)+""+ j );
				}System.out.println(" ");
				
			}
		}
*/			
		
		
		   // 문제4. 한층에 5호씩있는 3층짜리 아파트가 있다. 
	      // 1) 배열로 만들어서 각각 호마다 관리비를 입력받고, 전체 출력해보세요. 
	      // 2) 층별 관리비 평균을 구해서 출력해보세요. 
	      // 3) 전체 관리비 평균을 구해서 출력해보세요. 
	      // 4) 103호와 203호의 관리비가 서로 바뀌었다합니다. 교환해주세요. 
	      // 5) 전체 관리비 평균보다 관리비가 적게 나오는 호수들을 출력하세요. 
	      // 6) 관리비 가장 적게 나온 호수와 가장 많이 나온 호수를 출력하세요. 
		int [][] arr4 = new int [2][3];
		
		Scanner sc = new Scanner (System.in);
		int total = 0; // 
		int tot = 0;
		int i, j = 0;
		for( i=0; i<arr4.length; i++) {
				
			for(j=0; j<arr4[i].length; j++) {
				
				System.out.println((i+1)+"층" + (j+1)+"호" + "관리비" );
				arr4[i][j] = sc.nextInt();
				tot += arr4[i][j];
				total += arr4[i][j];
			}//2번
			System.out.println((i+1)+"층 전체 관리비는"+tot );
			System.out.println((i+1)+"층 전체 평균값은"+(double)(tot/arr4[i].length));
			
		
		} //3번
		System.out.println("모든층 전체 평균값은"+(double)(total/(arr4.length*arr4[0].length)));
		System.out.println(arr4[0][2]);
		//4번
		int tmp = arr4[0][2];
		arr4[0][2] = arr4[1][2];
		arr4[1][2] = tmp;
		System.out.println(arr4[0][2]);
		
		
		
		//5번 전체 관리비 평균보다 관리비가 적게 나오는 호수들을 출력하세요. 
		for( i=0; i<arr4.length; i++) {
			
			for(j=0; j<arr4[i].length; j++) {
				if(arr4[i][j]<(total/(arr4.length*arr4[i].length))) {
			System.out.println((i+1)+"동"+(j+1)+"호"+ arr4[i][j]);
			System.out.println("관리비가 적은 호수는"+(i+1)+"동"+(j+1)+"호");
				}
			}
		}
	/*	sc.close();
		//4-1
		
		for(int i = 0; i < arr4.length; i++) {//행
			for(int j = 0; j< arr4[i].length;j++) {
			
			
			System.out.println((i+1)+ "층 관리비 총합은" +tot);
			System.out.println((i+1)+ "층 관리비 평균은" +tot%arr4[i].length);
			System.out.println("다음층");
			}
		}
       
		for(int i = 0; i < arr4.length; i++) {//행
			for(int j = 0; j< arr4[i].length;j++) {
				System.out.println(arr4[i][j]);
				
			}
		}
		*/
	}
}

package day06;

import java.util.Scanner;

public class Test52 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// * 1차원 배열 문제 *
	      // 문제1-1. arr이라는 이름의 방 5개짜리 배열에 
	      //         사용자로부터 서로다른 5개의 정수를 입력받아 저장하고 출력해보세요. 
	      
	      // 문제1-2. 위에서 만들 배열 arr에 저장된 값을 오름차순으로 정렬해보세요. 
	      
	      // 문제1-3. 정수 한개를 더 입력받아 저장해보세요. 
	      //         입력받은 정수는 기존 arr 배열의 마지막 데이터 다음방에 저장되어야한다. 
	      //         (즉, 배열크기가 6개가 되어야한다. 단, 배열은 방크기 변경X) 
			int [] arr = {2, 6, 10, 32, 51};
			int [] tmp = arr;
			arr = new int [6]; // 6개 짜리 새 방만들기
			
			for(int i = 0; i < tmp.length; i++) {
				arr[i] = tmp[i];
			}
			arr[5] = 200; //마지막 방에 입력받아 저장
			
		
		
	      
	      // 문제2-1. 게임랭킹보드. 각 5개의 데이터를 저장할 수 있는 
	      //         users와 scores라는 이름의 배열이 있고, 
	      //         users배열에는 유저이름, scores 배열에는 유저의 게임점수를 입력받아 저장한다. 
	      //         단, 유저이름과 게임점수는 배열 인덱스상 서로 일치하게. 
	      
	      // 문제2-2. 위 저장된 users와 scores를 아래와 같은 형태로 출력해보세요. 
	      /*
	         user_name   score
	         --------------------
	         피카츄      87
	         파이리      24
	         .....
	      */
	      
	      // 문제2-3. 두번째 유저의 점수와 세번째 유저의 점수가 서로 바뀌었다합니다. 
	      //         교환해주세요. 
	      
	      // 문제2-4. 점수가 높은 순으로 출력되는 게임 랭킹 보드를 출력해주세요. 
	      /*         랭킹보드는 1위부터 5위까지 출력 
	         rank   user_name   score
	         ----------------------------
	         1      꼬북이      96
	         2      피카츄      87
	         .....
	      */
	      
	      // 문제2-5. 또 한명의 유저가 게임을 끝냈습니다. 
	      //         점수와 유저이름을 입력받고, users와 scores 배열에 추가 저장.
	      //         (문제 1-3. 참고 : 배열길이 6개로) 
	      //         게임 랭킹보드를 업데이트해 5위까지 출력해주세요. 

		int [][]arr2 = new int[3][2];
		Scanner sc = new Scanner (System.in);
		for(int i=0 ; i<arr2.length; i++) {
			for(int j=0; j<arr2[i].length; j++) {
				System.out.println(i+"행" + j+"렬" + "를 입력하세요" );
				arr2[i][j] = sc.nextInt();
			}
		}
		sc.close();
		
		for(int i = 0; i < arr2.length; i++) {//행
			for(int j = 0; j< arr2[i].length;j++) {
				System.out.println(arr2[i][j]);
			}
		}
	}	
}

package day06;

public class Test53 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	// 랜덤 : 난수 : 임의의 수  : 0~ 1 사이 실수의 값으로 돌려줌.
		for(int i = 0; i<10; i++) {
		//System.out.println(Math.random());
		
	// 0~9 사이 랜덤값
		
	//	System.out.println((int)(Math.random()*10));
		
		
	// 1~5 사이 랜덤값	  0- 4     1-5
	//	System.out.println((int)(Math.random()*10)/2+1);
		
	// 12~ 17 사이 랜덤값	  1- 10   0- 5  12 -17
		// System.out.println(((int)(Math.random()*10)+1)/2+12);
		//== System.out.println(((int)(Math.random()*6+12);
		}
	}
}

package day06;

import java.util.Scanner;

public class Test54 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	     // 문제1. 아래와같이 2차원 배열 arr을 출력하는 프로그램을 작성하세요. 
	     
	/*
	         1
	         1 2 3
	         1
	         1 2 3 4
	         1 2   
		int [][]arr = new int[4][];
		arr[0] = new int[0];
		arr[0][0] = 1;
				
		arr[1] = new int[2];
		arr[1][0]= 1;
		arr[1][1]= 2;
		arr[1][2]= 3;
		arr[2] = new int[0];
		arr[2][0] = 1;
		
		arr[3] = new int[3];
		arr[3][0] = 1;		
		arr[3][1] = 2;
		arr[3][2] = 3;
		arr[3][3] = 4;
		
		arr[4] = new int[1];
		arr[4][0] = 1;
		arr[4][1] = 2; 
		 
	     int [][]arr = new int [][]{
	     	{1},
	     	{1},{2},{3}
	     	{1},
	     	{1},{2},{3},{4}
	         {1},{2}
	         }
	    */     
	    
	      // 문제2. Scanner로 소문자 알파벳 하나 입력받고, 
	      //      아래와 같이 출력하는 프로그램을 작성하세요. 
	  /*     
	         소문자 알파벳 하나를 입력하세요 >>   e  <- 콘솔에 입력 
	      a abcde
	         abcd
	         abc
	         ab
	         a
	         
	         sca
	         
	         sc
	        
		Scanner sc = new Scanner (System.in);
		System.out.println("알파벳을 입력하세요>>");
		
		char a = sc.nextLine().charAt(0); //아스키코드 변환
		int b = (int)a;
		
		for (int i = 97; i <= b; i++ ) {
			System.out.print((char)i+" ");
		}
		
	*/		
			
	      // 문제3. 양의 정수 10개를 입력받아 배열에 저장하고, 
	      //       3의 배수만 출력하는 프로그램을 작성하세요. 
   /*   
		Scanner sc = new Scanner (System.in);
		int arr[]= new int [9];
		
		
		
		for(int i=0; i<arr.length;i++) {
		System.out.println((i+1)+"번째 양의 정수를 입력하세요>>");
		arr[i] = sc.nextInt();
		}
		
		for(int i=0; i<arr.length;i++) { 
			if (arr[i]%3==0) {
			System.out.println(arr[i]);
			}
	}
	*/	
	      // 문제4. 4x4의 2차원 배열(총16개방)을 만들고, 
	      //      1 ~ 10 까지 범위의 정수를 10개만 
	      //      랜덤하게 생성하여 임의의 위치에 저장하세요. 
	      //      동일한 정수가 있어도 상관없으나, 
	      //      나머지 6개의 숫자는 모두 0으로 만들고 
	      //      4x4의 형태로 출력하세요. 
	      /*
	         출력예시)
	         3   0   7   2
	         0   9   1   4
	         2   4   0   5
	         0   8   0   0
	      */ 
	int[][]arr4 = new int [4][4];
	int[]temp = new int [10];
	int i,j=0;
	int count = 0;
		// 보드판 모두 0으로 초기화
		  for(i=0; i<arr4.length;i++ ) {
			  	for(j=0; j<arr4[i].length;j++){
				arr4[i][j] = 0;
				} 	
		}
			
	
	 // 10개 랜덤 생성
	      for(i=0; i<temp.length;i++ ) {
	    	 
	    		  temp[i] =((int)(Math.random()*10)+1);	
	      }
	      // 10개 랜덤을 보드에 넣기
	      for(i = 0; i<temp.length; i++)
	      //보드의 임의의 위치
	    	  // 행 0~3렬 /렬 0~3렬
    	  int x =  (int)(Math.random()*4); //행 인덱스 랜덤
	      int y =  (int)(Math.random()*4); //행 인덱스 랜덤
	      // 중복체크 : 같은 자리가 다시 뽑히면 안된다.
	      if(arr4[x][y]!=0) {
	    	  1--;
	    	  System.out.println("자리중복");
	    	  count++;
	      }else {
	    	 arr4[x][y]=temp[i];
	      }
	      
	      
	      
	      
	
	      for(i=0; i<arr4.length;i++ ) {
	    			for(j=0; j<arr4[i].length;j++){
	    				System.out.print(arr4[i][j]+" ");
	    			} 	System.out.println();
	    }
		
	      /* Up & Down 게임 
        0 ~ 99 사이의 임의의 수를 받아 (사용자로부터) 숨기고, 그수를 맞추는 게임. 
        임의의 수보다 낮게 입력하면 "Up" 출력, 
        높게 입력하면 "Down" 출력하면서 범위 좁혀가며 수를 맞춘다. 
        게임을 반복하기 위해 y/n묻고, n 입력시 프로그램 종료. 
        콘솔예시) 
        숫자가 정해졌습니다. 맞춰보세요! 
        0 ~ 99 
        1 >>  55   (사용자 입력) 
        "Up"
        55 ~ 99 
        2 >>  70
        "Up"
        70 ~ 99 
        3 >>  85
        "Down"
        70 ~ 85 
        4 >>  80
        "Down"
        70 ~ 80
        5 >>  75
        "Up"
        75 ~ 80
        6 >>  77
        맞았습니다. 
        다시 하시겠습니까?(y/n) >>  y  
        숫자가 정해졌습니다. 맞춰보세요! 
        0 ~ 99 
        1 >>  30    
        "Up"
        30 ~ 99 
        2 >>  45
        맞았습니다. 
        다시 하시겠습니까?(y/n) >>  n 
        게임 종료!!  
     */
			/*
		Scanner sc = new Scanner(System.in);
		System.out.println("문자 입력>>");
		String str = sc.nextLine();
		if(str.equals("a")) {  //if(str == "A") 문자열은 안된다 !!
			System.out.println("같아요");
		}
	*/	
	}
}

package day06;

public class Test55 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][]arr4 = new int [4][4];
		int[]temp = new int [10];
		int i,j=0;
		int count = 0;
			// 보드판 모두 0으로 초기화
			  for(i=0; i<arr4.length;i++ ) {
				  	for(j=0; j<arr4[i].length;j++){
					arr4[i][j] = 0;
					} 	
			}
				
		
		 // 10개 랜덤 생성
		      for(i=0; i<temp.length;i++ ) {
		    	 
		    		  temp[i] =((int)(Math.random()*10)+1);	
		      }
		      // 10개 랜덤을 보드에 넣기
		      for(i = 0; i<temp.length; i++) {
		      //보드의 임의의 위치
		    	  // 행 0~3렬 /렬 0~3렬
	    	
		    	  
		   
	      		int x =  (int)(Math.random()*4); //행 인덱스 랜덤
	      		int y =  (int)(Math.random()*4); //행 인덱스 랜덤
	      		 
		     
		      // 중복체크 : 같은 자리가 다시 뽑히면 안된다.
		      if(arr4[x][y]!=0) {
		    	  i--;
		    	  System.out.println("자리중복");
		    	  count++;
		    	 
		      		}else {
		    	 arr4[x][y]=temp[i];
		      }
		      
		    }  
		       System.out.println(count+"번 반복됨");
		      
		
		      for(i=0; i<arr4.length;i++ ) {
		    			for(j=0; j<arr4[i].length;j++){
		    				System.out.print(arr4[i][j]+" ");
		    	}		 	System.out.println();
		    }
	}
}

package day06;
	import java.util.Scanner;
public class Test5511 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub



				/* Up & Down 게임 
					0 ~ 99 사이의 임의의 수를 받아 (사용자로부터) 숨기고, 그수를 맞추는 게임. 
					임의의 수보다 낮게 입력하면 "Up" 출력, 
					높게 입력하면 "Down" 출력하면서 범위 좁혀가며 수를 맞춘다. 
					게임을 반복하기 위해 y/n묻고, n 입력시 프로그램 종료. 
					콘솔예시) 
					숫자가 정해졌습니다. 맞춰보세요! 
					
					0 ~ 99 
					1 >>  55   (사용자 입력) 
					"Up"
					
					55 ~ 99 
					2 >>  70
					"Up"
					
					70 ~ 99 
					3 >>  85
					"Down"
					
					70 ~ 85 
					4 >>  80
					"Down"
					
					70 ~ 80
					5 >>  75
					"Up"
					
					75 ~ 80
					6 >>  77
					맞았습니다.
					 
					다시 하시겠습니까?(y/n) >>  y  
					
					숫자가 정해졌습니다. 맞춰보세요! 
					0 ~ 99 
					1 >>  30    
					"Up"
					30 ~ 99 
					2 >>  45
					맞았습니다. 
					다시 하시겠습니까?(y/n) >>  n 
					게임 종료!!  
				*/
				Scanner sc = new Scanner(System.in);
				// 게임 전체를 돌리는 반복문 (한판~ 두판~ 세판~) 
				boolean play = true; // 게임을 다시 돌릴지 안돌릴지 정해줄 변수 
				
				while(play) {
					int num = (int)(Math.random() * 100); // 0~99 임의의 값 생성
					int count = 1;  	// 입력 회차 
					int guess = -1; 	// 사용자가 입력한 수 저장해둘 변수 
					int low = 0; 		// 낮은 범위값 들고 있을 변수 
					int high = 99; 		// 높은 범위값 들고 있을 변수 
					
					System.out.println("숫자가 정해졌습니다. 맞춰보세요!"); 			
					while(true) {
						// 입력한값과 랜덤값 num이 같을 경우 
						System.out.println(low + " ~ " + high);
						System.out.print(count + " >> ");
						guess = Integer.parseInt(sc.nextLine());
						//guess = sc.nextInt();
						count++; 
						
						
						if(guess == num) {
							System.out.println("맞았습니다.");
							System.out.println("다시 하시겠습니까?(y/n) >>");
							String answer = sc.nextLine();
							
							if(answer.equalsIgnoreCase("n")) {
								System.out.println("게임종료!");
								play = false; // 겉에 while문 반복을 판단하는 값 false 바꾸기 
								// 다음 크게 돌때 검사하러가면 false라서 종료된다!! 
								break; // 숫자 계속 입력받고 검사하는 안쪽 while문 빠져나가기
							}else if(answer.equalsIgnoreCase("y")) {
								break; // 숫자 계속 입력받고 검사하는 안쪽 while문 빠져나가기
							}else {
								System.out.println("잘못 입력하셨습니다.");
								continue;
							}
						}
									
						if(guess < num) {
							System.out.println("Up");
							low = guess;
						}
						if(guess > num) {
							System.out.println("Down");
							high = guess;
						}		
					}
				}
				sc.close();
			}
		}

package day06;

import java.util.Scanner;

public class Test5522 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		Scanner sc = new Scanner(System.in);
		boolean play = true;
		
		while(play) {
			int num = (int)(Math.random()*100); //0-99 숫자만들기
			int guess = -1;
			int count = 1;
			int low   = 0 ;
			int high  = 99 ;
			
			System.out.println("숫자가 정해졌습니다! 맞춰보세요!");
			
			while(true) {
			System.out.println(low+" ~~"+ high);
			System.out.println(count + ">>");
			count++;
			guess = sc.nextInt();
					if(guess==num){  
	 				System.out.println("맞췄습니다!");            
	 				System.out.println("다시 하겠습니까? y/n>>");    
	 				String answer = sc.nextLine();
	 				
			 			if(answer.equalsIgnoreCase("n")) {
		 					System.out.println("종료!");
			 				play = false;	
					 	 	break;
			 			}else if (answer.equalsIgnoreCase("y")) {
					 				break;
						}else {
					 			System.out.println("잘못 입력하셨습니다");
					 				continue;
						}		 			
					}
					if(guess>num) {
						System.out.println("Down");
						high = guess;
					}
					
					if(guess<num) {
						System.out.println("Up");
						low = guess;
					}
	
			}

		}
		sc.close();
	}
		
}

[day05]

1. 배열 array (java에서 많이 쓰진 않는다. 나중에 나올 배열을 자주 씀. 단 이걸 모르면 나중에 나오는걸 모른다)
1) 같은 타입의 여러 변수를 합쳐놓은 것
2) 데이터 저장 공간 수정/ 변경이 안된다
3) 변수 = 값 1 개 저장, 배열은 값 여러개 저장
4) 선언
타입[] 배열명; int[] score;
타입 배열명[]; int score[];


int [] score ;

int : 배열에 저장될 데이터의 타입 (숫자)
[]  : 배열 선언 (이건 배열이다!)
score: 배열에 대한 레퍼런스(참조- 저장위치 주소) 변수 

선언만으로는 배열의 공간이 할당되지 않으며,
score 라는 레퍼런스 변수만 생성된다.  (stack / heap 메모리)
레퍼런스 변수는 배열공간에 대한 주소값 (레퍼런스값)을 가지며
그 변수 자체가 배열은 아니다.
배열 공간이 생성되지 않았으므로 선언만 할시, 레퍼런스 변수의 초기값은 null 이다.
-> 레퍼런스 : 주소, 레퍼런스변수 : 주소를 저장하는 변수

5) 생성

레퍼런스 변수 = new 타입[방개수];
score = new int[5];
new : 메모리 할당 키워드
int : 배열 타입 : 실제 저장될 데이터의 타입
[5] : 배열 방의 개수

6) 인덱스 index
배열의 방은 0부터 시작하는 방번호가 매겨지며 이를 인덱스라 한다.
인덱스를 이용하여 배열의 각 방에 접근 가능.

score[0] = 10;

7) length
배열의 길이 (방개수)를 알여주는 명령어.

score.length --> 5

8) 배열은 연속되는 숫자를 방 번호로 갖고 있어서 (index)
반복문과 함께 자주 사용된다.

9) 초기화
int [] score = {100, 90, 80, 70 60}; //(줄임)
int [] score = new int[]{100,90, 80 ,70, 60}; //(원형)

중괄호 {}안의 요소 개수를 계산해서 방 크기를 자동으로 만들어주고,
순서대로 값도 대입시켜줌, 
선언과 초기화를 따로 분리시키면 에러!!
int [] score;
score = {1,2,3,4} (x) 에러남

int [] score = {1,2,3,4};  

package day05;

public class Test40 {
 public static void main (String[] args) {
	 
	 // 중첩 for 문
	 for( int i= 0 ; i < 3 ; i++ ) {
		 for (int j = 0; j <3 ; j++){
			 System.out.println(i + " "+ j );
		 }
	 }

	/* 
	int a = 0 ;
	
	while(a<3) {
		int b = 0 ;	
		while(b<3) {
		
			System.out.println(a+ " " + b);
			b++;
		}
		a++;
	}
*/	 
	 
 }
}

package day05;

import java.util.Scanner;

public class Test41 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	//문제1. 구구단 2단 출력
		// 출력 형태 
		// 2 * 1 = 2
		// 2 * 2 = 4
		// 2 * 3 = 6
	
	//문제2. 구구단의 단수를 입력받아, 해당 단을 출력
		
	//문제3. 구구단 전체 출력 (2단 ~ 9단)
		
		
	//2단출력
/*		int a =	1 ;
		for (;a<10 ;a++) {

			System.out.println(2 + "*"+ a + "=" + ( 2 * a));
	}
*/
		
/*		
	//	
		Scanner sc = new Scanner (System.in); 
		System.out.println("단수를 입력하세요>>");
		int num = sc.nextInt();
		
		for(int i=1;i<10;i++) {
			System.out.println(num + "*" + i + "=" + ( i * num));
			
		}
		sc.close();
*/		
		
		
		
	
/*		
		 for( int i= 1 ; i < 10 ; i++ ) {
			 System.out.println("\n"+"******"+i+"단******");
			 
			 
			 for (int j = 1; j <10 ; j++){
				 System.out.println(i + "* "+ j + "=" +(i * j) );
			 } 
			
		 }
*/
		
/*		
		// 별찍기 
		for(int a = 0; a<5 ; a++) {
			for(int b = 0; b<=a; b++) {
				System.out.print("*");
			}
			System.out.println();
		}
			
*/
/*		for(int i = 1; i < 7; i+=3) {
	         System.out.println("***" + i + "단***\t***" + (i+1) + "단***\t***" + (i+2) + "단***");
	         for(int j = 1; j < 10; j++) {
	            System.out.print(i + " * " + j + " = " + (i * j) + "\t" );
	            System.out.print((i+1) + " * " + j + " = " + ((i+1) * j) + "\t" );
	            System.out.println((i+2) + " * " + j + " = " + ((i+2) * j) );
	         }
	         
	      }
*/		
		
	  //10번 	
		
		
	}

}

package day05;

public class Test41111 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
/*	 //1번 문제 	
		for(int a = 1; a<=5; a++) {
			System.out.println(a+"행 : ***");
			
			
		}
*/			
			
   //  2번 문제 
/*     for(int a = 0; a <=5; a++ ) {
    	 for(int b = 0; b<=a ; b++  ) {
    	 System.out.print("*");
    	}
    	 System.out.println();
     }
*/     
   // 3번문제   
/*     for(int a = 0; a <=5; a++ ) {
    	 for(int b = 5; b>a; b--) {
    	 System.out.print("*");
    	}
    	 System.out.println();
     }
*/
/*	// 4번문제	
	 for(int a = 0; a <=4; a++ ) {
	    	 for(int b = 1; b<=5 ; b++  ) {
	    	 System.out.print(b+a);
	    	}
	    	 System.out.println();
	     }
*/	     
	     //5번
/*	 for(int a = 0; a <=4; a++ ) {
	    	 for(int b = 5; b<=9 ; b++  ) {
	    	 System.out.print(b-a);
	    	}
	    	 System.out.println();
	     }
 */  
	// 6번
		int star = 1;
		boolean flag = true; // 별이 증가하면 true, 별이 감소해야되면 false 
		for(int a = 0; a < 9 ; a++) {
			for(int b = 0; b<star; b++ ) {
				System.out.print("*");
			}
			if(flag) { //== true)
			
				star++;
			}else {
				star--;
			}
			if(star == 5) {
				flag = false;
			}
			System.out.println();
		}
		
		
		
		
		
/*		  for(int a = 0; a <=4; a++ ) {
		    	 for(int b = 0; b<=a ; b++  ) {
		    	 System.out.print("*");
		    	}
		    	 System.out.println();
		     }
		  for(int a = 0; a <=3; a++ ) {
		    	 for(int b = 4; b>a; b--) {
		    	 System.out.print("*");
		    	}
		    	 System.out.println();
		     }
*/
		
		
		
		
/*		for() {int a = 0;a<5; a++
			for(int b = 5 ;b) {
				System.out.println();
			}
*/			 												// 첫번째 for  a의 길이는 칸수를 결정함  
															// 2번째 	for  
/*		 for(int a = 0; a <=4; a++ ) {			
	    	 for(int b = 5; b>a ; b--  ) {
	    	 System.out.print(" ");
	    	}
	    	 	for(int c = 0; c<a+1; c++) {
	    	 	System.out.print("*");
	    	 	}
	    	 System.out.println();
	     }
	     
	     */
		// for(int a = 0; a <=5; a++ ) {
	    //	 for(int b = 5; b>a; b--) {
	    //	 System.out.print("*");
	    //		}
	    //	 System.out.println();
	    //	 }
		
		// 7번문제
/*	 for(int a = 0; a <=4; a++ ) {			
	    	 for(int b = 5; b>a+1 ; b--  ) {
	    	 System.out.print(" ");
	    	}
	    	 	for(int c = 0; c<a+1; c++) {
	    	 	System.out.print("*");
	    	 	}
	    	 System.out.println();
	     }
	*/	
		 //8번문제
/*	 for(int a = 0; a <=4; a++ ) {   
	          for(int c = 0; c<a; c++) {
	              System.out.print(" ");
	          }
	           for(int b = 5; b>a ; b--  ) {
	           System.out.print("*");
	          }
	              
	              
	           System.out.println();
	 }
*/	
/*		 // 10번  삼각형 문제 
	  for(int a = 1 ; a <= 5 ; a++) {
		 for (int b = 5; b>a ; b--) {
			 System.out.print(" ");
		 	}
		 	for (int c = 0; c<2*a-1 ; c++) {
		 		System.out.print("*");
		 	}
		 	System.out.println();
	  }
	  */
	  	//10번 
/*		for(int a=1; a<=5;a++){
			for(int b=0;b<5-a;b++){
				System.out.print(" "); 
			}
			for(int c=0;c<2*a-1;c++){
				System.out.print("*"); 
			}
			System.out.println();
		
		}
*/
	 //11번
/*		for(int a=1; a<=5;a++){
			for(int b=0;b<a-1;b++){
				System.out.print(" "); 
			}
			for(int c=10;c>2*a-1;c--){
				System.out.print("*"); 
			}
			System.out.println();
		}
	*/
	}
	

}

package day05;

public class Test42 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 배열  선언
		//int a ;
		int [] score;
		
		// a= 10;
		score = new int [3]; // 방 3개 짜리 만들기
		// 선언 + 할당
		int [] score1 = new int [3]; 
	
		score[0] = 10;
		score[1] = 20;
		score[2] = 30;
		System.out.println(score[0]);
		System.out.println(score[1]);
		System.out.println(score[2]);
		
		// int a = score; 은 안들어감 
		int a = score[0];
		int tot = 0;
		for(int i = 0; i<3; i++) {
			tot += score[i];
		}
		System.out.println(tot);
		System.out.println(score.length);
	}

}

package day05;

public class Test43 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int [] num = new int [10];
		for(int i = 0; i<10; i++) {
			num[i]= 100;
			System.out.println(num[i]);
		}
		System.out.println("--------------------");
		for(int n: num) {
			System.out.println(n);
		}
				
		// 초기화
		String[] subject = {"java","jsp","spring"};
		
		for(int i = 0; i < subject.length; i++) {
			System.out.println(subject[i]);
		}
		
		System.out.println("--------------------");
	/*	String[] subject = new String[3]; // 
String[0] = java 
		double[] d = new double[3];
		
		
			float [] f = new float[3];
			boolean[] b = new boolean[3];
			
	*/		
		
		// 업그레이드 for 문 (forEach 문)
		for(String a:subject) {
			System.out.println(a);
		}
	}
}

package day05;

public class Test44 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		
		//레퍼런스 치환
	/*	int [] arr = {1,2,3,4,5};
		int [] myArr = arr;
		for(int i = 0; i < myArr.length; i++) {
			System.out.println(myArr[i]);
			
		
		
		arr = null;
			System.out.println(myArr	[i]);
		}
		
	*/	
		//예제. 최대값, 최소값 구하기
		
/*		int [] score = {79, 59, 36, 98, 25};
		// 최대값
		int max = score [0]; 
		for (int i = 0; i < score.length; i++) {
			if( max< score[i]) {
				max = score[i];
			}
		}
		System.out.println("최대값" + max);
		
		//최소값
		int min = score [0];
		for(int i = 0 ; i < score.length; i++) {
			if(min>score[i]) {
				min = score[i];
			}
		}
		System.out.println("최소값"+ min);
*/
		
		
		//===> 더 간단하게 
				int [] score = {79, 59, 36, 98, 25};
		// 최대값
		int max = score [0]; 
		int min = score [0];
		for (int i = 0; i < score.length; i++) {
			if( max< score[i]) {
				max = score[i];
			}
			if(min>score[i]) {
				min = score[i];
			}
		}
		
		System.out.println(max);
		System.out.println(min);
	}
}

package day05;

import java.util.Scanner;

public class Test45 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		  // 문제1-1. int형 방 5개 배열을 만들고 10,20,30,40,50 을 저장하고, 출력. 
		                                   //    0  1  2  3  4
	      // 문제1-2. 위 배열을 이용하여, 인덱스번호 1번과 3번안에 있는 데이터를 
	      //         더한 값을 출력해보세요. 
	      // 문제1-3. 인덱스번호를 사용자로부터 입력받고, 
	      //         해당 인덱스의 데이터를 출력해보세요. 
	      // 문제1-4. 배열안의 모든 요소의 총 합을 출력해보세요. 
	      // 문제1-5. 배열안에 있는 값(데이터)중 하나를 입력하면, 
	      //         그 값이 저장된 인덱스 번호를 출력해보세요. 
	      // 문제1-6. 인덱스 번호 2번과 4번의 값을 교환해보세요. 
	      // 문제1-7. (심화) 내림차순으로 정렬해보세요.
		
		// 1번 문제
/*		int [] score = {10, 30, 20, 40, 50};
		for(int i =0; i <score.length;  i++) {
		System.out.println(score[i]);
		}
				
		
		// 2번 문제 
		System.out.println(score[1]+score[3]);
		
		// 3번 문제
		Scanner sc = new Scanner(System.in);
		System.out.println("인덱스를 입력하세요>>");
		int num = sc.nextInt();
		System.out.println(score[num]);
		sc.close();
*/		
/*		//4번 문제
		int tot = 0;
		for(int i =0; i <score.length;  i++) {
			tot += score[i];
		}
*/		//5번 문제
/*		System.out.println(tot);
		Scanner sc = new Scanner(System.in);
		System.out.println("값을 입력하세요>>");
		int val = sc.nextInt();
			for(int i = 0; i < score.length; i++){
				if(val == score[i]){
					System.out.println(i);
					break;
		if(val==score[i]) {
		
		}
*/		//6번 인덱스 번호 2번 4번 교환 
		
//		int [] score = {10, 30, 30, 20, 50};
				//       0  1   2   3    4 

		
		//빈공간 생성
		
		
/*		
		int[] temp = new int[1]
		// int tmp = score[2]
		
		//인덱스 2번을 빈공간으로 잠깐 이동
		temp[0] = score[2];
		//int tmp = score[2];
		System.out.println(temp[0]); //20
		
		//인덱스 4번을 2번으로 이동
		score[2] = score[4];
		System.out.println(score[2]); //4
		
		//다시 temp의 값을 4번으로 이동
		score[4] = temp[0];
		socre[4] = tmp;
		System.out.println(score[4]); //3
		
		for(int i=0; i < score.length; i++) {
			System.out.print(score[i]);// 246315
		}
*/		
		//버블 정렬
		
	/*	
		int [] score = {10, 20,50, 40, 30};
  
		for(int i =0; i <score.length-1;  i++) {
			for(int j = i+1; j <score.length; j++) {
		
				if(score[i]<score[j]) {
				 int tmp = score[i]; 
						score[i]=score[j];
						score[j]=tmp;
		
				
				}
			}
		}
		*/	
		  //선택정렬
			int [] score = {10, 20,50, 40, 30};
			for(int i = 0; i < score.length-1; i++) {
				int max = i; //큰수의 인덱스 번호
					
				for(int j = i+1; j<score.length; j++) {
					if( score[max]>score[j]) {
					max = j;
				}
			
			
			
			}
				int tmp = score[i];
				score[i] = score[max];
				score[max] = tmp;
		
	        // 결과값 출력
	      
	        for (int a : score) {
	            System.out.print(a + "  ");
	        	}
	        System.out.println();
	        
			}
	}
}

[day04]

1. 조건문 switch
다중 선택문 : 하나의 변수값을 평가하여, 각 값에 대해 개별적인 처리를 하는 문장.

1) 구조
switch(변수){
case 값1 :  // 값1과 변수의 값이 동일한 경우 아래 샐행문들 실행~
실행문들....
break; // 위 실행문들을 실행하고 switch 강제종료!!
case 값2 : 
실행문들....
break;
case 값3 : 
실행문들....
break;


...
default : 
실행문들....
break; // 마지막 break는 생략가능
}

2) 특징과 주의점
1. switch 문으로 평가 할 수 있는 변수는 주로 정수형, String
(int, char, String) 

2. case 다음에는 반드시 값이 하나가 와야한다.
3. case 0 : .... case 2 : ... 와 같이 반드시 값을 정렬할 필요없다.
4. dafault 는 생략가능
5. case 별로 {}로 묶지 않는다. 콜론 : 으로 영역 인식.
6. 다음 case가 실행되지 않도록 할 경우에는 

2. 반복문 while
1) 조건식을 먼저 검사한 후, 실행하는 반복문 (루프)
2) 실행문 영역 {}안에서 반복(루프)를 종료할 수 있게 만들어 줘야한다.
3) 구조
#1. 반복의 횟수를 알때
변수 = 초기값;
while(조건식){
// 반복해서 실행할 명령문 작성
증감식;
}

#2. 무한반복 : 반복횟수가 달라질때
while(true){
반복해서 실행할 명령문.....
if(조건){break;} //종료시점이 반드시 필요함!!!
}

3. 반복문 do-while  (잘 안씀)

선 실행 후 비교 : 실행 먼저한 후 조건 검사하는 형태

1) 구조
do {
// 반복해서 실행할 명령문...
}while(조건식); // ; 꼭붙일것


4. 반복문 for 
지정된 수만큼 반복할때 사용

1) 구조
                     1         2       4 
for(초기식; 조건식; 증감식;){
// 반복해서 실행할 명령문들....  3
}


1번 -> 2번(조건이 참이면) -> 3번 -> 4번 -> (2 -> 3 -> 4) -> 2번 (거짓-> 종료!)
초기식 : for 문 처음 시작할때 한번만 실행.
조건식 : 결과가 true/ false 되도록
증감식 : 1씩 증/감 할때는 증감연산자(++;) 주로 사용  

package day04;
import java.util.Scanner;

public class Test30 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		Scanner sc = new Scanner(System.in);
		System.out.print("정수 입력>>");
		int num = Integer.parseInt(sc.nextLine());
		
		switch(num) {
			case 1 : 
				System.out.println("1을 입력하셨습니다");
				break;
				
			case 2 :
				System.out.println("2을 입력하셨습니다");
				break;
				
			case 3 :
				System.out.println("3을 입력하셨습니다");
				break;
				
			default :
				System.out.println("1.2.3이 아닌 숫자를 입력하셨습니다");
				break;
			
		}
		System.out.println("프로그램 종료!!");
		sc.close();
	}
}

package day04;

public class Test31 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//char ch = 'A';
		String str = "A" ;
		switch(str) {
		
		case "A" : 
			System.out.println("AAA");
			break;
		case "B" : 
			System.out.println("BBB");
			break;
		case "C" : 
			System.out.println("CCC");
			break;
	
	/*	case 'B' : 
			System.out.println("BBB");
			break;
			
		case 'C' : 
			System.out.println("CCC");
			break;
				*/
		}	
	}
}

package day04;
import java.util.Scanner;
public class Test32 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			
			// *switch 문제 *
			// 문제 1. 정수를 입력받아 3~5는 "봄" 6~8은 "여름",
			//	9~ 11은 "가을", 12 ~2는 "겨울" 을 출력하세요.
	/*	
		System.out.println("정수를 입력하세요");
		Scanner sc = new Scanner(System.in); 	
		int season = sc.nextInt();
		
		switch(season/3) {
			case 1 :
				System.out.println("봄");
				break;
			case 2 :
				System.out.println("여름");
				break;
			case 3 :
				System.out.println("가을");
				break;
				
			case 4 :
				System.out.println("가을");
				break;
			*/
	
		
		
		
			// 문제 2. 점수를 입력받고 90~ 100은 "수", 80~ 89는 "우"
			// 70 ~ 79는 " 미" 60 ~ 69 "양", 그 이하는 "가"를 출력하세요.
	/*
	
	
                 70~79 -> "미"
String str = "A" 

		switch(str) {
		
		case "미" : 
			System.out.println("AAA");
			break;
		case "B" : 
			System.out.println("BBB");
			break;
		case "C" : 
			System.out.println("CCC");
			break;
	
	
	
		System.out.println("정수를 입력하세요") ;
		Scanner sc1 = new Scanner(System.in); 	
		int score = sc1.nextInt();
		


		switch (score/10) { 
			case  : 10 , case 9 :
				System.out.println("수");
				break;

			case  : 8
				System.out.println("우");
				break;
		}
				
				*/
		
			// 문제 3. 덧셈 +, 뺄셈 -, 곱셈 *, 나눗셈/ 중 원하는 기호를 선택하여 
			//	a, b의 연산 결과값을 출력해보세요.
		

		System.out.println("정수를 입력하세요") ;
		Scanner sc1 = new Scanner(System.in); 	
		String op  = sc1.nextLine();
		int a = 10; int b= 5;
		switch(op) {
		case "+" :
			System.out.println(a + b);
			break;
			
		case "-" :
			System.out.println(a - b);
			
		case "*" :
			System.out.println(a * b);
			
		case "/" :
			System.out.println(a / b);
			
			dafault :
				System.out.println("사칙연산이 아닙니다");
		}
	}
}

package day04;

import java.util.Scanner;

public class Test33 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		/*
		 * 
		#1. 반복의 횟수를 알때
		변수 = 초기값;
		while(조건식){
			// 반복해서 실행할 명령문 작성
			증감식;
		}

		#2. 무한반복 : 반복횟수가 달라질때
		while(true){
			반복해서 실행할 명령문.....
			if(조건){break;} //종료시점이 반드시 필요함!!!
		}
		 */
		
		int a = 0;   // 초기식
		while(a<=4) {
			// 반복할 명령어
			System.out.println("안녕하세요" + a);
			a++; // 증감식
			
		}
		// 0 ~ 5 출력
		int n  = 0;
		while (n <=5) {
			System.out.println(n);
			n++;
		} 
	
	}
}

package day04;

import java.util.Scanner;

public class Test34 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/*
		#1. 반복의 횟수를 알때
		변수 = 초기값;
		while(조건식){
			// 반복해서 실행할 명령문 작성
			증감식;
		}

		#2. 무한반복 : 반복횟수가 달라질때
		while(true){
			반복해서 실행할 명령문.....
			if(조건){break;} //종료시점이 반드시 필요함!!!
		}
		 */
		
		
		//while 무한반복
		//숫자 0을 입력받을때 까지 계속 정수를 입력받아 출력하세요.
		//
		
		Scanner sc = new Scanner(System.in);
		System.out.println("숫자입력");
		
		while(true) {
			int num = Integer.parseInt(sc.nextLine());
			if(num==0) {
				System.out.println("종료");
				break;
			}
		}
	}
}

package day04;

import java.util.Scanner;

public class Test35 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//문제 1. 0~ 10 까지 출력해보세요
		/*
		int a = 0;
		while(a<11) {
			System.out.println(a);
			a++;
		}
//문제 2. 1~ 15 까지 출력해보세요
		int b = 1;
		while(b<=15) {
			System.out.println(b);
			b++;
		}
//문제 3. 0~ 100 까지 10단위로 출력해보세요
		int c = 1;
		while(c<=10) {
			System.out.println(c*10);
			c++;
		
		
		int c = 0;
		while(c<=100) {
			System.out.println(c);
			c+= 10;
		}


		/*
		#2. 무한반복 : 반복횟수가 달라질때
		while(true){
			반복해서 실행할 명령문.....
			if(조건){break;} //종료시점이 반드시 필요함!!!
		}
		
		
		
		
//문제 4. 1~ 20 까지 홀수만 출력해보세요
		int d = 1;
		while(d<=10) {
			System.out.println(d*2-1);
			d++;
		}
		
		int d = 1;
		while(d<=20) {
			if(d%2==1){
			System.out.println(d);
			}
		d++;
		}
		
		
			
		
		*/
//문제 5. 1~ 10 까지 총합을 출력해보세요
		// 1 2 3 4 5 6 7 8 9 10
	/*
		   int sum = 0;
	        int i = 1;
	        
	        while (i<=10) {
	            sum =sum + i; // (sum += i;)
	          
	            i++;
	            
	        }
	            System.out.println(sum);
	        }
				 */
			
//문제 6. 1~ 50 까지 짝수의 합 출력해보세요
	 /*
		int tot = 0;
      int i = 1 ;
      
      	while (i<=25) {
          tot =(tot + (i*2));
          i++;
          
      	}
      	System.out.println(tot);
      */
				/*
	  
	      int i = 0;
	      int tot = 0;
	      
	      while(i <= 50) {
	         if(i % 2 == 0) {
	            tot += i;
	         	}
	          i++;
	      }
	      System.out.println(tot);
	   
*/
		
		

					
// 주문 프로그램 		
// 1.아메리카노 2500/		
// 2. 카페라떼 3000/		
// 3. 카푸치노 3500/		
// 4. 카라멜마끼아또 4000/		
// 5. 샌드위치 6000/		
// 6. 종료 		
		//  1. 단계 위 메뉴를 출력하고, 번호로 주문을 받는다.
		//  주문 종료를 선택할때까지 계속 주문을 받고 
		//  주문 받은 모든 메뉴의 총 금액을 출력한 후 종료
		//   2단계 : int money = 20000; (내돈). 
        //   주문시, 내 돈에서 주문한 금액 차감, 돈이 부족하면 주문 못하게, 
        //   주문 종료시 주문한 총 금액과 내 돈의 잔액까지 출력. 

		System.out.println
				("1."+ "아메리카노 2500"+"\n" +		
				 "2."+ "카페라떼 3000 "+"\n" +	
				 "3."+ "카푸치노 3500 "+"\n" +	
				 "4."+ "카라멜마끼아또 4000"+"\n" +	
				 "5."+ "샌드위치 6000" +"\n" +	
				 "6."+ " 주문종료");
		Scanner sc = new Scanner(System.in);
		int tot = 0; // 주문 총금액
		int money = 20000;
		while(true) {
			System.out.println("주문 번호를 입력하세요");
			int num = sc.nextInt();
				if(num == 1) {
						System.out.println("아메리카노를 주문하셨습니다" ); tot += 2500;
					}else if(num == 2) {
						System.out.println("카페라떼를 주문하셨습니다" ); tot += 3000;
					}else if(num == 3) {
						System.out.println("카푸치느를 주문하셨습니다" );	tot += 3500;
					}else if(num == 4) {
						System.out.println("카라멜 마끼아또를 주문하셨습니다" );	tot += 4000;
					}else if(num == 5) {
						System.out.println("샌드위치를 주문하셨습니다" );	tot += 6000;
					}else if(num == 6) {
						System.out.println("총 금액은"+ tot + " 입니다");
						break;
					}else //if(num == 0 || num >6) 
						{
						System.out.println("잘못입력하셨습니다");
						}				
				if(money-tot<0) {
				System.out.println("잔액이 부족합니다");
				
				}
			
		System.out.println("남은 잔액은" + (money - tot) + "입니다");
		
		}
	


		/*
		#2. 무한반복 : 반복횟수가 달라질때
		while(true){
			반복해서 실행할 명령문.....
			if(조건){break;} //종료시점이 반드시 필요함!!!
		}
		
		 
		sc.close();
		*/
			
		
	}
}

package day04;

public class Test36 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		int num = 0; // 초기식
		do {
			System.out.println("hello");
			num++; //증감식
		}while(num <1); //조건식
		
	}
}

package day04;

public class Test37 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		
		//5번 반복
	//	for (int i= 0; i < 5 ; i++ ) {
	//		System.out.println("hello");
			
			
		
		
		//0~10까지 출력
	//	for (int i = 0; i<=10; i++) {
	//		System.out.println(i);
	//	}
		
		
		// #1. for문 안에서 만들어진 i 변수는 밖에서 사용 불가
		//System.out.println(i); for문 안에서만 i 동작함  -> i는 지역변수
		
		// #2. i를 밖에서도 사용하고 싶으면 밖에 선언하고 사용
	//	int i = 0 ;
		
		
		
		// #3. 초기값 생략 : 밖에서 먼저 만들어놓은 변수라면 for문 안에서 초기식 생략가능 *단 반드시 세미콜론은 작성
		// for (//(int i = 0); i < 10 ; i++ ){}
		
		// #4. 무한반복
		// for ( ;  ; ){}      == while(true)   가독성 면에서 무한반복은 while을 더 많이씀 for은 쓰다만 느낌
		
		
		// break, continue
		for (int a = 0; a < 10 ; a++) {
			if(a ==5) {
				//break; //강제종료 -> 반복문 종료
				continue; // 다음 동작으로 건너뜀 -> 아래 출력안하고, 증감식으로 가버림
			}
			
		 	System.out.println(a);	
		
		}
	}

}

package day04;

import java.util.Scanner;

public class Test38 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
 //1. 10- 30 까지 출력
 //2.		10 - 100까지 10단위 출력
 //3.		1 - 20 짝수만 출력		
//4.		1- 100까지 홀수의 총합 출력
//5.		정수 1개를 입력받고, 1부터 입력받은 수까지의 합 출력
		/*
		for (int i = 10 ; i <= 30 ; i++ ) {
		System.out.println(i);
		}
		
		//2번
		for (int i = 0; i<= 100 ; i +=10) {
			System.out.println(i);
		}
		
		
		//3번
		for (int k = 0; k<= 20 ; k ++) {
			if (k%2==0) {
				System.out.println(k);
			}
		}
		
		//4번
		int tot = 0; 
		for(int i = 0; i<=100 ; i++) {
			
			if(i%2==1) {
				
				tot += i;
				
			}
			
		}
		System.out.println("홀수의 합은 : " + tot);
		
		
		*/
		/*
		//5.		정수 1개를 입력받고, 1부터 입력받은 수까지의 합 출력
		Scanner sc = new Scanner(System.in);
		int i = 0;
		System.out.println("정수를 입력하세요>");
		int num = sc.nextInt();
		int tot = 0;
		for(; i <= num; i++) {
			tot += i;
			
		}
		
		System.out.println(tot);
		*/
		/*
		Scanner sc = new Scanner(System.in);
		
		System.out.println("정수를 입력하세요>");
		int i = sc.nextInt();
		int tot = 0;
		for( ;0< i ; i-- ) {
			tot += i;
		}
		System.out.println(tot);
		*/
		
		// 0을 입력할때 까지 입력받고, 입력받은 모든 총합을 마지막에 출력하세요.
		Scanner sc = new Scanner(System.in);
		
		System.out.println("정수를 입력하세요>");
		
		int tot = 0;
		for(; ; ) {
			int num = sc.nextInt();
			if(num==0) {
			break;	
			}
			tot+= num;
			
			System.out.println(tot);
		}
		
	}
	

}

[day03]

1. 연산자 operator
 
1) 종류 
단항 연산자 : + - (int 타입등) ++ -- !
이항 연산자 : 산술연산자 : + - * / % 
      비교연산자 : <  <= > >= == != (결과 true/false)
      논리연산자 : && || 


삼항 연산자 : ?  :
대입 연산자 : =
복합대입 연산자 : 산술 + 대입 : = += -= *= /= %=
(쉬프트/비트 연산자)

2) 연산자 우선순위 (높은순)
단항연산자 : ++ -- (전위형)
     + - (양수음수)  
     ++ -- (후위형)

형변환 : (타입)
산술연산자 : * / %
   : + - (덧셈뺄셈)
(쉬프트)
비교연산자 : <  <= > >=  instanceof
   : == !=
(비트)
논라연산자 : && (and) 
   : || (or)
삼항연산자 : ?:
복합대입연산자 : = += -= *= /= %= 


2. 제어문 
- 조건문 : if, switch
- 반복문 : While, do-while, for, 업그레이드 for (forEach)
- 보조제어문 : break, continue

break : 강제종료
continue : (반복문에서 주로 사용) 아래 작성된 실행문 건너뛰고 다음 반복으로 넘어간다. 

3. 조건문 if
조건이 참이면 영역안의 코드를 실행

1) 구조 
#1.
if(조건식){
//조건이 참일 경우 실행해야될 코드들 작성

}

조건식 : 비교연산이나 논리연산이 혼합된 식으로 구성한다.
                또는 boolean 타입의 변수가 올 수 있다.
        -> 결과 또는 값이 true/ false가 와야함
영역을 뜻하는 {} 중괄호 기호는 영역안에 들어갈 명령문이 1개면 생략가능

#2.
if(조건식){
//조건이 참일 경우 실행할 코드들
}else {
  //조건이 거짓일 경우 실행할 코드들
}


else : 뒤에 조건식이 안붙고 바로 {} 영역
혼자 사용불가. if와 else의 순서가 바뀌어도 안됨
옵션처럼 반드시 써야되지는 않는다.

#3.
if(조건식1){
//조건식1이 참이면 실행할 코드들
}else if(조건문2){
//조건식2이 참이면 실행할 코드들
}else if(조건문3){
//조건식3이 참이면 실행할 코드들
}else {
// 위의 모든 조건이 거짓일때 실행할 코드들..
}

package day03;

public class Test20 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	

	// 증감 연산자 : ++, --
	// 전위형 : 나 먼저
	// 후위형 : 가장 나중에
	/*
	int a = 10;
	System.out.println(a);
	++a;
	System.out.println(a);
	--a;
	System.out.println(a);
	System.out.println(++a);
	System.out.println(--a);
	*/
		
	int b = 10;
	System.out.println(b);
	System.out.println(b++);
	System.out.println(b);
	}
}

package day03;

public class Test21 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// 대입연산자 : 대입해야 변수안의 값이 변견된다.
		 /* int a = 10;
		  System.out.println(a+10);
		  System.out.println(a);
		  // a = a + 10
		  
		  int i =5 , j = 5;
		  System.out.println(i++);  // 5
		  System.out.println(++j);  // 6
		  System.out.println(+j); 
		
		  System.out.println("i=" +i+", j=" + j );
		  */
		
		  
		  // 문제 1. 출력결과를 먼저 주석으로 적어보고 실행
		 /*
		  int k = 10;
		  System.out.println(k++); // 10
		  System.out.println(++k); // 12
		  					 ++k;  // 13
		  System.out.println(++k); // 14
		  System.out.println(k++); // 14
		  System.out.println(k);    // 15
		  */
		
		
		  //문제2 r의 결과
		  int a = 10;
		  int b = 10;
		  int r = ++a + ++b;   // 11+ 11 22
		  r = ++a + b++;    
		  //System.out.println(r);// 12 + 11 23
		  r = ++a + a ;     
		  //System.out.println(r);//    // 13 + 13
		  r = ++a + a++ ;     
		  //System.out.println(r);//   // 14 + 14
		
		  r = ++a + ++a ;      //    // 16 + 17
		  System.out.println(r);
				
	}
}

package day03;

public class Test22 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/* 단축키 
		 *  실행 : ctrl + F11 
		 * syso 적고 ctrl + space 
		 * 공백만들기 shift + enter 공백만들기
		 * 한줄복사 : ctrl + alt + 화살표 위/아래
		 * 이동 : alt + 화살표 위/아래
		 * 한줄삭제 : ctrl + D
		 * 맨첫줄로 : Home  / 맨뒷줄로 END
		 * 
		 * */
		
		
		// 사칙연산 : + - * / % (나머지값)
		int a = 10 + 10;
		System.out.println(a);
		int b = 10 % 3 ;   // (나머지 값)
		System.out.println(b);
		
		long l = (long) 100000 * 100000;  // * 100000 은 인트타입이라 long 형변환 해줘야함
		long k = 100000L * 100000;  // * 100000 은 인트타입이라 long 형변환 해줘야함
		System.out.println(l);
		System.out.println(k);

	}
}

package day03;
import java.util.Scanner;

public abstract class Test23 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
	
		
		/*
		// 문제1. 숫자 2개를 입력받고, 사칙연산 결과를 출력해보세요.
		
		Scanner No1 = new Scanner(System.in);	
			int num1 , num2 ;
		 System.out.println("값 1을 입력하세요 >>");
		/* int num1 = Integer.parseInt(sc.nextLine()); */
		/*num1 = No1.nextInt();
		System.out.println("값 2를 입력하세요 >>");
		/*int num2 = Integer.parseInt(sc.nextLine()); */
		
		/*num2 = No1.nextInt();
		
		System.out.println("덧셈출력값은" + (num1 + num2) + "입니다") ;
		System.out.println("곱셈출력값은" + (num1 * num2) + "입니다");
		System.out.println("뺄셈출력값은" + (num1 - num2) + "입니다");
		System.out.println("나눗셈출력값은" + (num1 / num2) + "입니다");
		*/
		
		
	    
		// 문제2. 초단위로 정수를 입력받고,
	     //         계산된 "??분??초" 형태로 출력해보세요. 
		 
	        
	        Scanner No2 = new Scanner(System.in);
	        System.out.println("초를 입력>> ");
	        int sec = No2.nextInt();
	    	/*int sec = Integer.parseInt(No2.nextLine()); */
	        System.out.println((sec / 60) + "분"  + (sec%60)+ "초" + "입니다"); 
	      
	        No2.close();
		
	
	/*
	     / 문제3. 초단위로 정수를 입력받고, "??시간??분??초" 형태로 출력해보세요.
	   	
	        int sec;
	        Scanner No3 = new Scanner(System.in);
	        System.out.println("초를 입력>> ");
	     sec = No3.nextInt();
	        
	    
	        System.out.println((sec/3600) + "시간" + ((sec%3600)/60)+"분" + (sec%60) +"초");
	       
    */
	        
	      /* 문제4. 최소 화폐 매수 구하기
	                금액을 입력받으면, 최소한의 화폐매수를 구해주는 프로그램 
	          콘솔예시)


	          금액입력 :   67800   <- 사용자가 입력 
	          5만원 : 1장
	          1만원 : 1장
	          5천원 : 1장
	          1천원 : 2장
	          5백원 : 1개
	          1백원 : 3개
	                
		 Scanner No4 = new Scanner(System.in);
		System.out.println("금액을 입력하세요");
	    int money = Integer.parseInt(No4.nextLine());
	    System.out.println("5만원 : "  + (money / 50000) + "장");
	    System.out.println("1만원 : "  + (money % 50000/10000) + "장");
	    System.out.println("5천원 : "  + (money % 10000/5000) + "장");
	    System.out.println("1천원 : "  + (money % 5000/1000) + "장");
	    System.out.println("5백원 : "  + (money % 1000/500) + "장");
	    System.out.println("1천원 : "  + (money % 500/100) + "장");
    */
	     
	}
}

package day03;

public class Test24 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 비교 연산자 : < <= > >= == !=
	int a = 10;
	int b = 5;
	
	int c = a + b ;
	boolean d = a  != b;
	System.out.println(d);
		
		
		// 논리 연산자 : && ||
		// %% : and
		// a && b : a, b 둘다 참이여야 함 
		
		// || : or
		// a || b : a, b 둘중 하나라도 참이면 참

	boolean result = a >= b || a > b  && b > 0; // && 부분을 먼저 연산함  result = a >= b || (a > b  && b > 0)
	System.out.println(result);
	
		// 삼항 연산자 
		// true / false의 결과식 ? 참일때 결과값 : 거짓일때 결과값;
		// a = 10 , b = 5
	

	System.out.println(a < b ? a : b);
 	int res =   a > b ? a : b ;
	char resCh = a > b ? 'O' : 'X' ;
	
	
	}

}

package day03;

public class Test25 {

	public static void main(String[] args) {
// TODO Auto-generated method stub

//	int a = 10;
	//System.out.println(a = a +10);
	 
	//System.out.println(a);
		
		
		// 복합 대입 연산자 : += -= *= /= %=
		int a = 10;
		System.out.println(a);
		a = a + 1; // a += 1; // a++; 같은 말임
		System.out.println(a);
		a += 1;
		System.out.println(a);
		
		a -= 10;   // a = a - 10; 동일함
		a *= 3;    // a = a * 3
		System.out.println(a);
		
		a /= 3;   // a = a / 3 ;
		
		a %= 3; // a = a % 3;
		
		int b = 10;
		int c = 20;
		boolean d = b < c ;
		System.out.println(!d);    // ! : (not 연산자) true / false 값을 반전 시키는 연산자 
	}
}

package day03;
import java.util.Scanner;
public class Test26 {

	public static void main(String[] args) {
	/*
		int a = 20;
		if(a>10) {
			System.out.println("a는 10보다 크다");
			System.out.println("a는 10보다 크다");
			System.out.println("a는 10보다 크다");
			System.out.println("a는 10보다 크다");
			
		}
		// a - 10 하고 10이랑 비교
		// 연산자 우선순위에 따라 산술연산 먼저 계산됨
		
		if(a- 10 < 10) {
			System.out.println("안녕하세요");
			
		}
		
		
		int score = 50;
		if (score >= 60) {
			System.out.println("합격입니다");
		}
		if (score< 60) {
			System.out.println("불합격입니다");
		}
		
		
		if (score >= 60) {
			System.out.println("합격입니다");
		}else {

			System.out.println("불합격 입니다");
			
		System.out.println(score>= 60? "합격" : "불합격");
		}
		*/
		
		
		//문제 : 점수하나를 입력받고
		// 90점 이상이면 "수" 80점 이상이면 "우"
		// 70점 이상이면 " 미" 그 이하는 "재시험" 출력
		
		
		
		Scanner exam = new Scanner(System.in);
				
		System.out.println("점수를 입력하세요 >>");
				//String a = exam.nextLine();
				//int point = Integer.parseInt(a);
				// => int point = Integer.parseInt(sc.nextLine());
		int point = Integer.parseInt(exam.nextLine());
				if(point >= 90) {
					System.out.println("수");
				}else if(point>=80) {
					System.out.println("우");
				}else if(point>=70) {
					System.out.println("미");
				}else {
					System.out.println("재시험");
				}
		
		/*	///if(score > 100{
				System.out.println("점수가 이상해요");
		}else {
				if(score >= 90) {
					System.out.println("수");	
					} else if (score >= 80) {
					System.out.println("우");
					} else {
					System.out.println("재시험");
							
					}
		 						*/	
		exam.close();
	}
}

package day03;
import java.util.Scanner;
	public class Test27 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//* 연산자 문제*
		// 문제1. 정수 두개를 입력 받고, 몫과 나머지를 출력하세요.
		// 문제2. 일(day)수 입력받고, 몇개월 몇일인지 출력해보세요.
		//	단, 한달은 30일로 고정		
		// 문제3. 점수를 3개를 입력받고, 총점과 평균을 구하여 촐력해보세요.
			
		//*if문 문제*
		// 문제4. 숫자하나를 입력받고, "음수"인지 "양수"인주 "0"인지 출력해보세요.
		// 문제5. 1~99 사이 숫자를 입력받고. "짝수" 인지 "홀수"인지 출력해보세요.
		// 문제6. 정수 3개를 입력받고, 3개의 숫자중 가장 큰 수를 출력하세요.
		
		/* 문제 1번		
		Scanner sc = new Scanner(System.in);
		int num1 , num2 ;
		
		System.out.println("값 1을 입력하세요>>");
		num1 = sc.nextInt();
		
		System.out.println("값 2을 입력하세요>>");		
		num2 = sc.nextInt();
		
		System.out.println("몫은" + (num1/num2) + "입니다");
		System.out.println("나머지는" + (num1%num2) + "입니다");
 		*/
		/* 문제 2번
		Scanner sc = new Scanner(System.in);
				System.out.println("숫자를 입력하세요 >>");
				int day = sc.nextInt();
		System.out.println((day/30)+"개월"+(day%30)+"일 입니다.");
		*/
		
		/*
		Scanner sc = new Scanner(System.in);
		int num1 , num2 , num3;
		
		System.out.println("값 1을 입력하세요>>");
		num1 = sc.nextInt();
		
		System.out.println("값 2을 입력하세요>>");
		num2 = sc.nextInt();
		
		System.out.println("값 3을 입력하세요>>");
		num3 = sc.nextInt();
		
		System.out.println("총점은 "+ (num1+num2+num3)+"이고" + "평균은"+((num1+num2+num3)/3)+"입니다");
		*/
		
			//*if문 문제*
			// 문제4. 숫자하나를 입력받고, "음수"인지 "양수"인지 "0"인지 출력해보세요.
			// 문제5. 1~99 사이 숫자를 입력받고. "짝수" 인지 "홀수"인지 출력해보세요.
			// 문제6. 정수 3개를 입력받고, 3개의 숫자중 가장 큰 수를 출력하세요.
		/*
		Scanner sc = new Scanner(System.in);
		System.out.println("숫자 하나를 입력하세요>>");
		int num1 = sc.nextInt();
			if(num1 > 0) {
				System.out.println("양수");
			}else if(num1 < 0){ 
				System.out.println("음수");
			}else if(num1 == 0){
				System.out.println("0");
		    }
		*/
		
	/*
		Scanner sc = new Scanner(System.in)	;
				System.out.println("1 ~ 99 숫자하나를 입력하세요 >>");
		int num1 = sc.nextInt();
		 if(num1 > 0 && num1 < 100){	
			if(num1%2==0) {
				System.out.println("짝수입니다");
				} else 	{	
				System.out.println("홀수입니다");
				}
		}else {
		 System.out.println("1~99 사이의 숫자가 아닙니다");
		 }
	*/
		/*
		Scanner sc = new Scanner(System.in);
		//int num1 , num2 , num3;
		System.out.println("정수 1값을 입력하세요");
		int num1 = sc.nextInt();
		
		System.out.println("정수 2값을 입력하세요");
		int num2 = sc.nextInt();
		
		System.out.println("정수 3값을 입력하세요");
		int num3 = sc.nextInt();
		
		if(num1 > num2) {
			if (num1>num3) {
				System.out.println(num1);
			}else {
				System.out.println(num3);
			}
		}
		else {
			if (num2>num3) {
			System.out.println(num2);
			} 
			else {
			System.out.println(num3);
			}
		}
			
			
			/*
		 * if((num1>num2)&&(num1>num3)) {
		 
			System.out.println("정수 1값이 가장 큰값입니다.");
			}else if((num1>num2)&&(num1<num3)) {
			System.out.println("정수 3값이 가장 큰값입니다.");
			}else if((num1<num2)&&(num1>num3)) {
			System.out.println("정수 2값이 가장 큰값입니다.");
			}else if((num1<num2)&&(num1<num3)) {
			System.out.println("정수 3값이 가장 큰값입니다.");
			}
		
		*/
		
		
		
		/* 문제7. 2차원 평면에서 직사각형은 
        왼쪽 상단 모서리와 오른쪽 하단 모서리 두점으로 표현한다. 
      (100,100) 과 (200, 200) 의 두점으로 이루어진 사각형이 있을때,
      정수 x, y 값을 입력받고 점(x, y)가 이 직사각형안에 
      있는지 판단하는 프로그램을 작성하세요. 
		 */
		
		Scanner sc = new Scanner(System.in);
		int x, y;
		System.out.println("x값을 입력하세요");
		x = sc.nextInt();
		System.out.println("y값을 입력하세요");
		y = sc.nextInt();
		
		//boolean result = ((x > 100 && x < 200) && ( y > 100 && y < 200));
		//if((200 > x > 100 ) && (200 > y > 100)); { 
		//if(result==true) 
		if((x >= 100 && x <= 200) && ( y >= 100 && y <= 200)){ 
			System.out.println("사각형 안에 존재합니다");
		}else {
			System.out.println("존재하지않습니다");
		}
		
		
		sc.close();
		
	
	}
}

[day 02]

1. 변수의 사용
1) 접미사 :
리터럴값 뒤에 데이터 타입을 명시해주는 방법

2) 기본값 :
boolean : false; 
char    : ''; .'\u0000'; 
int     : 0;
double  : 0.0;
참조열  : null;

2. 출력문 : 콘솔에 출력하는 명령문 : 개발자가 확인용으로 많이 사용
1) 종류
System.out.println();  : 엔터기능 O
System.out.print();    : 엔터기능 X (옆으로 값이 출력)
System.out.printf();   : 엔터기능 X 값을 출력할때 서식문자를 사용해야함 (몰라도 됨)

2) 출력문 내 연산 
숫자 + 숫자 ==> 더한 결과 출력
"문자열" + "문자열" ==> 문자로 연결된 문자열 출력
"문자열" + 숫자 ==>  문자로 연결된 문자열 출력 
'문자' + 숫자 ==> 문자의 아스키코드값 + 숫자 결과값 숫자 출력 


3) 이스케이프 문자 
: 출력문 내에서 사용되며, 어떠한 기능을 가지고 있는 특수 문자
(홑따옴표나 겹따옴표 안에 작성) 

"\n" : 줄바꿈 
"\t" : 탭간격
"\"" : 쌍따옴표 문자로 취급
"\'" : 홑따옴표 문자로 취급
"\\" : 역슬래쉬를 문자로 취급

3. 형변환 Casting, Type Conversiom, Converting
boolean 타입을 제외한 다른 타입들을 변환 시키는 것
(타입)변수 
char < int < long           // float < double

1) 강제형변환 : (다운캐스팅, 디모션) : 큰타입 -> 작은타입 : 형변환 공식 적는다!
int a = 300;
byte b = a; ==> error !!
byte b = (byte)a; ==> 문법적으로 error는 안나지만, 값이 깨짐

double d = 1.5;
int i = (int)d; => i = 1


(int)3.5 + 4 => 7 
(double)4 + 4 = 8.0000000


2) 자동형변환 : (업캐스팅, 프로모션) : 작은타입 -> 큰타입 : 형변환 공식 생략가능 
 
double d = 3.14 * 10; 31.4
   3.14 * 10.0 (int -> double로 자동 변환)

5 + 3.5 ==> 8.5
5 / 2   ==> 2      5 / (double)2 ===> 2.5 
int/int ==> int


4. 입력문
1) Scanner : 자바패키지에서 제공하는 클래스. 입력 받을 때 사용. 

#1. import 문 사용 : 
자바 파일 최상단 package....; 명령문 밑에 작성
import java.util.Scanner;

#2. Scanner 객체 생성 (main 안에 작성) 

Scanner sc= new Scanner(System.in); 

#3. 입력받기 (받고싶은 만큼 메서드 작성)

String 변수 = sc.nextLine(); 

#4. Scanner 객체담기

sc.close();

package day02;

public class Test03 {
	public static void main(String[] args) {
		//변수 선언
		// 타입 변수명;
		int i;
		int a, b;
		i = 10; // i 변수 초기화
		System.out.println(i);
		
		//변수 선언 + 초기화(데이터에 값을 처음 넣는것) 
		int c = 100, d = 200;
		//int e, f = 100; // (이것은 안됨) 
		int abc = 10;
		abc=20;
		System.out.println(abc);
		
		abc = 10 + 20;
		System.out.println(abc);
		
		abc = 10 + 20 * 50 / 100;
		System.out.println(abc);
		// =: 대임연산자 : 대입연산자의 오른편 연산을 모두 마친후 결과를 왼편 변수에 저장한다.
	}
}

package day02; // 현재 파일이 위치한 패키지의 이름을 명시

public class Test04 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			/* public : 접근지정자 : 완전공개 ~ 나중에
			 * Class : 클래스 만들때 사용하는 키워드
			 * 			자바는 클래스들로 구성되어 있다. 자바의 최소단위. 클래스 바깥에는 코드작성 x
			 * Test04 : 클래스 이름 : 첫글자 대문자로 만들어야함 (변수와 구분하기 위해)
			 * 			-> 이클립스에서 파일생성시 Name에 이름작성하면 이것이 클래스 이름이 되고,
			 * 				파일 생성시 첫글자 대문자로 작성.
			 * 			클래스 명명규칙 : 첫글자 대문자, 띄어쓰기x 한글x , 특수기호 _ & 만가능, 키워드x, 대소문자 구분
			 * 			패키지 안에서는 같은 이름의 클래스가 있을 수 없다
			 * 
			 * static : 전역 키워드 (클래스 키워드) : 나중에
			 *			 
			 * void : 리턴타입 중 리턴 할 값 없다!
			 * main : 메서드 이름 public static void main(String[] args) {
			 * 			메인메서드는 프로그램이 시작되면 가장 먼저 자동으로 실행되는 메서드.				
			 * 			메인메서드가 종료되면 프로그램도 종료가 된다.
			 * 			프로그램내에 반드시 하나만 존재해야함.
			 * 
			 * (String[] args): 매개변수 : 나중에
			 * 
			 * 
			 * */
	}
}

package day02;

public class Test05 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		char ch = '\u0051';
		System.out.println(ch);
		
		
		//오버플로우 : 잘못된 형태  byte -128~127
		byte b = (byte)12;
		System.out.println(b);
		
		
		// int : 10 진수 / 8 진수 : 0으로 시작하는 수
	// 			 16진수 : 0x 로 시작하는 수  
		//		 2 진수 : 0b 로 시작하는 수
		int i = 15;     //10진수
		int j = 015;    // 8진수
		int k = 0x15;   //16진수
		int l = 0b0101; //2진수
		//  0    1   0    1
		// 2^3  2^2 2^1  2^0
		
		System.out.println(i);
		System.out.println(j);
		System.out.println(k);
		System.out.println(l);
	
		// 문자열 
		String abc = "안녕하세요";
		System.out.println(abc);
		abc  = "java 재밌어요";
		System.out.println(abc);
		//abc = 'A';
		abc = "A";

	}
}

package day02;

public class Test06 {

	public static void main(String[] args) {

		// 접미사
			//(명시적 형변환)
		int a = 100;
		long l = 100;  // 100L; 과 동일함 
		double d = 3.14;
		float f = 3.14F; // double이 아니라 float 타입이라고 값에 명시
		
		int i; 
	    i = 0;
		
		
		// 출력문 연산
		System.out.println(10 + 3);
		System.out.println("A"+ 10);
		System.out.println("A"+ 10 + 20);
		System.out.println("A" + (10 +20 ));
		System.out.println(10 + 20 + "A");
		System.out.println('A'+10);
		// 아스키코드 숫자 '0' = 48, 'A' = 65, 'a' = 97  
		
		System.out.println("hello \"hello\"");
		
	}
}

package day02;

public class Test07 {

	public static void main(String[] args) {
		// 문제 : 정수형 변수 A 와 B애 각각 10, 20을 대입하고,
		// 값을 서로 교환해서 출력해보세요.
		
		// 변수 생성 + 값 대입하기
		//System.out.println(a + "" + b); // 10  20
		// A 변수의 값과 B변수의 값을 교환해서 저장

		//System.out.println(a + "" + b); // 20  10
		
		int a = 10;
		int b = 20;
		
		System.out.println(a + " " + b); // 10  20
		// A 변수의 값과 B변수의 값을 교환해서 저장
		
		int tmp = a;
		a = b;
		b = tmp;
		System.out.println(a + " " + b); // 20  10
		
	}
}

package day02;

public class Test08 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		char ch = 'A';
		int a = ch;                //자동 형변환
		System.out.println(a);
		
		a = 65;
		char c = (char)a;          //강제 형변환
		System.out.println(c);
		System.out.println(a);
		
		
		int b = 5;
		double d = b;
		System.out.println(d);
		
		double e = 5.7;
		int f = (int)e;
		System.out.println(f);
		
		char g = 'ㄴ';
		double h = g;
		System.out.println(h);
	}
}

package day02;

public class Test09 {

	public static void main(String[] args) {
			byte b = 127;
			int i = 100;
			System.out.println(b+i);  //227
			System.out.println(10/4); //  2
			System.out.println(10.0/4); // 2.5
			System.out.println((byte)(b+i)); // -28
			System.out.println((int)2.9 + 1.8); //3.8
			System.out.println((int)(2.9 + 1.8)); //4
			System.out.println((int)2.9 +(int)1.8); //3
			
	}
}

package day02;


// #1. import 문 작성
import java.util.Scanner;

public class Test10 {

	public static void main(String[] args) {
		// #2. Scanner 객체 생성
		Scanner sc = new Scanner(System.in);
			
		// #3. 입력 받기
		// 사용자가 어떤 입력을 해야하는지 힌트를 줄 메세지 출력
		System.out.println("지금 많이 졸린가요??");
		
		// 입력받아, 받은 값 가져와 msg 변수에 저장
		// (입력받아오는 값의 타입은 무조건 String 타입이다)
		String msg = sc.nextLine();
		System.out.println("타이핑:"+  msg);  //잘 가져왔는지 확인용 출력문
		
		// #4. Scanner 닫기
		sc.close();
		
	} //main
} //class

package day02;

import java.util.Scanner;

public class Test11 {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("이름을 입력하세요 >>");
		String name = sc.nextLine();
		System.out.println("당신의 이름은 " +  name  + "입니다");	
		
		System.out.println("나이를 입력해주세요 >>");
		//String age = sc.nextLine();
		//int realAge = Integer.parseInt(age);
		int Age = Integer.parseInt(sc.nextLine());
		
		
		System.out.println("당신의 나이는 " + Age + "살 입니다");
		// 참조형 String과 기본형 타입은 형변환 공식으로 호환 불가능
		// int numAge = (int)age; 안됨
		// String -> int로 변환
		// int 변수명 = Integer.parseInt(String 타입변수or "값");
		
		// String -> double 
		// double 변수 = Double.parseDouble(String 타입변수or "값");
	    
		// String -> float
		// float 변수 = Float.parseFloat(String 타입변수or "값");
		
		// String -> boolean
		// boolean 변수 = Boolean.parseBoolean(String 타입변수or "값");
	
		
		
		System.out.println("당신의 내년 나이는 " + (Age + 1) + "살 입니다");
		
		/* String -> int 
		 * integer.parseInt(String타입변수 or "값"
		 * */
		
		sc.close();
		
	}
}

package day02;
import java.util.Scanner;

public class Test12 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
			
	
		
		
		System.out.println("이름을 입력하세요 >>");
					//String name = sc.nextLine();
					System.out.println("당신의 이름은 " +  sc.nextLine()  + "입니다");	
		
		System.out.println("나이를 입력해주세요 >>");
			int Age = Integer.parseInt(sc.nextLine());
					System.out.println("내년에는 " + (Age + 1) + "이 겠군요!");
	
					//System.out.println("내년에는 " + (sc.nextInt() + 1) + "이 겠군요!");
		
		System.out.println("당신의 키는 얼마인가요 ? >>");
			double Tall = Double.parseDouble(sc.nextLine());
       				System.out.println("당신의 키는 대략 " + ((int)Tall + 1) +"이 겠군요");
		
       		
       	System.out.println("당신의 전화번호는 무엇입니까? >> ");
       				//String num = sc.nextLine();
       				System.out.println("당신의 번호는 " +  sc.nextLine()  + "입니다");	
		
       		
       				
		sc.close();
	}

}

환경변수 세팅하는 이유?

- 자바파일 위치(경로)에 상관없이 실행하기위해서 

세팅방법은?

package day01;

public class Test01 {

	public static void main(String[] args) {
	// 한줄 주석
		
	/* 여러줄 주석
	 * 
	 * 실행 단축키 ctrl + F11
	 * */
		System.out.println("hello!!!");
	}
}

package day01;

public class Test02 {
	public static void main(String[] args) {
		// 변수 선언
		boolean b;
		char ch;
		int i;
		double d;

		int a, c;
		//같은 int 타입의 변수 두개 한번에 만들기.
		
		// 변수 선언만하고 값을 대입안한 후 출력하면 에러발생!!
		//System.out.println();
		/*
		b = false;
		System.out.println(b);
		b = true;
		System.out.println(b);
		*/
		
			
		/* 데이터 bit < byte < KB MB GB TB PB EB ZB YB
		 * 기본형 8가지
		 * 논리형 boolean true or false  1byte 
		 * 문자열 char                   2byte
		 * 숫자열 4가지
  		 *      - byte   1    -128~ 127
  		 *      - short  2     -3200~ 3200
  		 *      - int    4     -21억 ~ 21억
   		 *      - long   8
   		 *      
   		 *       실수형 - float   4 byte   8자리
   		 *              - double  8 byte   16자리
		 */   
	 

		ch='한';

		System.out.println(ch);
		i = 1000;
		System.out.println(i);
		d= 3.988778;
		System.out.println(d);
		
		// 문자열 변수 선언
		String test; 
		test = "javajava";  
		
		System.out.println(test);
		
	}
}